Implement new mixin application syntax

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 12 matching lines @@
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
+DEFINE_FLAG(bool, warn_mixin_typedef, true, "Warning on legacy mixin typedef");
 DECLARE_FLAG(bool, error_on_bad_type);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 // --enable-checked-mode and --checked both enable checked mode which is
 // equivalent to setting --enable-asserts and --enable-type-checks.
@@ skipping 3729 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);
   }
+
+  if (is_abstract) {
+    cls.set_is_abstract();
+  }
+  if (metadata_pos >= 0) {
+    library_.AddClassMetadata(cls, metadata_pos);
+  }
+
+  const bool is_mixin_declaration = (CurrentToken() == Token::kASSIGN);
+  if (is_mixin_declaration && is_patch) {
+    ErrorMsg(classname_pos,
+             "mixin application '%s' may not be a patch class",
+             class_name.ToCString());
+  }
+
   AbstractType& super_type = Type::Handle();
-  if (CurrentToken() == Token::kEXTENDS) {
-    ConsumeToken();
+  if ((CurrentToken() == Token::kEXTENDS) || is_mixin_declaration) {
+    ConsumeToken();  // extends or =
     const intptr_t type_pos = TokenPos();
     super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (super_type.IsDynamicType()) {
       // The string 'dynamic' is not resolved yet at this point, but a malformed
       // type mapped to dynamic can be encountered here.
       ErrorMsg(type_pos,
                "class '%s' may not extend a malformed type",
                class_name.ToCString());
     }
     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(pending_classes, super_type);
     }
+    if (is_mixin_declaration) {
+      cls.set_is_mixin_typedef();
+      cls.set_is_synthesized_class();
+    }
   } 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);
 
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(cls);
   }
 
-  if (is_abstract) {
-    cls.set_is_abstract();
-  }
   if (is_patch) {
     // Apply the changes to the patched class looked up above.
     ASSERT(obj.raw() == library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
     orig_class.set_patch_class(cls);
     cls.set_is_patch();
   }
   pending_classes.Add(cls, Heap::kOld);
-  if (metadata_pos >= 0) {
-    library_.AddClassMetadata(cls, metadata_pos);
+
+  if (is_mixin_declaration) {
+    ExpectSemicolon();
+  } else {
+    if (CurrentToken() != Token::kLBRACE) {
+      ErrorMsg("{ expected");
+    }
+    SkipBlock();
+    ExpectToken(Token::kRBRACE);
   }
-
-  if (CurrentToken() != Token::kLBRACE) {
-    ErrorMsg("{ expected");
-  }
-  SkipBlock();
-  ExpectToken(Token::kRBRACE);
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
   set_current_class(cls);
   is_top_level_ = true;
   String& class_name = String::Handle(cls.Name());
   const intptr_t class_pos = TokenPos();
   ClassDesc members(cls, class_name, false, class_pos);
@@ skipping 155 matching lines @@
              "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(pending_classes, type);
 
-  // TODO(12773): Treat the mixin application as an alias, not as a base
-  // class whose super class is the mixin application! This is difficult because
-  // of issues involving subsitution of type parameters
   mixin_application.set_super_type(type);
   mixin_application.set_is_synthesized_class();
 
   // 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) {
-    // At this point, the mixin_application alias already has an interface, but
-    // ParseInterfaceList will add to the list and not lose the one already
-    // there.
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
   if (metadata_pos >= 0) {
     library_.AddClassMetadata(mixin_application, metadata_pos);
   }
 }
 
 
@@ skipping 36 matching lines @@
   return is_mixin_def;
 }
 
 
 void Parser::ParseTypedef(const GrowableObjectArray& pending_classes,
                           intptr_t metadata_pos) {
   TRACE_PARSER("ParseTypedef");
   ExpectToken(Token::kTYPEDEF);
 
   if (IsMixinTypedef()) {
+    if (FLAG_warn_mixin_typedef) {
+      Warning("deprecated mixin typedef");
+    }
     ParseMixinTypedef(pending_classes, metadata_pos);
     return;
   }
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
@@ skipping 6519 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart