Support async/await in the dart2js frontend.

sdk/lib/_internal/compiler/implementation/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 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);
@@ skipping 59 matching lines @@
   R visitSwitchCase(SwitchCase node) => visitNode(node);
   R visitSwitchStatement(SwitchStatement node) => visitStatement(node);
   R visitLiteralSymbol(LiteralSymbol node) => visitExpression(node);
   R visitThrow(Throw node) => visitExpression(node);
   R visitTryStatement(TryStatement node) => visitStatement(node);
   R visitTypeAnnotation(TypeAnnotation node) => visitNode(node);
   R visitTypedef(Typedef node) => visitNode(node);
   R visitTypeVariable(TypeVariable node) => visitNode(node);
   R visitVariableDefinitions(VariableDefinitions node) => visitStatement(node);
   R visitWhile(While node) => visitLoop(node);
+  R visitYield(Yield node) => visitStatement(node);
 }
 
 Token firstBeginToken(Node first, Node second) {
   Token token = null;
   if (first != null) {
     token = first.getBeginToken();
   }
   if (token == null && second != null) {
     // [token] might be null even when [first] is not, e.g. for empty Modifiers.
     token = second.getBeginToken();
@@ skipping 33 matching lines @@
   toDebugString() {
     return PrettyPrinter.prettyPrint(this);
   }
 
   String getObjectDescription() => super.toString();
 
   Token getBeginToken();
 
   Token getEndToken();
 
+  AsyncModifier asAsyncModifier() => null;
+  Await asAwait() => null;
   Block asBlock() => null;
   BreakStatement asBreakStatement() => null;
   Cascade asCascade() => null;
   CascadeReceiver asCascadeReceiver() => null;
   CaseMatch asCaseMatch() => null;
   CatchBlock asCatchBlock() => null;
   ClassNode asClassNode() => null;
   Combinator asCombinator() => null;
   Conditional asConditional() => null;
   ContinueStatement asContinueStatement() => null;
@@ skipping 46 matching lines @@
   StringNode asStringNode() => null;
   SwitchCase asSwitchCase() => null;
   SwitchStatement asSwitchStatement() => null;
   Throw asThrow() => null;
   TryStatement asTryStatement() => null;
   TypeAnnotation asTypeAnnotation() => null;
   TypeVariable asTypeVariable() => null;
   Typedef asTypedef() => null;
   VariableDefinitions asVariableDefinitions() => null;
   While asWhile() => null;
+  Yield asYield() => null;
 
   bool isValidBreakTarget() => false;
   bool isValidContinueTarget() => false;
   bool isThis() => false;
   bool isSuper() => false;
 
   bool get isErroneous => false;
 }
 
 class ClassNode extends Node {
@@ skipping 480 matching lines @@
   FunctionDeclaration asFunctionDeclaration() => this;
 
   accept(Visitor visitor) => visitor.visitFunctionDeclaration(this);
 
   visitChildren(Visitor visitor) => function.accept(visitor);
 
   Token getBeginToken() => function.getBeginToken();
   Token getEndToken() => function.getEndToken();
 }
 
+/// Node representing the method implementation modifiers `sync*`, `async`, and
+/// `async*` or the invalid modifier `sync`.
+class AsyncModifier extends Node {
+  /// The `async` or `sync` token.
+  final Token asyncToken;
+
+  /// The `*` token.
+  final Token starToken;
+
+  AsyncModifier(this.asyncToken, this.starToken);
+
+  AsyncModifier asAsyncModifier() => this;
+
+  accept(Visitor visitor) => visitor.visitAsyncModifier(this);
+
+  visitChildren(Visitor visitor) {}
+
+  Token getBeginToken() => asyncToken;
+
+  Token getEndToken() => starToken != null ? starToken : asyncToken;
+
+  /// Is `true` if this modifier is either `async` or `async*`.
+  bool get isAsynchronous => asyncToken.value == 'async';
+
+  /// Is `true` if this modifier is either `sync*` or `async*`.
+  bool get isYielding => starToken != null;
+}
+
 class FunctionExpression extends Expression with StoredTreeElementMixin {
   final Node name;
 
   /**
    * List of VariableDefinitions or NodeList.
    *
    * A NodeList can only occur at the end and holds named parameters.
    */
   final NodeList parameters;
 
   final Statement body;
   final TypeAnnotation returnType;
   final Modifiers modifiers;
   final NodeList initializers;
 
   final Token getOrSet;
+  final AsyncModifier asyncModifier;
 
   FunctionExpression(this.name, this.parameters, this.body, this.returnType,
-                     this.modifiers, this.initializers, this.getOrSet) {
+                     this.modifiers, this.initializers, this.getOrSet,
+                     this.asyncModifier) {
     assert(modifiers != null);
   }
 
   FunctionExpression asFunctionExpression() => this;
 
   accept(Visitor visitor) => visitor.visitFunctionExpression(this);
 
   bool get isRedirectingFactory {
     return body != null && body.asRedirectingFactoryBody() != null;
   }
 
   visitChildren(Visitor visitor) {
     if (modifiers != null) modifiers.accept(visitor);
     if (returnType != null) returnType.accept(visitor);
     if (name != null) name.accept(visitor);
     if (parameters != null) parameters.accept(visitor);
     if (initializers != null) initializers.accept(visitor);
+    if (asyncModifier != null) asyncModifier.accept(visitor);
     if (body != null) body.accept(visitor);
   }
 
   bool hasBody() => body.asEmptyStatement() == null;
 
   bool hasEmptyBody() {
     Block block = body.asBlock();
     if (block == null) return false;
     return block.statements.isEmpty;
   }
@@ skipping 278 matching lines @@
   }
 
   Token getBeginToken() => beginToken;
 
   Token getEndToken() {
     if (endToken == null) return expression.getEndToken();
     return endToken;
   }
 }
 
+class Yield extends Statement {
+  final Node expression;
+  final Token yieldToken;
+  final Token starToken;
+  final Token endToken;
+
+  Yield(this.yieldToken, this.starToken, this.expression, this.endToken);
+
+  Yield asYield() => this;
+
+  bool get hasStar => starToken != null;
+
+  accept(Visitor visitor) => visitor.visitYield(this);
+
+  visitChildren(Visitor visitor) {
+    expression.accept(visitor);
+  }
+
+  Token getBeginToken() => yieldToken;
+
+  Token getEndToken() => endToken;
+}
+
 class RedirectingFactoryBody extends Statement with StoredTreeElementMixin {
   final Node constructorReference;
   final Token beginToken;
   final Token endToken;
 
   RedirectingFactoryBody(this.beginToken, this.endToken,
                          this.constructorReference);
 
   RedirectingFactoryBody asRedirectingFactoryBody() => this;
 
@@ skipping 41 matching lines @@
 
   visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
   Token getBeginToken() => throwToken;
 
   Token getEndToken() => endToken;
 }
 
+class Await extends Expression {
+  final Expression expression;
+
+  final Token awaitToken;
+
+  Await(this.awaitToken, this.expression);
+
+  Await asAwait() => this;
+
+  accept(Visitor visitor) => visitor.visitAwait(this);
+
+  visitChildren(Visitor visitor) {
+    expression.accept(visitor);
+  }
+
+  Token getBeginToken() => awaitToken;
+
+  Token getEndToken() => expression.getEndToken();
+}
+
 class Rethrow extends Statement {
   final Token throwToken;
   final Token endToken;
 
   Rethrow(this.throwToken, this.endToken);
 
   Rethrow asRethrow() => this;
 
   accept(Visitor visitor) => visitor.visitRethrow(this);
   visitChildren(Visitor visitor) { }
@@ skipping 572 matching lines @@
 
   ContinueStatement asContinueStatement() => this;
 
   accept(Visitor visitor) => visitor.visitContinueStatement(this);
 }
 
 class ForIn extends Loop with StoredTreeElementMixin {
   final Node declaredIdentifier;
   final Expression expression;
 
+  final Token awaitToken;
   final Token forToken;
   final Token inToken;
 
   ForIn(this.declaredIdentifier, this.expression,
-        Statement body, this.forToken, this.inToken) : super(body);
+        Statement body, this.awaitToken, this.forToken, this.inToken)
+      : super(body);
+
+  bool get isAsync => awaitToken != null;
 
   Expression get condition => null;
 
   ForIn asForIn() => this;
 
   accept(Visitor visitor) => visitor.visitForIn(this);
 
   visitChildren(Visitor visitor) {
     declaredIdentifier.accept(visitor);
     expression.accept(visitor);
     body.accept(visitor);
   }
 
-  Token getBeginToken() => forToken;
+  Token getBeginToken() => awaitToken != null ? awaitToken : forToken;
 
   Token getEndToken() => body.getEndToken();
 }
 
 class Label extends Node {
   final Identifier identifier;
   final Token colonToken;
 
   Label(this.identifier, this.colonToken);
 
@@ skipping 435 matching lines @@
 
   Token getEndToken() => token;
 
   accept(Visitor visitor) {}
 
   visitChildren(Visitor visitor) {}
 
   bool get isErroneous => true;
 
   // FunctionExpression.
+  get asyncModifier => null;
   get parameters => null;
   get body => null;
   get returnType => null;
   get modifiers => Modifiers.EMPTY;
   get initializers => null;
   get getOrSet => null;
   get isRedirectingFactory => false;
   bool hasBody() => false;
   bool hasEmptyBody() => false;
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }