Simplify VM internal representation of a mixin application clause (MixinAppType

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 1835 matching lines @@
     const GrowableObjectArray& collected_args) {
   ASSERT(type.HasResolvedTypeClass());
   Class& type_class = Class::Handle(type.type_class());
   AbstractTypeArguments& type_args =
       AbstractTypeArguments::Handle(type.arguments());
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
   const intptr_t num_type_arguments =
       type_args.IsNull() ? 0 : type_args.Length();
   AbstractType& arg = AbstractType::Handle();
   if (num_type_arguments > 0) {
-    if (num_type_arguments != num_type_parameters) {
+    if (num_type_arguments == num_type_parameters) {
+      for (int i = 0; i < num_type_arguments; i++) {
+        arg = type_args.TypeAt(i);
+        collected_args.Add(arg);
+      }
+      return;
+    }
+    if (FLAG_error_on_bad_type) {
       const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
-      // TODO(regis): This should not be a compile time error anymore.
       ReportError(Error::Handle(),  // No previous error.
                   script, type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
-    for (int i = 0; i < num_type_arguments; i++) {
-      arg = type_args.TypeAt(i);
-      collected_args.Add(arg);
-    }
-  } else {
-    // Fill arguments with type dynamic.
-    for (int i = 0; i < num_type_parameters; i++) {
-      arg = Type::DynamicType();
-      collected_args.Add(arg);
-    }
+    // Discard provided type arguments and treat type as raw.
+  }
+  // Fill arguments with type dynamic.
+  for (int i = 0; i < num_type_parameters; i++) {
+    arg = Type::DynamicType();
+    collected_args.Add(arg);
   }
 }
 
 
 RawType* ClassFinalizer::ResolveMixinAppType(const Class& cls,
                                              const MixinAppType& mixin_app) {
   // Resolve super type and all mixin types.
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
-  AbstractType& type = AbstractType::Handle(mixin_app.super_type());
+  AbstractType& type = AbstractType::Handle(mixin_app.SuperType());
   ResolveType(cls, type, kCanonicalizeWellFormed);
   ASSERT(type.HasResolvedTypeClass());
   // TODO(hausner): May need to handle BoundedType here.
   ASSERT(type.IsType());
   CollectTypeArguments(cls, Type::Cast(type), type_args);
-  const Array& mixins = Array::Handle(mixin_app.mixin_types());
   Class& mixin_app_class = Class::Handle();
-  for (int i = 0; i < mixins.Length(); i++) {
-    type ^= mixins.At(i);
-    ASSERT(type.HasResolvedTypeClass());  // Newly created class in parser.
-    mixin_app_class ^= type.type_class();
+  const intptr_t depth = mixin_app.Depth();
+  for (int i = 0; i < depth; i++) {
+    mixin_app_class = mixin_app.MixinAppAt(i);
     type = mixin_app_class.mixin();
     ASSERT(!type.IsNull());
     ResolveType(cls, type, kCanonicalizeWellFormed);
     ASSERT(type.HasResolvedTypeClass());
     ASSERT(type.IsType());
     CollectTypeArguments(cls, Type::Cast(type), type_args);
   }
   const TypeArguments& mixin_app_args =
     TypeArguments::Handle(TypeArguments::New(type_args.Length()));
   for (int i = 0; i < type_args.Length(); i++) {
     type ^= type_args.At(i);
     mixin_app_args.SetTypeAt(i, type);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("ResolveMixinAppType: mixin appl type args: %s\n",
               mixin_app_args.ToCString());
   }
-  // The last element in the mixins array is the lowest mixin application
-  // type in the mixin chain. Build a new super type with its type class
-  // and the collected type arguments from the super type and all
-  // mixin types. This super type replaces the MixinAppType object
-  // in the class that extends the mixin application.
-  type ^= mixins.At(mixins.Length() - 1);
-  mixin_app_class ^= type.type_class();
-  return Type::New(mixin_app_class,
-                   mixin_app_args,
-                   mixin_app.token_pos());
+  // The mixin application class at depth k is a subclass of mixin application
+  // class at depth k - 1. Build a new super type with the class at the highest
+  // depth (the last one processed by the loop above) as the type class and the
+  // collected type arguments from the super type and all mixin types.
+  // This super type replaces the MixinAppType object in the class that extends
+  // the mixin application.
+  return Type::New(mixin_app_class, mixin_app_args, mixin_app.token_pos());
 }
 
 
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
@@ skipping 386 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart