Fix many bugs with closure conversion in checked mode.

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 5990 matching lines @@
 }
 
 intptr_t Function::NumImplicitParameters() const {
   const RawFunction::Kind k = kind();
   if (k == RawFunction::kConstructor) {
     // Type arguments for factory; instance for generative constructor.
     return 1;
   }
   if ((k == RawFunction::kClosureFunction) ||
       (k == RawFunction::kImplicitClosureFunction) ||
-      (k == RawFunction::kSignatureFunction)) {
+      (k == RawFunction::kSignatureFunction) ||
+      (k == RawFunction::kConvertedClosureFunction)) {
     return 1;  // Closure object.
   }
   if (!is_static()) {
     // Closure functions defined inside instance (i.e. non-static) functions are
     // marked as non-static, but they do not have a receiver.
     // Closures are handled above.
     ASSERT((k != RawFunction::kClosureFunction) &&
            (k != RawFunction::kImplicitClosureFunction) &&
            (k != RawFunction::kSignatureFunction));
     return 1;  // Receiver.
@@ skipping 303 matching lines @@
 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()));
+
+  Function& sig = Function::Handle(zone, Function::null());
+  if (IsConvertedClosureFunction()) {
+    sig = Function::NewConvertedClosureFunction(
+        String::Handle(zone, name()), parent, TokenPosition::kNoSource);
+    // TODO(sjindel): Kernel generic methods undone. Handle type parameters
+    // correctly when generic closures are supported. Until then, all type
+    // parameters to this target are used for captured type variables, so they
+    // aren't relevant to the type of the function.
+    sig.set_type_parameters(TypeArguments::Handle(zone, TypeArguments::null()));
+  } else {
+    sig = 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,
                              function_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(),
@@ skipping 50 matching lines @@
                                        bound_trail, space)) {
       return false;
     }
   }
   return true;
 }
 
 bool Function::HasSameTypeParametersAndBounds(const Function& other) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
+
   const intptr_t num_type_params = NumTypeParameters(thread);
   if (num_type_params != other.NumTypeParameters(thread)) {
     return false;
   }
   if (num_type_params > 0) {
     const TypeArguments& type_params =
         TypeArguments::Handle(zone, type_parameters());
     ASSERT(!type_params.IsNull());
     const TypeArguments& other_type_params =
         TypeArguments::Handle(zone, other.type_parameters());
@@ skipping 748 matching lines @@
   pieces.Add(Symbols::RParenArrow());
   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 {
+  // This function works differently for converted closures.
+  //
+  // Unlike regular closures, it's not possible to know which type parameters
+  // are supposed to come from parent functions or classes and which are
+  // actually parameters to the closure it represents. For example, consider:
+  //
+  //     class C<T> {
+  //       getf() => (T x) { return x; }
+  //     }
+  //
+  //     class D {
+  //       getf() {
+  //         dynamic fn<T>(T x) { return x; }
+  //         return fn;
+  //       }
+  //     }
+  //
+  // The signature of `fn` as a converted closure will in both cases look like
+  // `<T>(T) => dynamic`, because the signaute of the converted closure function
+  // is the same as it's top-level target function. However, in the first case
+  // the closure's type is instantiated, and in the second case it's not.
+  //
+  // Since we can never assume a converted closure is instantiated if it has any
+  // type parameters, we always return true in these cases.
+  if (IsConvertedClosureFunction()) {
+    return genericity == kCurrentClass || NumTypeParameters() == 0;
+  }
+
   if (genericity != kCurrentClass) {
     // 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.
@@ skipping 8167 matching lines @@
           instantiated_other.IsDartFunctionType()) {
         return true;
       }
     }
     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.IsConvertedClosureFunction()) {
-      const String& closure_name = String::Handle(zone, sig_fun.name());
-      const Function& new_sig_fun = Function::Handle(
-          zone,
-          Function::NewConvertedClosureFunction(
-              closure_name, Function::Handle(zone, sig_fun.parent_function()),
-              TokenPosition::kNoSource));
-
-      new_sig_fun.set_type_parameters(
-          TypeArguments::Handle(zone, sig_fun.type_parameters()));
-      new_sig_fun.set_result_type(
-          AbstractType::Handle(zone, sig_fun.result_type()));
-      new_sig_fun.set_end_token_pos(TokenPosition::kNoSource);
-
-      new_sig_fun.set_is_debuggable(false);
-      new_sig_fun.set_is_visible(false);
-
-      // The converted closed top-level function type should have its first
-      // required optional parameter, i.e. context, removed.
-      const int num_fixed_params = sig_fun.num_fixed_parameters() - 1;
-      const int num_opt_params = sig_fun.NumOptionalParameters();
-      const bool has_opt_pos_params = sig_fun.HasOptionalPositionalParameters();
-      const int num_params = num_fixed_params + num_opt_params;
-      new_sig_fun.set_num_fixed_parameters(num_fixed_params);
-      new_sig_fun.SetNumOptionalParameters(num_opt_params, has_opt_pos_params);
-      new_sig_fun.set_parameter_types(
-          Array::Handle(zone, Array::New(num_params, Heap::kOld)));
-      new_sig_fun.set_parameter_names(
-          Array::Handle(zone, Array::New(num_params, Heap::kOld)));
-      AbstractType& param_type = AbstractType::Handle(zone);
-      String& param_name = String::Handle(zone);
-      for (int i = 0; i < num_params; i++) {
-        param_type = sig_fun.ParameterTypeAt(i + 1);
-        new_sig_fun.SetParameterTypeAt(i, param_type);
-        param_name = sig_fun.ParameterNameAt(i + 1);
-        new_sig_fun.SetParameterNameAt(i, param_name);
-      }
-
-      sig_fun = new_sig_fun.raw();
-    }
     if (!sig_fun.HasInstantiatedSignature()) {
       const TypeArguments& instantiator_type_arguments = TypeArguments::Handle(
           zone, Closure::Cast(*this).instantiator_type_arguments());
       const TypeArguments& function_type_arguments = TypeArguments::Handle(
           zone, Closure::Cast(*this).function_type_arguments());
       sig_fun = sig_fun.InstantiateSignatureFrom(
           instantiator_type_arguments, function_type_arguments, Heap::kOld);
     }
     return sig_fun.IsSubtypeOf(other_signature, bound_error, NULL, Heap::kOld);
   }
@@ skipping 7054 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart