Reuse function objects of async closure body

runtime/vm/parser.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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 3135 matching lines @@
   } else {
     UnexpectedToken();
   }
 
   ASSERT(func.end_token_pos() == func.token_pos() ||
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     body = CloseAsyncFunction(async_closure, body);
+    async_closure.set_end_token_pos(end_token_pos);
   } else if (func.is_async_closure()) {
     body = CloseAsyncClosure(body);
   }
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   await_is_keyword_ = saved_await_is_keyword;
   async_temp_scope_ = saved_async_temp_scope;
   parsed_function()->set_saved_try_ctx(saved_saved_try_ctx);
   parsed_function()->set_async_saved_try_ctx_name(
@@ skipping 2564 matching lines @@
 
   if (innermost_function().is_async_closure() ||
       innermost_function().IsAsyncFunction()) {
     SetupSavedTryContext(context_var);
   }
 }
 
 
 RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
   TRACE_PARSER("OpenAsyncFunction");
+  AddAsyncClosureVariables();
+  Function& closure = Function::Handle(I);
+  bool is_new_closure = false;
 
-  AddAsyncClosureVariables();
-
-  // Create the closure containing the old body of this function.
-  Class& sig_cls = Class::ZoneHandle(I);
-  Type& sig_type = Type::ZoneHandle(I);
-  Function& closure = Function::ZoneHandle(I);
-  String& sig = String::ZoneHandle(I);
+  // Check whether a function for the asynchronous function body of
+  // this async function has already been created by a previous
+  // compilation of this function.
+  const Function& found_func = Function::Handle(
+      I, current_class().LookupClosureFunction(formal_param_pos));
+  if (!found_func.IsNull() &&
+      (found_func.token_pos() == formal_param_pos) &&
+      (found_func.script() == innermost_function().script()) &&
+      (found_func.parent_function() == innermost_function().raw())) {
+    ASSERT(found_func.is_async_closure());
+    closure = found_func.raw();
+  } else {
+    // Create the closure containing the body of this async function.
+    const String& async_func_name =
+        String::Handle(I, innermost_function().name());
+    String& closure_name = String::Handle(I,
+        String::NewFormatted("<%s_async_body>", async_func_name.ToCString()));
+    closure = Function::NewClosureFunction(
+        String::Handle(I, Symbols::New(closure_name)),
+        innermost_function(),
+        formal_param_pos);
+    closure.set_is_async_closure(true);
+    closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
+    is_new_closure = true;
+  }
+  // Create the parameter list for the async body closure.
   ParamList closure_params;
   const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
   closure_params.AddFinalParameter(
       formal_param_pos, &Symbols::ClosureParameter(), &dynamic_type);
   ParamDesc result_param;
   result_param.name = &Symbols::AsyncOperationParam();
   result_param.default_value = &Object::null_instance();
   result_param.type = &dynamic_type;
+  closure_params.parameters->Add(result_param);
   ParamDesc error_param;
   error_param.name = &Symbols::AsyncOperationErrorParam();
   error_param.default_value = &Object::null_instance();
   error_param.type = &dynamic_type;
-  closure_params.parameters->Add(result_param);
   closure_params.parameters->Add(error_param);
   closure_params.has_optional_positional_parameters = true;
   closure_params.num_optional_parameters += 2;
-  closure = Function::NewClosureFunction(
-      Symbols::AnonymousClosure(),
-      innermost_function(),
-      formal_param_pos);
-  AddFormalParamsToFunction(&closure_params, closure);
-  closure.set_is_async_closure(true);
-  closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
-  sig = closure.Signature();
-  sig_cls = library_.LookupLocalClass(sig);
-  if (sig_cls.IsNull()) {
-    sig_cls = Class::NewSignatureClass(sig, closure, script_, formal_param_pos);
-    library_.AddClass(sig_cls);
+
+  if (is_new_closure) {
+    // Add the parameters to the newly created closure.
+    AddFormalParamsToFunction(&closure_params, closure);
+
+    // Create and set the signature class of the closure.
+    const String& sig = String::Handle(I, closure.Signature());
+    Class& sig_cls = Class::Handle(I, library_.LookupLocalClass(sig));
+    if (sig_cls.IsNull()) {
+      sig_cls =
+          Class::NewSignatureClass(sig, closure, script_, formal_param_pos);
+      library_.AddClass(sig_cls);
+    }
+    closure.set_signature_class(sig_cls);
+    const Type& sig_type = Type::Handle(I, sig_cls.SignatureType());
+    if (!sig_type.IsFinalized()) {
+      ClassFinalizer::FinalizeType(
+          sig_cls, sig_type, ClassFinalizer::kCanonicalize);
+    }
+    ASSERT(AbstractType::Handle(I, closure.result_type()).IsResolved());
+    ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
-  closure.set_signature_class(sig_cls);
-  sig_type = sig_cls.SignatureType();
-  if (!sig_type.IsFinalized()) {
-    ClassFinalizer::FinalizeType(
-        sig_cls, sig_type, ClassFinalizer::kCanonicalize);
-  }
-  ASSERT(AbstractType::Handle(I, closure.result_type()).IsResolved());
-  ASSERT(closure.NumParameters() == closure_params.parameters->length());
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   OpenBlock();
-
   async_temp_scope_ = current_block_->scope;
-
   return closure.raw();
 }
 
 
 void Parser::AddAsyncClosureVariables() {
   // Add to AST:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   //   var :async_op;
   //   var :async_completer;
@@ skipping 5985 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart