Enable await in while and do-while.

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 5930 matching lines @@
   const intptr_t ident_pos = TokenPos();
   const String& ident = *CurrentLiteral();
   LocalVariable* variable = new(I) LocalVariable(
       ident_pos, ident, type);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
-    AstNode* expr = ParseAwaitableExpr(is_const, kConsumeCascades);
+    AstNode* expr = ParseAwaitableExpr(is_const, kConsumeCascades, NULL);
     initialization = new(I) StoreLocalNode(
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ReportError(ident_pos,
                 "missing initialization of 'final' or 'const' variable");
   } else {
@@ skipping 728 matching lines @@
   ASSERT(CurrentToken() == Token::kIF);
   const intptr_t if_pos = TokenPos();
   SourceLabel* label = NULL;
   if (label_name != NULL) {
     label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(label);
   }
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
-  AstNode* cond_expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades);
+  AstNode* cond_expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body = false;
   SequenceNode* true_branch = ParseNestedStatement(parsing_loop_body, NULL);
   SequenceNode* false_branch = NULL;
   if (CurrentToken() == Token::kELSE) {
     ConsumeToken();
     false_branch = ParseNestedStatement(parsing_loop_body, NULL);
   }
   AstNode* if_node = new(I) IfNode(
       if_pos, cond_expr, true_branch, false_branch);
@@ skipping 152 matching lines @@
 
 AstNode* Parser::ParseSwitchStatement(String* label_name) {
   TRACE_PARSER("ParseSwitchStatement");
   ASSERT(CurrentToken() == Token::kSWITCH);
   const intptr_t switch_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   const intptr_t expr_pos = TokenPos();
-  AstNode* switch_expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades);
+  AstNode* switch_expr = ParseAwaitableExpr(
+      kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable. The type of the
   // variable is set to dynamic. It will later be patched to match the
   // type of the case clause expressions. Therefore, we have to allocate
   // a new type representing dynamic and can't reuse the canonical
   // type object for dynamic.
@@ skipping 76 matching lines @@
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
   const intptr_t while_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
-  AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
+  SequenceNode* await_preamble = NULL;
+  AstNode* cond_expr = ParseAwaitableExpr(
+      kAllowConst, kConsumeCascades, &await_preamble);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
-  return new(I) WhileNode(while_pos, label, cond_expr, while_body);
+  WhileNode* while_node = new (I) WhileNode(while_pos,
+                                            label,
+                                            cond_expr,
+                                            await_preamble,
+                                            while_body);
+  return while_node;
 }
 
 
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
   const intptr_t do_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body =  true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
-  AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
+  SequenceNode* await_preamble = NULL;
+  AstNode* cond_expr = ParseAwaitableExpr(
+      kAllowConst, kConsumeCascades, &await_preamble);
+  // No need for special handling of the await preamble as we can just append o
+  // it to the loop body.
+  if (await_preamble != NULL) {
+    dowhile_body->Add(await_preamble);
+  }
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new(I) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
@@ skipping 89 matching lines @@
   } else {
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
     }
   }
 
   SequenceNode* for_loop_statement = CloseBlock();
 
   AstNode* while_statement = new(I) WhileNode(
-      forin_pos, label, iterator_moveNext, for_loop_statement);
+      forin_pos, label, iterator_moveNext, NULL, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
   const intptr_t for_pos = TokenPos();
   ConsumeToken();
@@ skipping 733 matching lines @@
     statement = ParseTryStatement(label_name);
   } else if (token == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
         ReportError(return_pos,
                     "return of a value not allowed in constructors");
       }
-      AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades);
+      AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
       statement = new(I) ReturnNode(statement_pos, expr);
     } else {
       statement = new(I) ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if (token == Token::kASSERT) {
     statement = ParseAssertStatement();
@@ skipping 44 matching lines @@
         scope->LocalLookupVariable(Symbols::ExceptionVar());
     ASSERT(excp_var != NULL);
     LocalVariable* trace_var =
         scope->LocalLookupVariable(Symbols::StackTraceVar());
     ASSERT(trace_var != NULL);
     statement = new(I) ThrowNode(
         statement_pos,
         new(I) LoadLocalNode(statement_pos, excp_var),
         new(I) LoadLocalNode(statement_pos, trace_var));
   } else {
-    statement = ParseAwaitableExpr(kAllowConst, kConsumeCascades);
+    statement = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
 void Parser::ReportError(const Error& error) {
   Report::LongJump(error);
   UNREACHABLE();
 }
@@ skipping 642 matching lines @@
       ASSERT(field.value() != Object::transition_sentinel().raw());
       return new(iso) LiteralNode(expr->token_pos(),
                              Instance::ZoneHandle(iso, field.value()));
     }
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseAwaitableExpr(bool require_compiletime_const,
-                                    bool consume_cascades) {
+                                    bool consume_cascades,
+                                    SequenceNode** await_preamble) {
   TRACE_PARSER("ParseAwaitableExpr");
   parsed_function()->reset_have_seen_await();
   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,
                         library_,
                         parsed_function(),
                         async_temp_scope_);
     AstNode* result = at.Transform(expr);
-    AstNode* await_preamble = CloseBlock();
-    current_block_->statements->Add(await_preamble);
+    SequenceNode* preamble = CloseBlock();
+    if (await_preamble == NULL) {
+      current_block_->statements->Add(preamble);
+    } else {
+      *await_preamble = preamble;
+    }
     parsed_function()->reset_have_seen_await();
     return result;
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
@@ skipping 2913 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart