Model 'await for' as an explicit node in tree and fix its handling.

pkg/compiler/lib/src/tree/nodes.dart

 // 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.
 
 part of tree;
 
 abstract class Visitor<R> {
   const Visitor();
 
   R visitNode(Node node);
 
+  R visitAsyncForIn(AsyncForIn node) => visitLoop(node);
   R visitAsyncModifier(AsyncModifier node) => visitNode(node);
   R visitAwait(Await node) => visitExpression(node);
   R visitBlock(Block node) => visitStatement(node);
   R visitBreakStatement(BreakStatement node) => visitGotoStatement(node);
   R visitCascade(Cascade node) => visitExpression(node);
   R visitCascadeReceiver(CascadeReceiver node) => visitExpression(node);
   R visitCaseMatch(CaseMatch node) => visitNode(node);
   R visitCatchBlock(CatchBlock node) => visitNode(node);
   R visitClassNode(ClassNode node) => visitNode(node);
   R visitCombinator(Combinator node) => visitNode(node);
   R visitConditional(Conditional node) => visitExpression(node);
   R visitContinueStatement(ContinueStatement node) => visitGotoStatement(node);
   R visitDoWhile(DoWhile node) => visitLoop(node);
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
   R visitEnum(Enum node) => visitNode(node);
   R visitExport(Export node) => visitLibraryDependency(node);
   R visitExpression(Expression node) => visitNode(node);
   R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
   R visitFor(For node) => visitLoop(node);
-  R visitForIn(ForIn node) => visitLoop(node);
   R visitFunctionDeclaration(FunctionDeclaration node) => visitStatement(node);
   R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
   R visitGotoStatement(GotoStatement node) => visitStatement(node);
   R visitIdentifier(Identifier node) => visitExpression(node);
   R visitIf(If node) => visitStatement(node);
   R visitImport(Import node) => visitLibraryDependency(node);
   R visitLabel(Label node) => visitNode(node);
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   R visitLibraryDependency(LibraryDependency node) => visitLibraryTag(node);
   R visitLibraryName(LibraryName node) => visitLibraryTag(node);
   R visitLibraryTag(LibraryTag node) => visitNode(node);
   R visitLiteral(Literal node) => visitExpression(node);
   R visitLiteralBool(LiteralBool node) => visitLiteral(node);
   R visitLiteralDouble(LiteralDouble node) => visitLiteral(node);
   R visitLiteralInt(LiteralInt node) => visitLiteral(node);
   R visitLiteralList(LiteralList node) => visitExpression(node);
   R visitLiteralMap(LiteralMap node) => visitExpression(node);
   R visitLiteralMapEntry(LiteralMapEntry node) => visitNode(node);
   R visitLiteralNull(LiteralNull node) => visitLiteral(node);
   R visitLiteralString(LiteralString node) => visitStringNode(node);
   R visitStringJuxtaposition(StringJuxtaposition node) => visitStringNode(node);
+  R visitSyncForIn(SyncForIn node) => visitLoop(node);
   R visitLoop(Loop node) => visitStatement(node);
   R visitMetadata(Metadata node) => visitNode(node);
   R visitMixinApplication(MixinApplication node) => visitNode(node);
   R visitModifiers(Modifiers node) => visitNode(node);
   R visitNamedArgument(NamedArgument node) => visitExpression(node);
   R visitNamedMixinApplication(NamedMixinApplication node) {
     return visitMixinApplication(node);
   }
   R visitNewExpression(NewExpression node) => visitExpression(node);
   R visitNodeList(NodeList node) => visitNode(node);
@@ skipping 95 matching lines @@
   Conditional asConditional() => null;
   ContinueStatement asContinueStatement() => null;
   DoWhile asDoWhile() => null;
   EmptyStatement asEmptyStatement() => null;
   Enum asEnum() => null;
   ErrorExpression asErrorExpression() => null;
   Export asExport() => null;
   Expression asExpression() => null;
   ExpressionStatement asExpressionStatement() => null;
   For asFor() => null;
+  SyncForIn asSyncForIn() => null;
+  AsyncForIn asAsyncForIn() => null;
   ForIn asForIn() => null;
   FunctionDeclaration asFunctionDeclaration() => null;
   FunctionExpression asFunctionExpression() => null;
   Identifier asIdentifier() => null;
   If asIf() => null;
   Import asImport() => null;
   Label asLabel() => null;
   LabeledStatement asLabeledStatement() => null;
   LibraryName asLibraryName() => null;
   LibraryDependency asLibraryDependency() => null;
@@ skipping 1590 matching lines @@
 
 class ContinueStatement extends GotoStatement {
   ContinueStatement(Identifier target, Token keywordToken, Token semicolonToken)
     : super(target, keywordToken, semicolonToken);
 
   ContinueStatement asContinueStatement() => this;
 
   accept(Visitor visitor) => visitor.visitContinueStatement(this);
 }
 
-class ForIn extends Loop with StoredTreeElementMixin {
+abstract class ForIn extends Loop {
   final Node declaredIdentifier;
   final Expression expression;
 
-  final Token awaitToken;
   final Token forToken;
   final Token inToken;
 
   ForIn(this.declaredIdentifier, this.expression,
-        Statement body, this.awaitToken, this.forToken, this.inToken)
+        Statement body, this.forToken, this.inToken)
       : super(body);
 
-  bool get isAsync => awaitToken != null;
-
   Expression get condition => null;
 
   ForIn asForIn() => this;
 
-  accept(Visitor visitor) => visitor.visitForIn(this);
+  Token getEndToken() => body.getEndToken();
+}
+
+class SyncForIn extends ForIn with StoredTreeElementMixin {
+  SyncForIn(declaredIdentifier, expression, Statement body, forToken, inToken)
+      : super(declaredIdentifier, expression, body, forToken, inToken);
+
+  SyncForIn asSyncForIn() => this;
+
+  accept(Visitor visitor) => visitor.visitSyncForIn(this);
 
   visitChildren(Visitor visitor) {
     declaredIdentifier.accept(visitor);
     expression.accept(visitor);
     body.accept(visitor);
   }
 
-  Token getBeginToken() => awaitToken != null ? awaitToken : forToken;
+  Token getBeginToken() => forToken;
+}
 
-  Token getEndToken() => body.getEndToken();
+class AsyncForIn extends ForIn with StoredTreeElementMixin {
+  final Token awaitToken;
+
+  AsyncForIn(declaredIdentifier, expression,
+        Statement body, this.awaitToken, forToken, inToken)
+      : super(declaredIdentifier, expression, body, forToken, inToken);
+
+  AsyncForIn asAsyncForIn() => this;
+
+  accept(Visitor visitor) => visitor.visitAsyncForIn(this);
+
+  visitChildren(Visitor visitor) {
+    declaredIdentifier.accept(visitor);
+    expression.accept(visitor);
+    body.accept(visitor);
+  }
+
+  Token getBeginToken() => awaitToken;
 }
 
 class Label extends Node {
   final Identifier identifier;
   final Token colonToken;
 
   Label(this.identifier, this.colonToken);
 
   String get labelName => identifier.source;
 
@@ skipping 480 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }