New analyzer snapshot.

pkg/analyzer/lib/src/generated/ast.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart' show LineInfo, Source;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_dart.dart';
 import 'utilities_collection.dart' show TokenMap;
 import 'element.dart';
 import 'constant.dart';
+import 'parser.dart';
 
 /**
  * Instances of the class `AdjacentStrings` represents two or more string literals that are
  * implicitly concatenated because of being adjacent (separated only by whitespace).
  *
  * While the grammar only allows adjacent strings when all of the strings are of the same kind
  * (single line or multi-line), this class doesn't enforce that restriction.
  *
  * <pre>
  * adjacentStrings ::=
@@ skipping 954 matching lines @@
   @override
   AsExpression visitAsExpression(AsExpression node) => new AsExpression(cloneNode(node.expression), node.asOperator, cloneNode(node.type));
 
   @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(node.keyword, node.leftParenthesis, cloneNode(node.condition), node.rightParenthesis, node.semicolon);
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression(cloneNode(node.leftHandSide), node.operator, cloneNode(node.rightHandSide));
 
   @override
+  AwaitExpression visitAwaitExpression(AwaitExpression node) => new AwaitExpression(node.awaitKeyword, node.expression, node.semicolon);
+
+  @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression(cloneNode(node.leftOperand), node.operator, cloneNode(node.rightOperand));
 
   @override
   Block visitBlock(Block node) => new Block(node.leftBracket, cloneNodeList(node.statements), node.rightBracket);
 
   @override
-  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(cloneNode(node.block));
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(node.keyword, node.star, cloneNode(node.block));
 
   @override
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral(node.literal, node.value);
 
   @override
   BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(node.keyword, cloneNode(node.label), node.semicolon);
 
   @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) => new CascadeExpression(cloneNode(node.target), cloneNodeList(node.cascadeSections));
 
@@ skipping 65 matching lines @@
 
   @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective directive = new ExportDirective(cloneNode(node.documentationComment), cloneNodeList(node.metadata), node.keyword, cloneNode(node.uri), cloneNodeList(node.combinators), node.semicolon);
     directive.source = node.source;
     directive.uriContent = node.uriContent;
     return directive;
   }
 
   @override
-  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(node.functionDefinition, cloneNode(node.expression), node.semicolon);
+  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(node.keyword, node.functionDefinition, cloneNode(node.expression), node.semicolon);
 
   @override
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(cloneNode(node.expression), node.semicolon);
 
   @override
   ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(node.keyword, cloneNode(node.superclass));
 
   @override
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration(cloneNode(node.documentationComment), cloneNodeList(node.metadata), node.staticKeyword, cloneNode(node.fields), node.semicolon);
 
   @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter(cloneNode(node.documentationComment), cloneNodeList(node.metadata), node.keyword, cloneNode(node.type), node.thisToken, node.period, cloneNode(node.identifier), cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.con2(node.forKeyword, node.leftParenthesis, cloneNode(node.identifier), node.inKeyword, cloneNode(node.iterator), node.rightParenthesis, cloneNode(node.body));
+      return new ForEachStatement.con2(node.awaitKeyword, node.forKeyword, node.leftParenthesis, cloneNode(node.identifier), node.inKeyword, cloneNode(node.iterator), node.rightParenthesis, cloneNode(node.body));
     }
-    return new ForEachStatement.con1(node.forKeyword, node.leftParenthesis, cloneNode(loopVariable), node.inKeyword, cloneNode(node.iterator), node.rightParenthesis, cloneNode(node.body));
+    return new ForEachStatement.con1(node.awaitKeyword, node.forKeyword, node.leftParenthesis, cloneNode(loopVariable), node.inKeyword, cloneNode(node.iterator), node.rightParenthesis, cloneNode(node.body));
   }
 
   @override
   FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList(node.leftParenthesis, cloneNodeList(node.parameters), node.leftDelimiter, node.rightDelimiter, node.rightParenthesis);
 
   @override
   ForStatement visitForStatement(ForStatement node) => new ForStatement(node.forKeyword, node.leftParenthesis, cloneNode(node.variables), cloneNode(node.initialization), node.leftSeparator, cloneNode(node.condition), node.rightSeparator, cloneNodeList(node.updaters), node.rightParenthesis, cloneNode(node.body));
 
   @override
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(cloneNode(node.documentationComment), cloneNodeList(node.metadata), node.externalKeyword, cloneNode(node.returnType), node.propertyKeyword, cloneNode(node.name), cloneNode(node.functionExpression));
@@ skipping 197 matching lines @@
 
   @override
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(cloneNode(node.variables), node.semicolon);
 
   @override
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(node.keyword, node.leftParenthesis, cloneNode(node.condition), node.rightParenthesis, cloneNode(node.body));
 
   @override
   WithClause visitWithClause(WithClause node) => new WithClause(node.withKeyword, cloneNodeList(node.mixinTypes));
 
+  @override
+  YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(node.yieldKeyword, node.star, node.expression, node.semicolon);
+
   AstNode cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as AstNode;
   }
 }
 
 /**
  * Instances of the class `AstComparator` compare the structure of two ASTNodes to see whether
@@ skipping 48 matching lines @@
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression other = this._other as AssignmentExpression;
     return _isEqualNodes(node.leftHandSide, other.leftHandSide) && _isEqualTokens(node.operator, other.operator) && _isEqualNodes(node.rightHandSide, other.rightHandSide);
   }
 
   @override
+  bool visitAwaitExpression(AwaitExpression node) {
+    AwaitExpression other = this._other as AwaitExpression;
+    return _isEqualTokens(node.awaitKeyword, other.awaitKeyword) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.semicolon, other.semicolon);
+  }
+
+  @override
   bool visitBinaryExpression(BinaryExpression node) {
     BinaryExpression other = this._other as BinaryExpression;
     return _isEqualNodes(node.leftOperand, other.leftOperand) && _isEqualTokens(node.operator, other.operator) && _isEqualNodes(node.rightOperand, other.rightOperand);
   }
 
   @override
   bool visitBlock(Block node) {
     Block other = this._other as Block;
     return _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.statements, other.statements) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
@@ skipping 555 matching lines @@
     WhileStatement other = this._other as WhileStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitWithClause(WithClause node) {
     WithClause other = this._other as WithClause;
     return _isEqualTokens(node.withKeyword, other.withKeyword) && _isEqualNodeLists(node.mixinTypes, other.mixinTypes);
   }
 
+  @override
+  bool visitYieldStatement(YieldStatement node) {
+    YieldStatement other = this._other as YieldStatement;
+    return _isEqualTokens(node.yieldKeyword, other.yieldKeyword) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.semicolon, other.semicolon);
+  }
+
   /**
    * Return `true` if the given lists of AST nodes have the same size and corresponding
    * elements are equal.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the given AST nodes have the same size and corresponding elements are
    *         equal
    */
   bool _isEqualNodeLists(NodeList first, NodeList second) {
@@ skipping 319 matching lines @@
   R visitAnnotation(Annotation node);
 
   R visitArgumentList(ArgumentList node);
 
   R visitAsExpression(AsExpression node);
 
   R visitAssertStatement(AssertStatement assertStatement);
 
   R visitAssignmentExpression(AssignmentExpression node);
 
+  R visitAwaitExpression(AwaitExpression node);
+
   R visitBinaryExpression(BinaryExpression node);
 
   R visitBlock(Block node);
 
   R visitBlockFunctionBody(BlockFunctionBody node);
 
   R visitBooleanLiteral(BooleanLiteral node);
 
   R visitBreakStatement(BreakStatement node);
 
@@ skipping 171 matching lines @@
 
   R visitVariableDeclaration(VariableDeclaration node);
 
   R visitVariableDeclarationList(VariableDeclarationList node);
 
   R visitVariableDeclarationStatement(VariableDeclarationStatement node);
 
   R visitWhileStatement(WhileStatement node);
 
   R visitWithClause(WithClause node);
+
+  R visitYieldStatement(YieldStatement node);
 }
 
 /**
+ * Instances of the class `AwaitExpression` implement an await expression.
+ */
+class AwaitExpression extends Expression {
+  /**
+   * The 'await' keyword.
+   */
+  Token awaitKeyword;
+
+  /**
+   * The expression whose value is being waited on.
+   */
+  Expression _expression;
+
+  /**
+   * The semicolon following the expression.
+   */
+  Token semicolon;
+
+  /**
+   * Initialize a newly created await expression.
+   *
+   * @param awaitKeyword the 'await' keyword
+   * @param expression the expression whose value is being waited on
+   * @param semicolon the semicolon following the expression
+   */
+  AwaitExpression(this.awaitKeyword, Expression expression, this.semicolon) {
+    this._expression = becomeParentOf(expression);
+  }
+
+  @override
+  accept(AstVisitor visitor) => visitor.visitAwaitExpression(this);
+
+  @override
+  Token get beginToken {
+    if (awaitKeyword != null) {
+      return awaitKeyword;
+    }
+    return _expression.beginToken;
+  }
+
+  @override
+  Token get endToken {
+    if (semicolon != null) {
+      return semicolon;
+    }
+    return _expression.endToken;
+  }
+
+  /**
+   * Return the expression whose value is being waited on.
+   *
+   * @return the expression whose value is being waited on
+   */
+  Expression get expression => _expression;
+
+  @override
+  int get precedence => 0;
+
+  /**
+   * Set the expression whose value is being waited on to the given expression.
+   *
+   * @param expression the expression whose value is being waited on
+   */
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
+  }
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_expression, visitor);
+  }
+}
+
+/**
  * Instances of the class `BinaryExpression` represent a binary (infix) expression.
  *
  * <pre>
  * binaryExpression ::=
  *     [Expression] [Token] [Expression]
  * </pre>
  */
 class BinaryExpression extends Expression {
   /**
    * The expression used to compute the left operand.
@@ skipping 242 matching lines @@
     _statements.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BlockFunctionBody` represent a function body that consists of a
  * block of statements.
  *
  * <pre>
  * blockFunctionBody ::=
- *     [Block]
+ *     ('async' | 'async' '*' | 'sync' '*')? [Block]
  * </pre>
  */
 class BlockFunctionBody extends FunctionBody {
   /**
+   * The token representing the 'async' or 'sync' keyword, or `null` if there is no such
+   * keyword.
+   */
+  Token keyword;
+
+  /**
+   * The star optionally following the 'async' or following the 'sync' keyword.
+   */
+  Token star;
+
+  /**
    * The block representing the body of the function.
    */
   Block _block;
 
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
+   * @param keyword the token representing the 'async' or 'sync' keyword
+   * @param star the star following the 'async' or 'sync' keyword
    * @param block the block representing the body of the function
    */
-  BlockFunctionBody(Block block) {
+  BlockFunctionBody(this.keyword, this.star, Block block) {
     this._block = becomeParentOf(block);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBlockFunctionBody(this);
 
   @override
   Token get beginToken => _block.beginToken;
 
   /**
    * Return the block representing the body of the function.
    *
    * @return the block representing the body of the function
    */
   Block get block => _block;
 
   @override
   Token get endToken => _block.endToken;
 
+  @override
+  bool get isAsynchronous {
+    if (keyword == null) {
+      return false;
+    }
+    String keywordValue = keyword.lexeme;
+    return keywordValue == Parser.ASYNC;
+  }
+
+  @override
+  bool get isGenerator => star != null;
+
+  @override
+  bool get isSynchronous => keyword == null || keyword.lexeme != Parser.ASYNC;
+
   /**
    * Set the block representing the body of the function to the given block.
    *
    * @param block the block representing the body of the function
    */
   void set block(Block block) {
     this._block = becomeParentOf(block);
   }
 
   @override
@@ skipping 3408 matching lines @@
    */
   bool get isAssignable => false;
 }
 
 /**
  * Instances of the class `ExpressionFunctionBody` represent a function body consisting of a
  * single expression.
  *
  * <pre>
  * expressionFunctionBody ::=
- *     '=>' [Expression] ';'
+ *     'async'? '=>' [Expression] ';'
  * </pre>
  */
 class ExpressionFunctionBody extends FunctionBody {
   /**
+   * The token representing the 'async' keyword, or `null` if there is no such keyword.
+   */
+  Token keyword;
+
+  /**
    * The token introducing the expression that represents the body of the function.
    */
   Token functionDefinition;
 
   /**
    * The expression representing the body of the function.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
+   * @param keyword the token representing the 'async' keyword
    * @param functionDefinition the token introducing the expression that represents the body of the
    *          function
    * @param expression the expression representing the body of the function
    * @param semicolon the semicolon terminating the statement
    */
-  ExpressionFunctionBody(this.functionDefinition, Expression expression, this.semicolon) {
+  ExpressionFunctionBody(this.keyword, this.functionDefinition, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
 
   @override
   Token get beginToken => functionDefinition;
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression representing the body of the function.
    *
    * @return the expression representing the body of the function
    */
   Expression get expression => _expression;
 
+  @override
+  bool get isAsynchronous => keyword != null;
+
+  @override
+  bool get isSynchronous => keyword == null;
+
   /**
    * Set the expression representing the body of the function to the given expression.
    *
    * @param expression the expression representing the body of the function
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   @override
@@ skipping 336 matching lines @@
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `ForEachStatement` represent a for-each statement.
  *
  * <pre>
  * forEachStatement ::=
- *     'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
- *   | 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
+ *     'await'? 'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
+ *   | 'await'? 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
  * </pre>
  */
 class ForEachStatement extends Statement {
   /**
+   * The token representing the 'await' keyword, or `null` if there is no 'await' keyword.
+   */
+  Token awaitKeyword;
+
+  /**
    * The token representing the 'for' keyword.
    */
   Token forKeyword;
 
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
@@ skipping 23 matching lines @@
   Token rightParenthesis;
 
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * Initialize a newly created for-each statement.
    *
+   * @param awaitKeyword the token representing the 'await' keyword
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param loopVariable the declaration of the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForEachStatement.con1(this.forKeyword, this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
+  ForEachStatement.con1(this.awaitKeyword, this.forKeyword, this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
     this._loopVariable = becomeParentOf(loopVariable);
     this._iterator = becomeParentOf(iterator);
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for-each statement.
    *
+   * @param awaitKeyword the token representing the 'await' keyword
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param identifier the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForEachStatement.con2(this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
+  ForEachStatement.con2(this.awaitKeyword, this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
     this._identifier = becomeParentOf(identifier);
     this._iterator = becomeParentOf(iterator);
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForEachStatement(this);
 
   @override
   Token get beginToken => forKeyword;
@@ skipping 504 matching lines @@
  * body of a function or method.
  *
  * <pre>
  * functionBody ::=
  *     [BlockFunctionBody]
  *   | [EmptyFunctionBody]
  *   | [ExpressionFunctionBody]
  * </pre>
  */
 abstract class FunctionBody extends AstNode {
+  /**
+   * Return `true` if this function body is asynchronous.
+   *
+   * @return `true` if this function body is asynchronous
+   */
+  bool get isAsynchronous => false;
+
+  /**
+   * Return `true` if this function body is a generator.
+   *
+   * @return `true` if this function body is a generator
+   */
+  bool get isGenerator => false;
+
+  /**
+   * Return `true` if this function body is synchronous.
+   *
+   * @return `true` if this function body is synchronous
+   */
+  bool get isSynchronous => true;
 }
 
 /**
  * Instances of the class `FunctionDeclaration` wrap a [FunctionExpression] as a top-level declaration.
  *
  * <pre>
  * functionDeclaration ::=
  *     'external' functionSignature
  *   | functionSignature [FunctionBody]
  *
@@ skipping 692 matching lines @@
   @override
   R visitAsExpression(AsExpression node) => visitExpression(node);
 
   @override
   R visitAssertStatement(AssertStatement node) => visitStatement(node);
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) => visitExpression(node);
 
   @override
+  R visitAwaitExpression(AwaitExpression node) => visitExpression(node);
+
+  @override
   R visitBinaryExpression(BinaryExpression node) => visitExpression(node);
 
   @override
   R visitBlock(Block node) => visitStatement(node);
 
   @override
   R visitBlockFunctionBody(BlockFunctionBody node) => visitFunctionBody(node);
 
   @override
   R visitBooleanLiteral(BooleanLiteral node) => visitLiteral(node);
@@ skipping 311 matching lines @@
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
 
   @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitStatement(node);
 
   @override
   R visitWhileStatement(WhileStatement node) => visitStatement(node);
 
   @override
   R visitWithClause(WithClause node) => visitNode(node);
+
+  @override
+  R visitYieldStatement(YieldStatement node) => visitStatement(node);
 }
 
 class GeneralizingAstVisitor_BreadthFirstVisitor extends GeneralizingAstVisitor<Object> {
   final BreadthFirstVisitor BreadthFirstVisitor_this;
 
   GeneralizingAstVisitor_BreadthFirstVisitor(this.BreadthFirstVisitor_this) : super();
 
   @override
   Object visitNode(AstNode node) {
     BreadthFirstVisitor_this._queue.add(node);
@@ skipping 530 matching lines @@
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression copy = new AssignmentExpression(_cloneNode(node.leftHandSide), _mapToken(node.operator), _cloneNode(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
+  AwaitExpression visitAwaitExpression(AwaitExpression node) => new AwaitExpression(_mapToken(node.awaitKeyword), _cloneNode(node.expression), _mapToken(node.semicolon));
+
+  @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) {
     BinaryExpression copy = new BinaryExpression(_cloneNode(node.leftOperand), _mapToken(node.operator), _cloneNode(node.rightOperand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   Block visitBlock(Block node) => new Block(_mapToken(node.leftBracket), _cloneNodeList(node.statements), _mapToken(node.rightBracket));
 
   @override
-  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(_cloneNode(node.block));
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(_mapToken(node.keyword), _mapToken(node.star), _cloneNode(node.block));
 
   @override
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) {
     BooleanLiteral copy = new BooleanLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
@@ skipping 93 matching lines @@
   EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement(_mapToken(node.semicolon));
 
   @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective copy = new ExportDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.uri), _cloneNodeList(node.combinators), _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   @override
-  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(_mapToken(node.functionDefinition), _cloneNode(node.expression), _mapToken(node.semicolon));
+  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(_mapToken(node.keyword), _mapToken(node.functionDefinition), _cloneNode(node.expression), _mapToken(node.semicolon));
 
   @override
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(_cloneNode(node.expression), _mapToken(node.semicolon));
 
   @override
   ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(_mapToken(node.keyword), _cloneNode(node.superclass));
 
   @override
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.staticKeyword), _cloneNode(node.fields), _mapToken(node.semicolon));
 
   @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.type), _mapToken(node.thisToken), _mapToken(node.period), _cloneNode(node.identifier), _cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.con2(_mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.identifier), _mapToken(node.inKeyword), _cloneNode(node.iterator), _mapToken(node.rightParenthesis), _cloneNode(node.body));
+      return new ForEachStatement.con2(_mapToken(node.awaitKeyword), _mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.identifier), _mapToken(node.inKeyword), _cloneNode(node.iterator), _mapToken(node.rightParenthesis), _cloneNode(node.body));
     }
-    return new ForEachStatement.con1(_mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(loopVariable), _mapToken(node.inKeyword), _cloneNode(node.iterator), _mapToken(node.rightParenthesis), _cloneNode(node.body));
+    return new ForEachStatement.con1(_mapToken(node.awaitKeyword), _mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(loopVariable), _mapToken(node.inKeyword), _cloneNode(node.iterator), _mapToken(node.rightParenthesis), _cloneNode(node.body));
   }
 
   @override
   FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList(_mapToken(node.leftParenthesis), _cloneNodeList(node.parameters), _mapToken(node.leftDelimiter), _mapToken(node.rightDelimiter), _mapToken(node.rightParenthesis));
 
   @override
   ForStatement visitForStatement(ForStatement node) => new ForStatement(_mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.variables), _cloneNode(node.initialization), _mapToken(node.leftSeparator), _cloneNode(node.condition), _mapToken(node.rightSeparator), _cloneNodeList(node.updaters), _mapToken(node.rightParenthesis), _cloneNode(node.body));
 
   @override
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), _cloneNode(node.returnType), _mapToken(node.propertyKeyword), _cloneNode(node.name), _cloneNode(node.functionExpression));
@@ skipping 353 matching lines @@
 
   @override
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(_cloneNode(node.variables), _mapToken(node.semicolon));
 
   @override
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(_mapToken(node.keyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), _mapToken(node.rightParenthesis), _cloneNode(node.body));
 
   @override
   WithClause visitWithClause(WithClause node) => new WithClause(_mapToken(node.withKeyword), _cloneNodeList(node.mixinTypes));
 
+  @override
+  YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(_mapToken(node.yieldKeyword), _mapToken(node.star), _cloneNode(node.expression), _mapToken(node.semicolon));
+
   AstNode _cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     if (identical(node, _oldNode)) {
       return _newNode;
     }
     return node.accept(this) as AstNode;
   }
 
@@ skipping 2280 matching lines @@
       node.leftHandSide = _newNode as Expression;
       return true;
     } else if (identical(node.rightHandSide, _oldNode)) {
       node.rightHandSide = _newNode as Expression;
       return true;
     }
     return visitNode(node);
   }
 
   @override
+  bool visitAwaitExpression(AwaitExpression node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+    }
+    return visitNode(node);
+  }
+
+  @override
   bool visitBinaryExpression(BinaryExpression node) {
     if (identical(node.leftOperand, _oldNode)) {
       node.leftOperand = _newNode as Expression;
       return true;
     } else if (identical(node.rightOperand, _oldNode)) {
       node.rightOperand = _newNode as Expression;
       return true;
     }
     return visitNode(node);
   }
@@ skipping 974 matching lines @@
   }
 
   @override
   bool visitWithClause(WithClause node) {
     if (_replaceInList(node.mixinTypes)) {
       return true;
     }
     return visitNode(node);
   }
 
+  @override
+  bool visitYieldStatement(YieldStatement node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+    }
+    return visitNode(node);
+  }
+
   bool _replaceInList(NodeList list) {
     int count = list.length;
     for (int i = 0; i < count; i++) {
       if (identical(_oldNode, list[i])) {
         javaListSet(list, i, _newNode);
         return true;
       }
     }
     return false;
   }
@@ skipping 1068 matching lines @@
     return null;
   }
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
+  R visitAwaitExpression(AwaitExpression node) {
+    node.visitChildren(this);
+    return null;
+  }
+
+  @override
   R visitBinaryExpression(BinaryExpression node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitBlock(Block node) {
     node.visitChildren(this);
     return null;
   }
@@ skipping 554 matching lines @@
   R visitWhileStatement(WhileStatement node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitWithClause(WithClause node) {
     node.visitChildren(this);
     return null;
   }
+
+  @override
+  R visitYieldStatement(YieldStatement node) {
+    node.visitChildren(this);
+    return null;
+  }
 }
 
 /**
  * Instances of the class `RedirectingConstructorInvocation` represent the invocation of a
  * another constructor in the same class from within a constructor's initialization list.
  *
  * <pre>
  * redirectingConstructorInvocation ::=
  *     'this' ('.' identifier)? arguments
  * </pre>
@@ skipping 477 matching lines @@
   @override
   R visitAsExpression(AsExpression node) => null;
 
   @override
   R visitAssertStatement(AssertStatement node) => null;
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) => null;
 
   @override
+  R visitAwaitExpression(AwaitExpression node) => null;
+
+  @override
   R visitBinaryExpression(BinaryExpression node) => null;
 
   @override
   R visitBlock(Block node) => null;
 
   @override
   R visitBlockFunctionBody(BlockFunctionBody node) => null;
 
   @override
   R visitBooleanLiteral(BooleanLiteral node) => null;
@@ skipping 266 matching lines @@
   R visitVariableDeclarationList(VariableDeclarationList node) => null;
 
   @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => null;
 
   @override
   R visitWhileStatement(WhileStatement node) => null;
 
   @override
   R visitWithClause(WithClause node) => null;
+
+  @override
+  R visitYieldStatement(YieldStatement node) => null;
 }
 
 /**
  * Instances of the class `SimpleFormalParameter` represent a simple formal parameter.
  *
  * <pre>
  * simpleFormalParameter ::=
  *     ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  * </pre>
  */
@@ skipping 1231 matching lines @@
   Object visitAssignmentExpression(AssignmentExpression node) {
     _visitNode(node.leftHandSide);
     _writer.print(' ');
     _writer.print(node.operator.lexeme);
     _writer.print(' ');
     _visitNode(node.rightHandSide);
     return null;
   }
 
   @override
+  Object visitAwaitExpression(AwaitExpression node) {
+    _writer.print("await ");
+    _visitNode(node.expression);
+    _writer.print(";");
+    return null;
+  }
+
+  @override
   Object visitBinaryExpression(BinaryExpression node) {
     _visitNode(node.leftOperand);
     _writer.print(' ');
     _writer.print(node.operator.lexeme);
     _writer.print(' ');
     _visitNode(node.rightOperand);
     return null;
   }
 
   @override
   Object visitBlock(Block node) {
     _writer.print('{');
     _visitNodeListWithSeparator(node.statements, " ");
     _writer.print('}');
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
+    Token keyword = node.keyword;
+    if (keyword != null) {
+      _writer.print(keyword.lexeme);
+      if (node.star != null) {
+        _writer.print('*');
+      }
+      _writer.print(' ');
+    }
     _visitNode(node.block);
     return null;
   }
 
   @override
   Object visitBooleanLiteral(BooleanLiteral node) {
     _writer.print(node.literal.lexeme);
     return null;
   }
 
@@ skipping 183 matching lines @@
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _writer.print("export ");
     _visitNode(node.uri);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    Token keyword = node.keyword;
+    if (keyword != null) {
+      _writer.print(keyword.lexeme);
+      _writer.print(' ');
+    }
     _writer.print("=> ");
     _visitNode(node.expression);
     if (node.semicolon != null) {
       _writer.print(';');
     }
     return null;
   }
 
   @override
   Object visitExpressionStatement(ExpressionStatement node) {
@@ skipping 24 matching lines @@
     _visitNodeWithSuffix(node.type, " ");
     _writer.print("this.");
     _visitNode(node.identifier);
     _visitNode(node.parameters);
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
+    if (node.awaitKeyword != null) {
+      _writer.print("await ");
+    }
     _writer.print("for (");
     if (loopVariable == null) {
       _visitNode(node.identifier);
     } else {
       _visitNode(loopVariable);
     }
     _writer.print(" in ");
     _visitNode(node.iterator);
     _writer.print(") ");
     _visitNode(node.body);
@@ skipping 587 matching lines @@
     return null;
   }
 
   @override
   Object visitWithClause(WithClause node) {
     _writer.print("with ");
     _visitNodeListWithSeparator(node.mixinTypes, ", ");
     return null;
   }
 
+  @override
+  Object visitYieldStatement(YieldStatement node) {
+    if (node.star != null) {
+      _writer.print("yield* ");
+    } else {
+      _writer.print("yield ");
+    }
+    _visitNode(node.expression);
+    _writer.print(";");
+    return null;
+  }
+
   /**
    * Visit the given function body, printing the prefix before if given body is not empty.
    *
    * @param prefix the prefix to be printed if there is a node to visit
    * @param body the function body to be visited
    */
   void _visitFunctionWithPrefix(String prefix, FunctionBody body) {
     if (body is! EmptyFunctionBody) {
       _writer.print(prefix);
     }
@@ skipping 755 matching lines @@
   @override
   R visitAsExpression(AsExpression node) => visitNode(node);
 
   @override
   R visitAssertStatement(AssertStatement node) => visitNode(node);
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) => visitNode(node);
 
   @override
+  R visitAwaitExpression(AwaitExpression node) => visitNode(node);
+
+  @override
   R visitBinaryExpression(BinaryExpression node) => visitNode(node);
 
   @override
   R visitBlock(Block node) => visitNode(node);
 
   @override
   R visitBlockFunctionBody(BlockFunctionBody node) => visitNode(node);
 
   @override
   R visitBooleanLiteral(BooleanLiteral node) => visitNode(node);
@@ skipping 271 matching lines @@
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
 
   @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitNode(node);
 
   @override
   R visitWhileStatement(WhileStatement node) => visitNode(node);
 
   @override
   R visitWithClause(WithClause node) => visitNode(node);
+
+  @override
+  R visitYieldStatement(YieldStatement node) => visitNode(node);
 }
 
 /**
  * The abstract class `UriBasedDirective` defines the behavior common to nodes that represent
  * a directive that references a URI.
  *
  * <pre>
  * uriBasedDirective ::=
  *     [ExportDirective]
  *   | [ImportDirective]
@@ skipping 576 matching lines @@
    */
   void set mixinKeyword(Token withKeyword) {
     this._withKeyword = withKeyword;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     _mixinTypes.accept(visitor);
   }
 }
+
+/**
+ * Instances of the class `YieldStatement` implement a yield statement.
+ */
+class YieldStatement extends Statement {
+  /**
+   * The 'yield' keyword.
+   */
+  Token yieldKeyword;
+
+  /**
+   * The star optionally following the 'yield' keyword.
+   */
+  Token star;
+
+  /**
+   * The expression whose value will be yielded.
+   */
+  Expression _expression;
+
+  /**
+   * The semicolon following the expression.
+   */
+  Token semicolon;
+
+  /**
+   * Initialize a newly created yield expression.
+   *
+   * @param yieldKeyword the 'yield' keyword
+   * @param star the star following the 'yield' keyword
+   * @param expression the expression whose value will be yielded
+   * @param semicolon the semicolon following the expression
+   */
+  YieldStatement(this.yieldKeyword, this.star, Expression expression, this.semicolon) {
+    this._expression = becomeParentOf(expression);
+  }
+
+  @override
+  accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
+
+  @override
+  Token get beginToken {
+    if (yieldKeyword != null) {
+      return yieldKeyword;
+    }
+    return _expression.beginToken;
+  }
+
+  @override
+  Token get endToken {
+    if (semicolon != null) {
+      return semicolon;
+    }
+    return _expression.endToken;
+  }
+
+  /**
+   * Return the expression whose value will be yielded.
+   *
+   * @return the expression whose value will be yielded
+   */
+  Expression get expression => _expression;
+
+  /**
+   * Set the expression whose value will be yielded to the given expression.
+   *
+   * @param expression the expression whose value will be yielded
+   */
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
+  }
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_expression, visitor);
+  }
+}
 /**
  * Instances of the class {@code NodeList} represent a list of AST nodes that have a common parent.
  */
 class NodeList<E extends AstNode> extends Object with ListMixin<E> {
   /**
    * Create an empty list with the given owner. This is a convenience method that allows the
    * compiler to determine the correct value of the type argument [E] without needing to
    * explicitly specify it.
    *
    * @param owner the node that is the parent of each of the elements in the list
@@ skipping 105 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }