Remove signature classes from the VM.

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 121 matching lines @@
   EnsureConstructorsAreCompiled(func);
 
   bool has_extra_parameter_info = true;
   if (non_implicit_param_count == 0) {
     has_extra_parameter_info = false;
   }
   if (func.IsImplicitConstructor()) {
     // This covers the default constructor and forwarding constructors.
     has_extra_parameter_info = false;
   }
+  if (func.IsSignatureFunction() &&
+      (func.token_pos() == Token::kNoSourcePos)) {
+    // Signature functions (except those describing typedefs) get canonicalized,
+    // hence do not have a token position, and therefore cannot be reparsed.
+    has_extra_parameter_info = false;
+  }
 
   Array& param_descriptor = Array::Handle();
   if (has_extra_parameter_info) {
     // Reparse the function for the following information:
     // * The default value of a parameter.
-    // * Whether a parameters has been deflared as final.
+    // * Whether a parameters has been declared as final.
     // * Any metadata associated with the parameter.
     const Object& result =
         Object::Handle(Parser::ParseFunctionParameters(func));
     if (result.IsError()) {
       Exceptions::PropagateError(Error::Cast(result));
       UNREACHABLE();
     }
     param_descriptor ^= result.raw();
     ASSERT(param_descriptor.Length() ==
            (Parser::kParameterEntrySize * non_implicit_param_count));
@@ skipping 72 matching lines @@
 
 
 static RawInstance* CreateTypedefMirror(const Class& cls,
                                         const AbstractType& type,
                                         const Bool& is_declaration,
                                         const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   args.SetAt(2, String::Handle(cls.Name()));
-  args.SetAt(3, Bool::Get(cls.NumTypeParameters() != 0));
-  args.SetAt(4, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
+  args.SetAt(3, Bool::Get(cls.IsGeneric()));
+  args.SetAt(4, cls.IsGeneric() ? is_declaration : Bool::False());
   args.SetAt(5, owner_mirror);
   return CreateMirror(Symbols::_LocalTypedefMirror(), args);
 }
 
 
-static RawInstance* CreateFunctionTypeMirror(const Class& cls,
-                                             const AbstractType& type) {
-  const Array& args = Array::Handle(Array::New(2));
+static RawInstance* CreateFunctionTypeMirror(const AbstractType& type) {
+  ASSERT(type.IsFunctionType());
+  const Class& cls = Class::Handle(FunctionType::Cast(type).scope_class());
+  const Function& func = Function::Handle(FunctionType::Cast(type).signature());
+  const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
-  args.SetAt(1, type);
+  args.SetAt(1, MirrorReference::Handle(MirrorReference::New(func)));
+  args.SetAt(2, type);
   return CreateMirror(Symbols::_LocalFunctionTypeMirror(), args);
 }
 
 
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror,
                                        const AbstractType& instantiator) {
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
 
@@ skipping 35 matching lines @@
   args.SetAt(1, name);
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Object::null_instance());  // Null for type.
   args.SetAt(4, Bool::Get(field.is_static()));
   args.SetAt(5, Bool::Get(field.is_final()));
   args.SetAt(6, Bool::Get(field.is_const()));
 
   return CreateMirror(Symbols::_LocalVariableMirror(), args);
 }
 
-static RawFunction* CallMethod(const Class& cls) {
-  if (cls.IsSignatureClass()) {
-    return cls.signature_function();
-  }
-
-  Class& lookup_cls = Class::Handle(cls.raw());
-  Function& call_function = Function::Handle();
-  do {
-    call_function = lookup_cls.LookupDynamicFunction(Symbols::Call());
-    if (!call_function.IsNull()) {
-      return call_function.raw();
-    }
-    lookup_cls = lookup_cls.SuperClass();
-  } while (!lookup_cls.IsNull());
-  return Function::null();
-}
 
 static RawInstance* CreateClassMirror(const Class& cls,
                                       const AbstractType& type,
                                       const Bool& is_declaration,
                                       const Instance& owner_mirror) {
   if (type.IsTypeRef()) {
     AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type());
     ASSERT(!ref_type.IsTypeRef());
     ASSERT(ref_type.IsCanonical());
     return CreateClassMirror(cls, ref_type, is_declaration, owner_mirror);
   }
   ASSERT(!cls.IsDynamicClass() && !cls.IsVoidClass());
   ASSERT(!type.IsNull());
   ASSERT(type.IsFinalized());
 
-  if (cls.IsSignatureClass()) {
-    if (cls.IsCanonicalSignatureClass()) {
-      // We represent function types as canonical signature classes.
-      return CreateFunctionTypeMirror(cls, type);
-    } else {
-      // We represent typedefs as non-canonical signature classes.
-      return CreateTypedefMirror(cls, type, is_declaration, owner_mirror);
-    }
+  if (cls.IsTypedefClass()) {
+    return CreateTypedefMirror(cls, type, is_declaration, owner_mirror);
   }
 
   const Error& error = Error::Handle(cls.EnsureIsFinalized(Thread::Current()));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 
   const Array& args = Array::Handle(Array::New(9));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
@@ skipping 191 matching lines @@
   if (type.IsTypeRef()) {
     AbstractType& ref_type = AbstractType::Handle(TypeRef::Cast(type).type());
     ASSERT(!ref_type.IsTypeRef());
     ASSERT(ref_type.IsCanonical());
     return CreateTypeMirror(ref_type);
   }
   ASSERT(type.IsFinalized());
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsCanonical() || type.IsTypeParameter() || type.IsBoundedType());
 
+  if (type.IsFunctionType()) {
+    const Class& scope_class =
+        Class::Handle(FunctionType::Cast(type).scope_class());
+    if (scope_class.IsTypedefClass()) {
+      return CreateTypedefMirror(scope_class,
+                                 type, Bool::False(), Object::null_instance());
+    } else {
+      return CreateFunctionTypeMirror(type);
+    }
+  }
   if (type.HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type.type_class());
     // Handle void and dynamic types.
     if (cls.IsVoidClass()) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Void());
       return CreateMirror(Symbols::_SpecialTypeMirror(), args);
     } else if (cls.IsDynamicClass()) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Dynamic());
@@ skipping 211 matching lines @@
     return type.Canonicalize();
   }
 
   ASSERT(!instantiator.IsNull());
   ASSERT(instantiator.IsFinalized());
   PROPAGATE_IF_MALFORMED(instantiator);
 
   const TypeArguments& type_args =
       TypeArguments::Handle(instantiator.arguments());
   Error& bound_error = Error::Handle();
-  AbstractType& result =
-      AbstractType::Handle(type.InstantiateFrom(type_args, &bound_error));
+  AbstractType& result = AbstractType::Handle(
+      type.InstantiateFrom(type_args, &bound_error, NULL, Heap::kOld));
   if (!bound_error.IsNull()) {
     Exceptions::PropagateError(bound_error);
     UNREACHABLE();
   }
   ASSERT(result.IsFinalized());
   return result.Canonicalize();
 }
 
 
 DEFINE_NATIVE_ENTRY(MirrorSystem_libraries, 0) {
@@ skipping 21 matching lines @@
   VerifyMethodKindShifts();
 
   return CreateIsolateMirror();
 }
 
 
 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalClassMirror, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  ASSERT(type.HasResolvedTypeClass());
+  ASSERT(type.IsFunctionType() || type.HasResolvedTypeClass());
   const Class& cls = Class::Handle(type.type_class());
   ASSERT(!cls.IsNull());
-  if (cls.IsDynamicClass() ||
-      cls.IsVoidClass() ||
-      (cls.IsSignatureClass() && !cls.IsCanonicalSignatureClass())) {
+  if (cls.IsDynamicClass() || cls.IsVoidClass() || cls.IsTypedefClass()) {
     Exceptions::ThrowArgumentError(type);
     UNREACHABLE();
   }
   return CreateClassMirror(cls,
                            AbstractType::Handle(cls.DeclarationType()),
                            Bool::True(),  // is_declaration
                            Object::null_instance());
 }
 
 
@@ skipping 57 matching lines @@
   }
   return metadata.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_call_method, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance,
                                owner_mirror,
                                arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
-  const Class& cls = Class::Handle(ref.GetClassReferent());
-  const Function& func = Function::Handle(CallMethod(cls));
+  // TODO(rmacnak): Return get:call() method on class _Closure instead?
+  // This now returns the result of invoking that call getter.
+  const Function& func = Function::Handle(ref.GetFunctionReferent());
   ASSERT(!func.IsNull());
   return CreateMethodMirror(func, owner_mirror, AbstractType::Handle());
 }
 
 
 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_parameters, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
-  const Class& cls = Class::Handle(ref.GetClassReferent());
-  const Function& func = Function::Handle(cls.signature_function());
+  const Function& func = Function::Handle(ref.GetFunctionReferent());
   return CreateParameterMirrorList(func, owner);
 }
 
 
 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_return_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType,
                                instantiator,
                                arguments->NativeArgAt(1));
-  const Class& cls = Class::Handle(ref.GetClassReferent());
-  const Function& func = Function::Handle(CallMethod(cls));
+  const Function& func = Function::Handle(ref.GetFunctionReferent());
   ASSERT(!func.IsNull());
   AbstractType& type = AbstractType::Handle(func.result_type());
   return InstantiateType(type, instantiator);
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_libraryUri, 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 library.url();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  if (!type.HasResolvedTypeClass()) {
-    Exceptions::ThrowArgumentError(type);
-    UNREACHABLE();
-  }
   const Class& cls = Class::Handle(type.type_class());
   const AbstractType& super_type = AbstractType::Handle(cls.super_type());
   ASSERT(super_type.IsNull() || super_type.IsFinalized());
   return super_type.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_supertype_instantiated, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  if (!type.HasResolvedTypeClass()) {
-    Exceptions::ThrowArgumentError(type);
-    UNREACHABLE();
-  }
   const Class& cls = Class::Handle(type.type_class());
   const AbstractType& super_type = AbstractType::Handle(cls.super_type());
   return InstantiateType(super_type, type);
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_interfaces, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  if (!type.HasResolvedTypeClass()) {
-    Exceptions::ThrowArgumentError(type);
-    UNREACHABLE();
-  }
   const Class& cls = Class::Handle(type.type_class());
   const Error& error = Error::Handle(cls.EnsureIsFinalized(thread));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
 
   return cls.interfaces();
 }
 
 DEFINE_NATIVE_ENTRY(ClassMirror_interfaces_instantiated, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  if (!type.HasResolvedTypeClass()) {
-    Exceptions::ThrowArgumentError(type);
-    UNREACHABLE();
-  }
   const Class& cls = Class::Handle(type.type_class());
   const Error& error = Error::Handle(cls.EnsureIsFinalized(thread));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
 
   Array& interfaces = Array::Handle(cls.interfaces());
   Array& interfaces_inst = Array::Handle(Array::New(interfaces.Length()));
   AbstractType& interface = AbstractType::Handle();
 
   for (int i = 0; i < interfaces.Length(); i++) {
     interface ^= interfaces.At(i);
     interface = InstantiateType(interface, type);
     interfaces_inst.SetAt(i, interface);
   }
 
   return interfaces_inst.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_mixin, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  if (!type.HasResolvedTypeClass()) {
-    Exceptions::ThrowArgumentError(type);
-    UNREACHABLE();
-  }
   const Class& cls = Class::Handle(type.type_class());
   const AbstractType& mixin_type = AbstractType::Handle(cls.mixin());
   ASSERT(mixin_type.IsNull() || mixin_type.IsFinalized());
   return mixin_type.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_mixin_instantiated, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType,
                                instantiator,
                                arguments->NativeArgAt(1));
   PROPAGATE_IF_MALFORMED(type);
   ASSERT(type.IsFinalized());
-  if (!type.HasResolvedTypeClass()) {
-    Exceptions::ThrowArgumentError(type);
-    UNREACHABLE();
-  }
   const Class& cls = Class::Handle(type.type_class());
   const AbstractType& mixin_type = AbstractType::Handle(cls.mixin());
   if (mixin_type.IsNull()) {
     return mixin_type.raw();
   }
 
   return InstantiateType(mixin_type, instantiator);
 }
 
 
@@ skipping 97 matching lines @@
 
   Object& entry = Object::Handle();
   DictionaryIterator entries(library);
 
   AbstractType& type = AbstractType::Handle();
 
   while (entries.HasNext()) {
     entry = entries.GetNext();
     if (entry.IsClass()) {
       const Class& klass = Class::Cast(entry);
-      // We filter out function signature classes and dynamic.
+      // We filter out mixin application classes and dynamic.
       // TODO(12478): Should not need to filter out dynamic.
       // Note that the VM does not consider mixin application aliases to be
       // mixin applications.
-      if (!klass.IsCanonicalSignatureClass() &&
-          !klass.IsDynamicClass() &&
-          !klass.IsMixinApplication()) {
+      if (!klass.IsDynamicClass() && !klass.IsMixinApplication()) {
         type = klass.DeclarationType();
         member_mirror = CreateClassMirror(klass,
                                           type,
                                           Bool::True(),  // is_declaration
                                           owner_mirror);
         member_mirrors.Add(member_mirror);
       }
     } else if (entry.IsField()) {
       const Field& field = Field::Cast(entry);
       if (field.is_reflectable()) {
@@ skipping 114 matching lines @@
                                           Array::empty_array()));
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
 
   // Because we currently only use this native for building field extractors and
   // setters, assume the result is a closure and mark its function as invisible,
   // so it will not appear in stack traces. Whenever we support
   // ObjectMirror.evaluate this will need to be separated.
-  ASSERT(Instance::Cast(result).IsClosure());
-  const Function& func =
-      Function::Handle(Closure::function(Instance::Cast(result)));
+  ASSERT(result.IsClosure());
+  const Function& func = Function::Handle(Closure::Cast(result).function());
   func.set_is_visible(false);
   func.set_is_debuggable(false);
 
   return result.raw();
 }
 
 DEFINE_NATIVE_ENTRY(TypedefMirror_declaration, 1) {
-  GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
-  const Class& cls = Class::Handle(type.type_class());
-  // We represent typedefs as non-canonical signature classes.
-  ASSERT(cls.IsSignatureClass() && !cls.IsCanonicalSignatureClass());
+  GET_NON_NULL_NATIVE_ARGUMENT(FunctionType, type, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(type.scope_class());
+  ASSERT(cls.IsTypedefClass());
   return CreateTypedefMirror(cls,
                              AbstractType::Handle(cls.DeclarationType()),
                              Bool::True(),  // is_declaration
                              Object::null_instance());
 }
 
 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.
@@ skipping 113 matching lines @@
   return InvokeDynamicFunction(reflectee,
                                setter,
                                internal_setter_name,
                                args,
                                args_descriptor);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_computeType, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
-  const Type& type = Type::Handle(instance.GetType());
+  const AbstractType& type = AbstractType::Handle(instance.GetType());
   // The static type of null is specified to be the bottom type, however, the
   // runtime type of null is the Null type, which we correctly return here.
   return type.Canonicalize();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClosureMirror_function, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
   ASSERT(!closure.IsNull());
 
   Function& function = Function::Handle();
   bool callable = closure.IsCallable(&function);
   if (callable) {
     if (function.IsImplicitClosureFunction()) {
       // The VM uses separate Functions for tear-offs, but the mirrors consider
       // the tear-offs to be the same as the torn-off methods. Avoid handing out
       // a reference to the tear-off here to avoid a special case in the
       // the equality test.
       function = function.parent_function();
     }
 
     Type& instantiator = Type::Handle();
     if (closure.IsClosure()) {
       const TypeArguments& arguments =
-          TypeArguments::Handle(Closure::GetTypeArguments(closure));
+          TypeArguments::Handle(closure.GetTypeArguments());
       const Class& cls =
           Class::Handle(Isolate::Current()->object_store()->object_class());
       instantiator = Type::New(cls, arguments, Token::kNoSourcePos);
       instantiator.SetIsFinalized();
     }
     return CreateMethodMirror(function,
                               Instance::null_instance(),
                               instantiator);
   }
   return Instance::null();
@@ skipping 208 matching lines @@
   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& redirect_type = Type::Handle(lookup_constructor.RedirectionType());
 
     if (!redirect_type.IsInstantiated()) {
       // The type arguments of the redirection type are instantiated from the
       // type arguments of the type reflected by the class mirror.
       Error& bound_error = Error::Handle();
-      redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
-                                                     &bound_error);
+      redirect_type ^= redirect_type.InstantiateFrom(
+          type_arguments, &bound_error, NULL, Heap::kOld);
       if (!bound_error.IsNull()) {
         Exceptions::PropagateError(bound_error);
         UNREACHABLE();
       }
       redirect_type ^= redirect_type.Canonicalize();
     }
 
     type = redirect_type.raw();
     type_arguments = redirect_type.arguments();
 
@@ skipping 285 matching lines @@
   if (decl.IsFunction()) {
     const Function& func = Function::Cast(decl);
     if (func.IsImplicitConstructor() || func.IsSignatureFunction()) {
       // These are synthetic methods; they have no source.
       return Instance::null();
     }
     script = func.script();
     token_pos = func.token_pos();
   } else if (decl.IsClass()) {
     const Class& cls = Class::Cast(decl);
-    const bool is_typedef = cls.IsSignatureClass() &&
-                            !cls.IsCanonicalSignatureClass();
+    const bool is_typedef = cls.IsTypedefClass();
     if (cls.is_synthesized_class() &&
         !is_typedef &&
         !cls.is_mixin_app_alias() &&
         !cls.is_enum_class()) {
       return Instance::null();  // Synthetic.
     }
     script = cls.script();
     token_pos = cls.token_pos();
   } else if (decl.IsField()) {
     const Field& field = Field::Cast(decl);
@@ skipping 40 matching lines @@
     // information is not available.
     script.GetTokenLocation(token_pos, &from_line, NULL);
   }
   // We should always have at least the line number.
   ASSERT(from_line != 0);
   return CreateSourceLocation(uri, from_line, from_col);
 }
 
 
 DEFINE_NATIVE_ENTRY(TypedefMirror_referent, 1) {
-  GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
-  const Class& cls = Class::Handle(type.type_class());
+  GET_NON_NULL_NATIVE_ARGUMENT(FunctionType, type, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(type.scope_class());
+  ASSERT(cls.IsTypedefClass());
   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);
+  FunctionType& referent_type = FunctionType::Handle(sig_func.SignatureType());
+  // If the scope class of the function type is not generic, replace it with
+  // Closure class (Function::SignatureType() keeps it).
+  ASSERT(cls.raw() == referent_type.scope_class());
+  if (!cls.IsGeneric()) {
+    referent_type = FunctionType::New(
+        Class::Handle(Isolate::Current()->object_store()->closure_class()),
+        TypeArguments::Handle(referent_type.arguments()),
+        sig_func,
+        referent_type.token_pos());
+    referent_type ^= ClassFinalizer::FinalizeType(
+        cls, referent_type, ClassFinalizer::kCanonicalize);
+  }
+  referent_type ^= InstantiateType(referent_type, type);
+  return CreateFunctionTypeMirror(referent_type);
 }
 
 
 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());
   const AbstractType& type = AbstractType::Handle(
       func.ParameterTypeAt(func.NumImplicitParameters() + pos.Value()));
@@ skipping 10 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)).raw();
 }
 
 
 }  // namespace dart