Improve async code in VM by not unnecessarily capturing parameters of async and

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 6584 matching lines @@
     // signature type is not computed twice.
     ClassFinalizer::FinalizeTypesInClass(sig_cls);
     const Type& sig_type = Type::Handle(Z, sig_cls.SignatureType());
     ASSERT(sig_type.IsFinalized());
     ASSERT(AbstractType::Handle(Z, body.result_type()).IsResolved());
     ASSERT(body.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(body);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
-  OpenBlock();
   async_temp_scope_ = current_block_->scope;
   return body.raw();
 }
 
 SequenceNode* Parser::CloseSyncGenFunction(const Function& closure,
                                            SequenceNode* closure_body) {
-  // The block for the closure body has already been closed. Close the
-  // corresponding function block.
-  CloseBlock();
-
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
 
   // :await_jump_var = -1;
   LocalVariable* jump_var =
       current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
@@ skipping 112 matching lines @@
     // Finalize types in signature class here, so that the
     // signature type is not computed twice.
     ClassFinalizer::FinalizeTypesInClass(sig_cls);
     const Type& sig_type = Type::Handle(Z, sig_cls.SignatureType());
     ASSERT(sig_type.IsFinalized());
     ASSERT(AbstractType::Handle(Z, 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::AddContinuationVariables() {
   // Add to current block's scope:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* await_jump_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AwaitJumpVar(), dynamic_type);
   current_block_->scope->AddVariable(await_jump_var);
-  current_block_->scope->CaptureVariable(Symbols::AwaitJumpVar());
+  current_block_->scope->CaptureVariable(await_jump_var);
   LocalVariable* await_ctx_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AwaitContextVar(), dynamic_type);
   current_block_->scope->AddVariable(await_ctx_var);
-  current_block_->scope->CaptureVariable(Symbols::AwaitContextVar());
+  current_block_->scope->CaptureVariable(await_ctx_var);
 }
 
 
 void Parser::AddAsyncClosureVariables() {
   // Add to current block's scope:
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_completer;
   const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* async_op_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncOperation(), dynamic_type);
   current_block_->scope->AddVariable(async_op_var);
-  current_block_->scope->CaptureVariable(Symbols::AsyncOperation());
+  current_block_->scope->CaptureVariable(async_op_var);
   LocalVariable* async_then_callback_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncThenCallback(), dynamic_type);
   current_block_->scope->AddVariable(async_then_callback_var);
-  current_block_->scope->CaptureVariable(Symbols::AsyncThenCallback());
+  current_block_->scope->CaptureVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncCatchErrorCallback(), dynamic_type);
   current_block_->scope->AddVariable(async_catch_error_callback_var);
-  current_block_->scope->CaptureVariable(Symbols::AsyncCatchErrorCallback());
+  current_block_->scope->CaptureVariable(async_catch_error_callback_var);
   LocalVariable* async_completer = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncCompleter(), dynamic_type);
   current_block_->scope->AddVariable(async_completer);
-  current_block_->scope->CaptureVariable(Symbols::AsyncCompleter());
+  current_block_->scope->CaptureVariable(async_completer);
 }
 
 
 void Parser::AddAsyncGeneratorVariables() {
   // Add to current block's scope:
   //   var :controller;
   // The :controller variable is used by the async generator closure to
   // store the StreamController object to which the yielded expressions
   // are added.
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   // These variables are used to store the async generator closure containing
   // the body of the async* function. They are used by the await operator.
   const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* controller_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::Controller(), dynamic_type);
   current_block_->scope->AddVariable(controller_var);
-  current_block_->scope->CaptureVariable(Symbols::Controller());
-
+  current_block_->scope->CaptureVariable(controller_var);
   LocalVariable* async_op_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncOperation(), dynamic_type);
   current_block_->scope->AddVariable(async_op_var);
-  current_block_->scope->CaptureVariable(Symbols::AsyncOperation());
+  current_block_->scope->CaptureVariable(async_op_var);
   LocalVariable* async_then_callback_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncThenCallback(), dynamic_type);
   current_block_->scope->AddVariable(async_then_callback_var);
-  current_block_->scope->CaptureVariable(Symbols::AsyncThenCallback());
+  current_block_->scope->CaptureVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new(Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncCatchErrorCallback(), dynamic_type);
   current_block_->scope->AddVariable(async_catch_error_callback_var);
-  current_block_->scope->CaptureVariable(Symbols::AsyncCatchErrorCallback());
+  current_block_->scope->CaptureVariable(async_catch_error_callback_var);
 }
 
 
 RawFunction* Parser::OpenAsyncGeneratorFunction(intptr_t async_func_pos) {
   TRACE_PARSER("OpenAsyncGeneratorFunction");
   AddContinuationVariables();
   AddAsyncGeneratorVariables();
 
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
@@ skipping 45 matching lines @@
     // signature type is not computed twice.
     ClassFinalizer::FinalizeTypesInClass(sig_cls);
     const Type& sig_type = Type::Handle(Z, sig_cls.SignatureType());
     ASSERT(sig_type.IsFinalized());
     ASSERT(AbstractType::Handle(Z, 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();
 }
 
 
 // Generate the Ast nodes for the implicit code of the async* function.
 //
 // f(...) async* {
 //   var :controller;
 //   var :await_jump_var = -1;
 //   var :await_context_var;
 //   f_async_body() {
 //     ... source code of f ...
 //   }
 //   var :async_op = f_async_body;
 //   var :async_then_callback = _asyncThenWrapperHelper(:async_op);
 //   var :async_catch_error_callback = _asyncCatchErrorWrapperHelper(:async_op);
 //   :controller = new _AsyncStarStreamController(:async_op);
 //   return :controller.stream;
 // }
 SequenceNode* Parser::CloseAsyncGeneratorFunction(const Function& closure_func,
                                                   SequenceNode* closure_body) {
   TRACE_PARSER("CloseAsyncGeneratorFunction");
   ASSERT(!closure_func.IsNull());
   ASSERT(closure_body != NULL);
 
-  // The block for the async closure body has already been closed. Close the
-  // corresponding function block.
-  CloseBlock();
-
   // Make sure the implicit variables of the async generator function
   // are captured.
   LocalVariable* existing_var = closure_body->scope()->LookupVariable(
       Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::Controller(), false);
@@ skipping 181 matching lines @@
   return statements;
 }
 
 
 SequenceNode* Parser::CloseAsyncFunction(const Function& closure,
                                          SequenceNode* closure_body) {
   TRACE_PARSER("CloseAsyncFunction");
   ASSERT(!closure.IsNull());
   ASSERT(closure_body != NULL);
 
-  // The block for the async closure body has already been closed. Close the
-  // corresponding function block.
-  CloseBlock();
-
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
 
   // Create and return a new future that executes a closure with the current
   // body.
 
   // No need to capture parameters or other variables, since they have already
   // been captured in the corresponding scope as the body has been parsed within
-  // a nested block (contained in the async funtion's block).
+  // a nested block (contained in the async function's block).
   const Class& future =
       Class::ZoneHandle(Z, I->object_store()->future_class());
   ASSERT(!future.IsNull());
   const Function& constructor = Function::ZoneHandle(Z,
       future.LookupFunction(Symbols::FutureMicrotask()));
   ASSERT(!constructor.IsNull());
   const Class& completer =
       Class::ZoneHandle(Z, I->object_store()->completer_class());
   ASSERT(!completer.IsNull());
   const Function& completer_constructor = Function::ZoneHandle(Z,
@@ skipping 270 matching lines @@
 
 LocalVariable* Parser::LookupPhaseParameter() {
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(Symbols::PhaseParameter(),
                                                kTestOnly);
 }
 
 
 void Parser::CaptureInstantiator() {
   ASSERT(current_block_->scope->function_level() > 0);
-  bool found = false;
-  if (current_function().IsInFactoryScope()) {
-    found = current_block_->scope->CaptureVariable(
-        Symbols::TypeArgumentsParameter());
-  } else {
-    found = current_block_->scope->CaptureVariable(Symbols::This());
-  }
-  ASSERT(found);
+  const String* variable_name = current_function().IsInFactoryScope() ?
+      &Symbols::TypeArgumentsParameter() : &Symbols::This();
+  current_block_->scope->CaptureVariable(
+      current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
@@ skipping 67 matching lines @@
                   line_number);
     }
   }
 
   // Add variable to scope after parsing the initalizer expression.
   // The expression must not be able to refer to the variable.
   if (!current_block_->scope->AddVariable(variable)) {
     LocalVariable* existing_var =
         current_block_->scope->LookupVariable(variable->name(), true);
     ASSERT(existing_var != NULL);
-    if (existing_var->owner() == current_block_->scope) {
-      ReportError(ident_pos, "identifier '%s' already defined",
-                  variable->name().ToCString());
-    } else {
-      ReportError(ident_pos, "'%s' from outer scope has already been used, "
-                  "cannot redefine",
-                  variable->name().ToCString());
-    }
+    // Use before define cases have already been detected and reported above.
+    ASSERT(existing_var->owner() == current_block_->scope);
+    ReportError(ident_pos, "identifier '%s' already defined",
+                variable->name().ToCString());
   }
   if (is_final || is_const) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | 'const' [type] | type).
 // The presence of 'final' or 'const' must be detected and remembered
@@ skipping 172 matching lines @@
                                              *variable_name,
                                              function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
     if (!current_block_->scope->AddVariable(function_variable)) {
       LocalVariable* existing_var =
           current_block_->scope->LookupVariable(function_variable->name(),
                                                 true);
       ASSERT(existing_var != NULL);
-      if (existing_var->owner() == current_block_->scope) {
-        ReportError(function_pos, "identifier '%s' already defined",
-                    function_variable->name().ToCString());
-      } else {
-        ReportError(function_pos,
-                    "'%s' from outer scope has already been used, "
-                    "cannot redefine",
-                    function_variable->name().ToCString());
-      }
+      // Use before define cases have already been detected and reported above.
+      ASSERT(existing_var->owner() == current_block_->scope);
+      ReportError(function_pos, "identifier '%s' already defined",
+                  function_variable->name().ToCString());
     }
   }
 
   // Parse the local function.
   SequenceNode* statements = Parser::ParseFunc(function);
 
   // Now that the local function has formal parameters, lookup the signature
   // class in the current library (but not in its imports) and only create a new
   // canonical signature class if it does not exist yet.
   const String& signature = String::Handle(Z, function.Signature());
@@ skipping 1849 matching lines @@
       Symbols::New(String::Handle(Z,
           String::NewFormatted("%s%d",
                                Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
                                last_used_try_index_ - 1))));
   LocalVariable* async_saved_try_ctx = new (Z) LocalVariable(
       Scanner::kNoSourcePos,
       async_saved_try_ctx_name,
       Type::ZoneHandle(Z, Type::DynamicType()));
   ASSERT(async_temp_scope_ != NULL);
   async_temp_scope_->AddVariable(async_saved_try_ctx);
-  current_block_->scope->CaptureVariable(async_saved_try_ctx_name);
+  current_block_->scope->CaptureVariable(async_saved_try_ctx);
   ASSERT(saved_try_context != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_saved_try_ctx,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, saved_try_context)));
 }
 
 
 // We create three variables for exceptions:
 // ':saved_try_context_var' - Used to save the context before the start of
@@ skipping 4702 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart