Suspend after async generator terminates

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 6071 matching lines @@
   ReturnNode* return_node = new(Z) ReturnNode(Scanner::kNoSourcePos);
   AddNodeForFinallyInlining(return_node);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
   TryStack* try_statement = PopTry();
   ASSERT(try_stack_ == NULL);  // We popped the outermost try block.
 
-  // Finally block: closing the stream and returning. (Note: the return
-  // is necessary otherwise the back-end will append a rethrow of the
-  // current exception.)
+  // Finally block: closing the stream and returning. Instead of simply
+  // returning, create an await state and suspend. There may be outstanding
+  // calls to schedule the generator body. This suspension ensures that we
+  // do not repeat any code of the generator body.
   // :controller.close();
-  // return;
+  // suspend;
   // We need to inline this code in all recorded exit points.
   intptr_t node_index = 0;
   SequenceNode* finally_clause = NULL;
   do {
     OpenBlock();
     ArgumentListNode* no_args =
         new(Z) ArgumentListNode(Scanner::kNoSourcePos);
     current_block_->statements->Add(
         new(Z) InstanceCallNode(try_end_pos,
             new(Z) LoadLocalNode(Scanner::kNoSourcePos, controller),
             Symbols::Close(),
             no_args));
 
-    ReturnNode* return_node = new(Z) ReturnNode(Scanner::kNoSourcePos);
-    current_block_->statements->Add(return_node);
+    // Suspend after the close.
+    AwaitMarkerNode* await_marker = new(Z) AwaitMarkerNode();
+    await_marker->set_scope(current_block_->scope);
+    current_block_->statements->Add(await_marker);
+    ReturnNode* continuation_ret = new(Z) ReturnNode(try_end_pos);
+    continuation_ret->set_return_type(ReturnNode::kContinuationTarget);
+    current_block_->statements->Add(continuation_ret);
 
     finally_clause = CloseBlock();
     AstNode* node_to_inline = try_statement->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);
@@ skipping 7086 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart