Progress in generic mixins

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/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 3397 matching lines @@
   const Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
   if (!obj.IsNull()) {
     ErrorMsg(classname_pos, "'%s' is already defined",
              class_name.ToCString());
   }
   const Class& mixin_application =
       Class::Handle(Class::New(class_name, script_, classname_pos));
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
   ParseTypeParameters(mixin_application);
+
+  // TODO(hausner): Handle mixin application aliases with generics.
+  if (mixin_application.NumTypeParameters() > 0) {
+    ErrorMsg(classname_pos,
+             "type parameters on mixin applications not yet supported");
+  }
+
   ExpectToken(Token::kASSIGN);
 
   if (CurrentToken() == Token::kABSTRACT) {
     mixin_application.set_is_abstract();
     ConsumeToken();
   }
 
   const intptr_t supertype_pos = TokenPos();
   const AbstractType& type =
       AbstractType::Handle(ParseType(ClassFinalizer::kTryResolve));
   if (type.IsTypeParameter()) {
     ErrorMsg(supertype_pos,
              "class '%s' may not extend type parameter '%s'",
              class_name.ToCString(),
              String::Handle(type.UserVisibleName()).ToCString());
   }
   Type& mixin_super_type = Type::Handle();
   mixin_super_type ^= type.raw();
 
   if (CurrentToken() != Token::kWITH) {
     ErrorMsg("mixin application 'with Type' expected");
   }
 
-  Type& mixin_application_type = Type::Handle(ParseMixins(mixin_super_type));
-  // The result of ParseMixins() is a chain of super classes that is the
+  const Type& mixin_application_type =
+      Type::Handle(ParseMixins(mixin_super_type));
+  // TODO(hausner): Implement generic mixin support.
+  if (mixin_application_type.arguments() != AbstractTypeArguments::null()) {
+    ErrorMsg(mixin_application_type.token_pos(),
+             "mixin class with type arguments not yet supported");
+  }
+
+  // The result of ParseMixins() is a chain of super types that is the
   // result of the mixin composition 'S with M1, M2, ...'. The mixin
   // application classes are anonymous (i.e. not registered in the current
   // library). We steal the super type and mixin type from the bottom of
   // the chain and add it to the named mixin application class. The bottom
   // anonymous class in the chain is thrown away.
   const Class& anon_mixin_app_class =
       Class::Handle(mixin_application_type.type_class());
   mixin_application.set_super_type(
       Type::Handle(anon_mixin_app_class.super_type()));
   mixin_application.set_mixin(Type::Handle(anon_mixin_app_class.mixin()));
@@ skipping 388 matching lines @@
              "super class of mixin may not have type arguments");
   }
 
   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(super_type.raw());
   Array& mixin_application_interfaces = Array::Handle();
-  const TypeArguments& no_type_arguments = TypeArguments::Handle();
   do {
     ConsumeToken();
     const intptr_t mixin_pos = TokenPos();
     mixin_type = ParseType(ClassFinalizer::kTryResolve);
     if (mixin_type.IsTypeParameter()) {
       ErrorMsg(mixin_pos,
                "mixin type '%s' may not be a type parameter",
                String::Handle(mixin_type.UserVisibleName()).ToCString());
     }
-    // TODO(hausner): Remove this check once we handle mixins with type
-    // arguments.
-    mixin_type_arguments = mixin_type.arguments();
-    if (!mixin_type_arguments.IsNull()) {
-      ErrorMsg(mixin_pos,
-               "mixin type '%s' may not have type arguments",
-               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.Name();
     mixin_app_name = String::Concat(mixin_app_name, Symbols::Ampersand());
     mixin_app_name = String::Concat(mixin_app_name,
                                      String::Handle(mixin_type.Name()));
     mixin_app_name = Symbols::New(mixin_app_name);
 
     mixin_application = Class::New(mixin_app_name, script_, mixin_pos);
     mixin_application.set_super_type(mixin_super_type);
     mixin_application.set_mixin(Type::Cast(mixin_type));
     mixin_application.set_library(library_);
     AddImplicitConstructor(mixin_application);
     // 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);
 
-    // TODO(hausner): Need to support type arguments.
+    // For the type arguments of the mixin application type, we need
+    // a copy of the type arguments to the mixin type. The simplest way
+    // to get the copy is to rewind the parser, parse the mixin type
+    // again and steal its type arguments.
+    SetPosition(mixin_pos);
+    mixin_type = ParseType(ClassFinalizer::kTryResolve);
+    mixin_type_arguments = mixin_type.arguments();
+
     mixin_application_type = Type::New(mixin_application,
-                                       no_type_arguments,
-                                       Scanner::kDummyTokenIndex);
+                                       mixin_type_arguments,
+                                       mixin_pos);
     mixin_super_type = mixin_application_type.raw();
   } while (CurrentToken() == Token::kCOMMA);
   return mixin_application_type.raw();
 }
 
 
 // Add 'interface' to 'interface_list' if it is not already in the list.
 // An error is reported if the interface conflicts with an interface already in
 // the list with the same class and same type arguments.
 void Parser::AddInterfaceIfUnique(intptr_t interfaces_pos,
@@ skipping 6149 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart