Keep types in signatures of function types properly instantiated as the function

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 4806 matching lines @@
 
 
 bool TypeArguments::IsSubvectorInstantiated(intptr_t from_index,
                                             intptr_t len,
                                             Genericity genericity,
                                             TrailPtr trail) const {
   ASSERT(!IsNull());
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
-    // If the type argument is null, the type parameterized with this type
-    // argument is still being finalized. Skip this null type argument.
+    // If this type argument T is null, the type A containing T in its flattened
+    // type argument vector V is recursive and is still being finalized.
+    // T is the type argument of a super type of A. T is being instantiated
+    // during finalization of V, which is also the instantiator. T depends
+    // solely on the type parameters of A and will be replaced by a non-null
+    // type before A is marked as finalized.
     if (!type.IsNull() && !type.IsInstantiated(genericity, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsUninstantiatedIdentity() const {
   ASSERT(!IsInstantiated());
@@ skipping 239 matching lines @@
   }
   // The zero array should have been initialized.
   ASSERT(Object::zero_array().raw() != Array::null());
   COMPILE_ASSERT(StubCode::kNoInstantiator == 0);
   result.set_instantiations(Object::zero_array());
   return result.raw();
 }
 
 
 RawAbstractType* const* TypeArguments::TypeAddr(intptr_t index) const {
-  // TODO(iposva): Determine if we should throw an exception here.
   ASSERT((index >= 0) && (index < Length()));
   return &raw_ptr()->types()[index];
 }
 
 
 void TypeArguments::SetLength(intptr_t value) const {
   ASSERT(!IsCanonical());
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->length_, Smi::New(value));
@@ skipping 519 matching lines @@
   Type& type = Type::Handle();
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   if (IsSignatureFunction()) {
     type = SignatureData::Cast(obj).signature_type();
   } else {
     ASSERT(IsClosureFunction());
     type = ClosureData::Cast(obj).signature_type();
   }
   if (type.IsNull()) {
-    // A function type is parameterized in the same way as the owner class of
-    // its non-static signature function.
-    // It is not type parameterized if its signature function is static.
-    // During type finalization, the type arguments of the super class of the
-    // owner class of its signature function will be prepended to the type
-    // argument vector. Therefore, we only need to set the type arguments
-    // matching the type parameters here.
-    // In case of a function type alias, the function owner is the alias class,
-    // i.e. the typedef. The signature type is therefore parameterized according
-    // to the alias class declaration, even if the function type is not generic.
-    // Otherwise, if the function is static or if its signature type is
-    // non-generic, i.e. it does not depend on any type parameter of the owner
-    // class, then the signature type is not parameterized, although the owner
-    // class may be. In this case, the scope class of the function type is reset
-    // to _Closure class as well as the owner of the signature function.
+    // The function type of this function is not yet cached and needs to be
+    // constructed and cached here.
+    // A function type is type parameterized in the same way as the owner class
+    // of its non-static signature function.
+    // It is not type parameterized if its signature function is static, or if
+    // none of its result type or formal parameter types are type parameterized.
+    // Unless the function type is a generic typedef, the type arguments of the
+    // function type are not explicitly stored in the function type as a vector
+    // of type arguments.
+    // The type class of a non-typedef function type is always the non-generic
+    // _Closure class, whether the type is generic or not.
+    // The type class of a typedef function type is always the typedef class,
+    // which may be generic, in which case the type stores type arguments.
     // With the introduction of generic functions, we may reach here before the
     // function type parameters have been resolved. Therefore, we cannot yet
     // check whether the function type has an instantiated signature.
-    // We will do it later when resolving the type.
+    // We can do it only when the signature has been resolved.
+    // We only set the type class of the function type to the typedef class
+    // if the signature of the function type is the signature of the typedef.
+    // Note that a function type can have a typedef class as owner without
+    // representing the typedef, as in the following example:
+    // typedef F(f(int x)); where the type of f is a function type with F as
+    // owner, without representing the function type of F.
     Class& scope_class = Class::Handle(Owner());
-    if (!scope_class.IsTypedefClass() &&
-        (is_static() || !scope_class.IsGeneric())) {
+    if (!scope_class.IsTypedefClass() ||
+        (scope_class.signature_function() != raw())) {
       scope_class = Isolate::Current()->object_store()->closure_class();
-      if (IsSignatureFunction()) {
-        set_owner(scope_class);
-        set_token_pos(TokenPosition::kNoSource);
-      }
     }
-    // TODO(regis): With generic functions, this type is not only parameterized
-    // with the type parameters of the scope class, but also with those of all
-    // enclosing generic functions, which may not even have been parsed at this
-    // point. What actually matters is that a signature type can be expressed in
-    // a right-hand side type test by name. This is only possible with a typedef
-    // and the free variables are only the type parameters of the typedef.
     const TypeArguments& signature_type_arguments =
         TypeArguments::Handle(scope_class.type_parameters());
     // Return the still unfinalized signature type.
     type = Type::New(scope_class, signature_type_arguments, token_pos());
     type.set_signature(*this);
     SetSignatureType(type);
   }
   return type.raw();
 }
 
@@ skipping 716 matching lines @@
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
                                            Error* bound_error) const {
   ASSERT(Isolate::Current()->error_on_bad_override());
   ASSERT((bound_error != NULL) && bound_error->IsNull());
   // Check that this function's signature type is a subtype of the other
   // function's signature type.
-  if (!TypeTest(kIsSubtypeOf, Object::null_type_arguments(), other,
-                Object::null_type_arguments(), bound_error, Heap::kOld)) {
+  // Map type parameters in the signature to dynamic before the test.
+  Function& this_fun = Function::Handle(raw());
+  if (!this_fun.HasInstantiatedSignature()) {
+    // TODO(regis): Should we pass the context explicitly here (i.e. null) once
+    // we support generic functions?
+    this_fun = this_fun.InstantiateSignatureFrom(Object::null_type_arguments(),
+                                                 Heap::kOld);
+  }
+  Function& other_fun = Function::Handle(other.raw());
+  if (!other_fun.HasInstantiatedSignature()) {
+    // TODO(regis): Should we pass the context explicitly here (i.e. null) once
+    // we support generic functions?
+    other_fun = other_fun.InstantiateSignatureFrom(
+        Object::null_type_arguments(), Heap::kOld);
+  }
+  if (!this_fun.TypeTest(kIsSubtypeOf, other_fun, bound_error, Heap::kOld)) {
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
     *bound_error = LanguageError::NewFormatted(
         *bound_error,  // A bound error if non null.
         Script::Handle(other.script()), other.token_pos(), Report::AtLocation,
         Report::kError, Heap::kNew,
         "signature type '%s' of function '%s' is not a subtype of signature "
-        "type '%s' of function '%s' where\n%s%s",
+        "type '%s' of function '%s'\n",
         String::Handle(UserVisibleSignature()).ToCString(),
         String::Handle(UserVisibleName()).ToCString(),
         String::Handle(other.UserVisibleSignature()).ToCString(),
-        String::Handle(other.UserVisibleName()).ToCString(),
-        String::Handle(Type::Handle(SignatureType()).EnumerateURIs())
-            .ToCString(),
-        String::Handle(Type::Handle(other.SignatureType()).EnumerateURIs())
-            .ToCString());
+        String::Handle(other.UserVisibleName()).ToCString());
     return false;
   }
   // We should also check that if the other function explicitly specifies a
   // default value for a formal parameter, this function does not specify a
   // different default value for the same parameter. However, this check is not
   // possible in the current implementation, because the default parameter
   // values are not stored in the Function object, but discarded after a
   // function is compiled.
   return true;
 }
 
 
+RawFunction* Function::InstantiateSignatureFrom(
+    const TypeArguments& instantiator_type_arguments,
+    Heap::Space space) const {
+  Zone* zone = Thread::Current()->zone();
+  const Object& owner = Object::Handle(zone, RawOwner());
+  // TODO(regis): Should we change Function::New() to accept a space, since
+  // InstantiateFrom is sometimes called with Heap::kNew?
+  ASSERT(!HasInstantiatedSignature());
+  Function& sig = Function::Handle(
+      zone, Function::NewSignatureFunction(owner, TokenPosition::kNoSource));
+  sig.set_type_parameters(TypeArguments::Handle(zone, type_parameters()));
+  AbstractType& type = AbstractType::Handle(zone, result_type());
+  if (!type.IsInstantiated()) {
+    type = type.InstantiateFrom(instantiator_type_arguments, NULL, NULL, NULL,
+                                space);
+  }
+  sig.set_result_type(type);
+  const intptr_t num_params = NumParameters();
+  sig.set_num_fixed_parameters(num_fixed_parameters());
+  sig.SetNumOptionalParameters(NumOptionalParameters(),
+                               HasOptionalPositionalParameters());
+  sig.set_parameter_types(Array::Handle(Array::New(num_params, space)));
+  for (intptr_t i = 0; i < num_params; i++) {
+    type = ParameterTypeAt(i);
+    if (!type.IsInstantiated()) {
+      type = type.InstantiateFrom(instantiator_type_arguments, NULL, NULL, NULL,
+                                  space);
+    }
+    sig.SetParameterTypeAt(i, type);
+  }
+  sig.set_parameter_names(Array::Handle(zone, parameter_names()));
+  return sig.raw();
+}
+
+
 // If test_kind == kIsSubtypeOf, checks if the type of the specified parameter
 // of this function is a subtype or a supertype of the type of the specified
 // parameter of the other function.
 // If test_kind == kIsMoreSpecificThan, checks if the type of the specified
 // parameter of this function is more specific than the type of the specified
 // parameter of the other function.
 // Note that we do not apply contravariance of parameter types, but covariance
 // of both parameter types and result type.
 bool Function::TestParameterType(TypeTestKind test_kind,
                                  intptr_t parameter_position,
                                  intptr_t other_parameter_position,
-                                 const TypeArguments& type_arguments,
                                  const Function& other,
-                                 const TypeArguments& other_type_arguments,
                                  Error* bound_error,
                                  Heap::Space space) const {
-  AbstractType& other_param_type =
+  const AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(other_parameter_position));
-  if (!other_param_type.IsInstantiated()) {
-    other_param_type =
-        other_param_type.InstantiateFrom(other_type_arguments, bound_error,
-                                         NULL,  // instantiation_trail
-                                         NULL,  // bound_trail
-                                         space);
-    ASSERT((bound_error == NULL) || bound_error->IsNull());
-  }
   if (other_param_type.IsDynamicType()) {
     return true;
   }
-  AbstractType& param_type =
+  const AbstractType& param_type =
       AbstractType::Handle(ParameterTypeAt(parameter_position));
-  if (!param_type.IsInstantiated()) {
-    param_type = param_type.InstantiateFrom(type_arguments, bound_error,
-                                            NULL,  // instantiation_trail
-                                            NULL,  // bound_trail
-                                            space);
-    ASSERT((bound_error == NULL) || bound_error->IsNull());
-  }
   if (param_type.IsDynamicType()) {
     return test_kind == kIsSubtypeOf;
   }
   if (test_kind == kIsSubtypeOf) {
     if (!param_type.IsSubtypeOf(other_param_type, bound_error, NULL, space) &&
         !other_param_type.IsSubtypeOf(param_type, bound_error, NULL, space)) {
       return false;
     }
   } else {
     ASSERT(test_kind == kIsMoreSpecificThan);
     if (!param_type.IsMoreSpecificThan(other_param_type, bound_error, NULL,
                                        space)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::TypeTest(TypeTestKind test_kind,
-                        const TypeArguments& type_arguments,
                         const Function& other,
-                        const TypeArguments& other_type_arguments,
                         Error* bound_error,
                         Heap::Space space) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_pos_params =
       other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
       other.NumOptionalNamedParameters();
   // This function requires the same arguments or less and accepts the same
   // arguments or more. We can ignore implicit parameters.
   const intptr_t num_ignored_params = NumImplicitParameters();
   const intptr_t other_num_ignored_params = other.NumImplicitParameters();
   if (((num_fixed_params - num_ignored_params) >
        (other_num_fixed_params - other_num_ignored_params)) ||
       ((num_fixed_params - num_ignored_params + num_opt_pos_params) <
        (other_num_fixed_params - other_num_ignored_params +
         other_num_opt_pos_params)) ||
       (num_opt_named_params < other_num_opt_named_params)) {
     return false;
   }
   // Check the result type.
-  AbstractType& other_res_type = AbstractType::Handle(other.result_type());
-  if (!other_res_type.IsInstantiated()) {
-    other_res_type = other_res_type.InstantiateFrom(
-        other_type_arguments, bound_error, NULL, NULL, space);
-    ASSERT((bound_error == NULL) || bound_error->IsNull());
-  }
+  const AbstractType& other_res_type =
+      AbstractType::Handle(other.result_type());
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
-    AbstractType& res_type = AbstractType::Handle(result_type());
-    if (!res_type.IsInstantiated()) {
-      res_type = res_type.InstantiateFrom(type_arguments, bound_error, NULL,
-                                          NULL, space);
-      ASSERT((bound_error == NULL) || bound_error->IsNull());
-    }
+    const AbstractType& res_type = AbstractType::Handle(result_type());
     if (res_type.IsVoidType()) {
       return false;
     }
     if (test_kind == kIsSubtypeOf) {
       if (!res_type.IsSubtypeOf(other_res_type, bound_error, NULL, space) &&
           !other_res_type.IsSubtypeOf(res_type, bound_error, NULL, space)) {
         return false;
       }
     } else {
       ASSERT(test_kind == kIsMoreSpecificThan);
       if (!res_type.IsMoreSpecificThan(other_res_type, bound_error, NULL,
                                        space)) {
         return false;
       }
     }
   }
   // Check the types of fixed and optional positional parameters.
   for (intptr_t i = 0; i < (other_num_fixed_params - other_num_ignored_params +
                             other_num_opt_pos_params);
        i++) {
     if (!TestParameterType(test_kind, i + num_ignored_params,
-                           i + other_num_ignored_params, type_arguments, other,
-                           other_type_arguments, bound_error, space)) {
+                           i + other_num_ignored_params, other, bound_error,
+                           space)) {
       return false;
     }
   }
   // Check the names and types of optional named parameters.
   if (other_num_opt_named_params == 0) {
     return true;
   }
   // Check that for each optional named parameter of type T of the other
   // function type, there exists an optional named parameter of this function
   // type with an identical name and with a type S that is a either a subtype
   // or supertype of T (if test_kind == kIsSubtypeOf) or that is more specific
   // than T (if test_kind == kIsMoreSpecificThan).
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
   const int num_params = num_fixed_params + num_opt_named_params;
   const int other_num_params =
       other_num_fixed_params + other_num_opt_named_params;
   bool found_param_name;
   String& other_param_name = String::Handle();
   for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     ASSERT(other_param_name.IsSymbol());
     found_param_name = false;
     for (intptr_t j = num_fixed_params; j < num_params; j++) {
       ASSERT(String::Handle(ParameterNameAt(j)).IsSymbol());
       if (ParameterNameAt(j) == other_param_name.raw()) {
         found_param_name = true;
-        if (!TestParameterType(test_kind, j, i, type_arguments, other,
-                               other_type_arguments, bound_error, space)) {
+        if (!TestParameterType(test_kind, j, i, other, bound_error, space)) {
           return false;
         }
         break;
       }
     }
     if (!found_param_name) {
       return false;
     }
   }
   return true;
@@ skipping 48 matching lines @@
 
 RawFunction* Function::New(const String& name,
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
                            bool is_abstract,
                            bool is_external,
                            bool is_native,
                            const Object& owner,
                            TokenPosition token_pos) {
-  ASSERT(!owner.IsNull());
+  ASSERT(!owner.IsNull() || (kind == RawFunction::kSignatureFunction));
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Object::empty_array());
   result.set_parameter_names(Object::empty_array());
   result.set_name(name);
   result.set_kind(kind);
   result.set_recognized_kind(MethodRecognizer::kUnknown);
   result.set_modifier(RawFunction::kNoModifier);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_is_abstract(is_abstract);
@@ skipping 43 matching lines @@
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, origin));
   clone.set_owner(clone_owner);
   clone.ClearICDataArray();
   clone.ClearCode();
   clone.set_usage_counter(0);
   clone.set_deoptimization_counter(0);
   clone.set_optimized_instruction_count(0);
   clone.set_optimized_call_site_count(0);
   clone.set_kernel_function(kernel_function());
+  // TODO(regis): Clone function type parameters (their bounds may change).
   if (new_owner.NumTypeParameters() > 0) {
     // Adjust uninstantiated types to refer to type parameters of the new owner.
     AbstractType& type = AbstractType::Handle(clone.result_type());
     type ^= type.CloneUninstantiated(new_owner);
     clone.set_result_type(type);
     const intptr_t num_params = clone.NumParameters();
     Array& array = Array::Handle(clone.parameter_types());
     array ^= Object::Clone(array, Heap::kOld);
     clone.set_parameter_types(array);
     for (intptr_t i = 0; i < num_params; i++) {
@@ skipping 18 matching lines @@
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false, parent_owner, token_pos));
   result.set_parent_function(parent);
   return result.raw();
 }
 
 
-RawFunction* Function::NewSignatureFunction(const Class& owner,
+RawFunction* Function::NewSignatureFunction(const Object& owner,
                                             TokenPosition token_pos) {
   const Function& result = Function::Handle(Function::New(
       Symbols::AnonymousSignature(), RawFunction::kSignatureFunction,
       /* is_static = */ false,
       /* is_const = */ false,
       /* is_abstract = */ false,
       /* is_external = */ false,
       /* is_native = */ false,
       owner,  // Same as function type scope class.
       token_pos));
@@ skipping 103 matching lines @@
   }
 }
 
 
 RawString* Function::UserVisibleFormalParameters() const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   // Typically 3, 5,.. elements in 'pieces', e.g.:
   // '_LoadRequest', CommaSpace, '_LoadError'.
   GrowableHandlePtrArray<const String> pieces(zone, 5);
-  const TypeArguments& instantiator = TypeArguments::Handle(zone);
-  BuildSignatureParameters(thread, zone, false, kUserVisibleName, instantiator,
-                           &pieces);
+  BuildSignatureParameters(thread, zone, kUserVisibleName, &pieces);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 void Function::BuildSignatureParameters(
     Thread* thread,
     Zone* zone,
-    bool instantiate,
     NameVisibility name_visibility,
-    const TypeArguments& instantiator,
     GrowableHandlePtrArray<const String>* pieces) const {
   AbstractType& param_type = AbstractType::Handle(zone);
   const intptr_t num_params = NumParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   intptr_t i = 0;
   if (name_visibility == kUserVisibleName) {
     // Hide implicit parameters.
     i = NumImplicitParameters();
   }
   String& name = String::Handle(zone);
   while (i < num_fixed_params) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
-    if (instantiate && param_type.IsFinalized() &&
-        !param_type.IsInstantiated()) {
-      param_type = param_type.InstantiateFrom(instantiator, NULL, NULL, NULL,
-                                              Heap::kNew);
-    }
     name = param_type.BuildName(name_visibility);
     pieces->Add(name);
     if (i != (num_params - 1)) {
       pieces->Add(Symbols::CommaSpace());
     }
     i++;
   }
   if (num_opt_params > 0) {
     if (num_opt_pos_params > 0) {
       pieces->Add(Symbols::LBracket());
     } else {
       pieces->Add(Symbols::LBrace());
     }
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       param_type = ParameterTypeAt(i);
-      if (instantiate && param_type.IsFinalized() &&
-          !param_type.IsInstantiated()) {
-        param_type = param_type.InstantiateFrom(instantiator, NULL, NULL, NULL,
-                                                Heap::kNew);
-      }
       ASSERT(!param_type.IsNull());
       name = param_type.BuildName(name_visibility);
       pieces->Add(name);
       // The parameter name of an optional positional parameter does not need
       // to be part of the signature, since it is not used.
       if (num_opt_named_params > 0) {
         name = ParameterNameAt(i);
         pieces->Add(Symbols::Blank());
         pieces->Add(name);
       }
@@ skipping 19 matching lines @@
         zone, Closure::New(instantiator, *this, context, Heap::kOld));
     set_implicit_static_closure(closure);
   }
   return implicit_static_closure();
 }
 
 
 RawInstance* Function::ImplicitInstanceClosure(const Instance& receiver) const {
   ASSERT(IsImplicitClosureFunction());
   Zone* zone = Thread::Current()->zone();
-  const Type& signature_type = Type::Handle(zone, SignatureType());
-  const Class& cls = Class::Handle(zone, signature_type.type_class());
   const Context& context = Context::Handle(zone, Context::New(1));
   context.SetAt(0, receiver);
   TypeArguments& instantiator = TypeArguments::Handle(zone);
-  if (cls.IsGeneric()) {
+  if (!HasInstantiatedSignature(kClass)) {
     instantiator = receiver.GetTypeArguments();
   }
   return Closure::New(instantiator, *this, context);
 }
 
 
 RawSmi* Function::GetClosureHashCode() const {
   ASSERT(IsClosureFunction());
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   if (ClosureData::Cast(obj).hash() != Object::null()) {
     return Smi::RawCast(ClosureData::Cast(obj).hash());
   }
   // Hash not yet computed. Compute and cache it.
   const Class& cls = Class::Handle(Owner());
   intptr_t result = String::Handle(name()).Hash();
   result += String::Handle(Signature()).Hash();
   result += String::Handle(cls.Name()).Hash();
   // Finalize hash value like for strings so that it fits into a smi.
   result += result << 3;
   result ^= result >> 11;
   result += result << 15;
   result &= ((static_cast<intptr_t>(1) << String::kHashBits) - 1);
   ClosureData::Cast(obj).set_hash(result);
   return Smi::New(result);
 }
 
 
-RawString* Function::BuildSignature(bool instantiate,
-                                    NameVisibility name_visibility,
-                                    const TypeArguments& instantiator) const {
+RawString* Function::BuildSignature(NameVisibility name_visibility) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, 4);
-  String& name = String::Handle(zone);
-  if (!instantiate && !is_static() && (name_visibility == kInternalName)) {
-    // Prefix the signature with its scope class and type parameters, if any
-    // (e.g. "Map<K, V>(K) => bool"). In case of a function type alias, the
-    // scope class name is the alias name.
-    // The signature of static functions cannot be type parameterized.
-    const Class& scope_class = Class::Handle(zone, Owner());
-    ASSERT(!scope_class.IsNull());
-    if (scope_class.IsGeneric()) {
-      const TypeArguments& type_parameters =
-          TypeArguments::Handle(zone, scope_class.type_parameters());
-      const String& scope_class_name = String::Handle(zone, scope_class.Name());
-      pieces.Add(scope_class_name);
-      const intptr_t num_type_parameters = type_parameters.Length();
-      pieces.Add(Symbols::LAngleBracket());
-      TypeParameter& type_parameter = TypeParameter::Handle(zone);
-      AbstractType& bound = AbstractType::Handle(zone);
-      for (intptr_t i = 0; i < num_type_parameters; i++) {
-        type_parameter ^= type_parameters.TypeAt(i);
-        name = type_parameter.name();
-        pieces.Add(name);
-        bound = type_parameter.bound();
-        if (!bound.IsNull() && !bound.IsObjectType()) {
-          pieces.Add(Symbols::SpaceExtendsSpace());
-          name = bound.BuildName(name_visibility);
-          pieces.Add(name);
-        }
-        if (i < num_type_parameters - 1) {
-          pieces.Add(Symbols::CommaSpace());
-        }
-      }
-      pieces.Add(Symbols::RAngleBracket());
-    }
-  }
   pieces.Add(Symbols::LParen());
-  BuildSignatureParameters(thread, zone, instantiate, name_visibility,
-                           instantiator, &pieces);
+  BuildSignatureParameters(thread, zone, name_visibility, &pieces);
   pieces.Add(Symbols::RParenArrow());
-  AbstractType& res_type = AbstractType::Handle(zone, result_type());
-  if (instantiate && res_type.IsFinalized() && !res_type.IsInstantiated()) {
-    res_type =
-        res_type.InstantiateFrom(instantiator, NULL, NULL, NULL, Heap::kNew);
-  }
-  name = res_type.BuildName(name_visibility);
+  const AbstractType& res_type = AbstractType::Handle(zone, result_type());
+  const String& name =
+      String::Handle(zone, res_type.BuildName(name_visibility));
   pieces.Add(name);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
-bool Function::HasInstantiatedSignature() const {
+bool Function::HasInstantiatedSignature(Genericity genericity,
+                                        TrailPtr trail) const {
   AbstractType& type = AbstractType::Handle(result_type());
-  if (!type.IsInstantiated()) {
+  if (!type.IsInstantiated(genericity, trail)) {
     return false;
   }
   const intptr_t num_parameters = NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = ParameterTypeAt(i);
-    if (!type.IsInstantiated()) {
+    if (!type.IsInstantiated(genericity, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawClass* Function::Owner() const {
   if (raw_ptr()->owner_ == Object::null()) {
     ASSERT(IsSignatureFunction());
@@ skipping 8589 matching lines @@
 
 RawAbstractType* Instance::GetType(Heap::Space space) const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   if (cls.IsClosureClass()) {
     const Function& signature =
         Function::Handle(Closure::Cast(*this).function());
     Type& type = Type::Handle(signature.SignatureType());
-    if (type.type_class() == cls.raw()) {
-      // Type is not parameterized.
-      if (!type.IsCanonical()) {
-        type ^= type.Canonicalize();
-        signature.SetSignatureType(type);
-      }
-      return type.raw();
+    if (!type.IsInstantiated()) {
+      TypeArguments& instantiator_type_arguments =
+          TypeArguments::Handle(Closure::Cast(*this).instantiator());
+      // TODO(regis): Should we pass the context explicitly here (i.e. null)
+      // once we support generic functions?
+      type ^= type.InstantiateFrom(instantiator_type_arguments, NULL, NULL,
+                                   NULL, space);
     }
-    const Class& scope_cls = Class::Handle(type.type_class());
-    ASSERT(scope_cls.NumTypeArguments() > 0);
-    TypeArguments& type_arguments =
-        TypeArguments::Handle(Closure::Cast(*this).instantiator());
-    type =
-        Type::New(scope_cls, type_arguments, TokenPosition::kNoSource, space);
-    type.set_signature(signature);
-    type.SetIsFinalized();
     type ^= type.Canonicalize();
     return type.raw();
   }
   Type& type = Type::Handle();
   if (!cls.IsGeneric()) {
     type = cls.CanonicalType();
   }
   if (type.IsNull()) {
     TypeArguments& type_arguments = TypeArguments::Handle();
     if (cls.NumTypeArguments() > 0) {
@@ skipping 37 matching lines @@
   if (other.IsVoidType()) {
     return false;
   }
   Zone* zone = Thread::Current()->zone();
   const Class& cls = Class::Handle(zone, clazz());
   if (cls.IsClosureClass()) {
     if (other.IsObjectType() || other.IsDartFunctionType() ||
         other.IsDartClosureType()) {
       return true;
     }
-    Function& other_signature = Function::Handle(zone);
-    TypeArguments& other_type_arguments = TypeArguments::Handle(zone);
+    AbstractType& instantiated_other = AbstractType::Handle(zone, other.raw());
     // Note that we may encounter a bound error in checked mode.
     if (!other.IsInstantiated()) {
-      AbstractType& instantiated_other = AbstractType::Handle(
-          zone, other.InstantiateFrom(other_instantiator, bound_error, NULL,
-                                      NULL, Heap::kOld));
+      instantiated_other = other.InstantiateFrom(
+          other_instantiator, bound_error, NULL, NULL, Heap::kOld);
       if ((bound_error != NULL) && !bound_error->IsNull()) {
         ASSERT(Isolate::Current()->type_checks());
         return false;
       }
       if (instantiated_other.IsTypeRef()) {
         instantiated_other = TypeRef::Cast(instantiated_other).type();
       }
       if (instantiated_other.IsDynamicType() ||
           instantiated_other.IsObjectType() ||
           instantiated_other.IsDartFunctionType()) {
         return true;
       }
-      if (!instantiated_other.IsFunctionType()) {
-        return false;
-      }
-      other_signature = Type::Cast(instantiated_other).signature();
-      other_type_arguments = instantiated_other.arguments();
-    } else {
-      if (!other.IsFunctionType()) {
-        return false;
-      }
-      other_signature = Type::Cast(other).signature();
-      other_type_arguments = other.arguments();
     }
-    const Function& signature =
-        Function::Handle(zone, Closure::Cast(*this).function());
-    const TypeArguments& type_arguments =
-        TypeArguments::Handle(zone, Closure::Cast(*this).instantiator());
-    // TODO(regis): If signature function is generic, pass its type parameters
-    // as function instantiator, otherwise pass null.
-    // Pass the closure context as well to the the IsSubtypeOf call.
-    return signature.IsSubtypeOf(type_arguments, other_signature,
-                                 other_type_arguments, bound_error, Heap::kOld);
+    if (!instantiated_other.IsFunctionType()) {
+      return false;
+    }
+    Function& other_signature =
+        Function::Handle(zone, Type::Cast(instantiated_other).signature());
+    Function& sig_fun = Function::Handle(zone, Closure::Cast(*this).function());
+    if (!sig_fun.HasInstantiatedSignature()) {
+      const TypeArguments& instantiator_type_arguments =
+          TypeArguments::Handle(zone, Closure::Cast(*this).instantiator());
+      // TODO(regis): If sig_fun is generic, pass its type parameters
+      // as function instantiator, otherwise pass null.
+      // Pass the closure context as well to InstantiateSignatureFrom().
+      // No bound error possible, since the instance exists.
+      sig_fun = sig_fun.InstantiateSignatureFrom(instantiator_type_arguments,
+                                                 Heap::kOld);
+    }
+    return sig_fun.IsSubtypeOf(other_signature, bound_error, Heap::kOld);
   }
   TypeArguments& type_arguments = TypeArguments::Handle(zone);
   if (cls.NumTypeArguments() > 0) {
     type_arguments = GetTypeArguments();
     ASSERT(type_arguments.IsNull() || type_arguments.IsCanonical());
     // The number of type arguments in the instance must be greater or equal to
     // the number of type arguments expected by the instance class.
     // A discrepancy is allowed for closures, which borrow the type argument
     // vector of their instantiator, which may be of a subclass of the class
     // defining the closure. Truncating the vector to the correct length on
@@ skipping 18 matching lines @@
       instantiated_other = TypeRef::Cast(instantiated_other).type();
     }
     if (instantiated_other.IsDynamicType()) {
       return true;
     }
   }
   other_type_arguments = instantiated_other.arguments();
   const bool other_is_dart_function = instantiated_other.IsDartFunctionType();
   if (other_is_dart_function || instantiated_other.IsFunctionType()) {
     // Check if this instance understands a call() method of a compatible type.
-    const Function& call_function =
+    Function& sig_fun =
         Function::Handle(zone, cls.LookupCallFunctionForTypeTest());
-    if (!call_function.IsNull()) {
+    if (!sig_fun.IsNull()) {
       if (other_is_dart_function) {
         return true;
       }
+      if (!sig_fun.HasInstantiatedSignature()) {
+        // TODO(regis): If sig_fun is generic, pass its type parameters
+        // as function instantiator, otherwise pass null.
+        // Pass the closure context as well to InstantiateSignatureFrom().
+        // No bound error possible, since the instance exists.
+        sig_fun = sig_fun.InstantiateSignatureFrom(type_arguments, Heap::kOld);
+      }
       const Function& other_signature =
           Function::Handle(zone, Type::Cast(instantiated_other).signature());
-      if (call_function.IsSubtypeOf(type_arguments, other_signature,
-                                    other_type_arguments, bound_error,
-                                    Heap::kOld)) {
+      if (sig_fun.IsSubtypeOf(other_signature, bound_error, Heap::kOld)) {
         return true;
       }
     }
   }
   if (!instantiated_other.IsType()) {
     return false;
   }
   other_class = instantiated_other.type_class();
   if (IsNull()) {
     ASSERT(cls.IsNullClass());
@@ skipping 488 matching lines @@
   const TypeArguments& args = TypeArguments::Handle(zone, arguments());
   const intptr_t num_args = args.IsNull() ? 0 : args.Length();
   String& class_name = String::Handle(zone);
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   Class& cls = Class::Handle(zone);
   if (IsFunctionType()) {
     cls = type_class();
     const Function& signature_function =
         Function::Handle(zone, Type::Cast(*this).signature());
-    if (!cls.IsTypedefClass() ||
-        (cls.signature_function() != signature_function.raw())) {
-      if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
-        return signature_function.UserVisibleSignature();
-      }
-      return signature_function.InstantiatedSignatureFrom(args,
-                                                          name_visibility);
+    if (!cls.IsTypedefClass()) {
+      return signature_function.UserVisibleSignature();
     }
+    // Instead of printing the actual signature, use the typedef name with
+    // its type arguments, if any.
     class_name = cls.Name();  // Typedef name.
     // We may be reporting an error about a malformed function type. In that
     // case, avoid instantiating the signature, since it may cause divergence.
     if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
       return class_name.raw();
     }
     // Print the name of a typedef as a regular, possibly parameterized, class.
   } else if (HasResolvedTypeClass()) {
     cls = type_class();
   }
@@ skipping 266 matching lines @@
   if (other_is_dart_function_type || other.IsFunctionType()) {
     if (IsFunctionType()) {
       if (other_is_dart_function_type) {
         return true;
       }
       const Function& other_fun =
           Function::Handle(zone, Type::Cast(other).signature());
       // Check for two function types.
       const Function& fun =
           Function::Handle(zone, Type::Cast(*this).signature());
-      return fun.TypeTest(
-          test_kind, TypeArguments::Handle(zone, arguments()), other_fun,
-          TypeArguments::Handle(zone, other.arguments()), bound_error, space);
+      return fun.TypeTest(test_kind, other_fun, bound_error, space);
     }
     // Check if type S has a call() method of function type T.
     const Function& call_function =
         Function::Handle(zone, type_cls.LookupCallFunctionForTypeTest());
     if (!call_function.IsNull()) {
       if (other_is_dart_function_type ||
           call_function.TypeTest(
-              test_kind, TypeArguments::Handle(zone, arguments()),
-              Function::Handle(zone, Type::Cast(other).signature()),
-              TypeArguments::Handle(zone, other.arguments()), bound_error,
-              space)) {
+              test_kind, Function::Handle(zone, Type::Cast(other).signature()),
+              bound_error, space)) {
         return true;
       }
     }
   }
   if (IsFunctionType()) {
     return false;
   }
   return type_cls.TypeTest(test_kind, TypeArguments::Handle(zone, arguments()),
                            Class::Handle(zone, other.type_class()),
                            TypeArguments::Handle(zone, other.arguments()),
@@ skipping 255 matching lines @@
 
 
 bool Type::IsInstantiated(Genericity genericity, TrailPtr trail) const {
   if (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) {
     return true;
   }
   if ((genericity == kAny) &&
       (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated)) {
     return false;
   }
+  if (IsFunctionType()) {
+    const Function& sig_fun = Function::Handle(signature());
+    if (!sig_fun.HasInstantiatedSignature(genericity, trail)) {
+      return false;
+    }
+    // Because a generic typedef with an instantiated signature is considered
+    // uninstantiated, we still need to check the type arguments, even if the
+    // signature is instantiated.
+  }
   if (arguments() == TypeArguments::null()) {
     return true;
   }
   const TypeArguments& args = TypeArguments::Handle(arguments());
   intptr_t num_type_args = args.Length();
   intptr_t len = num_type_args;  // Check the full vector of type args.
   ASSERT(num_type_args > 0);
   // This type is not instantiated if it refers to type parameters.
   // Although this type may still be unresolved, the type parameters it may
   // refer to are resolved by definition. We can therefore return the correct
@@ skipping 20 matching lines @@
   ASSERT(!IsInstantiated());
   // Return the uninstantiated type unchanged if malformed. No copy needed.
   if (IsMalformed()) {
     return raw();
   }
   // Note that the type class has to be resolved at this time, but not
   // necessarily finalized yet. We may be checking bounds at compile time or
   // finalizing the type argument vector of a recursive type.
   const Class& cls = Class::Handle(zone, type_class());
   TypeArguments& type_arguments = TypeArguments::Handle(zone, arguments());
-  ASSERT(type_arguments.Length() == cls.NumTypeArguments());
-  type_arguments =
-      type_arguments.InstantiateFrom(instantiator_type_arguments, bound_error,
-                                     instantiation_trail, bound_trail, space);
+  Function& sig_fun = Function::Handle(zone, signature());
+  if (!type_arguments.IsNull() &&
+      (sig_fun.IsNull() || !type_arguments.IsInstantiated())) {
+    // This type is uninstantiated because either its type arguments or its
+    // signature, or both are uninstantiated.
+    // Note that the type arguments of a function type merely document the
+    // parameterization of a generic typedef. They are otherwise ignored.
+    ASSERT(type_arguments.Length() == cls.NumTypeArguments());
+    type_arguments =
+        type_arguments.InstantiateFrom(instantiator_type_arguments, bound_error,
+                                       instantiation_trail, bound_trail, space);
+  }
   // This uninstantiated type is not modified, as it can be instantiated
   // with different instantiators. Allocate a new instantiated version of it.
   const Type& instantiated_type =
       Type::Handle(zone, Type::New(cls, type_arguments, token_pos(), space));
   // Preserve the bound error if any.
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     instantiated_type.set_error(bound_error);
   }
-  // Preserve the signature if this type represents a function type.
-  // Note that the types in the signature remain unchanged. They get indirectly
-  // instantiated by instantiating the type arguments above.
-  const Function& sig_fun = Function::Handle(zone, signature());
+  // If this type is a function type, instantiate its signature.
   if (!sig_fun.IsNull()) {
+    // If we are finalizing a typedef, do not yet instantiate its signature.
+    // Other function types should never be instantiated while unfinalized.
+    if (IsFinalized()) {
+      // A generic typedef may actually declare an instantiated signature.
+      if (!sig_fun.HasInstantiatedSignature()) {
+        sig_fun = sig_fun.InstantiateSignatureFrom(instantiator_type_arguments,
+                                                   space);
+      }
+    } else {
+      ASSERT(cls.IsTypedefClass());
+    }
     instantiated_type.set_signature(sig_fun);
   }
   if (IsFinalized()) {
     instantiated_type.SetIsFinalized();
   } else {
     instantiated_type.SetIsResolved();
     if (IsBeingFinalized()) {
       instantiated_type.SetIsBeingFinalized();
     }
   }
@@ skipping 231 matching lines @@
   if (!clone.IsNull()) {
     return clone.raw();
   }
   const Class& type_cls = Class::Handle(zone, type_class());
   clone = Type::New(type_cls, TypeArguments::Handle(zone), token_pos());
   // Preserve the bound error if any.
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     clone.set_error(bound_error);
   }
-  TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
-  bool type_args_cloned = false;
   // Clone the signature if this type represents a function type.
   const Function& fun = Function::Handle(zone, signature());
   if (!fun.IsNull()) {
+    ASSERT(type_cls.IsTypedefClass() || type_cls.IsClosureClass());
     // If the scope class is not a typedef and if it is generic, it must be the
     // mixin class, set it to the new owner.
-    if (!type_cls.IsTypedefClass() && type_cls.IsGeneric()) {
-      clone.set_type_class(new_owner);
-      AbstractType& decl_type = AbstractType::Handle(zone);
-#ifdef DEBUG
-      decl_type = type_cls.DeclarationType();
-      ASSERT(decl_type.IsFinalized());
-      const TypeArguments& decl_type_args =
-          TypeArguments::Handle(zone, decl_type.arguments());
-      ASSERT(type_args.Equals(decl_type_args));
-#endif  // DEBUG
-      decl_type = new_owner.DeclarationType();
-      ASSERT(decl_type.IsFinalized());
-      type_args = decl_type.arguments();
-      clone.set_arguments(type_args);
-      type_args_cloned = true;
-    }
     Function& fun_clone = Function::Handle(
         zone,
         Function::NewSignatureFunction(new_owner, TokenPosition::kNoSource));
     AbstractType& type = AbstractType::Handle(zone, fun.result_type());
     type = type.CloneUninstantiated(new_owner, trail);
     fun_clone.set_result_type(type);
     const intptr_t num_params = fun.NumParameters();
     fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
     fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                        fun.HasOptionalPositionalParameters());
     fun_clone.set_parameter_types(
         Array::Handle(Array::New(num_params, Heap::kOld)));
     for (intptr_t i = 0; i < num_params; i++) {
       type = fun.ParameterTypeAt(i);
       type = type.CloneUninstantiated(new_owner, trail);
       fun_clone.SetParameterTypeAt(i, type);
     }
     fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
     clone.set_signature(fun_clone);
   }
-  if (!type_args_cloned) {
+  TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
+  if (!type_args.IsNull()) {
     // Upper bounds of uninstantiated type arguments may form a cycle.
     if (type_args.IsRecursive() || !type_args.IsInstantiated()) {
       AddOnlyBuddyToTrail(&trail, clone);
     }
     type_args = type_args.CloneUninstantiated(new_owner, trail);
     clone.set_arguments(type_args);
   }
   clone.SetIsFinalized();
   clone ^= clone.Canonicalize();
   return clone.raw();
@@ skipping 307 matching lines @@
   Class& cls = Class::Handle(zone);
   const char* class_name;
   if (HasResolvedTypeClass()) {
     cls = type_class();
     class_name = String::Handle(zone, cls.Name()).ToCString();
   } else {
     class_name = UnresolvedClass::Handle(zone, unresolved_class()).ToCString();
   }
   if (IsFunctionType()) {
     const Function& sig_fun = Function::Handle(zone, signature());
-    const String& sig =
-        IsFinalized() ? String::Handle(zone, sig_fun.InstantiatedSignatureFrom(
-                                                 type_args, kInternalName))
-                      : String::Handle(zone, sig_fun.Signature());
+    const String& sig = String::Handle(zone, sig_fun.Signature());
     if (cls.IsClosureClass()) {
       ASSERT(type_args.IsNull());
       return OS::SCreate(zone, "%sFunction Type: %s", unresolved,
                          sig.ToCString());
     }
     return OS::SCreate(zone, "%s Function Type: %s (class: %s, args: %s)",
                        unresolved, sig.ToCString(), class_name, args_cstr);
   }
   if (type_args.IsNull()) {
     return OS::SCreate(zone, "%sType: class '%s'", unresolved, class_name);
@@ skipping 644 matching lines @@
       if (!instantiated_bounded_type.IsFinalized() ||
           !instantiated_upper_bound.IsFinalized() ||
           (!type_param.CheckBound(instantiated_bounded_type,
                                   instantiated_upper_bound, bound_error,
                                   bound_trail, space) &&
            bound_error->IsNull())) {
         // We cannot determine yet whether the bounded_type is below the
         // upper_bound, because one or both of them is still being finalized or
         // uninstantiated. For example, instantiated_bounded_type may be the
         // still unfinalized cloned type parameter of a mixin application class.
+        // There is another special case where we do not want to report a bound
+        // error yet: if the upper bound is a function type, but the bounded
+        // type is not and its class is not compiled yet, i.e. we cannot look
+        // for a call method yet.
         ASSERT(instantiated_bounded_type.IsBeingFinalized() ||
                instantiated_upper_bound.IsBeingFinalized() ||
                !instantiated_bounded_type.IsInstantiated() ||
-               !instantiated_upper_bound.IsInstantiated());
+               !instantiated_upper_bound.IsInstantiated() ||
+               (!instantiated_bounded_type.IsFunctionType() &&
+                instantiated_upper_bound.IsFunctionType() &&
+                instantiated_bounded_type.HasResolvedTypeClass() &&
+                !Class::Handle(instantiated_bounded_type.type_class())
+                     .is_finalized()));
         // Postpone bound check by returning a new BoundedType with unfinalized
         // or partially instantiated bounded_type and upper_bound, but keeping
         // type_param.
         instantiated_bounded_type = BoundedType::New(
             instantiated_bounded_type, instantiated_upper_bound, type_param);
       }
     }
   }
   return instantiated_bounded_type.raw();
 }
@@ skipping 4844 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart