Improve the performance of closure-converted code.

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 5468 matching lines @@
   while (!parent.IsNull()) {
     if (parent.IsGeneric()) {
       return true;
     }
     parent = parent.parent_function();
   }
   return false;
 }
 
 RawFunction* Function::implicit_closure_function() const {
-  if (IsClosureFunction() || IsSignatureFunction() || IsFactory()) {
+  if (IsClosureFunction() || IsConvertedClosureFunction() ||
+      IsSignatureFunction() || IsFactory()) {
     return Function::null();
   }
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(obj.IsNull() || obj.IsScript() || obj.IsFunction() || obj.IsArray());
   if (obj.IsNull() || obj.IsScript()) {
     return Function::null();
   }
   if (obj.IsFunction()) {
     return Function::Cast(obj).raw();
   }
   ASSERT(is_native());
   ASSERT(obj.IsArray());
   const Object& res = Object::Handle(Array::Cast(obj).At(1));
   return res.IsNull() ? Function::null() : Function::Cast(res).raw();
 }
 
 void Function::set_implicit_closure_function(const Function& value) const {
-  ASSERT(!IsClosureFunction() && !IsSignatureFunction());
+  ASSERT(!IsClosureFunction() && !IsSignatureFunction() &&
+         !IsConvertedClosureFunction());
   if (is_native()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(obj.IsArray());
     ASSERT((Array::Cast(obj).At(1) == Object::null()) || value.IsNull());
     Array::Cast(obj).SetAt(1, value);
   } else {
     ASSERT((raw_ptr()->data_ == Object::null()) || value.IsNull());
     set_data(value);
   }
 }
@@ skipping 100 matching lines @@
   switch (kind) {
     case RawFunction::kRegularFunction:
       return "RegularFunction";
       break;
     case RawFunction::kClosureFunction:
       return "ClosureFunction";
       break;
     case RawFunction::kImplicitClosureFunction:
       return "ImplicitClosureFunction";
       break;
+    case RawFunction::kConvertedClosureFunction:
+      return "ConvertedClosureFunction";
+      break;
     case RawFunction::kSignatureFunction:
       return "SignatureFunction";
       break;
     case RawFunction::kGetterFunction:
       return "GetterFunction";
       break;
     case RawFunction::kSetterFunction:
       return "SetterFunction";
       break;
     case RawFunction::kConstructor:
@@ skipping 707 matching lines @@
   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::null());
   if (IsConvertedClosureFunction()) {
     sig = Function::NewConvertedClosureFunction(
         String::Handle(zone, name()), parent, TokenPosition::kNoSource);
-    // TODO(sjindel): Kernel generic methods undone. Handle type parameters
+    // TODO(30455): 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()));
   }
 
@@ skipping 614 matching lines @@
   // Set closure function's type parameters.
   closure_function.set_type_parameters(
       TypeArguments::Handle(zone, type_parameters()));
 
   // Set closure function's result type to this result type.
   closure_function.set_result_type(AbstractType::Handle(zone, result_type()));
 
   // Set closure function's end token to this end token.
   closure_function.set_end_token_pos(end_token_pos());
 
-  // The closurized method stub just calls into the original method and should
-  // therefore be skipped by the debugger and in stack traces.
-  closure_function.set_is_debuggable(false);
-  closure_function.set_is_visible(false);
-
   // Set closure function's formal parameters to this formal parameters,
   // removing the first parameter over which the currying is done, and adding
   // the closure class instance as the first parameter.  So, the overall number
   // of fixed parameters doesn't change.
   const int num_fixed_params = num_fixed_parameters();
   const int num_opt_params = NumOptionalParameters();
   const bool has_opt_pos_params = HasOptionalPositionalParameters();
   const int num_params = num_fixed_params + num_opt_params;
 
   closure_function.set_num_fixed_parameters(num_fixed_params);
@@ skipping 105 matching lines @@
     }
     if (num_opt_pos_params > 0) {
       pieces->Add(Symbols::RBracket());
     } else {
       pieces->Add(Symbols::RBrace());
     }
   }
 }
 
 RawInstance* Function::ImplicitStaticClosure() const {
+  ASSERT(IsImplicitStaticClosureFunction());
   if (implicit_static_closure() == Instance::null()) {
     Zone* zone = Thread::Current()->zone();
     const Context& context = Object::empty_context();
     TypeArguments& function_type_arguments = TypeArguments::Handle(zone);
     if (!HasInstantiatedSignature(kFunctions)) {
       function_type_arguments = Object::empty_type_arguments().raw();
     }
     Instance& closure =
         Instance::Handle(zone, Closure::New(Object::null_type_arguments(),
                                             function_type_arguments, *this,
@@ skipping 162 matching lines @@
   // NOTE(turnidge): If you update this function, you probably want to
   // update Class::PatchFieldsAndFunctions() at the same time.
   if (token_pos() == TokenPosition::kMinSource) {
     // Testing for position 0 is an optimization that relies on temporary
     // eval functions having token position 0.
     const Script& script = Script::Handle(eval_script());
     if (!script.IsNull()) {
       return script.raw();
     }
   }
-  if (IsClosureFunction()) {
+  if (IsClosureFunction() || IsConvertedClosureFunction()) {
     return Function::Handle(parent_function()).script();
   }
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsNull()) {
     ASSERT(IsSignatureFunction());
     return Script::null();
   }
   if (obj.IsClass()) {
     return Class::Cast(obj).script();
   }
@@ skipping 15171 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart