Handle creating ParameterMirrors for the parameters of forwarding constructors.

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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 473 matching lines @@
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument);
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeTypeParameters(
     const Class& cls,
     GrowableObjectArray* pending_types) {
-  if (cls.IsMixinApplication()) {
+  if (cls.IsAnonymousMixinApplication()) {
     // Setup the type parameters of the mixin application and finalize the
     // mixin type.
     ApplyMixinType(cls, pending_types);
   }
   // The type parameter bounds are not finalized here.
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
   if (!type_parameters.IsNull()) {
     TypeParameter& type_parameter = TypeParameter::Handle();
     const intptr_t num_types = type_parameters.Length();
@@ skipping 1196 matching lines @@
   // The appended type arguments are those of the super type of the mixin
   // application alias that are forwarding to the aliased mixin type, except
   // that they must refer to the type parameters of the mixin application
   // class rather than to those of the mixin application alias class.
   // This type parameter substitution is performed by an instantiation step.
   // It is important that the type parameters of the mixin application class
   // are not finalized yet, because new type parameters may have been added
   // to the super class.
   Class& super_class = Class::Handle(isolate, super_type.type_class());
   ASSERT(mixin_app_class.SuperClass() == super_class.raw());
-  while (super_class.IsMixinApplication()) {
+  while (super_class.IsAnonymousMixinApplication()) {

[rmacnak, 2014/03/27 01:36:07]

Do we have tests where the superclass is another mixin app alias?

     super_class = super_class.SuperClass();
   }
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
   const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
   intptr_t offset =
       mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
   const TypeArguments& type_params =
       TypeArguments::Handle(isolate, mixin_app_class.type_parameters());
   TypeArguments& instantiator = TypeArguments::Handle(isolate,
       TypeArguments::New(offset + num_mixin_type_params));
@@ skipping 216 matching lines @@
       // The cloned ctor shares the parameter names array with the
       // original.
       const Array& parameter_names = Array::Handle(func.parameter_names());
       ASSERT(parameter_names.Length() == num_parameters);
       clone.set_parameter_names(parameter_names);
       // The parameter types of the cloned constructor are 'dynamic'.
       clone.set_parameter_types(Array::Handle(Array::New(num_parameters)));
       for (intptr_t n = 0; n < num_parameters; n++) {
         clone.SetParameterTypeAt(n, dynamic_type);
       }
+      clone.SetForwardingTarget(func);
       cloned_funcs.Add(clone);
     }
   }
 }
 
 
 void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
   Isolate* isolate = Isolate::Current();
   const Type& mixin_type = Type::Handle(isolate, cls.mixin());
   ASSERT(!mixin_type.IsNull());
@@ skipping 203 matching lines @@
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
-  if (cls.IsMixinApplication()) {
+  if (cls.IsAnonymousMixinApplication()) {
     // Copy instance methods and fields from the mixin class.
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
     ApplyMixinMembers(cls);
   }
   GrowableArray<intptr_t> added_subclass_to_cids;
   CollectFinalizedSuperClasses(cls, &added_subclass_to_cids);
   // Ensure super class is finalized.
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull()) {
@@ skipping 138 matching lines @@
     if ((*visited)[i] == cls_index) {
       // We have already visited mixin 'cls'. We found a cycle.
       return false;
     }
   }
 
   // Visit the super chain of cls.
   visited->Add(cls.id());
   Class& super_class = Class::Handle(cls.raw());
   do {
-    if (super_class.IsMixinApplication()) {
+    if (super_class.IsAnonymousMixinApplication()) {
       const Type& mixin_type = Type::Handle(super_class.mixin());
       ASSERT(!mixin_type.IsNull());
       ASSERT(mixin_type.HasResolvedTypeClass());
       const Class& mixin_class = Class::Handle(mixin_type.type_class());
       if (!IsMixinCycleFree(mixin_class, visited)) {
         return false;
       }
     }
     super_class = super_class.SuperClass();
   } while (!super_class.IsNull());
@@ skipping 590 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