Enable await in for and for-in loops.

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 5917 matching lines @@
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
   return new(I) InstanceGetterNode(token_pos, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
-                                          bool is_const) {
+                                          bool is_const,
+                                          SequenceNode** await_preamble) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   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, NULL);
+    AstNode* expr = ParseAwaitableExpr(
+        is_const, kConsumeCascades, await_preamble);
     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 92 matching lines @@
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
   const AbstractType& type = AbstractType::ZoneHandle(I,
       ParseConstFinalVarOrType(FLAG_enable_type_checks ?
           ClassFinalizer::kCanonicalize : ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ReportError("identifier expected");
   }
 
-  AstNode* initializers = ParseVariableDeclaration(type, is_final, is_const);
+  SequenceNode* preamble = NULL;
+  AstNode* initializers =
+      ParseVariableDeclaration(type, is_final, is_const, &preamble);
   ASSERT(initializers != NULL);
+  if (preamble != NULL) {
+    preamble->Add(initializers);
+    initializers = preamble;
+  }
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
       ReportError("identifier expected after comma");
     }
     // We have a second initializer. Allocate a sequence node now.
     // The sequence does not own the current scope. Set its own scope to NULL.
     SequenceNode* sequence = NodeAsSequenceNode(initializers->token_pos(),
                                                 initializers,
                                                 NULL);
-    sequence->Add(ParseVariableDeclaration(type, is_final, is_const));
+    preamble = NULL;
+    AstNode* declaration = ParseVariableDeclaration(
+        type, is_final, is_const, &preamble);
+    if (preamble != NULL) {
+      sequence->Add(preamble);
+    }
+    sequence->Add(declaration);
     initializers = sequence;
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::Handle(I);
   const String* variable_name = NULL;
@@ skipping 941 matching lines @@
                                       ClassFinalizer::kIgnore));
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new(I) LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
-  AstNode* collection_expr = ParseExpr(kAllowConst, kConsumeCascades);
+  AstNode* collection_expr =
+      ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
@@ skipping 80 matching lines @@
   // Open a block that contains the loop variable. Make it a loop block so
   // that we allocate a new context if the loop variable is captured.
   OpenLoopBlock();
   AstNode* initializer = NULL;
   const intptr_t init_pos = TokenPos();
   LocalScope* init_scope = current_block_->scope;
   if (CurrentToken() != Token::kSEMICOLON) {
     if (IsVariableDeclaration()) {
       initializer = ParseVariableDeclarationList();
     } else {
-      initializer = ParseExpr(kAllowConst, kConsumeCascades);
+      initializer = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     }
   }
   ExpectSemicolon();
   AstNode* condition = NULL;
+  SequenceNode* condition_preamble = NULL;
   if (CurrentToken() != Token::kSEMICOLON) {
-    condition = ParseExpr(kAllowConst, kConsumeCascades);
+    condition = ParseAwaitableExpr(
+        kAllowConst, kConsumeCascades, &condition_preamble);
   }
   ExpectSemicolon();
   AstNode* increment = NULL;
   const intptr_t incr_pos = TokenPos();
   if (CurrentToken() != Token::kRPAREN) {
-    increment = ParseExprList();
+    increment = ParseAwaitableExprList();
   }
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* body = ParseNestedStatement(parsing_loop_body, label);
 
   // Check whether any of the variables in the initializer part of
   // the for statement are captured by a closure. If so, we insert a
   // node that creates a new Context for the loop variable before
   // the increment expression is evaluated.
   for (int i = 0; i < init_scope->num_variables(); i++) {
     if (init_scope->VariableAt(i)->is_captured() &&
         (init_scope->VariableAt(i)->owner() == init_scope)) {
       SequenceNode* incr_sequence = new(I) SequenceNode(incr_pos, NULL);
       incr_sequence->Add(new(I) CloneContextNode(for_pos));
       if (increment != NULL) {
         incr_sequence->Add(increment);
       }
       increment = incr_sequence;
       break;
     }
   }
   AstNode* for_node = new(I) ForNode(
       for_pos,
       label,
       NodeAsSequenceNode(init_pos, initializer, NULL),
       condition,
+      condition_preamble,
       NodeAsSequenceNode(incr_pos, increment, NULL),
       body);
   current_block_->statements->Add(for_node);
   return CloseBlock();
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
@@ skipping 1067 matching lines @@
         left_operand = OptimizeBinaryOpNode(
             op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
-AstNode* Parser::ParseExprList() {
-  TRACE_PARSER("ParseExprList");
-  AstNode* expressions = ParseExpr(kAllowConst, kConsumeCascades);
+AstNode* Parser::ParseAwaitableExprList() {
+  TRACE_PARSER("ParseAwaitableExprList");
+  SequenceNode* preamble = NULL;
+  AstNode* expressions = ParseAwaitableExpr(
+      kAllowConst, kConsumeCascades, &preamble);
+  if (preamble != NULL) {
+    preamble->Add(expressions);
+    expressions = preamble;
+  }
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
     SequenceNode* list = new(I) SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
-      AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
+      preamble = NULL;
+      AstNode* expr = ParseAwaitableExpr(
+          kAllowConst, kConsumeCascades, &preamble);
+      if (preamble != NULL) {
+        list->Add(preamble);
+      }
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
@@ skipping 3250 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart