[VM mirrors and reified generic functions] Mirrors do not (and will probably

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/mirrors.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 692 matching lines @@
     // Invoke the getter and return the result.
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(getter, Object::empty_array()));
     return ReturnResult(result);
   }
   return field.StaticValue();
 }
 
 static RawAbstractType* InstantiateType(const AbstractType& type,
                                         const AbstractType& instantiator) {
+  // Generic function type parameters are not reified, but mapped to dynamic.
   ASSERT(type.IsFinalized());
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType());
 
-  // TODO(regis): Support uninstantiated type referring to function type params.
-  if (!type.IsInstantiated(kFunctions)) {
-    UNIMPLEMENTED();
-  }
-
-  if (type.IsInstantiated() || instantiator.IsNull()) {
-    // TODO(regis): Shouldn't type parameters be replaced by dynamic?
+  if (type.IsInstantiated()) {
     return type.Canonicalize();
   }
-
-  ASSERT(!instantiator.IsNull());
-  ASSERT(instantiator.IsFinalized());
-  PROPAGATE_IF_MALFORMED(instantiator);
-
-  const TypeArguments& instantiator_type_args =
-      TypeArguments::Handle(instantiator.arguments());
+  TypeArguments& instantiator_type_args = TypeArguments::Handle();
+  if (!instantiator.IsNull()) {
+    ASSERT(instantiator.IsFinalized());
+    PROPAGATE_IF_MALFORMED(instantiator);
+    instantiator_type_args = instantiator.arguments();
+  }
   Error& bound_error = Error::Handle();
   AbstractType& result = AbstractType::Handle(type.InstantiateFrom(
       instantiator_type_args, Object::null_type_arguments(), &bound_error, NULL,
       NULL, Heap::kOld));
   if (!bound_error.IsNull()) {
     Exceptions::PropagateError(bound_error);
     UNREACHABLE();
   }
   ASSERT(result.IsFinalized());
   return result.Canonicalize();
@@ skipping 141 matching lines @@
     library = klass.library();
   } else if (decl.IsFunction() && !Function::Cast(decl).IsSignatureFunction()) {
     klass = Function::Cast(decl).origin();
     library = klass.library();
   } else if (decl.IsField()) {
     klass = Field::Cast(decl).Origin();
     library = klass.library();
   } else if (decl.IsLibrary()) {
     library ^= decl.raw();
   } else if (decl.IsTypeParameter()) {
+    if (TypeParameter::Cast(decl).IsFunctionTypeParameter()) {
+      // TODO(regis): Fully support generic functions.
+      return Object::empty_array().raw();
+    }
     klass ^= TypeParameter::Cast(decl).parameterized_class();
     library = klass.library();
   } else {
     return Object::empty_array().raw();
   }
 
   const Object& metadata = Object::Handle(library.GetMetadata(decl));
   if (metadata.IsError()) {
     Exceptions::PropagateError(Error::Cast(metadata));
   }
@@ skipping 291 matching lines @@
   for (intptr_t i = 0; i < num_params; i++) {
     arg_type ^= args.TypeAt(i + num_inherited_args);
     type_mirror = CreateTypeMirror(arg_type);
     result.SetAt(i, type_mirror);
   }
   return result.raw();
 }
 
 DEFINE_NATIVE_ENTRY(TypeVariableMirror_owner, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
-  const Class& owner = Class::Handle(param.parameterized_class());
-  const AbstractType& type = AbstractType::Handle(owner.DeclarationType());
+  Class& owner = Class::Handle(param.parameterized_class());
+  AbstractType& type = AbstractType::Handle();
+  if (owner.IsNull()) {
+    // TODO(regis): Fully support generic functions. For now, reify function
+    // type parameters to dynamic and map their function owner to Null class.
+    ASSERT(param.IsFunctionTypeParameter());
+    type = Type::NullType();
+    owner = type.type_class();
+  } else {
+    type = owner.DeclarationType();
+  }
   return CreateClassMirror(owner, type,
                            Bool::True(),  // is_declaration
                            Instance::null_instance());
 }
 
 DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
   return param.bound();
 }
 
@@ skipping 726 matching lines @@
       return Instance::null();  // Synthetic.
     }
     script = cls.script();
     token_pos = cls.token_pos();
   } else if (decl.IsField()) {
     const Field& field = Field::Cast(decl);
     script = field.Script();
     token_pos = field.token_pos();
   } else if (decl.IsTypeParameter()) {
     const TypeParameter& type_var = TypeParameter::Cast(decl);
+    if (type_var.IsFunctionTypeParameter()) {
+      // TODO(regis): Support generic functions.
+      return Instance::null();
+    }
     const Class& owner = Class::Handle(zone, type_var.parameterized_class());
     script = owner.script();
     token_pos = type_var.token_pos();
   } else if (decl.IsLibrary()) {
     const Library& lib = Library::Cast(decl);
     if (lib.raw() == Library::NativeWrappersLibrary()) {
       return Instance::null();  // No source.
     }
     const Array& scripts = Array::Handle(zone, lib.LoadedScripts());
     for (intptr_t i = 0; i < scripts.Length(); i++) {
@@ skipping 64 matching lines @@
 
 DEFINE_NATIVE_ENTRY(TypeMirror_subtypeTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsSubtypeOf(b, NULL, NULL, Heap::kNew)).raw();
 }
 
 #endif  // !DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart