Substitution for type variables in mirrors on instantiated generics.

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 851 matching lines @@
 DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   const Library& library = Library::Handle(klass.library());
   ASSERT(!library.IsNull());
   return CreateLibraryMirror(library);
 }
 
 
 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();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_interfaces, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
 
   const Error& error = Error::Handle(klass.EnsureIsFinalized(isolate));
   if (!error.IsNull()) {
     ThrowInvokeError(error);
@@ skipping 194 matching lines @@
                            Instance::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
   return param.bound();
 }
 
 
+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
   // with its cousins.
   GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
@@ skipping 615 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