Fix more async machinery (capture return value when necessary, issue 22620).

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 134 matching lines @@
                               Symbols::ExprTemp(),
                               Type::ZoneHandle(Type::DynamicType()));
     ASSERT(temp != NULL);
     set_expression_temp_var(temp);
   }
   ASSERT(has_expression_temp_var());
   return expression_temp_var();
 }
 
 
-void ParsedFunction::EnsureFinallyReturnTemp() {
+void ParsedFunction::EnsureFinallyReturnTemp(bool is_async) {
   if (!has_finally_return_temp_var()) {
     LocalVariable* temp = new(Z) LocalVariable(
         function_.token_pos(),
         String::ZoneHandle(Z, Symbols::New(":finally_ret_val")),
         Type::ZoneHandle(Z, Type::DynamicType()));
     ASSERT(temp != NULL);
     temp->set_is_final();
+    if (is_async) {
+      temp->set_is_captured();
+    }
     set_finally_return_temp_var(temp);
   }
   ASSERT(has_finally_return_temp_var());
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
@@ skipping 5921 matching lines @@
     finally_clause = CloseBlock();
     AstNode* node_to_inline = try_block->GetNodeToInlineFinally(node_index);
     if (node_to_inline != NULL) {
       InlinedFinallyNode* node =
           new(Z) InlinedFinallyNode(try_end_pos,
                                     finally_clause,
                                     context_var,
                                     // No outer try statement
                                     CatchClauseNode::kInvalidTryIndex);
       finally_clause = NULL;
-      AddFinallyBlockToNode(node_to_inline, node);
+      AddFinallyBlockToNode(true, node_to_inline, node);
       node_index++;
     }
   } while (finally_clause == NULL);
 
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   handler_types.Add(dynamic_type);  // Catch block handles all exceptions.
 
   CatchClauseNode* catch_clause = new(Z) CatchClauseNode(
       Scanner::kNoSourcePos,
@@ skipping 2647 matching lines @@
         break;
       }
     }
     iterator->AddNodeForFinallyInlining(node);
     iterator = iterator->outer_try_block();
   }
 }
 
 
 // Add the inlined finally block to the specified node.
-void Parser::AddFinallyBlockToNode(AstNode* node,
+void Parser::AddFinallyBlockToNode(bool is_async,
+                                   AstNode* node,
                                    InlinedFinallyNode* finally_node) {
   ReturnNode* return_node = node->AsReturnNode();
   if (return_node != NULL) {
-    parsed_function()->EnsureFinallyReturnTemp();
+    parsed_function()->EnsureFinallyReturnTemp(is_async);
     return_node->AddInlinedFinallyNode(finally_node);
     return;
   }
   JumpNode* jump_node = node->AsJumpNode();
   ASSERT(jump_node != NULL);
   jump_node->AddInlinedFinallyNode(finally_node);
 }
 
 
 SequenceNode* Parser::ParseCatchClauses(
@@ skipping 383 matching lines @@
       finally_block = ParseFinallyBlock(
           is_async,
           exception_var,
           stack_trace_var,
           is_async ? saved_exception_var : exception_var,
           is_async ? saved_stack_trace_var : stack_trace_var);
       InlinedFinallyNode* node = new(Z) InlinedFinallyNode(finally_pos,
                                                            finally_block,
                                                            context_var,
                                                            outer_try_index);
-      AddFinallyBlockToNode(node_to_inline, node);
+      AddFinallyBlockToNode(is_async, node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock(
         is_async,
         exception_var,
         stack_trace_var,
         is_async ? saved_exception_var : exception_var,
         is_async ? saved_stack_trace_var : stack_trace_var);
@@ skipping 342 matching lines @@
     // 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()) {
+        innermost_function().IsSyncGenerator() ||
+        innermost_function().IsAsyncGenClosure() ||
+        innermost_function().IsAsyncGenerator()) {
       excp_var = scope->LocalLookupVariable(Symbols::SavedExceptionVar());
       trace_var = scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
     } else {
       excp_var = scope->LocalLookupVariable(Symbols::ExceptionVar());
       trace_var = scope->LocalLookupVariable(Symbols::StackTraceVar());
     }
     ASSERT(excp_var != NULL);
     ASSERT(trace_var != NULL);
 
     statement = new(Z) ThrowNode(
@@ skipping 3636 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart