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.
+void Parser::CheckAwaitInTryBlock(

[Ivan Posva, 2015/02/27 10:23:43]

CheckAsyncOpInTryBlock as it is either await or yield that need this extra
handling.

[hausner, 2015/02/27 18:05:32]

DBC: It's not necessarily an async op either. Yield can be in a synchronous
generator. There is really nothing async specific here. This function just
gathers info about the current nesting of try scopes.

[regis, 2015/02/27 21:41:53]

Done. I was just keeping the current style :-)
I think we need a renaming pass over the source, since yield came after await.

[regis, 2015/02/27 21:41:53]

Acknowledged.

+    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;
+    if (scope->function_level() == current_block_->scope->function_level()) {
+      // 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() &&

[Ivan Posva, 2015/02/27 10:23:43]

Shouldn't this if be nested inside the one above? Or is there really a case
where you expect to set *outer_try_scope, but not *try_scope?

Also you might want to expand on the fact that the checking for being
inside_catch() here is an optimization as it would not be wrong to restore the
outer value unconditionally. It is just only needed from within a catch (or
finally which is its own "catchall" since you have the potential of leaving the
current block in an unstructured fashion.

[regis, 2015/02/27 21:41:53]

Done. The second function level check would always fail if the first one did,
but you are right that this is clearer and more efficient to nest.

 
I moved a comment from the helper function to here and updated the portion
explaining finally. The key point is that the try block matching the finally has
already been popped when parsing finally.

+        (try_blocks_list_->outer_try_block() != NULL)) {
+      scope = try_blocks_list_->outer_try_block()->try_block()->scope;
+      if (scope->function_level() == current_block_->scope->function_level()) {
+        *outer_try_scope = scope->parent();
+        *outer_try_index = try_blocks_list_->outer_try_block()->try_index();
+      }
+    }
+  }
+}
+
+
 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;
+  CheckAwaitInTryBlock(&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(
+  LocalVariable* saved_exception_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedExceptionVar());
+  if (saved_exception_var == NULL) {

[Ivan Posva, 2015/02/27 10:23:43]

How could this have already been defined before in this scope? Shouldn't this be
an assertion instead?

[regis, 2015/02/27 21:41:53]

No. Note that I moved these variables in the parent scope of where they were
earlier, because these need to be accessible in the finally clause (issue 22595
to be fixed).

Now, several parallel try statements will reuse the variables, as the
non-captured versions of these variables are reused too.
I added a comment here and where the non-captured versions are created.

+    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) {

[Ivan Posva, 2015/02/27 10:23:43]

ditto

[regis, 2015/02/27 21:41:53]

ditto

+    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
@@ skipping 27 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);
   }
 
+  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;
+    CheckAwaitInTryBlock(&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;
+    CheckAwaitInTryBlock(&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