ClassMirror.mixin

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 3570 matching lines @@
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (super_type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
                String::Handle(super_type.UserVisibleName()).ToCString());
     }
     if (CurrentToken() == Token::kWITH) {
-      super_type = ParseMixins(super_type);
+      super_type = ParseMixins(super_type, Class::Handle());
     }
   } else {
     // No extends clause: implicitly extend Object, unless Object itself.
     if (!cls.IsObjectClass()) {
       super_type = Type::ObjectType();
     }
   }
   ASSERT(!super_type.IsNull() || cls.IsObjectClass());
   cls.set_super_type(super_type);
 
@@ skipping 186 matching lines @@
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "class '%s' may not extend type parameter '%s'",
              class_name.ToCString(),
              String::Handle(type.UserVisibleName()).ToCString());
   }
 
   if (CurrentToken() != Token::kWITH) {
     ErrorMsg("mixin application 'with Type' expected");
   }
-  type = ParseMixins(type);
-
-  // TODO(hausner): treat the mixin application as an alias, not as a base
-  // class whose super class is the mixin application!
-  mixin_application.set_super_type(type);
-  mixin_application.set_is_synthesized_class();
+  type = ParseMixins(type, mixin_application);
 
   // This mixin application typedef needs an implicit constructor, but it is
   // too early to call 'AddImplicitConstructor(mixin_application)' here,
   // because this class should be lazily compiled.
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);

[regis, 2013/08/20 18:56:37]

At this point, the mixin_application alias already has an interface, but 
ParseInterfaceList should be able to add to the list. Add a comment here.

   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
@@ skipping 340 matching lines @@
                "type parameter '%s' may not be used in interface list",
                String::Handle(interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
-RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
+RawAbstractType* Parser::ParseMixins(const AbstractType& super_type,
+                                     const Class& final_mixin_application) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
 
   const GrowableObjectArray& mixin_apps =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   AbstractType& mixin_type = AbstractType::Handle();
   AbstractTypeArguments& mixin_type_arguments =
       AbstractTypeArguments::Handle();
   Class& mixin_application = Class::Handle();
   Type& mixin_application_type = Type::Handle();
   Type& mixin_super_type = Type::Handle();
   ASSERT(super_type.IsType());
   mixin_super_type ^= super_type.raw();
   Array& mixin_application_interfaces = Array::Handle();
   do {
     ConsumeToken();
     const intptr_t mixin_pos = TokenPos();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (mixin_type.IsTypeParameter()) {
       ErrorMsg(mixin_pos,
                "mixin type '%s' may not be a type parameter",
                String::Handle(mixin_type.UserVisibleName()).ToCString());
     }
 
     // The name of the mixin application class is a combination of
     // the superclass and mixin class.
-    String& mixin_app_name = String::Handle();
-    mixin_app_name = mixin_super_type.ClassName();
-    mixin_app_name = String::Concat(mixin_app_name, Symbols::Ampersand());
-    mixin_app_name = String::Concat(mixin_app_name,
+    if (CurrentToken() != Token::kCOMMA && !final_mixin_application.IsNull()) {
+      mixin_application = final_mixin_application.raw();
+    } else {
+      String& mixin_app_name = String::Handle();
+      mixin_app_name = mixin_super_type.ClassName();
+      mixin_app_name = String::Concat(mixin_app_name, Symbols::Ampersand());
+      mixin_app_name = String::Concat(mixin_app_name,
                                     String::Handle(mixin_type.ClassName()));
-    mixin_app_name = Symbols::New(mixin_app_name);
+      mixin_app_name = Symbols::New(mixin_app_name);
 
-    mixin_application = Class::New(mixin_app_name, script_, mixin_pos);
+      mixin_application = Class::New(mixin_app_name, script_, mixin_pos);
+      mixin_application.set_library(library_);
+    }
     mixin_application.set_super_type(mixin_super_type);
     mixin_application.set_mixin(Type::Cast(mixin_type));
-    mixin_application.set_library(library_);
     mixin_application.set_is_synthesized_class();
 
     // Add the mixin type to the interfaces that the mixin application
     // class implements. This is necessary so that type tests work.
     mixin_application_interfaces = Array::New(1);
     mixin_application_interfaces.SetAt(0, mixin_type);
     mixin_application.set_interfaces(mixin_application_interfaces);
 
     // For the type arguments of the mixin application type, we need
     // a copy of the type arguments to the mixin type. The simplest way
@@ skipping 6109 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart