Fix scoping async functions.

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 278 matching lines @@
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
       innermost_function_(Function::Handle(isolate_)),
       literal_token_(LiteralToken::Handle(isolate_)),
       current_class_(Class::Handle(isolate_)),
       library_(Library::Handle(isolate_, library.raw())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
-      unregister_pending_function_(false) {
+      unregister_pending_function_(false),
+      async_temp_scope_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t token_position)
     : isolate_(Isolate::Current()),
@@ skipping 10 matching lines @@
       innermost_function_(Function::Handle(isolate_,
                                            parsed_function->function().raw())),
       literal_token_(LiteralToken::Handle(isolate_)),
       current_class_(Class::Handle(isolate_,
                                    parsed_function->function().Owner())),
       library_(Library::Handle(isolate_, Class::Handle(
           isolate_,
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
-      unregister_pending_function_(false) {
+      unregister_pending_function_(false),
+      async_temp_scope_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
 Parser::~Parser() {
   if (unregister_pending_function_) {
@@ skipping 2594 matching lines @@
       Function::Handle(I, innermost_function().raw());
   innermost_function_ = func.raw();
 
   // Save current try index. Try index starts at zero for each function.
   intptr_t saved_try_index = last_used_try_index_;
   last_used_try_index_ = 0;
 
   intptr_t formal_params_pos = TokenPos();
   // TODO(12455) : Need better validation mechanism.
 
+  LocalVariable* saved_saved_try_ctx = parsed_function()->saved_try_ctx();

[hausner, 2014/09/02 20:04:47]

We only have to save and restore these values if a nested function is parsed,
right?

[Michael Lippautz (Google), 2014/09/02 20:25:22]

Yes, I added a comment.

+  const String& saved_async_saved_try_ctx_name =
+      String::Handle(I, parsed_function()->async_saved_try_ctx_name());
+  parsed_function()->reset_saved_try_ctx_vars();
+  LocalScope* saved_async_temp_scope = async_temp_scope_;
+
   if (func.IsConstructor()) {
     SequenceNode* statements = ParseConstructor(func, default_parameter_values);
     innermost_function_ = saved_innermost_function.raw();
     last_used_try_index_ = saved_try_index;
     return statements;
   }
 
   ASSERT(!func.IsConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
@@ skipping 89 matching lines @@
   }
 
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   func.set_modifier(func_modifier);
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& async_closure = Function::ZoneHandle(I);
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     async_closure = OpenAsyncFunction(formal_params_pos);
+    async_temp_scope_ = current_block_->scope;
   } else if (func.is_async_closure()) {
     OpenAsyncClosure();
+    async_temp_scope_ = current_block_->scope;
   }
 
   bool saved_await_is_keyword = await_is_keyword_;
   if (func.IsAsyncFunction() || func.is_async_closure()) {
     await_is_keyword_ = true;
   }
 
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
@@ skipping 56 matching lines @@
   SequenceNode* body = CloseBlock();
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     body = CloseAsyncFunction(async_closure, body);
   } else if (func.is_async_closure()) {
     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(
+      saved_async_saved_try_ctx_name);
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
       new LoadLocalNode(Scanner::kNoSourcePos,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
       new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle(I));
@@ skipping 2379 matching lines @@
         new(I) LocalScope(current_block_->scope,
                                   current_block_->scope->function_level() + 1,
                                   0);
   }
   ChainNewBlock(outer_scope);
 }
 
 
 void Parser::OpenAsyncClosure() {
   TRACE_PARSER("OpenAsyncClosure");
-  parsed_function()->set_await_temps_scope(current_block_->scope);
 }
 
 
 RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
   TRACE_PARSER("OpenAsyncFunction");
+
+  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);
   ParamList closure_params;
   closure_params.AddFinalParameter(
       formal_param_pos,
       &Symbols::ClosureParameter(),
       &Type::ZoneHandle(I, Type::DynamicType()));
@@ skipping 25 matching lines @@
   }
   ASSERT(AbstractType::Handle(I, closure.result_type()).IsResolved());
   ASSERT(closure.NumParameters() == closure_params.parameters->length());
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   OpenBlock();
   return closure.raw();
 }
 
 
+void Parser::AddAsyncClosureVariables() {
+  // Add to AST:
+  //   var :await_jump_var;
+  //   var :await_ctx_var;
+  //   var :async_op;
+  //   var :async_completer;
+  const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
+  LocalVariable* await_jump_var = new (I) LocalVariable(
+      Scanner::kNoSourcePos, Symbols::AwaitJumpVar(), dynamic_type);
+  current_block_->scope->AddVariable(await_jump_var);
+  current_block_->scope->CaptureVariable(Symbols::AwaitJumpVar());
+  await_jump_var->set_is_captured();
+  LocalVariable* await_ctx_var = new (I) LocalVariable(
+      Scanner::kNoSourcePos, Symbols::AwaitContextVar(), dynamic_type);
+  current_block_->scope->AddVariable(await_ctx_var);
+  current_block_->scope->CaptureVariable(Symbols::AwaitContextVar());
+  await_ctx_var->set_is_captured();
+  LocalVariable* async_op_var = new (I) LocalVariable(
+      Scanner::kNoSourcePos, Symbols::AsyncOperation(), dynamic_type);
+  current_block_->scope->AddVariable(async_op_var);
+  current_block_->scope->CaptureVariable(Symbols::AsyncOperation());
+  async_op_var->set_is_captured();
+  LocalVariable* async_completer = new (I) LocalVariable(
+      Scanner::kNoSourcePos, Symbols::AsyncCompleter(), dynamic_type);
+  current_block_->scope->AddVariable(async_completer);
+  current_block_->scope->CaptureVariable(Symbols::AsyncCompleter());
+  async_completer->set_is_captured();
+}
+
+
 SequenceNode* Parser::CloseBlock() {
   SequenceNode* statements = current_block_->statements;
   if (current_block_->scope != NULL) {
     // Record the begin and end token index of the scope.
     ASSERT(statements != NULL);
     current_block_->scope->set_begin_token_pos(statements->token_pos());
     current_block_->scope->set_end_token_pos(TokenPos());
   }
   current_block_ = current_block_->parent;
   return statements;
@@ skipping 12 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()->CaptureVariable(Symbols::AsyncCompleter());
+
   // 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(I,
       GetClassForAsync(Symbols::Future()));
   ASSERT(!future.IsNull());
   const Function& constructor = Function::ZoneHandle(I,
       future.LookupFunction(Symbols::FutureConstructor()));
   ASSERT(!constructor.IsNull());
   const Class& completer = Class::ZoneHandle(I,
       GetClassForAsync(Symbols::Completer()));
   ASSERT(!completer.IsNull());
   const Function& completer_constructor = Function::ZoneHandle(I,
       completer.LookupFunction(Symbols::CompleterConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
-  bool found = false;
-  // Add to AST:
-  //   var :async_op;
-  //   var :async_completer;
-  //   var :await_jump_var;
-  //   var :await_ctx_var;
-  // Add as many variables to saved the try block ctx as there were try blocks.
-  //   var :async_saved_try_ctx_var_<x>;
-  const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
-  LocalVariable* async_op_var = new (I) LocalVariable(
-      Scanner::kNoSourcePos, Symbols::AsyncOperation(), dynamic_type);
-  current_block_->scope->AddVariable(async_op_var);
-  found = closure_body->scope()->CaptureVariable(Symbols::AsyncOperation());
-  ASSERT(found);
-  LocalVariable* async_completer = new (I) LocalVariable(
-      Scanner::kNoSourcePos, Symbols::AsyncCompleter(), dynamic_type);
-  current_block_->scope->AddVariable(async_completer);
-  found = closure_body->scope()->CaptureVariable(Symbols::AsyncCompleter());
-  ASSERT(found);
-  LocalVariable* await_jump_var = new (I) LocalVariable(
-      Scanner::kNoSourcePos, Symbols::AwaitJumpVar(), dynamic_type);
-  current_block_->scope->AddVariable(await_jump_var);
-  found = closure_body->scope()->CaptureVariable(Symbols::AwaitJumpVar());
-  ASSERT(found);
-  LocalVariable* await_ctx_var = new (I) LocalVariable(
-      Scanner::kNoSourcePos, Symbols::AwaitContextVar(), dynamic_type);
-  current_block_->scope->AddVariable(await_ctx_var);
-  found = closure_body->scope()->CaptureVariable(Symbols::AwaitContextVar());
-  ASSERT(found);
-  LocalVariable* async_saved_try_ctx_var;
-  for (int16_t i = 0; i < last_used_try_index_; i++) {
-    String& async_saved_try_ctx_name = BuildAsyncSavedTryContextName(I, i);
-    async_saved_try_ctx_var = new (I) LocalVariable(
-        Scanner::kNoSourcePos, async_saved_try_ctx_name, dynamic_type);
-    current_block_->scope->AddVariable(async_saved_try_ctx_var);
-    found = closure_body->scope()->CaptureVariable(async_saved_try_ctx_name);
-    ASSERT(found);
-  }
+  LocalVariable* async_completer = current_block_->scope->LookupVariable(
+      Symbols::AsyncCompleter(), false);
 
   // Add to AST:
   //   :async_completer = new Completer();
   ArgumentListNode* empty_args =
       new (I) ArgumentListNode(Scanner::kNoSourcePos);
   ConstructorCallNode* completer_constructor_node = new (I) ConstructorCallNode(
       Scanner::kNoSourcePos,
       TypeArguments::ZoneHandle(I),
       completer_constructor,
       empty_args);
   StoreLocalNode* store_completer = new (I) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_completer,
       completer_constructor_node);
   current_block_->statements->Add(store_completer);
 
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
+  LocalVariable* async_op_var = current_block_->scope->LookupVariable(
+      Symbols::AsyncOperation(), false);
   ClosureNode* cn = new(I) ClosureNode(
       Scanner::kNoSourcePos, closure, NULL, closure_body->scope());
   StoreLocalNode* store_async_op = new (I) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_op_var,
       cn);
   current_block_->statements->Add(store_async_op);
 
   // Add to AST:
   //   new Future(:async_op);
@@ skipping 20 matching lines @@
 }
 
 
 void Parser::CloseAsyncClosure(SequenceNode* body) {
   TRACE_PARSER("CloseAsyncClosure");
   // 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.
-  body->scope()->LookupVariable(Symbols::Completer(), false);
   body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
+  body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
   body->scope()->RecursivelyCaptureAllVariables();
 }
 
 
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList* params,
                                             Array* default_values) {
   if (params->num_optional_parameters > 0) {
     // Build array of default parameter values.
     ParamDesc* param =
@@ skipping 1519 matching lines @@
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
   TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
 
   // 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 (current_function().is_async_closure() && (try_blocks_list_ != NULL)) {
+  if ((innermost_function().is_async_closure() ||
+       innermost_function().IsAsyncFunction()) &&
+      (try_blocks_list_ != NULL)) {
     // We need two unchain two scopes: finally clause, and the try block level.
-    SetupSavedTryContext(current_block_->scope->parent()->parent(),
-                         try_blocks_list_->try_index(),
-                         current_block_->statements);
+    RestoreSavedTryContext(current_block_->scope->parent()->parent(),
+                           try_blocks_list_->try_index(),
+                           current_block_->statements);
   } else {
     parsed_function()->reset_saved_try_ctx_vars();
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* finally_block = CloseBlock();
   return finally_block;
 }
 
@@ skipping 133 matching lines @@
           no_args));
     }
 
     // Add nested block with user-defined code.  This blocks allows
     // declarations in the body to shadow the catch parameters.
     CheckToken(Token::kLBRACE);
 
     // In case of async closures we need to restore the saved try index of an
     // outer try block (if it exists).
     ASSERT(try_blocks_list_ != NULL);
-    if (current_function().is_async_closure() &&
-        (try_blocks_list_->outer_try_block() != NULL)) {
-      // We need to unchain three scope levels: catch clause, catch parameters,
-      // and the general try block.
-      SetupSavedTryContext(current_block_->scope->parent()->parent()->parent(),
-                           try_blocks_list_->outer_try_block()->try_index(),
-                           current_block_->statements);
-    } else {
-      parsed_function()->reset_saved_try_ctx_vars();
+    if (innermost_function().is_async_closure() ||
+        innermost_function().IsAsyncFunction()) {
+      if ((try_blocks_list_->outer_try_block() != NULL) &&
+          (try_blocks_list_->outer_try_block()->try_block()
+              ->scope->function_level() ==
+           current_block_->scope->function_level())) {
+        // We need to unchain three scope levels: catch clause, catch
+        // parameters, and the general try block.
+        RestoreSavedTryContext(
+            current_block_->scope->parent()->parent()->parent(),
+            try_blocks_list_->outer_try_block()->try_index(),
+            current_block_->statements);
+      } else {
+        parsed_function()->reset_saved_try_ctx_vars();
+      }
     }
 
     current_block_->statements->Add(ParseNestedStatement(false, NULL));
     catch_blocks.Add(CloseBlock());
 
     const bool is_bad_type =
         exception_param.type->IsMalformed() ||
         exception_param.type->IsMalbounded();
     if (exception_param.type->IsDynamicType() || is_bad_type) {
       // There is no exception type or else it is malformed or malbounded.
@@ skipping 77 matching lines @@
     AstNode* type_test = type_tests.RemoveLast();
     SequenceNode* catch_block = catch_blocks.RemoveLast();
     current_block_->statements->Add(new(I) IfNode(
         type_test->token_pos(), type_test, catch_block, current));
     current = CloseBlock();
   }
   return current;
 }
 
 
+void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
+  const String& async_saved_try_ctx_name =
+      BuildAsyncSavedTryContextName(I, last_used_try_index_ - 1);
+  LocalVariable* async_saved_try_ctx = new (I) LocalVariable(
+      Scanner::kNoSourcePos,
+      async_saved_try_ctx_name,
+      Type::ZoneHandle(I, Type::DynamicType()));
+  async_temp_scope_->AddVariable(async_saved_try_ctx);
+  async_saved_try_ctx->set_is_captured();
+  async_saved_try_ctx = current_block_->scope->LookupVariable(
+      async_saved_try_ctx_name, false);
+  ASSERT(async_saved_try_ctx != NULL);
+  ASSERT(saved_try_context != NULL);
+  current_block_->statements->Add(new (I) StoreLocalNode(
+      Scanner::kNoSourcePos, async_saved_try_ctx, new (I) LoadLocalNode(
+          Scanner::kNoSourcePos, saved_try_context)));
+  parsed_function()->set_saved_try_ctx(saved_try_context);
+  parsed_function()->set_async_saved_try_ctx_name(async_saved_try_ctx_name);
+}
+
+
 // Set up the currently relevant :saved_try_context_var on the stack:
 // * Try blocks: Set the context variable for this try block.
 // * Catch/finally blocks: Set the context variable for any outer try block (if
 //   existent).
 //
 // Also save the captured variable and the stack variable to be able to set
 // it after a function continues execution (await).
-void Parser::SetupSavedTryContext(LocalScope* saved_try_context_scope,
-                                  int16_t try_index,
-                                  SequenceNode* target) {
+void Parser::RestoreSavedTryContext(LocalScope* saved_try_context_scope,
+                                    int16_t try_index,
+                                    SequenceNode* target) {
   LocalVariable* saved_try_ctx = saved_try_context_scope->LookupVariable(
       Symbols::SavedTryContextVar(), false);
   ASSERT((saved_try_ctx != NULL) && !saved_try_ctx->is_captured());
   const String& async_saved_try_ctx_name =
       BuildAsyncSavedTryContextName(I, try_index);
   LocalVariable* async_saved_try_ctx =
       target->scope()->LookupVariable(async_saved_try_ctx_name, false);
-  ASSERT((async_saved_try_ctx != NULL) && async_saved_try_ctx->is_captured());
+  ASSERT(async_saved_try_ctx != NULL);
+  ASSERT(async_saved_try_ctx->is_captured());
   target->Add(new (I) StoreLocalNode(
-      Scanner::kNoSourcePos, saved_try_ctx, new (I) LoadLocalNode(
-          Scanner::kNoSourcePos, async_saved_try_ctx)));
+      Scanner::kNoSourcePos,
+      saved_try_ctx,
+      new (I) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
 
   parsed_function()->set_saved_try_ctx(saved_try_ctx);
-  parsed_function()->set_async_saved_try_ctx(async_saved_try_ctx);
+  parsed_function()->set_async_saved_try_ctx_name(async_saved_try_ctx_name);
 }
 
 
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
 
   // We create three variables for exceptions here:
   // ':saved_try_context_var' - Used to save the context before the start of
   //                            the try block. The context register is
   //                            restored from this variable before
@@ skipping 42 matching lines @@
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
   PushTryBlock(current_block_);
   ExpectToken(Token::kLBRACE);
 
-  if (current_function().is_async_closure()) {
-    const String& async_saved_try_ctx_name =
-        BuildAsyncSavedTryContextName(I, last_used_try_index_ - 1);
-    LocalVariable* async_saved_try_ctx =
-        current_block_->scope->LookupVariable(
-            async_saved_try_ctx_name, false);
-    ASSERT(async_saved_try_ctx != NULL);
-    ASSERT(context_var != NULL);
-    current_block_->statements->Add(new (I) StoreLocalNode(
-        Scanner::kNoSourcePos, async_saved_try_ctx, new (I) LoadLocalNode(
-            Scanner::kNoSourcePos, context_var)));
-    parsed_function()->set_saved_try_ctx(context_var);
-    parsed_function()->set_async_saved_try_ctx(async_saved_try_ctx);
+  if (innermost_function().is_async_closure() ||
+      innermost_function().IsAsyncFunction()) {
+    SetupSavedTryContext(context_var);
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
       (CurrentToken() != Token::kFINALLY)) {
     ReportError("catch or finally clause expected");
   }
@@ skipping 55 matching lines @@
   AstNode* try_catch_node = new(I) TryCatchNode(
       try_pos, try_block, context_var, catch_clause, finally_block, try_index);
 
   if (try_label != NULL) {
     current_block_->statements->Add(try_catch_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(try_label);
     try_catch_node = sequence;
   }
 
-  // In case of async closures we need to restore the saved try index of an
-  // outer try block (if it exists).
-  if (current_function().is_async_closure() &&
-      (outer_try_index != CatchClauseNode::kInvalidTryIndex)) {
-    SequenceNode* try_catch_and_restore_try_ctx = new (I) SequenceNode(
-        Scanner::kNoSourcePos, current_block_->scope);
-    try_catch_and_restore_try_ctx->Add(try_catch_node);
-    SetupSavedTryContext(
-        current_block_->scope, outer_try_index, try_catch_and_restore_try_ctx);
-    return try_catch_and_restore_try_ctx;
-  } else {
-    parsed_function()->reset_saved_try_ctx_vars();
-  }
-
   return try_catch_node;
 }
 
 
 AstNode* Parser::ParseJump(String* label_name) {
   TRACE_PARSER("ParseJump");
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
   const intptr_t jump_pos = TokenPos();
   SourceLabel* target = NULL;
@@ skipping 817 matching lines @@
   return expr;
 }
 
 
 AstNode* Parser::ParseAwaitableExpr(bool require_compiletime_const,
                                     bool consume_cascades) {
   TRACE_PARSER("ParseAwaitableExpr");
   parsed_function()->reset_have_seen_await();
   AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (parsed_function()->have_seen_await()) {
-    if (!current_block_->scope->LookupVariable(
-          Symbols::AsyncOperation(), true)) {
-      // Async operations are always encapsulated into a local function. We only
-      // need to transform the expression when generating code for this inner
-      // function.
-      return expr;
-    }
-    SequenceNode* intermediates_block = new(I) SequenceNode(
-        Scanner::kNoSourcePos, current_block_->scope);
-    AwaitTransformer at(intermediates_block, library_, parsed_function());
+    // Make sure we do not reuse the scope to avoid creating contexts that we
+    // are unaware of, i.e, creating contexts that have already been covered.
+    // See FlowGraphBuilder::VisitSequenceNode() for details on when contexts
+    // are created.
+    OpenBlock();
+    AwaitTransformer at(current_block_->statements,
+                        library_,
+                        parsed_function(),
+                        async_temp_scope_);
     AstNode* result = at.Transform(expr);
-    current_block_->statements->Add(intermediates_block);
+    current_block_->statements->Add(CloseBlock());
     parsed_function()->reset_have_seen_await();
     return result;
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
@@ skipping 2913 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart