Make ClassMirror.newInstance deal with reordered etc type arguments for redirecting factories.

runtime/lib/mirrors.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 "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 1392 matching lines @@
     // so as to produce the same NoSuchMethodError as the non-reflective case.
     lookup_constructor = Function::null();
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       lookup_constructor,
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
+  ASSERT(!type.IsNull());
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(type.arguments());
+
   Class& redirected_klass = Class::Handle(klass.raw());
   Function& redirected_constructor = Function::Handle(lookup_constructor.raw());
   if (lookup_constructor.IsRedirectingFactory()) {
     ClassFinalizer::ResolveRedirectingFactory(klass, lookup_constructor);
-    Type& type = Type::Handle(lookup_constructor.RedirectionType());
+    Type& redirect_type = Type::Handle(lookup_constructor.RedirectionType());
+
+    if (!redirect_type.IsMalformed() && !redirect_type.IsInstantiated()) {
+      // The type arguments of the redirection type are instantiated from the
+      // type arguments of the parsed type of the 'new' or 'const' expression.
+      Error& malformed_error = Error::Handle();

[regis, 2013/10/01 18:01:53]

Actually, this can only be a bound_error, not malformed_error. You probably copy
pasted this from a source that I have not fixed yet. I'll do a pass later and
fix these.

[rmacnak, 2013/10/01 18:23:12]

Done. Was from the parser code for new.

+      redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
+                                                     &malformed_error);
+      if (!malformed_error.IsNull()) {
+        ThrowInvokeError(malformed_error);
+        UNREACHABLE();
+      }
+    }
+
+    type = redirect_type.raw();
+    type_arguments = redirect_type.arguments();
+
     redirected_constructor = lookup_constructor.RedirectionTarget();
     ASSERT(!redirected_constructor.IsNull());
     redirected_klass = type.type_class();
   }
 
   const intptr_t num_explicit_args = explicit_args.Length();
   const intptr_t num_implicit_args =
       redirected_constructor.IsConstructor() ? 2 : 1;
   const Array& args =
       Array::Handle(Array::New(num_implicit_args + num_explicit_args));
@@ skipping 16 matching lines @@
     // so as to produce the same NoSuchMethodError as the non-reflective case.
     redirected_constructor = Function::null();
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       redirected_constructor,
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
-  ASSERT(!type.IsNull());
-  const AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(type.arguments());
-
   Instance& new_object = Instance::Handle();
   if (redirected_constructor.IsConstructor()) {
     // Constructors get the uninitialized object and a constructor phase. Note
     // we have delayed allocation until after the function type and argument
     // matching checks.
     new_object = Instance::New(redirected_klass);
     if (!type_arguments.IsNull()) {
       // The type arguments will be null if the class has no type parameters, in
       // which case the following call would fail because there is no slot
       // reserved in the object for the type vector.
@@ skipping 213 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
   return field.type();
 }
 
 }  // namespace dart