Keep track of type parameter processing in mixin application classes.

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 2382 matching lines @@
   ParseInitializedInstanceFields(
       current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
 
   // If the class of this implicit constructor is a mixin application class,
   // it is a forwarding constructor of the mixin. The forwarding
   // constructor initializes the instance fields that have initializer
   // expressions and then calls the respective super constructor with
   // the same name and number of parameters.
   ArgumentListNode* forwarding_args = NULL;
-  if (current_class().mixin() != Type::null()) {
+  if (current_class().IsMixinApplication()) {
     // At this point we don't support forwarding constructors
     // that have optional parameters because we don't know the default
     // values of the optional parameters. We would have to compile the super
     // constructor to get the default values. Also, the spec is not clear
     // whether optional parameters are even allowed in this situation.
     // TODO(hausner): Remove this limitation if the language spec indeed
     // allows optional parameters.
     if (func.HasOptionalParameters()) {
       ErrorMsg(ctor_pos,
                "forwarding constructors must not have optional parameters");
@@ skipping 490 matching lines @@
   qual_ident->ident = CurrentLiteral();
   qual_ident->lib_prefix = NULL;
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
-      if (current_class().mixin() == Type::null()) {
+      if (!current_class().IsMixinApplication()) {
         lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       } else {
         // TODO(hausner): Should we resolve the prefix via the library scope
         // rather than via the class?
         Class& cls = Class::Handle(parsed_function()->function().origin());
         lib_prefix = cls.LookupLibraryPrefix(*(qual_ident->ident));
       }
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier, unless the prefix is
         // shadowed by a type parameter in scope.
@@ skipping 5782 matching lines @@
         *node = new LoadLocalNode(ident_pos, local);
       }
     }
     return true;
   }
 
   // Try to find the identifier in the class scope of the current class.
   // If the current class is the result of a mixin application, we must
   // use the class scope of the class from which the function originates.
   Class& cls = Class::Handle(isolate());
-  if (current_class().mixin() == Type::null()) {
+  if (!current_class().IsMixinApplication()) {
     cls = current_class().raw();
   } else {
     cls = parsed_function()->function().origin();
   }
   Function& func = Function::Handle(isolate(), Function::null());
   Field& field = Field::Handle(isolate(), Field::null());
 
   // First check if a field exists.
   field = cls.LookupField(ident);
   if (!field.IsNull()) {
@@ skipping 1402 matching lines @@
              CurrentToken() == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
   } else if (CurrentToken() == Token::kSUPER) {
     if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     }
     if (current_class().SuperClass() == Class::null()) {
       ErrorMsg("class '%s' does not have a superclass",
                String::Handle(current_class().Name()).ToCString());
     }
-    if (current_class().mixin() != Type::null()) {
+    if (current_class().IsMixinApplication()) {
       const Type& mixin_type = Type::Handle(current_class().mixin());
       if (mixin_type.type_class() == current_function().origin()) {
-        ErrorMsg("class '%s' may not use super "
-                 "because it is used as mixin class",
-                 String::Handle(current_class().Name()).ToCString());
+        ErrorMsg("method of mixin class '%s' may not refer to 'super'",
+                 String::Handle(Class::Handle(
+                     current_function().origin()).Name()).ToCString());
       }
     }
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident);
@@ skipping 347 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart