Fix yield statements in catch blocks

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 3153 matching lines @@
     // The closure containing the body of an async function is debuggable.
     ASSERT(func.is_debuggable());
     OpenAsyncClosure();
   } else if (func.IsSyncGenerator()) {
     // The code of a sync generator is synthesized. Disable debugging.
     func.set_is_debuggable(false);
     generated_body_closure = OpenSyncGeneratorFunction(func.token_pos());
   } else if (func.IsSyncGenClosure()) {
     // The closure containing the body of a sync generator is debuggable.
     ASSERT(func.is_debuggable());
-    // Nothing special to do.
+    async_temp_scope_ = current_block_->scope;
   }
 
   BoolScope allow_await(&this->await_is_keyword_,
                         func.IsAsyncOrGenerator() || func.is_generated_body());
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
@@ skipping 2783 matching lines @@
         stack_trace_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
     current_block_->statements->Add(new(Z) InstanceCallNode(
         Scanner::kNoSourcePos,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var),
         Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
         no_args));
   }
 
   ASSERT(try_blocks_list_ != NULL);
-  if (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();
-    }
+  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();
   }
 
   // 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 71 matching lines @@
         Symbols::StackTraceVar(),
         Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
   // Open the try block.
   OpenBlock();
   PushTryBlock(current_block_);
 
   if (innermost_function().IsAsyncClosure() ||
-      innermost_function().IsAsyncFunction()) {
+      innermost_function().IsAsyncFunction() ||
+      innermost_function().IsSyncGenClosure() ||
+      innermost_function().IsSyncGenerator()) {
     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());
@@ skipping 62 matching lines @@
       ClassFinalizer::FinalizeType(
           sig_cls, sig_type, ClassFinalizer::kCanonicalize);
     }
     ASSERT(AbstractType::Handle(Z, body.result_type()).IsResolved());
     ASSERT(body.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(body);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   OpenBlock();
-
-  /*
-  async_temp_scope_ = current_block_->scope; // Is this needed?
-  */
+  async_temp_scope_ = current_block_->scope;
   return body.raw();
 }
 
 SequenceNode* Parser::CloseSyncGenFunction(const Function& closure,
                                            SequenceNode* closure_body) {
   // The block for the closure body has already been closed. Close the
   // corresponding function block.
   CloseBlock();
 
   closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
@@ skipping 2008 matching lines @@
 
 SequenceNode* Parser::ParseFinallyBlock() {
   TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
 
   // In case of async closures we need to restore the saved try index of an
   // outer try block (if it exists).  The current try block has already been
   // removed from the stack of try blocks.
   if ((innermost_function().IsAsyncClosure() ||
-       innermost_function().IsAsyncFunction()) &&
+       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();
   }
 
   ParseStatementSequence();
@@ skipping 139 matching lines @@
     }
 
     // Add nested block with user-defined code.  This blocks allows
     // declarations in the body to shadow the catch parameters.
     CheckToken(Token::kLBRACE);
 
     // In case of async closures we need to restore the saved try index of an
     // outer try block (if it exists).
     ASSERT(try_blocks_list_ != NULL);
     if (innermost_function().IsAsyncClosure() ||
-        innermost_function().IsAsyncFunction()) {
+        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);
@@ skipping 87 matching lines @@
   // 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();
 
     // 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().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(),
             try_blocks_list_->outer_try_block()->try_index(),
             current_block_->statements);
@@ skipping 10 matching lines @@
 }
 
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name =
       BuildAsyncSavedTryContextName(Z, 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)));
@@ skipping 85 matching lines @@
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
   PushTryBlock(current_block_);
   ExpectToken(Token::kLBRACE);
 
   if (innermost_function().IsAsyncClosure() ||
-      innermost_function().IsAsyncFunction()) {
+      innermost_function().IsAsyncFunction() ||
+      innermost_function().IsSyncGenClosure() ||
+      innermost_function().IsSyncGenerator()) {
     SetupSavedTryContext(context_var);
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
       (CurrentToken() != Token::kFINALLY)) {
     ReportError("catch or finally clause expected");
@@ skipping 221 matching lines @@
       yield->AddNode(set_is_yield_each);
     }
     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)));
+    }
+
     statement = yield;
     ExpectSemicolon();
   } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if (token == Token::kASSERT) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
     statement = ParseVariableDeclarationList();
     ExpectSemicolon();
@@ skipping 3669 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart