Use correct scope to lookup saved async context variable.

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 6577 matching lines @@
   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();
 
-  closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
+  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);
   LiteralNode* init_value =
       new(Z) LiteralNode(Scanner::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
       new(Z) StoreLocalNode(Scanner::kNoSourcePos, jump_var, init_value));
 
   // return new SyncIterable(body_closure);
@@ skipping 281 matching lines @@
   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.
-  closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
-  closure_body->scope()->LookupVariable(Symbols::Controller(), false);
-  closure_body->scope()->LookupVariable(Symbols::AsyncOperation(), false);
-  closure_body->scope()->LookupVariable(Symbols::AsyncThenCallback(), false);
-  closure_body->scope()->LookupVariable(
+  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(
+      Symbols::AsyncOperation(), false);
+  ASSERT((existing_var != NULL) && existing_var->is_captured());
+  existing_var = closure_body->scope()->LookupVariable(
+      Symbols::AsyncThenCallback(), false);
+  ASSERT((existing_var != NULL) && existing_var->is_captured());
+  existing_var = closure_body->scope()->LookupVariable(
       Symbols::AsyncCatchErrorCallback(), false);
+  ASSERT((existing_var != NULL) && existing_var->is_captured());
 
   const Library& async_lib = Library::Handle(Library::AsyncLibrary());
 
   const Class& controller_class = Class::Handle(Z,
       async_lib.LookupClassAllowPrivate(
           Symbols::_AsyncStarStreamController()));
   ASSERT(!controller_class.IsNull());
   const Function& controller_constructor = Function::ZoneHandle(Z,
       controller_class.LookupConstructorAllowPrivate(
           Symbols::_AsyncStarStreamControllerConstructor()));
@@ skipping 103 matching lines @@
   // 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.
-  new_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  new_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
-  new_body->scope()->LookupVariable(Symbols::Controller(), false);
-  new_body->scope()->LookupVariable(Symbols::AsyncOperationParam(), false);
-  new_body->scope()->LookupVariable(Symbols::AsyncOperationErrorParam(), false);
-  new_body->scope()->LookupVariable(
+  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();
@@ skipping 24 matching lines @@
 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();
 
-  closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
-  closure_body->scope()->CaptureVariable(Symbols::AsyncCompleter());
+  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).
   const Class& future =
       Class::ZoneHandle(Z, I->object_store()->future_class());
   ASSERT(!future.IsNull());
@@ skipping 120 matching lines @@
 
 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);
-  new_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  new_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
-  new_body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
+  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,
     ZoneGrowableArray<const Instance*>* default_values) {
   if (params.num_optional_parameters > 0) {
@@ skipping 1270 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) && var->is_captured());
   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 15 matching lines @@
   *outer_saved_try_ctx = NULL;
   *outer_async_saved_try_ctx = NULL;
   if (try_stack_ != NULL) {
     LocalScope* scope = try_stack_->try_block()->scope;
     uint16_t try_index = try_stack_->try_index();
     const int current_function_level = current_block_->scope->function_level();
     if (scope->function_level() == current_function_level) {
       // The block declaring :saved_try_ctx_var variable is the parent of the
       // pushed try block.
       *saved_try_ctx = LookupSavedTryContextVar(scope->parent());
-      *async_saved_try_ctx = LookupAsyncSavedTryContextVar(scope, try_index);
+      *async_saved_try_ctx = LookupAsyncSavedTryContextVar(async_temp_scope_,
+                                                           try_index);
       if ((try_stack_->outer_try() != NULL) && !try_stack_->inside_finally()) {
         // Collecting the outer try scope is not necessary if we
         // are in a finally block.
         scope = try_stack_->outer_try()->try_block()->scope;
         try_index = try_stack_->outer_try()->try_index();
         if (scope->function_level() == current_function_level) {
           *outer_saved_try_ctx = LookupSavedTryContextVar(scope->parent());
           *outer_async_saved_try_ctx =
-              LookupAsyncSavedTryContextVar(scope, try_index);
+              LookupAsyncSavedTryContextVar(async_temp_scope_, try_index);
         }
       }
     }
   }
   // An async or async* has an implicitly created try-catch around the
   // function body, so the await or yield inside the async closure should always
   // be created with a try scope.
   ASSERT((*saved_try_ctx != NULL) ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsAsyncGenerator() ||
@@ skipping 651 matching lines @@
   // In case of async closures we need to restore the saved try index of an
   // outer try block (if it exists).  The current try block has already been
   // removed from the stack of try blocks.
   if (is_async) {
     if (try_stack_ != NULL) {
       LocalScope* scope = try_stack_->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
         LocalVariable* async_saved_try_ctx =
-            LookupAsyncSavedTryContextVar(scope->parent(),
+            LookupAsyncSavedTryContextVar(async_temp_scope_,
                                           try_stack_->try_index());
         current_block_->statements->Add(
             new (Z) StoreLocalNode(
                 Scanner::kNoSourcePos,
                 saved_try_ctx,
                 new (Z) LoadLocalNode(Scanner::kNoSourcePos,
                                       async_saved_try_ctx)));
       }
     }
     // We need to save the exception variables as in catch clauses, whether
@@ skipping 253 matching lines @@
   if (is_async && (current != NULL)) {
     ASSERT(try_stack_ != NULL);
     SequenceNode* async_code = new(Z) SequenceNode(handler_pos, NULL);
     const TryStack* try_block = try_stack_->outer_try();
     if (try_block != NULL) {
       LocalScope* scope = try_block->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
         LocalVariable* async_saved_try_ctx =
-            LookupAsyncSavedTryContextVar(scope->parent(),
+            LookupAsyncSavedTryContextVar(async_temp_scope_,
                                           try_block->try_index());
         async_code->Add(
             new (Z) StoreLocalNode(
                 Scanner::kNoSourcePos,
                 saved_try_ctx,
                 new (Z) LoadLocalNode(Scanner::kNoSourcePos,
                                       async_saved_try_ctx)));
       }
     }
     SaveExceptionAndStacktrace(async_code,
@@ skipping 4660 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart