Reduce the number of captured variables in async code, by only capturing local

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 3472 matching lines @@
   SequenceNode* body = CloseBlock();
   if (func.IsAsyncFunction()) {
     body = CloseAsyncFunction(generated_body_closure, body);
     generated_body_closure.set_end_token_pos(end_token_pos);
   } else if (func.IsAsyncClosure()) {
     body = CloseAsyncClosure(body);
   } else if (func.IsSyncGenerator()) {
     body = CloseSyncGenFunction(generated_body_closure, body);
     generated_body_closure.set_end_token_pos(end_token_pos);
   } else if (func.IsSyncGenClosure()) {
-    body->scope()->RecursivelyCaptureAllVariables();
+    // body is unchanged.
   } else if (func.IsAsyncGenerator()) {
     body = CloseAsyncGeneratorFunction(generated_body_closure, body);
     generated_body_closure.set_end_token_pos(end_token_pos);
   } else if (func.IsAsyncGenClosure()) {
     body = CloseAsyncGeneratorClosure(body);
   }
   EnsureHasReturnStatement(body, end_token_pos);
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
@@ skipping 2808 matching lines @@
     OpenBlock();
     ArgumentListNode* no_args =
         new(Z) ArgumentListNode(Scanner::kNoSourcePos);
     current_block_->statements->Add(
         new(Z) InstanceCallNode(try_end_pos,
             new(Z) LoadLocalNode(Scanner::kNoSourcePos, controller),
             Symbols::Close(),
             no_args));
 
     // Suspend after the close.
-    AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
-    await_marker->set_scope(current_block_->scope);
+    AwaitMarkerNode* await_marker =
+        new(Z) AwaitMarkerNode(async_temp_scope_, current_block_->scope);
     current_block_->statements->Add(await_marker);
     ReturnNode* continuation_ret = new(Z) ReturnNode(try_end_pos);
     continuation_ret->set_return_type(ReturnNode::kContinuationTarget);
     current_block_->statements->Add(continuation_ret);
 
     finally_clause = CloseBlock();
     AstNode* node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
     if (node_to_inline != NULL) {
       InlinedFinallyNode* node =
           new(Z) InlinedFinallyNode(try_end_pos,
@@ skipping 268 matching lines @@
   }
 
   OpenFunctionBlock(body);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
   return body.raw();
 }
 
 SequenceNode* Parser::CloseSyncGenFunction(const Function& closure,
                                            SequenceNode* closure_body) {
+  // Explicitly reference variables of the sync generator function from the
+  // closure body in order to mark them as 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());
 
   // :await_jump_var = -1;
   LocalVariable* jump_var =
       current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
@@ skipping 125 matching lines @@
 
 
 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(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(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(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(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(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(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(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(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(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(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 71 matching lines @@
 //   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);
 
-  // Make sure the implicit variables of the async generator function
-  // are captured.
+  // Explicitly reference variables of the async genenerator function from the
+  // closure body in order to mark them as 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);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
@@ skipping 117 matching lines @@
 }
 
 
 SequenceNode* Parser::CloseAsyncGeneratorClosure(SequenceNode* body) {
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
 
   SequenceNode* new_body = CloseAsyncGeneratorTryBlock(body);
   ASSERT(new_body != NULL);
   ASSERT(new_body->scope() != NULL);
-
-  // Implicitly mark those variables below as captured. We currently mark all
-  // variables of all scopes as captured, but as soon as we do something
-  // smarter we rely on these internal variables to be available.
-  LocalVariable* existing_var = new_body->scope()->LookupVariable(
-      Symbols::AwaitJumpVar(), false);
-  ASSERT((existing_var != NULL) && existing_var->is_captured());
-  existing_var = new_body->scope()->LookupVariable(
-      Symbols::AwaitContextVar(), false);
-  ASSERT((existing_var != NULL) && existing_var->is_captured());
-  existing_var = new_body->scope()->LookupVariable(
-      Symbols::Controller(), false);
-  ASSERT((existing_var != NULL) && existing_var->is_captured());
-  existing_var = new_body->scope()->LookupVariable(
-      Symbols::AsyncOperationParam(), false);
-  ASSERT(existing_var != NULL);
-  existing_var = new_body->scope()->LookupVariable(
-      Symbols::AsyncOperationErrorParam(), false);
-  ASSERT(existing_var != NULL);
-  existing_var = new_body->scope()->LookupVariable(
-      Symbols::AsyncOperationStackTraceParam(), false);
-  ASSERT(existing_var != NULL);
-  new_body->scope()->RecursivelyCaptureAllVariables();
   return new_body;
 }
 
 
 // Add a return node to the sequence if necessary.
 void Parser::EnsureHasReturnStatement(SequenceNode* seq, intptr_t return_pos) {
   if ((seq->length() == 0) ||
       !seq->NodeAt(seq->length() - 1)->IsReturnNode()) {
     const Function& func = innermost_function();
     // The implicit return value of synchronous generator closures is false,
@@ skipping 19 matching lines @@
   return statements;
 }
 
 
 SequenceNode* Parser::CloseAsyncFunction(const Function& closure,
                                          SequenceNode* closure_body) {
   TRACE_PARSER("CloseAsyncFunction");
   ASSERT(!closure.IsNull());
   ASSERT(closure_body != NULL);
 
+  // Explicitly reference variables of the async function from the
+  // closure body in order to mark them as 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::AsyncCompleter(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
 
@@ skipping 123 matching lines @@
               async_completer),
           Symbols::CompleterFuture()));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::CloseAsyncClosure(SequenceNode* body) {
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
-  // Implicitly mark those variables below as captured. We currently mark all
-  // variables of all scopes as captured (below), but as soon as we do something
-  // smarter we rely on these internal variables to be available.
+
   SequenceNode* new_body = CloseAsyncTryBlock(body);
   ASSERT(new_body != NULL);
   ASSERT(new_body->scope() != NULL);
-  LocalVariable* existing_var =
-      new_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  ASSERT((existing_var != NULL) && existing_var->is_captured());
-  existing_var =
-      new_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
-  ASSERT((existing_var != NULL) && existing_var->is_captured());
-  existing_var =
-      new_body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
-  ASSERT((existing_var != NULL) && existing_var->is_captured());
-  new_body->scope()->RecursivelyCaptureAllVariables();
   return new_body;
 }
 
 
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList& params) {
   if ((current_function().raw() == innermost_function().raw()) &&
       (params.num_optional_parameters > 0)) {
     ZoneGrowableArray<const Instance*>* default_values =
         new ZoneGrowableArray<const Instance*>(zone(),
@@ skipping 1256 matching lines @@
 
 static LocalVariable* LookupAsyncSavedTryContextVar(LocalScope* scope,
                                                     uint16_t try_index) {
   const String& async_saved_try_ctx_name =
       String::ZoneHandle(Symbols::New(String::Handle(
           String::NewFormatted(
               "%s%d",
               Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
               try_index))));
   LocalVariable* var = scope->LocalLookupVariable(async_saved_try_ctx_name);
-  ASSERT((var != NULL) && var->is_captured());
+  ASSERT(var != NULL);
   return var;
 }
 
 
 // If the await or yield being parsed is in a try block, the continuation code
 // needs to restore the corresponding stack-based variable :saved_try_ctx_var,
 // and the stack-based variable :saved_try_ctx_var of the outer try block.
 // The inner :saved_try_ctx_var is used by a finally clause handling an
 // exception thrown by the continuation code in a try block or catch block.
 // If no finally clause exists, the catch or finally clause of the outer try
@@ skipping 171 matching lines @@
   CheckAsyncOpInTryBlock(&saved_try_ctx,
                          &async_saved_try_ctx,
                          &outer_saved_try_ctx,
                          &outer_async_saved_try_ctx);
   ArgumentListNode* no_args = new(Z) ArgumentListNode(stream_pos);
   AstNode* iterator_moveNext = new(Z) InstanceCallNode(
       stream_pos,
       new(Z) LoadLocalNode(stream_pos, iterator_var),
                            Symbols::MoveNext(),
                            no_args);
+  OpenBlock();
   AstNode* await_moveNext =
       new(Z) AwaitNode(stream_pos,
                        iterator_moveNext,
                        saved_try_ctx,
                        async_saved_try_ctx,
                        outer_saved_try_ctx,
-                       outer_async_saved_try_ctx);
-  OpenBlock();
+                       outer_async_saved_try_ctx,
+                       current_block_->scope);
   AwaitTransformer at(current_block_->statements, async_temp_scope_);
   await_moveNext = at.Transform(await_moveNext);
   SequenceNode* await_preamble = CloseBlock();
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
 
@@ skipping 811 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);
   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 313 matching lines @@
     yield->AddNode(store_current);
     if (is_yield_each) {
       // Generate :iterator.isYieldEach = true;
       AstNode* set_is_yield_each =
           new(Z) InstanceSetterNode(Scanner::kNoSourcePos,
               iterator,
               String::ZoneHandle(Symbols::IsYieldEach().raw()),
               new(Z) LiteralNode(TokenPos(), Bool::True()));
       yield->AddNode(set_is_yield_each);
     }
-    AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
-    await_marker->set_scope(current_block_->scope);
+    AwaitMarkerNode* await_marker =
+        new(Z) AwaitMarkerNode(async_temp_scope_, current_block_->scope);
     yield->AddNode(await_marker);
     // Return true to indicate that a value has been generated.
     ReturnNode* return_true = new(Z) ReturnNode(yield_pos,
         new(Z) LiteralNode(TokenPos(), Bool::True()));
     return_true->set_return_type(ReturnNode::kContinuationTarget);
     yield->AddNode(return_true);
 
     // If this expression is part of a try block, also append the code for
     // restoring the saved try context that lives on the stack and possibly the
     // saved try context of the outer try block.
@@ skipping 46 matching lines @@
 
     SequenceNode* true_branch =
         new(Z) SequenceNode(Scanner::kNoSourcePos, NULL);
     AstNode* return_from_generator = new(Z) ReturnNode(yield_pos);
     true_branch->Add(return_from_generator);
     AddNodeForFinallyInlining(return_from_generator);
     AstNode* if_is_cancelled =
        new(Z) IfNode(Scanner::kNoSourcePos, add_call, true_branch, NULL);
     yield->AddNode(if_is_cancelled);
 
-    AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
-    await_marker->set_scope(current_block_->scope);
+    AwaitMarkerNode* await_marker =
+        new(Z) AwaitMarkerNode(async_temp_scope_, current_block_->scope);
     yield->AddNode(await_marker);
     ReturnNode* continuation_return = new(Z) ReturnNode(yield_pos);
     continuation_return->set_return_type(ReturnNode::kContinuationTarget);
     yield->AddNode(continuation_return);
 
     // If this expression is part of a try block, also append the code for
     // restoring the saved try context that lives on the stack and possibly the
     // saved try context of the outer try block.
     LocalVariable* saved_try_ctx;
     LocalVariable* async_saved_try_ctx;
@@ skipping 999 matching lines @@
     LocalVariable* outer_async_saved_try_ctx;
     CheckAsyncOpInTryBlock(&saved_try_ctx,
                            &async_saved_try_ctx,
                            &outer_saved_try_ctx,
                            &outer_async_saved_try_ctx);
     expr = new (Z) AwaitNode(op_pos,
                              ParseUnaryExpr(),
                              saved_try_ctx,
                              async_saved_try_ctx,
                              outer_saved_try_ctx,
-                             outer_async_saved_try_ctx);
+                             outer_async_saved_try_ctx,
+                             current_block_->scope);
   } else if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     if (unary_op == Token::kSUB) {
       unary_op = Token::kNEGATE;
     }
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (expr->IsPrimaryNode() && (expr->AsPrimaryNode()->IsSuper())) {
       expr = BuildUnarySuperOperator(unary_op, expr->AsPrimaryNode());
     } else {
@@ skipping 3291 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart