Substitution for type variables in mirrors on instantiated generics.

runtime/lib/mirrors.cc

Index: runtime/lib/mirrors.cc
diff --git a/runtime/lib/mirrors.cc b/runtime/lib/mirrors.cc
index be30b5deb8d1184d08c65f9bbff634554e7a01b2..0247923909e0903d83e0cd63c7d234c93fe22af4 100644
--- a/runtime/lib/mirrors.cc
+++ b/runtime/lib/mirrors.cc
@@ -869,9 +869,32 @@ DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) {
-  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
-  const Class& klass = Class::Handle(ref.GetClassReferent());
-  return klass.super_type();
+  GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(type.type_class());
+  AbstractType& super_type = AbstractType::Handle(cls.super_type());
+  return super_type.raw();

[regis, 2013/10/09 15:46:51]

You can spare a handle: return cls.super_type();

[rmacnak, 2013/10/11 01:04:22]

Done.

+}
+
+DEFINE_NATIVE_ENTRY(ClassMirror_supertype_instantiated, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(type.type_class());
+  AbstractType& super_type = AbstractType::Handle(cls.super_type());
+  AbstractType& result = AbstractType::Handle(super_type.raw());
+
+  ASSERT(super_type.IsType() || super_type.IsMixinAppType());

[regis, 2013/10/09 15:46:51]

That is not correct. This could also be a BoundedType, but you cannot encounter
a MixinAppType after class finalization.

[rmacnak, 2013/10/11 01:04:22]

We never see a BoundType here even with the addition of the bounded type tests.

+  if (!super_type.IsInstantiated()) {
+    // Why should mixin app types always be instantiated?

[regis, 2013/10/09 15:46:51]

MixinAppType live at compile time only.

[rmacnak, 2013/10/11 01:04:22]

ASSERT now excludes MixinAppType

+    ASSERT(super_type.IsType());

[regis, 2013/10/09 15:46:51]

|| super_type.IsBoundedType()

+    AbstractTypeArguments& type_args =
+        AbstractTypeArguments::Handle(type.arguments());
+    Error& error = Error::Handle();
+    result ^= super_type.InstantiateFrom(type_args, &error);

[regis, 2013/10/09 15:46:51]

Instantiating is correct, but using a prefix of type's vector would work too.

+    // Is result canonical?

[regis, 2013/10/09 15:46:51]

No, result is finalized, but not canonical.

+    ASSERT(error.IsNull());

[regis, 2013/10/09 15:46:51]

You could get a bound error if the instance was created in production mode and
you are running here in checked mode. I do not know if this is possible. I guess
not.

[rmacnak, 2013/10/11 01:04:22]

Added ThrowInvokeError to be cautious.

+    ASSERT(result.IsType());
+  }
+
+  return result.raw();
 }
 
 
@@ -1086,6 +1109,19 @@ DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) {
 }
 
 
+DEFINE_NATIVE_ENTRY(TypeVariableMirror_instantiate_from, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Type, instantiator, arguments->NativeArgAt(1));
+  AbstractTypeArguments& type_args =
+      AbstractTypeArguments::Handle(instantiator.arguments());
+  Error& error = Error::Handle();
+  AbstractType& result =
+      AbstractType::Handle(param.InstantiateFrom(type_args, &error));
+  ASSERT(error.IsNull());

[regis, 2013/10/09 15:46:51]

Why are you certain you will not get a bound error? Btw, you should rename error
to bound_error to make it clear, here and above too.

In the ClassMirror_supertype function above, you cannot get an error (unless you
switch from production mode to checked mode on the fly), because you instantiate
the super_type with the vector of the instance of its own subtype. But is this
the case here? Is the instantiator guaranteed to be valid for this type
parameter? If it is not, it will assert fault. Some comments about how this
function is supposed to be used would be helpful.

[rmacnak, 2013/10/11 01:04:22]

The instantiator should always be the type of the class that defined the
parameter. This is basically like what happens inside t() below.

class G<T> {
  t() => T;
}

+  return result.raw();
+}
+
+
 DEFINE_NATIVE_ENTRY(InstanceMirror_invoke, 5) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic