Simplify restoring of saved try contexts in async code by passing around the

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 8237 matching lines @@
     await_cond->AddNode(await_preamble);
     await_cond->AddNode(cond_expr);
     cond_expr = await_cond;
   }
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new(Z) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
+static LocalVariable* LookupSavedTryContextVar(LocalScope* scope) {
+  LocalVariable* var =
+      scope->LocalLookupVariable(Symbols::SavedTryContextVar());
+  ASSERT((var != NULL) && !var->is_captured());
+  return var;
+}
+
+
+static LocalVariable* LookupAsyncSavedTryContextVar(LocalScope* scope,
+                                                    uint16_t try_index) {
+  const String& async_saved_try_ctx_name =
+      String::ZoneHandle(Symbols::New(String::Handle(
+          String::NewFormatted(
+              "%s%d",
+              Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
+              try_index))));
+  LocalVariable* var = scope->LocalLookupVariable(async_saved_try_ctx_name);
+  ASSERT((var != NULL) && var->is_captured());\
+  return var;
+}
+
+
 // If the await or yield being parsed is in a try block, the continuation code
 // needs to restore the corresponding stack-based variable :saved_try_ctx_var,
 // and the stack-based variable :saved_try_ctx_var of the outer try block.
 // The inner :saved_try_ctx_var is used by a finally clause handling an
 // exception thrown by the continuation code in a try block or catch block.
 // If no finally clause exists, the catch or finally clause of the outer try
 // block, if any, uses the outer :saved_try_ctx_var to handle the exception.
 //
 // * Try blocks and catch blocks:
 //     Set the context variable for this try block and for the outer try block.
 // * Finally blocks:
 //     Set the context variable for the outer try block. Note that the try
 //     declaring the finally is popped before parsing the finally clause, so the
 //     outer try block 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;
+void Parser::CheckAsyncOpInTryBlock(
+    LocalVariable** saved_try_ctx,
+    LocalVariable** async_saved_try_ctx,
+    LocalVariable** outer_saved_try_ctx,
+    LocalVariable** outer_async_saved_try_ctx) const {
+  *saved_try_ctx = NULL;
+  *async_saved_try_ctx = NULL;
+  *outer_saved_try_ctx = NULL;
+  *outer_async_saved_try_ctx = NULL;
   if (try_stack_ != NULL) {
     LocalScope* scope = try_stack_->try_block()->scope;
+    uint16_t try_index = try_stack_->try_index();
     const int current_function_level = current_block_->scope->function_level();
     if (scope->function_level() == current_function_level) {
       // The block declaring :saved_try_ctx_var variable is the parent of the
       // pushed try block.
-      *try_scope = scope->parent();
-      *try_index = try_stack_->try_index();
+      *saved_try_ctx = LookupSavedTryContextVar(scope->parent());
+      *async_saved_try_ctx = LookupAsyncSavedTryContextVar(scope, try_index);
       if (try_stack_->outer_try() != NULL) {
         // TODO(regis): Collecting the outer try scope is not necessary if we
         // are in a finally block. Add support for try_stack_->inside_finally().
         scope = try_stack_->outer_try()->try_block()->scope;
+        try_index = try_stack_->outer_try()->try_index();
         if (scope->function_level() == current_function_level) {
-          *outer_try_scope = scope->parent();
-          *outer_try_index = try_stack_->outer_try()->try_index();
+          *outer_saved_try_ctx = LookupSavedTryContextVar(scope->parent());
+          *outer_async_saved_try_ctx =
+              LookupAsyncSavedTryContextVar(scope, try_index);
         }
       }
     }
   }
   // An async or async* has an implicitly created try-catch around the
   // function body, so the await or yield inside the async closure should always
   // be created with a try scope.
-  ASSERT((*try_scope != NULL) ||
+  ASSERT((*saved_try_ctx != NULL) ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsAsyncGenerator() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator());
 }
 
 
 // Build an AST node for static call to Dart function print(str).
 // Used during debugging to insert print in generated dart code.
 AstNode* Parser::DartPrint(const char* str) {
@@ skipping 103 matching lines @@
                           &exception_var,
                           &stack_trace_var,
                           &saved_exception_var,
                           &saved_stack_trace_var);
   OpenBlock();  // try block.
   PushTry(current_block_);
   SetupSavedTryContext(context_var);
 
   // Build while loop condition.
   // while (await :for-in-iter.moveNext())
-  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);
-
+  LocalVariable* saved_try_ctx;
+  LocalVariable* async_saved_try_ctx;
+  LocalVariable* outer_saved_try_ctx;
+  LocalVariable* outer_async_saved_try_ctx;
+  CheckAsyncOpInTryBlock(&saved_try_ctx,
+                         &async_saved_try_ctx,
+                         &outer_saved_try_ctx,
+                         &outer_async_saved_try_ctx);
   ArgumentListNode* no_args = new(Z) ArgumentListNode(stream_pos);
   AstNode* iterator_moveNext = new(Z) InstanceCallNode(
       stream_pos,
       new(Z) LoadLocalNode(stream_pos, iterator_var),
                            Symbols::MoveNext(),
                            no_args);
   AstNode* await_moveNext =
       new(Z) AwaitNode(stream_pos,
                        iterator_moveNext,
-                       try_scope,
-                       try_index,
-                       outer_try_scope,
-                       outer_try_index);
+                       saved_try_ctx,
+                       async_saved_try_ctx,
+                       outer_saved_try_ctx,
+                       outer_async_saved_try_ctx);
   OpenBlock();
   AwaitTransformer at(current_block_->statements, async_temp_scope_);
   await_moveNext = at.Transform(await_moveNext);
   SequenceNode* await_preamble = CloseBlock();
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
@@ skipping 57 matching lines @@
                                             for_loop_block);
   // Add the while loop to the try block.
   current_block_->statements->Add(while_node);
   SequenceNode* try_block = CloseBlock();
 
   // Create an empty "catch all" block that rethrows the current
   // exception and stacktrace.
   try_stack_->enter_catch();
   SequenceNode* catch_block = new(Z) SequenceNode(await_for_pos, NULL);
 
-  if (outer_try_scope != NULL) {
-    catch_block->Add(AwaitTransformer::RestoreSavedTryContext(
-        Z, outer_try_scope, outer_try_index));
+  if (outer_saved_try_ctx != NULL) {
+    catch_block->Add(new (Z) StoreLocalNode(
+        Scanner::kNoSourcePos,
+        outer_saved_try_ctx,
+        new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                              outer_async_saved_try_ctx)));
   }
 
   // We don't need to copy the current exception and stack trace variables
   // into :saved_exception_var and :saved_stack_trace_var here because there
   // is no code in the catch clause that could suspend the function.
 
   // Rethrow the exception.
   catch_block->Add(new(Z) ThrowNode(
       await_for_pos,
       new(Z) LoadLocalNode(await_for_pos, exception_var),
       new(Z) LoadLocalNode(await_for_pos, stack_trace_var)));
 
   TryStack* try_statement = PopTry();
-  ASSERT(try_index == try_statement->try_index());
+  const intptr_t try_index = try_statement->try_index();
+  TryStack* outer_try = try_stack_;
+  const intptr_t outer_try_index = (outer_try != NULL) ?
+      outer_try->try_index() : CatchClauseNode::kInvalidTryIndex;
 
   // The finally block contains a call to cancel the stream.
   // :for-in-iter.cancel()
 
   // Inline the finally block to the exit points in the try block.
   intptr_t node_index = 0;
   SequenceNode* finally_clause = NULL;
   do {
     OpenBlock();
     ArgumentListNode* no_args =
@@ skipping 382 matching lines @@
   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 (is_async) {
     if (try_stack_ != NULL) {
       LocalScope* scope = try_stack_->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
+        LocalVariable* saved_try_ctx =
+            LookupSavedTryContextVar(scope->parent());
+        LocalVariable* async_saved_try_ctx =
+            LookupAsyncSavedTryContextVar(scope->parent(),
+                                          try_stack_->try_index());
         current_block_->statements->Add(
-            AwaitTransformer::RestoreSavedTryContext(
-                Z, scope->parent(), try_stack_->try_index()));
+            new (Z) StoreLocalNode(
+                Scanner::kNoSourcePos,
+                saved_try_ctx,
+                new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                                      async_saved_try_ctx)));
       }
     }
     // We need to save the exception variables as in catch clauses, whether
     // there is an outer try or not. Note that this is only necessary if the
     // finally clause contains an await or yield.
     // TODO(hausner): Optimize.
     SaveExceptionAndStacktrace(current_block_->statements,
                                exception_var,
                                stack_trace_var,
                                rethrow_exception_var,
@@ skipping 237 matching lines @@
     current = CloseBlock();
   }
   // In case of async closures, restore :saved_try_context_var before executing
   // the catch clauses.
   if (is_async && (current != NULL)) {
     ASSERT(try_stack_ != NULL);
     SequenceNode* async_code = new(Z) SequenceNode(handler_pos, NULL);
     const TryStack* try_block = try_stack_->outer_try();
     if (try_block != NULL) {
       LocalScope* scope = try_block->try_block()->scope;
-      if (scope->function_level() ==
-          current_block_->scope->function_level()) {
-        async_code->Add(
-            AwaitTransformer::RestoreSavedTryContext(
-                Z, scope->parent(), try_block->try_index()));
+      if (scope->function_level() == current_block_->scope->function_level()) {
+        LocalVariable* saved_try_ctx =
+            LookupSavedTryContextVar(scope->parent());
+        LocalVariable* async_saved_try_ctx =
+            LookupAsyncSavedTryContextVar(scope->parent(),
+                                          try_block->try_index());
+        current_block_->statements->Add(
+            new (Z) StoreLocalNode(
+                Scanner::kNoSourcePos,
+                saved_try_ctx,
+                new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                                      async_saved_try_ctx)));
       }
     }
     SaveExceptionAndStacktrace(async_code,
                                exception_var,
                                stack_trace_var,
                                rethrow_exception_var,
                                rethrow_stack_trace_var);
     // The async_code node sequence contains code to restore the context (if
     // an outer try block is present) and code to save the exception and
     // stack trace variables.
@@ skipping 345 matching lines @@
     yield->AddNode(await_marker);
     // Return true to indicate that a value has been generated.
     ReturnNode* return_true = new(Z) ReturnNode(yield_pos,
         new(Z) LiteralNode(TokenPos(), Bool::True()));
     return_true->set_return_type(ReturnNode::kContinuationTarget);
     yield->AddNode(return_true);
 
     // If this expression is part of a try block, also append the code for
     // restoring the saved try context that lives on the stack and possibly the
     // saved try context of the outer try block.
-    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));
+    LocalVariable* saved_try_ctx;
+    LocalVariable* async_saved_try_ctx;
+    LocalVariable* outer_saved_try_ctx;
+    LocalVariable* outer_async_saved_try_ctx;
+    CheckAsyncOpInTryBlock(&saved_try_ctx,
+                           &async_saved_try_ctx,
+                           &outer_saved_try_ctx,
+                           &outer_async_saved_try_ctx);
+    if (saved_try_ctx != NULL) {
+      yield->AddNode(new (Z) StoreLocalNode(
+          Scanner::kNoSourcePos,
+          saved_try_ctx,
+          new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                                async_saved_try_ctx)));
+      if (outer_saved_try_ctx != NULL) {
+        yield->AddNode(new (Z) StoreLocalNode(
+            Scanner::kNoSourcePos,
+            outer_saved_try_ctx,
+            new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                                  outer_async_saved_try_ctx)));
       }
     } else {
-      ASSERT(outer_try_scope == NULL);
+      ASSERT(outer_saved_try_ctx == NULL);
     }
   } else {
     // yield statement in async* function.
     ASSERT(innermost_function().IsAsyncGenerator() ||
            innermost_function().IsAsyncGenClosure());
 
     LocalVariable* controller_var = LookupLocalScope(Symbols::Controller());
     ASSERT(controller_var != NULL);
     // :controller.add[Stream](expr);
     ArgumentListNode* add_args = new(Z) ArgumentListNode(yield_pos);
     add_args->Add(expr);
     AstNode* add_call =
         new(Z) InstanceCallNode(yield_pos,
             new(Z) LoadLocalNode(Scanner::kNoSourcePos, controller_var),
             is_yield_each ? Symbols::AddStream() : Symbols::add(),
             add_args);
 
-
     // if (:controller.add[Stream](expr)) {
     //   return;
     // }
     // await_marker;
     // continuation_return;
     // restore saved_try_context
 
     SequenceNode* true_branch =
         new(Z) SequenceNode(Scanner::kNoSourcePos, NULL);
     AstNode* return_from_generator = new(Z) ReturnNode(yield_pos);
     true_branch->Add(return_from_generator);
     AddNodeForFinallyInlining(return_from_generator);
     AstNode* if_is_cancelled =
        new(Z) IfNode(Scanner::kNoSourcePos, add_call, true_branch, NULL);
     yield->AddNode(if_is_cancelled);
 
     AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
     await_marker->set_scope(current_block_->scope);
     yield->AddNode(await_marker);
     ReturnNode* continuation_return = new(Z) ReturnNode(yield_pos);
     continuation_return->set_return_type(ReturnNode::kContinuationTarget);
     yield->AddNode(continuation_return);
 
     // If this expression is part of a try block, also append the code for
     // restoring the saved try context that lives on the stack and possibly the
     // saved try context of the outer try block.
-    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));
+    LocalVariable* saved_try_ctx;
+    LocalVariable* async_saved_try_ctx;
+    LocalVariable* outer_saved_try_ctx;
+    LocalVariable* outer_async_saved_try_ctx;
+    CheckAsyncOpInTryBlock(&saved_try_ctx,
+                           &async_saved_try_ctx,
+                           &outer_saved_try_ctx,
+                           &outer_async_saved_try_ctx);
+    if (saved_try_ctx != NULL) {
+      yield->AddNode(new (Z) StoreLocalNode(
+          Scanner::kNoSourcePos,
+          saved_try_ctx,
+          new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                                async_saved_try_ctx)));
+      if (outer_saved_try_ctx != NULL) {
+        yield->AddNode(new (Z) StoreLocalNode(
+            Scanner::kNoSourcePos,
+            outer_saved_try_ctx,
+            new (Z) LoadLocalNode(Scanner::kNoSourcePos,
+                                  outer_async_saved_try_ctx)));
       }
     } else {
-      ASSERT(outer_try_scope == NULL);
+      ASSERT(outer_saved_try_ctx == NULL);
     }
   }
   return yield;
 }
 
 
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
   intptr_t label_pos = 0;
@@ skipping 913 matching lines @@
     TRACE_PARSER("ParseAwaitExpr");
     if (!innermost_function().IsAsyncFunction() &&
         !innermost_function().IsAsyncClosure() &&
         !innermost_function().IsAsyncGenerator() &&
         !innermost_function().IsAsyncGenClosure()) {
       ReportError("await operator is only allowed in an asynchronous function");
     }
     ConsumeToken();
     parsed_function()->record_await();
 
-    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);
-
+    LocalVariable* saved_try_ctx;
+    LocalVariable* async_saved_try_ctx;
+    LocalVariable* outer_saved_try_ctx;
+    LocalVariable* outer_async_saved_try_ctx;
+    CheckAsyncOpInTryBlock(&saved_try_ctx,
+                           &async_saved_try_ctx,
+                           &outer_saved_try_ctx,
+                           &outer_async_saved_try_ctx);
     expr = new (Z) AwaitNode(op_pos,
                              ParseUnaryExpr(),
-                             try_scope,
-                             try_index,
-                             outer_try_scope,
-                             outer_try_index);
+                             saved_try_ctx,
+                             async_saved_try_ctx,
+                             outer_saved_try_ctx,
+                             outer_async_saved_try_ctx);
   } 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 2827 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart