Mixins with Generics

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 3226 matching lines @@
                  "original type parameter '%s'",
                  new_name.ToCString(),
                  class_name.ToCString(),
                  orig_name.ToCString());
       }
       // We do not check that the bounds are repeated. We use the original ones.
       // TODO(regis): Should we check?
     }
     cls.set_type_parameters(orig_type_parameters);
   }
-  Type& super_type = Type::Handle();
+  AbstractType& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
-    const AbstractType& type = AbstractType::Handle(
-        ParseType(ClassFinalizer::kTryResolve));
-    if (type.IsTypeParameter()) {
+    super_type = ParseType(ClassFinalizer::kTryResolve);
+    if (super_type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
-               String::Handle(type.UserVisibleName()).ToCString());
+               String::Handle(super_type.UserVisibleName()).ToCString());
     }
-    super_type ^= type.raw();
     if (CurrentToken() == Token::kWITH) {
       super_type = ParseMixins(super_type);
     }
   } else {
     // No extends clause: implicitly extend Object.
     super_type = Type::ObjectType();
   }
   ASSERT(!super_type.IsNull());
   cls.set_super_type(super_type);
 
@@ skipping 139 matching lines @@
   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 =
+  const intptr_t type_pos = TokenPos();
+  AbstractType& type =
       AbstractType::Handle(ParseType(ClassFinalizer::kTryResolve));
   if (type.IsTypeParameter()) {
-    ErrorMsg(supertype_pos,
+    ErrorMsg(type_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 = ParseMixins(type);
 
-  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");
-  }
+  // 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);
 
-  // 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(
-      AbstractType::Handle(anon_mixin_app_class.super_type()));
-  mixin_application.set_mixin(Type::Handle(anon_mixin_app_class.mixin()));
-  const Array& interfaces = Array::Handle(anon_mixin_app_class.interfaces());
-  mixin_application.set_interfaces(interfaces);
   AddImplicitConstructor(mixin_application);
-
   if (CurrentToken() == Token::kIMPLEMENTS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = TokenPos();
-    Type& super_type = Type::Handle();
-    super_type ^= mixin_application.super_type();
-    interfaces = ParseInterfaceList(super_type);
+    interfaces = ParseInterfaceList(type);
     AddInterfaces(interfaces_pos, mixin_application, interfaces);
   }
-
+  ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
-  ExpectSemicolon();
 }
 
 
 // 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.
 bool Parser::IsFunctionTypeAliasName() {
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     return true;
@@ skipping 311 matching lines @@
     }
     if (finalization != ClassFinalizer::kIgnore) {
       return NewTypeArguments(types);
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse and return an array of interface types.
-RawArray* Parser::ParseInterfaceList(const Type& super_type) {
+RawArray* Parser::ParseInterfaceList(const AbstractType& super_type) {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   String& interface_name = String::Handle();
   AbstractType& interface = AbstractType::Handle();
   String& other_name = String::Handle();
   AbstractType& other_interface = AbstractType::Handle();
   const String& super_type_name = String::Handle(super_type.Name());
   do {
@@ skipping 15 matching lines @@
         ErrorMsg(interface_pos, "duplicate interface '%s'",
                  interface_name.ToCString());
       }
     }
     interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   return Array::MakeArray(interfaces);
 }
 
 
-RawType* Parser::ParseMixins(const Type& super_type) {
+RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
 
-  // TODO(hausner): Remove this restriction.
-  if (super_type.arguments() != AbstractTypeArguments::null()) {
-    ErrorMsg(super_type.token_pos(),
-             "super class in mixin application may not have type arguments");
-  }
-
+  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(super_type.raw());
+  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::kTryResolve);
     if (mixin_type.IsTypeParameter()) {
       ErrorMsg(mixin_pos,
                "mixin type '%s' may not be a type parameter",
                String::Handle(mixin_type.UserVisibleName()).ToCString());
     }
@@ skipping 23 matching lines @@
     // 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,
                                        mixin_type_arguments,
                                        mixin_pos);
     mixin_super_type = mixin_application_type.raw();
+    mixin_apps.Add(mixin_application_type);
   } while (CurrentToken() == Token::kCOMMA);
-  return mixin_application_type.raw();
+  return MixinAppType::New(super_type,
+                           Array::Handle(Array::MakeArray(mixin_apps)));
 }
 
 
 // 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,
                                   const GrowableObjectArray& interface_list,
                                   const AbstractType& interface) {
   String& interface_name = String::Handle(interface.Name());
@@ 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