Use the runtime for generic subsitution of variable types, return types, parameter types.

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/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
@@ skipping 1883 matching lines @@
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_parameters, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   return CreateParameterMirrorList(func, owner);
 }
 
 
-DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 1) {
+DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
+  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
   // We handle constructors in Dart code.
   ASSERT(!func.IsConstructor());
-  return func.result_type();
+  const AbstractType& type = AbstractType::Handle(func.result_type());
+  if (instantiator.IsNull()) {

[rmacnak, 2013/11/06 18:40:33]

Null in the case the method is top-level, libraries thankfully being
non-generic.

[regis, 2013/11/06 19:06:07]

You could have a null instantiator, because the instantiating class is raw. In
this case, you still want to instantiate your generic result type with dynamic.
So you should replace
if (instantiator.IsNull()) {
with
if (type.IsInstantiated()) {

Of course, this requires your InstantiateType function to handle a null
instantiator correctly. The corresponding calls in object.cc do the right thing.

[rmacnak, 2013/11/07 19:56:00]

The instantiator here isn't a type vector, it's the reflected type of the
enclosing class mirror, which is never null. Still, it seems like adjusting
InstantiateType is the right way to go.

Also cleaned-up substitution for function types to use the runtime and pass the
stronger asserts.

+    return type.raw();
+  } else {
+    return InstantiateType(type, instantiator);
+  }
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_source, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   const Script& script = Script::Handle(func.script());
   const TokenStream& stream = TokenStream::Handle(script.tokens());
   const TokenStream::Iterator tkit(stream, func.end_token_pos());
   intptr_t from_line;
@@ skipping 25 matching lines @@
   const Function& sig_func = Function::Handle(cls.signature_function());
   const Class& sig_cls = Class::Handle(sig_func.signature_class());
 
   AbstractType& referent_type = AbstractType::Handle(sig_cls.DeclarationType());
   referent_type = InstantiateType(referent_type, type);
 
   return CreateFunctionTypeMirror(sig_cls, referent_type);
 }
 
 
-DEFINE_NATIVE_ENTRY(ParameterMirror_type, 2) {
+DEFINE_NATIVE_ENTRY(ParameterMirror_type, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, pos, arguments->NativeArgAt(1));
+  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(2));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
-  return func.ParameterTypeAt(func.NumImplicitParameters() + pos.Value());
+  const AbstractType& type = AbstractType::Handle(
+      func.ParameterTypeAt(func.NumImplicitParameters() + pos.Value()));
+  if (instantiator.IsNull()) {

[regis, 2013/11/06 19:06:07]

ditto

+    return type.raw();
+  } else {
+    return InstantiateType(type, instantiator);
+  }
 }
 
 
-DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
+DEFINE_NATIVE_ENTRY(VariableMirror_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
-  return field.type();
+  GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
+  const AbstractType& type = AbstractType::Handle(field.type());
+  if (instantiator.IsNull()) {

[regis, 2013/11/06 19:06:07]

ditto

+    return type.raw();
+  } else {
+    return InstantiateType(type, instantiator);
+  }
 }
 
 }  // namespace dart