Fix async machinery (issue 22445 and possibly others to be triaged later).

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 3018 matching lines @@
                                 Array* default_parameter_values) {
   TRACE_PARSER("ParseFunc");
   Function& saved_innermost_function =
       Function::Handle(Z, 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;
 
-  // In case of nested async functions we also need to save the currently saved
-  // try context, the corresponding stack variable, and the scope where
+  // In case of nested async functions we also need to save the scope where
   // temporaries are added.
-  LocalVariable* saved_saved_try_ctx = parsed_function()->saved_try_ctx();
-  const String& saved_async_saved_try_ctx_name =
-      String::Handle(Z, parsed_function()->async_saved_try_ctx_name());
-  parsed_function()->reset_saved_try_ctx_vars();
   LocalScope* saved_async_temp_scope = async_temp_scope_;
 
   if (func.IsGenerativeConstructor()) {
     SequenceNode* statements = ParseConstructor(func, default_parameter_values);
     innermost_function_ = saved_innermost_function.raw();
     last_used_try_index_ = saved_try_index;
     return statements;
   }
 
   ASSERT(!func.IsGenerativeConstructor());
@@ skipping 202 matching lines @@
   } 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();
   }
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   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(Z));
@@ skipping 2711 matching lines @@
   if (stack_trace_param.var != NULL) {
     // A stack trace variable is specified in this block, so generate code
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
     current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         stack_trace_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
   }
 
-  AddSavedExceptionAndStacktraceToScope(
-      exception_var, stack_trace_var, current_block_->scope);
+  SaveExceptionAndStacktrace(exception_var, stack_trace_var);
 
   ASSERT(try_blocks_list_ != NULL);
   ASSERT(innermost_function().IsAsyncClosure() ||
          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(
+        AwaitTransformer::RestoreSavedTryContext(
+            Z,
+            current_block_->scope->parent()->parent()->parent(),
+            try_blocks_list_->outer_try_block()->try_index()));
   }
 
   // Complete the async future with an error.
   // Since we control the catch block there is no need to generate a nested
   // if/then/else.
   LocalVariable* async_completer = current_block_->scope->LookupVariable(
       Symbols::AsyncCompleter(), false);
   ASSERT(async_completer != NULL);
   ArgumentListNode* completer_args =
       new (Z) ArgumentListNode(Scanner::kNoSourcePos);
@@ skipping 66 matching lines @@
   LocalVariable* stack_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (stack_trace_var == NULL) {
     stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
         Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
+  SetupSavedExceptionAndStacktrace();
+
   // Open the try block.
   OpenBlock();
   PushTryBlock(current_block_);
 
-  if (innermost_function().IsAsyncClosure() ||
-      innermost_function().IsAsyncFunction() ||
-      innermost_function().IsSyncGenClosure() ||
-      innermost_function().IsSyncGenerator()) {
-    SetupSavedTryContext(context_var);
-  }
+  SetupSavedTryContext(context_var);
 }
 
 
 void Parser::AddSyncGenClosureParameters(ParamList* params) {
   // Create the parameter list for the body closure of a sync generator:
   // 1) Implicit closure parameter;
   // 2) Iterator
   const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   // Add implicit closure parameter if not already present.
   if (params->parameters->length() == 0) {
@@ skipping 252 matching lines @@
     // 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;
 }
 
 
-static inline String& BuildAsyncSavedTryContextName(Zone* zone,
-                                                    int16_t id) {
-  const char* async_saved_prefix = ":async_saved_try_ctx_var_";
-  // Can be a regular handle since we only use it to build an actual symbol.
-  const String& cnt_str = String::Handle(zone,
-      String::NewFormatted("%s%d", async_saved_prefix, id));
-  return String::ZoneHandle(zone, Symbols::New(cnt_str));
-}
-
-
 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);
@@ skipping 1362 matching lines @@
   // it to the loop body.
   if (await_preamble != NULL) {
     dowhile_body->Add(await_preamble);
   }
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new(Z) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
+// 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 possibly 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 catch clause. If no finally
+// clause exists, the catch or finally clause of the outer try block, if any,
+// uses the outer :saved_try_ctx_var to handle the exception.
+//
+// * Try blocks: Set the context variable for this try block.
+// * Catch blocks: Set the context variable for this try block and for any outer
+//                 try block (if existent).
+// * Finally blocks: Set the context variable for any outer try block (if
+//                   existent). Note that this try block is popped before
+//                   parsing the finally clause, so the outer try block (if
+//                   existent) is at the top of the try block list.
+//
+// TODO(regis): Could we return the variables instead of their containing
+// scopes? Check if they are already setup at this point.
+void Parser::CheckAsyncOpInTryBlock(LocalScope** try_scope,
+                                    int16_t* try_index,
+                                    LocalScope** outer_try_scope,
+                                    int16_t* outer_try_index) const {
+  *try_scope = NULL;
+  *try_index = CatchClauseNode::kInvalidTryIndex;
+  *outer_try_scope = NULL;
+  *outer_try_index = CatchClauseNode::kInvalidTryIndex;
+  if (try_blocks_list_ != NULL) {
+    LocalScope* scope = try_blocks_list_->try_block()->scope;
+    const int current_function_level = current_block_->scope->function_level();
+    if (scope->function_level() == current_function_level) {

[Ivan Posva, 2015/02/27 22:15:25]

We need to evaluate the need for this check.

+      // The block declaring :saved_try_ctx_var variable is the parent of the
+      // pushed try block.
+      *try_scope = scope->parent();
+      *try_index = try_blocks_list_->try_index();
+      if (try_blocks_list_->inside_catch() &&
+          (try_blocks_list_->outer_try_block() != NULL)) {
+        scope = try_blocks_list_->outer_try_block()->try_block()->scope;
+        if (scope->function_level() == current_function_level) {
+          *outer_try_scope = scope->parent();
+          *outer_try_index = try_blocks_list_->outer_try_block()->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((*try_scope != NULL) ||
+         innermost_function().IsAsyncFunction() ||
+         innermost_function().IsSyncGenClosure() ||
+         innermost_function().IsSyncGenerator());
+}
+
+
 AstNode* Parser::ParseAwaitForStatement(String* label_name) {
   TRACE_PARSER("ParseAwaitForStatement");
   ASSERT(IsAwaitKeyword());
   const intptr_t await_for_pos = TokenPos();
   ConsumeToken();  // await.
   ASSERT(CurrentToken() == Token::kFOR);
   ConsumeToken();  // for.
   ExpectToken(Token::kLPAREN);
 
   if (!innermost_function().IsAsyncFunction() &&
@@ skipping 47 matching lines @@
                               iterator_ctor,
                               ctor_args);
   const AbstractType& iterator_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* iterator_var = new(Z) LocalVariable(
       stream_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
   AstNode* iterator_init =
       new(Z) StoreLocalNode(stream_pos, iterator_var, ctor_call);
   current_block_->statements->Add(iterator_init);
 
+  LocalScope* try_scope;
+  int16_t try_index;
+  LocalScope* outer_try_scope;
+  int16_t outer_try_index;
+  CheckAsyncOpInTryBlock(&try_scope, &try_index,
+                         &outer_try_scope, &outer_try_index);
+
   // Build while loop condition.
   // while (await :for-in-iter.moveNext())
   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);
-  AstNode* await_moveNext = new (Z) AwaitNode(stream_pos, iterator_moveNext);
+  AstNode* await_moveNext = new (Z) AwaitNode(stream_pos,
+                                              iterator_moveNext,
+                                              try_scope,
+                                              try_index,
+                                              outer_try_scope,
+                                              outer_try_index);
   OpenBlock();
-  AwaitTransformer at(current_block_->statements,
-                      *parsed_function(),
-                      async_temp_scope_);
+  AwaitTransformer at(current_block_->statements, async_temp_scope_);
   AstNode* transformed_await = 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();
   SourceLabel* label =
       SourceLabel::New(await_for_pos, label_name, SourceLabel::kFor);
@@ skipping 341 matching lines @@
       // The name of the exception param is reused for the stack trace param.
       ReportError(stack_trace_param->token_pos,
                   "name '%s' already exists in scope",
                   stack_trace_param->name->ToCString());
     }
     stack_trace_param->var = var;
   }
 }
 
 
-// Populate local scope of the catch block with the saved exception and saved
+// Populate current scope of the try block with the saved exception and saved
 // stack trace.
-void Parser::AddSavedExceptionAndStacktraceToScope(
-    LocalVariable* exception_var,
-    LocalVariable* stack_trace_var,
-    LocalScope* scope) {
+void Parser::SetupSavedExceptionAndStacktrace() {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator());
-  // Add :saved_exception_var and :saved_stack_trace_var to scope.
+  // Add :saved_exception_var and :saved_stack_trace_var to current scope.
   // They will automatically get captured.
-  LocalVariable* saved_exception_var = new (Z) LocalVariable(
-      Scanner::kNoSourcePos,
-      Symbols::SavedExceptionVar(),
-      Type::ZoneHandle(Z, Type::DynamicType()));
-  saved_exception_var->set_is_final();
-  scope->AddVariable(saved_exception_var);
-  LocalVariable* saved_stack_trace_var = new (Z) LocalVariable(
+  // Parallel try statements share the same set of variables.
+  LocalVariable* saved_exception_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedExceptionVar());
+  if (saved_exception_var == NULL) {
+    saved_exception_var = new (Z) LocalVariable(
+        Scanner::kNoSourcePos,
+        Symbols::SavedExceptionVar(),
+        Type::ZoneHandle(Z, Type::DynamicType()));
+    saved_exception_var->set_is_final();
+    current_block_->scope->AddVariable(saved_exception_var);
+  }
+  LocalVariable* saved_stack_trace_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
+  if (saved_stack_trace_var == NULL) {
+    saved_stack_trace_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos,
       Symbols::SavedStackTraceVar(),
       Type::ZoneHandle(Z, Type::DynamicType()));
-  saved_exception_var->set_is_final();
-  scope->AddVariable(saved_stack_trace_var);
+    saved_exception_var->set_is_final();
+    current_block_->scope->AddVariable(saved_stack_trace_var);
+  }
+}
 
-  // Generate code to load the exception object (:exception_var) into
-  // the saved exception variable (:saved_exception_var) used to rethrow.
-  saved_exception_var = current_block_->scope->LookupVariable(
+
+// Generate code to load the exception object (:exception_var) into
+// the saved exception variable (:saved_exception_var) used to rethrow.
+void Parser::SaveExceptionAndStacktrace(LocalVariable* exception_var,
+                                        LocalVariable* stack_trace_var) {
+  ASSERT(innermost_function().IsAsyncClosure() ||
+         innermost_function().IsAsyncFunction() ||
+         innermost_function().IsSyncGenClosure() ||
+         innermost_function().IsSyncGenerator());
+  LocalVariable* saved_exception_var = current_block_->scope->LookupVariable(
       Symbols::SavedExceptionVar(), false);
   ASSERT(saved_exception_var != NULL);
   ASSERT(exception_var != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_exception_var,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
 
   // Generate code to load the stack trace object (:stack_trace_var) into
   // the saved stacktrace variable (:saved_stack_trace_var) used to rethrow.
-  saved_stack_trace_var = current_block_->scope->LookupVariable(
+  LocalVariable* saved_stack_trace_var = current_block_->scope->LookupVariable(
       Symbols::SavedStackTraceVar(), false);
   ASSERT(saved_stack_trace_var != NULL);
   ASSERT(stack_trace_var != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_stack_trace_var,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
 }
 
 
 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 ((innermost_function().IsAsyncClosure() ||
        innermost_function().IsAsyncFunction() ||
        innermost_function().IsSyncGenClosure() ||
        innermost_function().IsSyncGenerator()) &&
       (try_blocks_list_ != NULL)) {
     // We need two unchain two scopes: finally clause, and the try block level.
-    RestoreSavedTryContext(current_block_->scope->parent()->parent(),
-                           try_blocks_list_->try_index(),
-                           current_block_->statements);
-  } else {
-    parsed_function()->reset_saved_try_ctx_vars();
+    current_block_->statements->Add(
+        AwaitTransformer::RestoreSavedTryContext(
+            Z,
+            current_block_->scope->parent()->parent(),
+            try_blocks_list_->try_index()));
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* finally_block = CloseBlock();
   return finally_block;
 }
 
 
 void Parser::PushTryBlock(Block* try_block) {
@@ skipping 137 matching lines @@
     if (innermost_function().IsAsyncClosure() ||
         innermost_function().IsAsyncFunction() ||
         innermost_function().IsSyncGenClosure() ||
         innermost_function().IsSyncGenerator()) {
       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(
+            AwaitTransformer::RestoreSavedTryContext(
+                Z,
+                current_block_->scope->parent()->parent()->parent(),
+                try_blocks_list_->outer_try_block()->try_index()));
       }
-      AddSavedExceptionAndStacktraceToScope(
-          exception_var, stack_trace_var, current_block_->scope);
+      SaveExceptionAndStacktrace(exception_var, stack_trace_var);
     }
 
     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 47 matching lines @@
 
   // Build the if/then/else nest from the inside out.  Keep the AST simple
   // for the case of a single generic catch clause.  The initial value of
   // current is the last (innermost) else block if there were any catch
   // clauses.
   SequenceNode* current = NULL;
   if (!generic_catch_seen) {
     // There isn't a generic catch clause so create a clause body that
     // rethrows the exception.  This includes the case that there were no
     // catch clauses.
+    // An await cannot possibly be executed inbetween the catch entry and here,
+    // therefore, it is safe to rethrow the stack-based :exception_var instead
+    // of the captured copy :saved_exception_var.
     current = new(Z) SequenceNode(handler_pos, NULL);
     current->Add(new(Z) ThrowNode(
         handler_pos,
         new(Z) LoadLocalNode(handler_pos, exception_var),
         new(Z) LoadLocalNode(handler_pos, stack_trace_var)));
   } else if (type_tests.Last()->IsLiteralNode()) {
     ASSERT(type_tests.Last()->AsLiteralNode()->literal().raw() ==
            Bool::True().raw());
     // The last body is entered unconditionally.  Start building the
     // if/then/else nest with that body as the innermost else block.
     // Note that it is nested inside an extra block which we opened
     // before we knew the body was entered unconditionally.
     type_tests.RemoveLast();
     current_block_->statements->Add(catch_blocks.RemoveLast());
     current = CloseBlock();
   }
   // If the last body was entered conditionally and there is no need to add
   // a rethrow, use an empty else body (current = NULL above).
 
   while (!type_tests.is_empty()) {
     AstNode* type_test = type_tests.RemoveLast();
     SequenceNode* catch_block = catch_blocks.RemoveLast();
 
+    // TODO(regis): Understand the purpose of the following code restoring
+    // :saved_try_context_var. This code was added as part of r39926.
+    // In some cases, this code even crashed the compiler (debug mode assert),
+    // because the scope unchaining was starting from the wrong block.
+    // The catch clause(s) emitted below contain the same restoring code.
+    // So why is it necessary? Could it be an attempt to handle the case where
+    // the catch clause is replaced by a throw because of a bad type? It is not
+    // necessary in this case either, because no await could have been executed
+    // between the setup of :saved_try_context_var in the try clause and here
+    // (it is the execution of an await that clears all stack-based variables).
+
     // 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 (innermost_function().IsAsyncClosure() ||
         innermost_function().IsAsyncFunction() ||
         innermost_function().IsSyncGenClosure() ||
         innermost_function().IsSyncGenerator()) {
       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
+        // We need to unchain three scope levels (from the catch block and not
+        // from the current block): catch clause, catch
         // parameters, and the general try block.
-        RestoreSavedTryContext(
-            current_block_->scope->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(
+            AwaitTransformer::RestoreSavedTryContext(
+                Z,
+                catch_block->scope()->parent()->parent()->parent(),
+                try_blocks_list_->outer_try_block()->try_index()));
       }
     }
 
     current_block_->statements->Add(new(Z) 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(Z, last_used_try_index_ - 1);
+  const String& async_saved_try_ctx_name = String::ZoneHandle(Z,
+      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);
   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(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_saved_try_ctx,
       new(Z) 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);
-}
-
-
-// Restore the currently relevant :saved_try_context_var on the stack
-// from the captured :async_saved_try_ctx_var_.
-// * 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::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(Z, try_index);
-  LocalVariable* async_saved_try_ctx =
-      target->scope()->LookupVariable(async_saved_try_ctx_name, false);
-  ASSERT(async_saved_try_ctx != NULL);
-  ASSERT(async_saved_try_ctx->is_captured());
-  target->Add(new (Z) StoreLocalNode(
-      Scanner::kNoSourcePos,
-      saved_try_ctx,
-      new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
-
-  parsed_function()->set_saved_try_ctx(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
   //                            processing the catch block handler.
   // ':exception_var' - Used to save the current exception object that was
   //                    thrown.
   // ':stack_trace_var' - Used to save the current stack trace object which
   //                      the stack trace was copied into when an exception
   //                      was thrown.
   // :exception_var and :stack_trace_var get set with the exception object
   // and the stack trace object when an exception is thrown.  These three
   // implicit variables can never be captured.
+  // Parallel try statements share the same set of variables.
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
     context_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::SavedTryContextVar(),
         Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
     exception_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::ExceptionVar(),
         Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(exception_var);
   }
   LocalVariable* stack_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (stack_trace_var == NULL) {
     stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
         Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
+  if (innermost_function().IsAsyncClosure() ||
+      innermost_function().IsAsyncFunction() ||
+      innermost_function().IsSyncGenClosure() ||
+      innermost_function().IsSyncGenerator()) {
+    SetupSavedExceptionAndStacktrace();
+  }
+
   const intptr_t try_pos = TokenPos();
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
@@ skipping 242 matching lines @@
     AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
     await_marker->set_scope(current_block_->scope);
     yield->AddNode(await_marker);
     // Return true to indicate that a value has been generated.
     ReturnNode* return_true = new(Z) ReturnNode(statement_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.
-    const String& async_saved_try_ctx_name =
-        String::Handle(Z, parsed_function()->async_saved_try_ctx_name());
-    if (!async_saved_try_ctx_name.IsNull()) {
-      LocalVariable* async_saved_try_ctx =
-          current_block_->scope->LookupVariable(async_saved_try_ctx_name,
-                                                false);
-      ASSERT(async_saved_try_ctx != NULL);
-      yield->AddNode(new (Z) StoreLocalNode(
-          Scanner::kNoSourcePos,
-          parsed_function()->saved_try_ctx(),
-          new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
+    // restoring the saved try context that lives on the stack and possibly the
+    // saved try context of the outer try block.
+    LocalScope* try_scope;
+    int16_t try_index;
+    LocalScope* outer_try_scope;
+    int16_t outer_try_index;
+    CheckAsyncOpInTryBlock(&try_scope, &try_index,
+                           &outer_try_scope, &outer_try_index);
+    if (try_scope != NULL) {
+      yield->AddNode(
+          AwaitTransformer::RestoreSavedTryContext(Z,
+                                                   try_scope,
+                                                   try_index));
+      if (outer_try_scope != NULL) {
+        yield->AddNode(
+            AwaitTransformer::RestoreSavedTryContext(Z,
+                                                     outer_try_scope,
+                                                     outer_try_index));
+      }
+    } else {
+      ASSERT(outer_try_scope == NULL);
     }
 
     statement = yield;
     ExpectSemicolon();
   } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if (token == Token::kASSERT) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
@@ skipping 30 matching lines @@
     // Rethrow of current exception.
     ConsumeToken();
     ExpectSemicolon();
     // Check if it is ok to do a rethrow.
     if ((try_blocks_list_ == NULL) || !try_blocks_list_->inside_catch()) {
       ReportError(statement_pos, "rethrow of an exception is not valid here");
     }
 
     // If in async code, use :saved_exception_var and :saved_stack_trace_var
     // instead of :exception_var and :stack_trace_var.
+    // These variables are bound in the block containing the try.
+    // Look in the try scope directly.
+    LocalScope* scope = try_blocks_list_->try_block()->scope->parent();
+    ASSERT(scope != NULL);
     LocalVariable* excp_var;
     LocalVariable* trace_var;
     if (innermost_function().IsAsyncClosure() ||
         innermost_function().IsAsyncFunction() ||
         innermost_function().IsSyncGenClosure() ||
         innermost_function().IsSyncGenerator()) {
-      // The saved exception and stack trace variables are bound in the block
-      // containing the catch. So start looking in the current scope.
-      LocalScope* scope = current_block_->scope;
-      excp_var = scope->LookupVariable(Symbols::SavedExceptionVar(), false);
-      trace_var = scope->LookupVariable(Symbols::SavedStackTraceVar(), false);
+      excp_var = scope->LocalLookupVariable(Symbols::SavedExceptionVar());
+      trace_var = scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
     } else {
-      // The exception and stack trace variables are bound in the block
-      // containing the try. Look in the try scope directly.
-      LocalScope* scope = try_blocks_list_->try_block()->scope->parent();
-      ASSERT(scope != NULL);
       excp_var = scope->LocalLookupVariable(Symbols::ExceptionVar());
       trace_var = scope->LocalLookupVariable(Symbols::StackTraceVar());
     }
     ASSERT(excp_var != NULL);
     ASSERT(trace_var != NULL);
 
     statement = new(Z) ThrowNode(
         statement_pos,
         new(Z) LoadLocalNode(statement_pos, excp_var),
         new(Z) LoadLocalNode(statement_pos, trace_var));
@@ skipping 669 matching lines @@
                                     SequenceNode** await_preamble) {
   TRACE_PARSER("ParseAwaitableExpr");
   BoolScope saved_seen_await(&parsed_function()->have_seen_await_expr_, false);
   AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (parsed_function()->have_seen_await()) {
     // 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,
-                        *parsed_function(),
-                        async_temp_scope_);
+    AwaitTransformer at(current_block_->statements, async_temp_scope_);
     AstNode* result = at.Transform(expr);
     SequenceNode* preamble = CloseBlock();
     if (await_preamble == NULL) {
       current_block_->statements->Add(preamble);
     } else {
       *await_preamble = preamble;
     }
     return result;
   }
   return expr;
@@ skipping 95 matching lines @@
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
   if (IsAwaitKeyword()) {
     TRACE_PARSER("ParseAwaitExpr");
     if (!innermost_function().IsAsyncFunction() &&
         !innermost_function().IsAsyncClosure()) {
       ReportError("await operator is only allowed in async function");
     }
     ConsumeToken();
     parsed_function()->record_await();
-    expr = new (Z) AwaitNode(op_pos, ParseUnaryExpr());
+
+    LocalScope* try_scope;
+    int16_t try_index;
+    LocalScope* outer_try_scope;
+    int16_t outer_try_index;
+    CheckAsyncOpInTryBlock(&try_scope, &try_index,
+                           &outer_try_scope, &outer_try_index);
+
+    expr = new (Z) AwaitNode(op_pos,
+                             ParseUnaryExpr(),
+                             try_scope,
+                             try_index,
+                             outer_try_scope,
+                             outer_try_index);
   } 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 1252 matching lines @@
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
     bool allow_deferred_type,
     bool consume_unresolved_prefix) {
   TRACE_PARSER("ParseType");
   CheckToken(Token::kIDENT, "type name expected");
   intptr_t ident_pos = TokenPos();
   LibraryPrefix& prefix = LibraryPrefix::Handle(Z);
-  String& type_name = String::Handle(Z);;
+  String& type_name = String::Handle(Z);
 
   if (finalization == ClassFinalizer::kIgnore) {
     if (!is_top_level_ && (current_block_ != NULL)) {
       // Add the library prefix or type class name to the list of referenced
       // names of this scope, even if the type is ignored.
       current_block_->scope->AddReferencedName(TokenPos(), *CurrentLiteral());
     }
     SkipQualIdent();
   } else {
     prefix = ParsePrefix();
@@ skipping 1539 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart