[VM generic function types] Properly set the scope function after parsing a

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 4565 matching lines @@
     // argument is still being finalized and is definitely recursive. The null
     // type argument will be replaced by a non-null type before the type is
     // marked as finalized.
     if (type.IsNull() || type.IsRecursive()) {
       return true;
     }
   }
   return false;
 }
 
+void TypeArguments::SetScopeFunction(const Function& function) const {
+  if (IsNull()) return;
+  const intptr_t num_types = Length();
+  AbstractType& type = AbstractType::Handle();
+  for (intptr_t i = 0; i < num_types; i++) {
+    type = TypeAt(i);
+    if (!type.IsNull()) {
+      type.SetScopeFunction(function);
+    }
+  }
+}
+
 bool TypeArguments::IsDynamicTypes(bool raw_instantiated,
                                    intptr_t from_index,
                                    intptr_t len) const {
   ASSERT(Length() >= (from_index + len));
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     if (type.IsNull()) {
       return false;
@@ skipping 876 matching lines @@
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   if (IsSignatureFunction()) {
     return SignatureData::Cast(obj).signature_type();
   } else {
     ASSERT(IsClosureFunction());
     return ClosureData::Cast(obj).signature_type();
   }
 }
 
-RawFunction* Function::CanonicalSignatureFunction(TrailPtr trail) const {
-  ASSERT(!IsSignatureFunction());
-  Zone* zone = Thread::Current()->zone();
-  Function& parent = Function::Handle(zone, parent_function());
-  if (!parent.IsNull() && !parent.IsSignatureFunction()) {
-    // Make sure the parent function is also a signature function.
-    parent = parent.CanonicalSignatureFunction(trail);
-  }
-  const Class& owner = Class::Handle(zone, Owner());
-  const Function& sig_fun = Function::Handle(
-      zone,
-      Function::NewSignatureFunction(owner, parent, TokenPosition::kNoSource));
-  // In case of a generic function, the function type parameters in the
-  // signature will still refer to the original function. This should not
-  // be a problem, since once finalized the indices will be identical.
-  sig_fun.set_type_parameters(TypeArguments::Handle(zone, type_parameters()));
-  ASSERT(HasGenericParent() == sig_fun.HasGenericParent());
-  ASSERT(IsGeneric() == sig_fun.IsGeneric());
-  AbstractType& type = AbstractType::Handle(zone);
-  type = result_type();
-  type = type.Canonicalize(trail);
-  sig_fun.set_result_type(type);
-  const intptr_t num_params = NumParameters();
-  sig_fun.set_num_fixed_parameters(num_fixed_parameters());
-  sig_fun.SetNumOptionalParameters(NumOptionalParameters(),
-                                   HasOptionalPositionalParameters());
-  sig_fun.set_parameter_types(
-      Array::Handle(Array::New(num_params, Heap::kOld)));
-  for (intptr_t i = 0; i < num_params; i++) {
-    type = ParameterTypeAt(i);
-    type = type.Canonicalize(trail);
-    sig_fun.SetParameterTypeAt(i, type);
-  }
-  sig_fun.set_parameter_names(Array::Handle(zone, parameter_names()));
-  return sig_fun.raw();
-}
-
 RawType* Function::SignatureType() const {
   Type& type = Type::Handle(ExistingSignatureType());
   if (type.IsNull()) {
     // 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
@@ skipping 233 matching lines @@
   ASSERT(raw_ptr()->data_ == Object::null());
   const Array& pair = Array::Handle(Array::New(2, Heap::kOld));
   pair.SetAt(0, value);
   // pair[1] will be the implicit closure function if needed.
   set_data(pair);
 }
 
 void Function::set_result_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->result_type_, value.raw());
-  if (value.IsFunctionType()) {
-    // The function result type may refer to this function's type parameters.
-    // Change its parent function.
-    const Function& result_signature_function =
-        Function::Handle(Type::Cast(value).signature());
-    result_signature_function.set_parent_function(*this);
-  }
 }
 
 RawAbstractType* Function::ParameterTypeAt(intptr_t index) const {
   const Array& parameter_types = Array::Handle(raw_ptr()->parameter_types_);
   return AbstractType::RawCast(parameter_types.At(index));
 }
 
 void Function::SetParameterTypeAt(intptr_t index,
                                   const AbstractType& value) const {
   ASSERT(!value.IsNull());
@@ skipping 40 matching lines @@
 
 intptr_t Function::NumParentTypeParameters() const {
   if (IsImplicitClosureFunction()) {
     return 0;
   }
   Thread* thread = Thread::Current();
   Function& parent = Function::Handle(parent_function());
   intptr_t num_parent_type_params = 0;
   while (!parent.IsNull()) {
     num_parent_type_params += parent.NumTypeParameters(thread);
+    if (parent.IsImplicitClosureFunction()) break;
     parent ^= parent.parent_function();
   }
   return num_parent_type_params;
 }
 
+void Function::PrintSignatureTypes() const {
+  Function& sig_fun = Function::Handle(raw());
+  Type& sig_type = Type::Handle();
+  while (!sig_fun.IsNull()) {
+    sig_type = sig_fun.SignatureType();
+    THR_Print("%s%s\n",
+              sig_fun.IsImplicitClosureFunction() ? "implicit closure: " : "",
+              sig_type.ToCString());
+    sig_fun ^= sig_fun.parent_function();
+  }
+}
+
 RawTypeParameter* Function::LookupTypeParameter(
     const String& type_name,
     intptr_t* function_level) const {
   ASSERT(!type_name.IsNull());
   Thread* thread = Thread::Current();
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   REUSABLE_TYPE_PARAMETER_HANDLESCOPE(thread);
   REUSABLE_STRING_HANDLESCOPE(thread);
   REUSABLE_FUNCTION_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
@@ skipping 436 matching lines @@
   // function is compiled.
   return true;
 }
 
 RawFunction* Function::InstantiateSignatureFrom(
     const TypeArguments& instantiator_type_arguments,
     const TypeArguments& function_type_arguments,
     Heap::Space space) const {
   Zone* zone = Thread::Current()->zone();
   const Object& owner = Object::Handle(zone, RawOwner());
+  // Note that parent pointers in newly instantiated signatures still points to
+  // the original uninstantiated parent signatures. That is not a problem.
   const Function& parent = Function::Handle(zone, parent_function());
   ASSERT(!HasInstantiatedSignature());
   Function& sig = Function::Handle(
       zone, Function::NewSignatureFunction(owner, parent,
                                            TokenPosition::kNoSource, space));
   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,
@@ skipping 654 matching lines @@
   const AbstractType& res_type = AbstractType::Handle(zone, result_type());
   name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 bool Function::HasInstantiatedSignature(Genericity genericity,
                                         intptr_t num_free_fun_type_params,
                                         TrailPtr trail) const {
   if (genericity != kCurrentClass) {
-    // We only consider the function type parameters declared by the parents of
-    // this signature function.
-    const int num_parent_type_params = NumParentTypeParameters();
-    if (num_parent_type_params < num_free_fun_type_params) {
-      num_free_fun_type_params = num_parent_type_params;
+    // A generic typedef may declare a non-generic function type and get
+    // instantiated with unrelated function type parameters. In that case, its
+    // signature is still uninstantiated, because these type parameters are
+    // free (they are not declared by the typedef).
+    // For that reason, we only adjust num_free_fun_type_params if this
+    // signature is generic or has a generic parent.
+    if (IsGeneric() || HasGenericParent()) {
+      // We only consider the function type parameters declared by the parents
+      // of this signature function as free.
+      const int num_parent_type_params = NumParentTypeParameters();
+      if (num_parent_type_params < num_free_fun_type_params) {
+        num_free_fun_type_params = num_parent_type_params;
+      }
     }
+    // TODO(regis): Should we check the owners of the function type parameters
+    // in addition to their indexes to decide if they are free or not?
   }
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated(genericity, num_free_fun_type_params, trail)) {
     return false;
   }
   const intptr_t num_parameters = NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = ParameterTypeAt(i);
     if (!type.IsInstantiated(genericity, num_free_fun_type_params, trail)) {
       return false;
@@ skipping 8528 matching lines @@
   UNREACHABLE();
   return false;
 }
 
 bool AbstractType::IsRecursive() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
+void AbstractType::SetScopeFunction(const Function& function) const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+}
+
 RawAbstractType* AbstractType::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
@@ skipping 381 matching lines @@
   // For example, with class A<K, V extends K>, new A<T, T> called from within
   // a class B<T> will never require a run time bound check, even if T is
   // uninstantiated at compile time.
   if (IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(*this);
     if (other.IsTypeParameter()) {
       const TypeParameter& other_type_param = TypeParameter::Cast(other);
       if (type_param.Equals(other_type_param)) {
         return true;
       }
-      // TODO(regis): Should we update TypeParameter::IsEquivalent() instead?
       if (type_param.IsFunctionTypeParameter() &&
           other_type_param.IsFunctionTypeParameter() &&
           type_param.IsFinalized() && other_type_param.IsFinalized()) {
         // To be compatible, the function type parameters should be declared at
         // the same position in the generic function. Their index therefore
         // needs adjustement before comparison.
         // Example: 'foo<F>(bar<B>(B b)) { }' and 'baz<Z>(Z z) { }', baz can be
         // assigned to bar, although B has index 1 and Z index 0.
         const Function& sig_fun =
             Function::Handle(zone, type_param.parameterized_function());
@@ skipping 562 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 bool Type::IsRecursive() const {
   return TypeArguments::Handle(arguments()).IsRecursive();
 }
 
+void Type::SetScopeFunction(const Function& function) const {
+  TypeArguments::Handle(arguments()).SetScopeFunction(function);
+  if (IsFunctionType()) {
+    const Function& sig_fun = Function::Handle(signature());
+    sig_fun.set_parent_function(function);
+    // No need to traverse result type and parameter types (and bounds, in case
+    // sig_fun is generic), since they have sig_fun as scope function.
+  }
+}
+
 RawAbstractType* Type::CloneUnfinalized() const {
   ASSERT(IsResolved());
   if (IsFinalized()) {
     return raw();
   }
   ASSERT(!IsMalformed());       // Malformed types are finalized.
   ASSERT(!IsBeingFinalized());  // Cloning must occur prior to finalization.
   Zone* zone = Thread::Current()->zone();
   const TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
   const TypeArguments& type_args_clone =
@@ skipping 218 matching lines @@
     if (IsCanonical()) {
       // Canonicalizing type_args canonicalized this type as a side effect.
       ASSERT(IsRecursive());
       // Cycles via typedefs are detected and disallowed, but a function type
       // can be recursive due to a cycle in its type arguments.
       return this->raw();
     }
     set_arguments(type_args);
     ASSERT(type_args.IsNull() || type_args.IsOld());
 
-    // In case of a function type, replace the actual function by a signature
-    // function.
-    if (IsFunctionType()) {
-      Function& sig_fun = Function::Handle(zone, signature());
-      if (!sig_fun.IsSignatureFunction()) {
-        sig_fun = sig_fun.CanonicalSignatureFunction(trail);
-        set_signature(sig_fun);
-        // Note that the signature type of the signature function may be
-        // different than the type being canonicalized.
-        // Consider F<int> being canonicalized, with F being a typedef and F<T>
-        // being its signature type.
-      }
-    }
+    // In case of a function type, the signature has already been canonicalized
+    // when finalizing the type and passing kCanonicalize as finalization.
+    // Therefore, we do not canonicalize the signature here, which would have no
+    // effect on selecting the canonical type anyway, because the function
+    // object is not replaced when canonicalizing the signature.
 
     // Check to see if the type got added to canonical list as part of the
     // type arguments canonicalization.
     SafepointMutexLocker ml(isolate->type_canonicalization_mutex());
     CanonicalTypeSet table(zone, object_store->canonical_types());
     type ^= table.GetOrNull(CanonicalTypeKey(*this));
     if (type.IsNull()) {
       // Add this Type into the canonical list of types.
       if (this->IsNew()) {
         type ^= Object::Clone(*this, Heap::kOld);
@@ skipping 213 matching lines @@
   if (!other.IsAbstractType()) {
     return false;
   }
   if (TestAndAddBuddyToTrail(&trail, AbstractType::Cast(other))) {
     return true;
   }
   const AbstractType& ref_type = AbstractType::Handle(type());
   return !ref_type.IsNull() && ref_type.IsEquivalent(other, trail);
 }
 
+void TypeRef::SetScopeFunction(const Function& function) const {
+  // TypeRefs are created during finalization, when scope functions have
+  // already been adjusted.
+  UNREACHABLE();
+}
+
 RawTypeRef* TypeRef::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   TypeRef& instantiated_type_ref = TypeRef::Handle();
   instantiated_type_ref ^= OnlyBuddyInTrail(instantiation_trail);
   if (!instantiated_type_ref.IsNull()) {
@@ skipping 503 matching lines @@
   const AbstractType& this_bound = AbstractType::Handle(bound());
   const AbstractType& other_bound = AbstractType::Handle(other_bounded.bound());
   return this_bound.IsFinalized() && other_bound.IsFinalized() &&
          this_bound.Equals(other_bound);  // Different graph, do not pass trail.
 }
 
 bool BoundedType::IsRecursive() const {
   return AbstractType::Handle(type()).IsRecursive();
 }
 
+void BoundedType::SetScopeFunction(const Function& function) const {
+  AbstractType::Handle(type()).SetScopeFunction(function);
+  AbstractType::Handle(bound()).SetScopeFunction(function);
+}
+
 void BoundedType::set_type(const AbstractType& value) const {
   ASSERT(value.IsFinalized() || value.IsBeingFinalized() ||
          value.IsTypeParameter());
   ASSERT(!value.IsMalformed());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 void BoundedType::set_bound(const AbstractType& value) const {
   // The bound may still be unfinalized because of legal cycles.
   // It must be finalized before it is checked at run time, though.
@@ skipping 4708 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart