Push new analyzer-experimental with Resolver and ResolverTest.

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

 // 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 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_dart.dart';
 import 'element.dart' hide Annotation;
 
 /**
  * The abstract class {@code ASTNode} defines the behavior common to all nodes in the AST structure
  * for a Dart program.
+ * @coverage dart.engine.ast
  */
 abstract class ASTNode {
   /**
    * The parent of the node, or {@code null} if the node is the root of an AST structure.
    */
   ASTNode _parent;
   /**
    * A table mapping the names of properties to their values, or {@code null} if this node does not
    * have any properties associated with it.
    */
@@ skipping 170 matching lines @@
    */
   void set parent(ASTNode newParent) {
     _parent = newParent;
   }
   static int _hashCodeGenerator = 0;
   final int hashCode = ++_hashCodeGenerator;
 }
 /**
  * The interface {@code ASTVisitor} defines the behavior of objects that can be used to visit an AST
  * structure.
+ * @coverage dart.engine.ast
  */
 abstract class ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node);
   R visitAnnotation(Annotation node);
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node);
   R visitArgumentList(ArgumentList node);
   R visitAsExpression(AsExpression node);
   R visitAssertStatement(AssertStatement assertStatement);
   R visitAssignmentExpression(AssignmentExpression node);
   R visitBinaryExpression(BinaryExpression node);
   R visitBlock(Block node);
   R visitBlockFunctionBody(BlockFunctionBody node);
   R visitBooleanLiteral(BooleanLiteral node);
   R visitBreakStatement(BreakStatement node);
   R visitCascadeExpression(CascadeExpression node);
   R visitCatchClause(CatchClause node);
   R visitClassDeclaration(ClassDeclaration node);
   R visitClassTypeAlias(ClassTypeAlias node);
   R visitComment(Comment node);
   R visitCommentReference(CommentReference node);
   R visitCompilationUnit(CompilationUnit node);
   R visitConditionalExpression(ConditionalExpression node);
   R visitConstructorDeclaration(ConstructorDeclaration node);
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node);
   R visitConstructorName(ConstructorName node);
   R visitContinueStatement(ContinueStatement node);
+  R visitDeclaredIdentifier(DeclaredIdentifier node);
   R visitDefaultFormalParameter(DefaultFormalParameter node);
   R visitDoStatement(DoStatement node);
   R visitDoubleLiteral(DoubleLiteral node);
   R visitEmptyFunctionBody(EmptyFunctionBody node);
   R visitEmptyStatement(EmptyStatement node);
   R visitExportDirective(ExportDirective node);
   R visitExpressionFunctionBody(ExpressionFunctionBody node);
   R visitExpressionStatement(ExpressionStatement node);
   R visitExtendsClause(ExtendsClause node);
   R visitFieldDeclaration(FieldDeclaration node);
@@ skipping 64 matching lines @@
 }
 /**
  * Instances of the class {@code AdjacentStrings} represents two or more string literals that are
  * implicitly concatenated because of being adjacent (separated only by whitespace).
  * <p>
  * 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 ::={@link StringLiteral string} {@link StringLiteral string}+
  * </pre>
+ * @coverage dart.engine.ast
  */
 class AdjacentStrings extends StringLiteral {
   /**
    * The strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> _strings;
   /**
    * Initialize a newly created list of adjacent strings.
    * @param strings the strings that are implicitly concatenated
    */
@@ skipping 14 matching lines @@
    * @return the strings that are implicitly concatenated
    */
   NodeList<StringLiteral> get strings => _strings;
   void visitChildren(ASTVisitor<Object> visitor) {
     _strings.accept(visitor);
   }
 }
 /**
  * The abstract class {@code AnnotatedNode} defines the behavior of nodes that can be annotated with
  * both a comment and metadata.
+ * @coverage dart.engine.ast
  */
 abstract class AnnotatedNode extends ASTNode {
   /**
    * The documentation comment associated with this node, or {@code null} if this node does not have
    * a documentation comment associated with it.
    */
   Comment _comment;
   /**
    * The annotations associated with this node.
    */
@@ skipping 92 matching lines @@
 }
 /**
  * Instances of the class {@code Annotation} represent an annotation that can be associated with an
  * AST node.
  * <pre>
  * metadata ::=
  * annotation
  * annotation ::=
  * '@' {@link Identifier qualified} (‘.’ {@link SimpleIdentifier identifier})? {@link ArgumentList arguments}?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class Annotation extends ASTNode {
   /**
    * The at sign that introduced the annotation.
    */
   Token _atSign;
   /**
    * The name of the class defining the constructor that is being invoked or the name of the field
    * that is being referenced.
    */
@@ skipping 124 matching lines @@
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 /**
  * Instances of the class {@code ArgumentDefinitionTest} represent an argument definition test.
  * <pre>
  * argumentDefinitionTest ::=
  * '?' {@link SimpleIdentifier identifier}</pre>
+ * @coverage dart.engine.ast
  */
 class ArgumentDefinitionTest extends Expression {
   /**
    * The token representing the question mark.
    */
   Token _question;
   /**
    * The identifier representing the argument being tested.
    */
   SimpleIdentifier _identifier;
@@ skipping 45 matching lines @@
 }
 /**
  * Instances of the class {@code ArgumentList} represent a list of arguments in the invocation of a
  * executable element: a function, method, or constructor.
  * <pre>
  * argumentList ::=
  * '(' arguments? ')'
  * arguments ::={@link NamedExpression namedArgument} (',' {@link NamedExpression namedArgument})
  * | {@link Expression expressionList} (',' {@link NamedExpression namedArgument})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ArgumentList extends ASTNode {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
   /**
    * The expressions producing the values of the arguments.
    */
   NodeList<Expression> _arguments;
@@ skipping 97 matching lines @@
     if (index < 0) {
       return null;
     }
     return _correspondingParameters[index];
   }
 }
 /**
  * Instances of the class {@code AsExpression} represent an 'as' expression.
  * <pre>
  * asExpression ::={@link Expression expression} 'as' {@link TypeName type}</pre>
+ * @coverage dart.engine.ast
  */
 class AsExpression extends Expression {
   /**
    * The expression used to compute the value being cast.
    */
   Expression _expression;
   /**
    * The as operator.
    */
   Token _asOperator;
@@ skipping 62 matching lines @@
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
  * Instances of the class {@code AssertStatement} represent an assert statement.
  * <pre>
  * assertStatement ::=
  * 'assert' '(' {@link Expression conditionalExpression} ')' ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class AssertStatement extends Statement {
   /**
    * The token representing the 'assert' keyword.
    */
   Token _keyword;
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
@@ skipping 97 matching lines @@
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
  * Instances of the class {@code AssignmentExpression} represent an assignment expression.
  * <pre>
  * assignmentExpression ::={@link Expression leftHandSide} {@link Token operator} {@link Expression rightHandSide}</pre>
+ * @coverage dart.engine.ast
  */
 class AssignmentExpression extends Expression {
   /**
    * The expression used to compute the left hand side.
    */
   Expression _leftHandSide;
   /**
    * The assignment operator being applied.
    */
   Token _operator;
@@ skipping 80 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftHandSide, visitor);
     safelyVisitChild(_rightHandSide, visitor);
   }
 }
 /**
  * Instances of the class {@code BinaryExpression} represent a binary (infix) expression.
  * <pre>
  * binaryExpression ::={@link Expression leftOperand} {@link Token operator} {@link Expression rightOperand}</pre>
+ * @coverage dart.engine.ast
  */
 class BinaryExpression extends Expression {
   /**
    * The expression used to compute the left operand.
    */
   Expression _leftOperand;
   /**
    * The binary operator being applied.
    */
   Token _operator;
@@ skipping 82 matching lines @@
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 }
 /**
  * Instances of the class {@code Block} represent a sequence of statements.
  * <pre>
  * block ::=
  * '{' statement* '}'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class Block extends Statement {
   /**
    * The left curly bracket.
    */
   Token _leftBracket;
   /**
    * The statements contained in the block.
    */
   NodeList<Statement> _statements;
@@ skipping 54 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _statements.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code BlockFunctionBody} represent a function body that consists of a
  * block of statements.
  * <pre>
  * blockFunctionBody ::={@link Block block}</pre>
+ * @coverage dart.engine.ast
  */
 class BlockFunctionBody extends FunctionBody {
   /**
    * The block representing the body of the function.
    */
   Block _block;
   /**
    * Initialize a newly created function body consisting of a block of statements.
    * @param block the block representing the body of the function
    */
@@ skipping 23 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 /**
  * Instances of the class {@code BooleanLiteral} represent a boolean literal expression.
  * <pre>
  * booleanLiteral ::=
  * 'false' | 'true'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class BooleanLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token _literal;
   /**
    * The value of the literal.
    */
   bool _value = false;
@@ skipping 42 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code BreakStatement} represent a break statement.
  * <pre>
  * breakStatement ::=
  * 'break' {@link SimpleIdentifier label}? ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class BreakStatement extends Statement {
   /**
    * The token representing the 'break' keyword.
    */
   Token _keyword;
   /**
    * The label associated with the statement, or {@code null} if there is no label.
    */
   SimpleIdentifier _label;
@@ skipping 67 matching lines @@
  * expressions that share a common target. There are three kinds of expressions that can be used in
  * a cascade expression: {@link IndexExpression}, {@link MethodInvocation} and{@link PropertyAccess}.
  * <pre>
  * cascadeExpression ::={@link Expression conditionalExpression} cascadeSection
  * cascadeSection ::=
  * '..'  (cascadeSelector arguments*) (assignableSelector arguments*)* (assignmentOperator expressionWithoutCascade)?
  * cascadeSelector ::=
  * '[ ' expression '] '
  * | identifier
  * </pre>
+ * @coverage dart.engine.ast
  */
 class CascadeExpression extends Expression {
   /**
    * The target of the cascade sections.
    */
   Expression _target;
   /**
    * The cascade sections sharing the common target.
    */
   NodeList<Expression> _cascadeSections;
@@ skipping 38 matching lines @@
     _cascadeSections.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code CatchClause} represent a catch clause within a try statement.
  * <pre>
  * onPart ::=
  * catchPart {@link Block block}| 'on' type catchPart? {@link Block block}catchPart ::=
  * 'catch' '(' {@link SimpleIdentifier exceptionParameter} (',' {@link SimpleIdentifier stackTraceParameter})? ')'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class CatchClause extends ASTNode {
   /**
    * The token representing the 'on' keyword, or {@code null} if there is no 'on' keyword.
    */
   Token _onKeyword;
   /**
    * The type of exceptions caught by this catch clause, or {@code null} if this catch clause
    * catches every type of exception.
    */
@@ skipping 190 matching lines @@
   }
 }
 /**
  * Instances of the class {@code ClassDeclaration} represent the declaration of a class.
  * <pre>
  * classDeclaration ::=
  * 'abstract'? 'class' {@link SimpleIdentifier name} {@link TypeParameterList typeParameterList}?
  * ({@link ExtendsClause extendsClause} {@link WithClause withClause}?)?{@link ImplementsClause implementsClause}?
  * '{' {@link ClassMember classMember}* '}'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ClassDeclaration extends CompilationUnitMember {
   /**
    * The 'abstract' keyword, or {@code null} if the keyword was absent.
    */
   Token _abstractKeyword;
   /**
    * The token representing the 'class' keyword.
    */
   Token _classKeyword;
@@ skipping 206 matching lines @@
   Token get firstTokenAfterCommentAndMetadata {
     if (_abstractKeyword != null) {
       return _abstractKeyword;
     }
     return _classKeyword;
   }
 }
 /**
  * The abstract class {@code ClassMember} defines the behavior common to nodes that declare a name
  * within the scope of a class.
+ * @coverage dart.engine.ast
  */
 abstract class ClassMember extends Declaration {
   /**
    * Initialize a newly created member of a class.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   ClassMember.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
   /**
    * Initialize a newly created member of a class.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   ClassMember({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
 }
 /**
  * Instances of the class {@code ClassTypeAlias} represent a class type alias.
  * <pre>
  * classTypeAlias ::={@link SimpleIdentifier identifier} {@link TypeParameterList typeParameters}? '=' 'abstract'? mixinApplication
  * mixinApplication ::={@link TypeName superclass} {@link WithClause withClause} {@link ImplementsClause implementsClause}? ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ClassTypeAlias extends TypeAlias {
   /**
    * The name of the class being declared.
    */
   SimpleIdentifier _name;
   /**
    * The type parameters for the class, or {@code null} if the class does not have any type
    * parameters.
    */
@@ skipping 152 matching lines @@
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
 /**
  * Instances of the class {@code Combinator} represent the combinator associated with an import
  * directive.
  * <pre>
  * combinator ::={@link HideCombinator hideCombinator}| {@link ShowCombinator showCombinator}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class Combinator extends ASTNode {
   /**
    * The keyword specifying what kind of processing is to be done on the imported names.
    */
   Token _keyword;
   /**
    * Initialize a newly created import combinator.
    * @param keyword the keyword specifying what kind of processing is to be done on the imported
    * names
@@ skipping 31 matching lines @@
  * | blockComment
  * | documentationComment
  * endOfLineComment ::=
  * '//' (CHARACTER - EOL)* EOL
  * blockComment ::=
  * '/ *' CHARACTER* '&#42;/'
  * documentationComment ::=
  * '/ **' (CHARACTER | {@link CommentReference commentReference})* '&#42;/'
  * | ('///' (CHARACTER - EOL)* EOL)+
  * </pre>
+ * @coverage dart.engine.ast
  */
 class Comment extends ASTNode {
   /**
    * Create a block comment.
    * @param tokens the tokens representing the comment
    * @return the block comment that was created
    */
   static Comment createBlockComment(List<Token> tokens) => new Comment.full(tokens, CommentType.BLOCK, null);
   /**
    * Create a documentation comment.
@@ skipping 86 matching lines @@
    * A block comment.
    */
   static final CommentType BLOCK = new CommentType('BLOCK', 1);
   /**
    * A documentation comment.
    */
   static final CommentType DOCUMENTATION = new CommentType('DOCUMENTATION', 2);
   static final List<CommentType> values = [END_OF_LINE, BLOCK, DOCUMENTATION];
   final String __name;
   final int __ordinal;
+  int get ordinal => __ordinal;
   CommentType(this.__name, this.__ordinal) {
   }
   String toString() => __name;
 }
 /**
  * Instances of the class {@code CommentReference} represent a reference to a Dart element that is
  * found within a documentation comment.
  * <pre>
  * commentReference ::=
  * '[' 'new'? {@link Identifier identifier} ']'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class CommentReference extends ASTNode {
   /**
    * The token representing the 'new' keyword, or {@code null} if there was no 'new' keyword.
    */
   Token _newKeyword;
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
@@ skipping 22 matching lines @@
   Identifier get identifier => _identifier;
   /**
    * Return the token representing the 'new' keyword, or {@code null} if there was no 'new' keyword.
    * @return the token representing the 'new' keyword
    */
   Token get newKeyword => _newKeyword;
   /**
    * Set the identifier being referenced to the given identifier.
    * @param identifier the identifier being referenced
    */
-  void set identifier(Identifier identifier23) {
-    identifier23 = becomeParentOf(identifier23);
+  void set identifier(Identifier identifier24) {
+    identifier24 = becomeParentOf(identifier24);
   }
   /**
    * Set the token representing the 'new' keyword to the given token.
    * @param newKeyword the token representing the 'new' keyword
    */
   void set newKeyword(Token newKeyword2) {
     this._newKeyword = newKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code CompilationUnit} represent a compilation unit.
  * <p>
  * While the grammar restricts the order of the directives and declarations within a compilation
  * unit, this class does not enforce those restrictions. In particular, the children of a
  * compilation unit will be visited in lexical order even if lexical order does not conform to the
  * restrictions of the grammar.
  * <pre>
  * compilationUnit ::=
  * directives declarations
  * directives ::={@link ScriptTag scriptTag}? {@link LibraryDirective libraryDirective}? namespaceDirective* {@link PartDirective partDirective}| {@link PartOfDirective partOfDirective}namespaceDirective ::={@link ImportDirective importDirective}| {@link ExportDirective exportDirective}declarations ::={@link CompilationUnitMember compilationUnitMember}</pre>
+ * @coverage dart.engine.ast
  */
 class CompilationUnit extends ASTNode {
   /**
    * The first token in the token stream that was parsed to form this compilation unit.
    */
   Token _beginToken;
   /**
    * The script tag at the beginning of the compilation unit, or {@code null} if there is no script
    * tag in this compilation unit.
    */
@@ skipping 91 matching lines @@
       JavaSystem.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
       JavaSystem.arraycopy(resolverErrors, 0, allErrors, parserErrors.length, resolverErrors.length);
       return allErrors;
     }
   }
   int get length {
     Token endToken3 = endToken;
     if (endToken3 == null) {
       return 0;
     }
-    return endToken3.offset + endToken3.length - beginToken.offset;
+    return endToken3.offset + endToken3.length;
   }
   /**
    * Get the {@link LineInfo} object for this compilation unit.
    * @return the associated {@link LineInfo}
    */
   LineInfo get lineInfo => _lineInfo;
-  int get offset {
-    Token beginToken4 = beginToken;
-    if (beginToken4 == null) {
-      return 0;
-    }
-    return beginToken4.offset;
-  }
+  int get offset => 0;
   /**
    * Return an array containing all of the parsing errors associated with the receiver.
    * @return an array of errors (not {@code null}, contains no {@code null}s).
    */
   List<AnalysisError> get parsingErrors => _parsingErrors;
   /**
    * Return an array containing all of the resolution errors associated with the receiver. If the
    * receiver has not been resolved, then return {@code null}.
    * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
    * been resolved
@@ skipping 78 matching lines @@
     List<ASTNode> children = new List.from(childList);
     children.sort();
     return children;
   }
 }
 /**
  * Instances of the class {@code CompilationUnitMember} defines the behavior common to nodes that
  * declare a name within the scope of a compilation unit.
  * <pre>
  * compilationUnitMember ::={@link ClassDeclaration classDeclaration}| {@link TypeAlias typeAlias}| {@link FunctionDeclaration functionDeclaration}| {@link MethodDeclaration getOrSetDeclaration}| {@link VariableDeclaration constantsDeclaration}| {@link VariableDeclaration variablesDeclaration}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class CompilationUnitMember extends Declaration {
   /**
    * Initialize a newly created generic compilation unit member.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   CompilationUnitMember.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
   /**
    * Initialize a newly created generic compilation unit member.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   CompilationUnitMember({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
 }
 /**
  * Instances of the class {@code ConditionalExpression} represent a conditional expression.
  * <pre>
  * conditionalExpression ::={@link Expression condition} '?' {@link Expression thenExpression} ':' {@link Expression elseExpression}</pre>
+ * @coverage dart.engine.ast
  */
 class ConditionalExpression extends Expression {
   /**
    * The condition used to determine which of the expressions is executed next.
    */
   Expression _condition;
   /**
    * The token used to separate the condition from the then expression.
    */
   Token _question;
@@ skipping 113 matching lines @@
  * | constructorName formalParameterList ':' 'this' ('.' {@link SimpleIdentifier name})? arguments
  * constructorSignature ::=
  * 'external'? constructorName formalParameterList initializerList?
  * | 'external'? 'factory' factoryName formalParameterList initializerList?
  * | 'external'? 'const'  constructorName formalParameterList initializerList?
  * constructorName ::={@link SimpleIdentifier returnType} ('.' {@link SimpleIdentifier name})?
  * factoryName ::={@link Identifier returnType} ('.' {@link SimpleIdentifier name})?
  * initializerList ::=
  * ':' {@link ConstructorInitializer initializer} (',' {@link ConstructorInitializer initializer})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ConstructorDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or {@code null} if the constructor is not external.
    */
   Token _externalKeyword;
   /**
    * The token for the 'const' keyword, or {@code null} if the constructor is not a const
    * constructor.
    */
@@ skipping 274 matching lines @@
     }
     return leftMost;
   }
 }
 /**
  * Instances of the class {@code ConstructorFieldInitializer} represent the initialization of a
  * field within a constructor's initialization list.
  * <pre>
  * fieldInitializer ::=
  * ('this' '.')? {@link SimpleIdentifier fieldName} '=' {@link Expression conditionalExpression cascadeSection*}</pre>
+ * @coverage dart.engine.ast
  */
 class ConstructorFieldInitializer extends ConstructorInitializer {
   /**
    * The token for the 'this' keyword, or {@code null} if there is no 'this' keyword.
    */
   Token _keyword;
   /**
    * The token for the period after the 'this' keyword, or {@code null} if there is no 'this'
    * keyword.
    */
@@ skipping 109 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_fieldName, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ConstructorInitializer} defines the behavior of nodes that can
  * occur in the initializer list of a constructor declaration.
  * <pre>
  * constructorInitializer ::={@link SuperConstructorInvocation superInvocation}| {@link ConstructorFieldInitializer fieldInitializer}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class ConstructorInitializer extends ASTNode {
 }
 /**
  * Instances of the class {@code ConstructorName} represent the name of the constructor.
  * <pre>
  * constructorName:
  * type ('.' identifier)?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ConstructorName extends ASTNode {
   /**
    * The name of the type defining the constructor.
    */
   TypeName _type;
   /**
    * The token for the period before the constructor name, or {@code null} if the specified
    * constructor is the unnamed constructor.
    */
@@ skipping 89 matching lines @@
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 /**
  * Instances of the class {@code ContinueStatement} represent a continue statement.
  * <pre>
  * continueStatement ::=
  * 'continue' {@link SimpleIdentifier label}? ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ContinueStatement extends Statement {
   /**
    * The token representing the 'continue' keyword.
    */
   Token _keyword;
   /**
    * The label associated with the statement, or {@code null} if there is no label.
    */
   SimpleIdentifier _label;
@@ skipping 58 matching lines @@
   void set semicolon(Token semicolon4) {
     this._semicolon = semicolon4;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * The abstract class {@code Declaration} defines the behavior common to nodes that represent the
  * declaration of a name. Each declared name is visible within a name scope.
+ * @coverage dart.engine.ast
  */
 abstract class Declaration extends AnnotatedNode {
   /**
    * Initialize a newly created declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    */
   Declaration.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
   /**
    * Initialize a newly created declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    */
   Declaration({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
   /**
    * Return the element associated with this declaration, or {@code null} if either this node
    * corresponds to a list of declarations or if the AST structure has not been resolved.
    * @return the element associated with this declaration
    */
   Element get element;
 }
 /**
+ * Instances of the class {@code DeclaredIdentifier} represent the declaration of a single
+ * identifier.
+ * <pre>
+ * declaredIdentifier ::=
+ * ({@link Annotation metadata} finalConstVarOrType {@link SimpleIdentifier identifier}</pre>
+ * @coverage dart.engine.ast
+ */
+class DeclaredIdentifier extends Declaration {
+  /**
+   * The token representing either the 'final', 'const' or 'var' keyword, or {@code null} if no
+   * keyword was used.
+   */
+  Token _keyword;
+  /**
+   * The name of the declared type of the parameter, or {@code null} if the parameter does not have
+   * a declared type.
+   */
+  TypeName _type;
+  /**
+   * The name of the variable being declared.
+   */
+  SimpleIdentifier _identifier;
+  /**
+   * Initialize a newly created formal parameter.
+   * @param comment the documentation comment associated with this parameter
+   * @param metadata the annotations associated with this parameter
+   * @param keyword the token representing either the 'final', 'const' or 'var' keyword
+   * @param type the name of the declared type of the parameter
+   * @param identifier the name of the parameter being declared
+   */
+  DeclaredIdentifier.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier) : super.full(comment, metadata) {
+    this._keyword = keyword;
+    this._type = becomeParentOf(type);
+    this._identifier = becomeParentOf(identifier);
+  }
+  /**
+   * Initialize a newly created formal parameter.
+   * @param comment the documentation comment associated with this parameter
+   * @param metadata the annotations associated with this parameter
+   * @param keyword the token representing either the 'final', 'const' or 'var' keyword
+   * @param type the name of the declared type of the parameter
+   * @param identifier the name of the parameter being declared
+   */
+  DeclaredIdentifier({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier}) : this.full(comment, metadata, keyword, type, identifier);
+  accept(ASTVisitor visitor) => visitor.visitDeclaredIdentifier(this);
+  LocalVariableElement get element {
+    SimpleIdentifier identifier11 = identifier;
+    if (identifier11 == null) {
+      return null;
+    }
+    return identifier11.element as LocalVariableElement;
+  }
+  Token get endToken => _identifier.endToken;
+  /**
+   * Return the name of the variable being declared.
+   * @return the name of the variable being declared
+   */
+  SimpleIdentifier get identifier => _identifier;
+  /**
+   * Return the token representing either the 'final', 'const' or 'var' keyword.
+   * @return the token representing either the 'final', 'const' or 'var' keyword
+   */
+  Token get keyword => _keyword;
+  /**
+   * Return the name of the declared type of the parameter, or {@code null} if the parameter does
+   * not have a declared type.
+   * @return the name of the declared type of the parameter
+   */
+  TypeName get type => _type;
+  /**
+   * Return {@code true} if this variable was declared with the 'const' modifier.
+   * @return {@code true} if this variable was declared with the 'const' modifier
+   */
+  bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  /**
+   * Return {@code true} if this variable was declared with the 'final' modifier. Variables that are
+   * declared with the 'const' modifier will return {@code false} even though they are implicitly
+   * final.
+   * @return {@code true} if this variable was declared with the 'final' modifier
+   */
+  bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
+  /**
+   * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
+   * @param keyword the token representing either the 'final', 'const' or 'var' keyword
+   */
+  void set keyword(Token keyword8) {
+    this._keyword = keyword8;
+  }
+  /**
+   * Set the name of the declared type of the parameter to the given type name.
+   * @param typeName the name of the declared type of the parameter
+   */
+  void set type(TypeName typeName) {
+    _type = becomeParentOf(typeName);
+  }
+  void visitChildren(ASTVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChild(_type, visitor);
+    safelyVisitChild(_identifier, visitor);
+  }
+  Token get firstTokenAfterCommentAndMetadata {
+    if (_keyword != null) {
+      return _keyword;
+    } else if (_type != null) {
+      return _type.beginToken;
+    }
+    return _identifier.beginToken;
+  }
+}
+/**
  * Instances of the class {@code DefaultFormalParameter} represent a formal parameter with a default
  * value. There are two kinds of parameters that are both represented by this class: named formal
  * parameters and positional formal parameters.
  * <pre>
  * defaultFormalParameter ::={@link NormalFormalParameter normalFormalParameter} ('=' {@link Expression defaultValue})?
  * defaultNamedParameter ::={@link NormalFormalParameter normalFormalParameter} (':' {@link Expression defaultValue})?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class DefaultFormalParameter extends FormalParameter {
   /**
    * The formal parameter with which the default value is associated.
    */
   NormalFormalParameter _parameter;
   /**
    * The kind of this parameter.
    */
   ParameterKind _kind;
@@ skipping 49 matching lines @@
    * @return the formal parameter with which the default value is associated
    */
   NormalFormalParameter get parameter => _parameter;
   /**
    * Return the token separating the parameter from the default value, or {@code null} if there is
    * no default value.
    * @return the token separating the parameter from the default value
    */
   Token get separator => _separator;
   /**
-   * Return {@code true} if this parameter is a const parameter.
-   * @return {@code true} if this parameter is a const parameter
+   * Return {@code true} if this parameter was declared with the 'const' modifier.
+   * @return {@code true} if this parameter was declared with the 'const' modifier
    */
   bool isConst() => _parameter != null && _parameter.isConst();
   /**
-   * Return {@code true} if this parameter is a final parameter.
-   * @return {@code true} if this parameter is a final parameter
+   * Return {@code true} if this parameter was declared with the 'final' modifier. Parameters that
+   * are declared with the 'const' modifier will return {@code false} even though they are
+   * implicitly final.
+   * @return {@code true} if this parameter was declared with the 'final' modifier
    */
   bool isFinal() => _parameter != null && _parameter.isFinal();
   /**
    * Set the expression computing the default value for the parameter to the given expression.
    * @param expression the expression computing the default value for the parameter
    */
   void set defaultValue(Expression expression) {
     _defaultValue = becomeParentOf(expression);
   }
   /**
@@ skipping 20 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 /**
  * The abstract class {@code Directive} defines the behavior common to nodes that represent a
  * directive.
  * <pre>
  * directive ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link LibraryDirective libraryDirective}| {@link PartDirective partDirective}| {@link PartOfDirective partOfDirective}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class Directive extends AnnotatedNode {
   /**
    * The element associated with this directive, or {@code null} if the AST structure has not been
    * resolved or if this directive could not be resolved.
    */
   Element _element;
   /**
    * Initialize a newly create directive.
    * @param comment the documentation comment associated with this directive
@@ skipping 27 matching lines @@
   void set element(Element element8) {
     this._element = element8;
   }
 }
 /**
  * Instances of the class {@code DoStatement} represent a do statement.
  * <pre>
  * doStatement ::=
  * 'do' {@link Statement body} 'while' '(' {@link Expression condition} ')' ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class DoStatement extends Statement {
   /**
    * The token representing the 'do' keyword.
    */
   Token _doKeyword;
   /**
    * The body of the loop.
    */
   Statement _body;
@@ skipping 141 matching lines @@
 }
 /**
  * Instances of the class {@code DoubleLiteral} represent a floating point literal expression.
  * <pre>
  * doubleLiteral ::=
  * decimalDigit+ ('.' decimalDigit*)? exponent?
  * | '.' decimalDigit+ exponent?
  * exponent ::=
  * ('e' | 'E') ('+' | '-')? decimalDigit+
  * </pre>
+ * @coverage dart.engine.ast
  */
 class DoubleLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token _literal;
   /**
    * The value of the literal.
    */
   double _value = 0.0;
@@ skipping 42 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code EmptyFunctionBody} represent an empty function body, which can only
  * appear in constructors or abstract methods.
  * <pre>
  * emptyFunctionBody ::=
  * ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class EmptyFunctionBody extends FunctionBody {
   /**
    * The token representing the semicolon that marks the end of the function body.
    */
   Token _semicolon;
   /**
    * Initialize a newly created function body.
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
@@ skipping 23 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code EmptyStatement} represent an empty statement.
  * <pre>
  * emptyStatement ::=
  * ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class EmptyStatement extends Statement {
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
   /**
    * Initialize a newly created empty statement.
    * @param semicolon the semicolon terminating the statement
    */
@@ skipping 18 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon7) {
     this._semicolon = semicolon7;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
+ * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
   EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new Token(TokenType.IDENTIFIER, location)) {
     parent.becomeParentOf(this);
   }
   EphemeralIdentifier({ASTNode parent, int location}) : this.full(parent, location);
 }
 /**
  * Instances of the class {@code ExportDirective} represent an export directive.
  * <pre>
  * exportDirective ::={@link Annotation metadata} 'export' {@link StringLiteral libraryUri} {@link Combinator combinator}* ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ExportDirective extends NamespaceDirective {
   /**
    * Initialize a newly created export directive.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'export' keyword
    * @param libraryUri the URI of the library being exported
    * @param combinators the combinators used to control which names are exported
    * @param semicolon the semicolon terminating the directive
@@ skipping 15 matching lines @@
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code Expression} defines the behavior common to nodes that represent an
  * expression.
  * <pre>
  * expression ::={@link AssignmentExpression assignmentExpression}| {@link ConditionalExpression conditionalExpression} cascadeSection
  * | {@link ThrowExpression throwExpression}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class Expression extends ASTNode {
   /**
    * The static type of this expression, or {@code null} if the AST structure has not been resolved.
    */
   Type2 _staticType;
   /**
    * The propagated type of this expression, or {@code null} if type propagation has not been
    * performed on the AST structure.
    */
@@ skipping 45 matching lines @@
     this._staticType = staticType2;
   }
 }
 /**
  * Instances of the class {@code ExpressionFunctionBody} represent a function body consisting of a
  * single expression.
  * <pre>
  * expressionFunctionBody ::=
  * '=>' {@link Expression expression} ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ExpressionFunctionBody extends FunctionBody {
   /**
    * The token introducing the expression that represents the body of the function.
    */
   Token _functionDefinition;
   /**
    * The expression representing the body of the function.
    */
   Expression _expression;
@@ skipping 68 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ExpressionStatement} wrap an expression as a statement.
  * <pre>
  * expressionStatement ::={@link Expression expression}? ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ExpressionStatement extends Statement {
   /**
    * The expression that comprises the statement.
    */
   Expression _expression;
   /**
    * The semicolon terminating the statement, or {@code null} if the expression is a function
    * expression and isn't followed by a semicolon.
    */
@@ skipping 49 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ExtendsClause} represent the "extends" clause in a class
  * declaration.
  * <pre>
  * extendsClause ::=
  * 'extends' {@link TypeName superclass}</pre>
+ * @coverage dart.engine.ast
  */
 class ExtendsClause extends ASTNode {
   /**
    * The token representing the 'extends' keyword.
    */
   Token _keyword;
   /**
    * The name of the class that is being extended.
    */
   TypeName _superclass;
@@ skipping 22 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the name of the class that is being extended.
    * @return the name of the class that is being extended
    */
   TypeName get superclass => _superclass;
   /**
    * Set the token representing the 'extends' keyword to the given token.
    * @param keyword the token representing the 'extends' keyword
    */
-  void set keyword(Token keyword8) {
-    this._keyword = keyword8;
+  void set keyword(Token keyword9) {
+    this._keyword = keyword9;
   }
   /**
    * Set the name of the class that is being extended to the given name.
    * @param name the name of the class that is being extended
    */
   void set superclass(TypeName name) {
     _superclass = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_superclass, visitor);
   }
 }
 /**
  * Instances of the class {@code FieldDeclaration} represent the declaration of one or more fields
  * of the same type.
  * <pre>
  * fieldDeclaration ::=
  * 'static'? {@link VariableDeclarationList fieldList} ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class FieldDeclaration extends ClassMember {
   /**
    * The token representing the 'static' keyword, or {@code null} if the fields are not static.
    */
   Token _keyword;
   /**
    * The fields being declared.
    */
   VariableDeclarationList _fieldList;
@@ skipping 46 matching lines @@
    * Set the fields being declared to the given list of variables.
    * @param fieldList the fields being declared
    */
   void set fields(VariableDeclarationList fieldList) {
     fieldList = becomeParentOf(fieldList);
   }
   /**
    * Set the token representing the 'static' keyword to the given token.
    * @param keyword the token representing the 'static' keyword
    */
-  void set keyword(Token keyword9) {
-    this._keyword = keyword9;
+  void set keyword(Token keyword10) {
+    this._keyword = keyword10;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
   void set semicolon(Token semicolon10) {
     this._semicolon = semicolon10;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     }
     return _fieldList.beginToken;
   }
 }
 /**
  * Instances of the class {@code FieldFormalParameter} represent a field formal parameter.
  * <pre>
  * fieldFormalParameter ::=
  * ('final' {@link TypeName type} | 'const' {@link TypeName type} | 'var' | {@link TypeName type})? 'this' '.' {@link SimpleIdentifier identifier}</pre>
+ * @coverage dart.engine.ast
  */
 class FieldFormalParameter extends NormalFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or {@code null} if no
    * keyword was used.
    */
   Token _keyword;
   /**
    * The name of the declared type of the parameter, or {@code null} if the parameter does not have
    * a declared type.
@@ skipping 64 matching lines @@
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword10) {
-    this._keyword = keyword10;
+  void set keyword(Token keyword11) {
+    this._keyword = keyword11;
   }
   /**
    * Set the token representing the period to the given token.
    * @param period the token representing the period
    */
   void set period(Token period6) {
     this._period = period6;
   }
   /**
    * Set the token representing the 'this' keyword to the given token.
@@ skipping 13 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code ForEachStatement} represent a for-each statement.
  * <pre>
  * forEachStatement ::=
  * 'for' '(' {@link SimpleFormalParameter loopParameter} 'in' {@link Expression iterator} ')' {@link Block body}</pre>
+ * @coverage dart.engine.ast
  */
 class ForEachStatement extends Statement {
   /**
    * The token representing the 'for' keyword.
    */
   Token _forKeyword;
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
   /**
    * The declaration of the loop variable.
    */
-  SimpleFormalParameter _loopParameter;
+  DeclaredIdentifier _loopVariable;
   /**
    * The token representing the 'in' keyword.
    */
   Token _inKeyword;
   /**
    * The expression evaluated to produce the iterator.
    */
   Expression _iterator;
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
   /**
    * The body of the loop.
    */
   Statement _body;
   /**
    * Initialize a newly created for-each statement.
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
-   * @param loopParameter the declaration of the loop variable
+   * @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.full(Token forKeyword, Token leftParenthesis, SimpleFormalParameter loopParameter, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
+  ForEachStatement.full(Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
     this._forKeyword = forKeyword;
     this._leftParenthesis = leftParenthesis;
-    this._loopParameter = becomeParentOf(loopParameter);
+    this._loopVariable = becomeParentOf(loopVariable);
     this._inKeyword = inKeyword;
     this._iterator = becomeParentOf(iterator);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
   /**
    * Initialize a newly created for-each statement.
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
-   * @param loopParameter the declaration of the loop variable
+   * @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({Token forKeyword, Token leftParenthesis, SimpleFormalParameter loopParameter, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.full(forKeyword, leftParenthesis, loopParameter, inKeyword, iterator, rightParenthesis, body);
+  ForEachStatement({Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.full(forKeyword, leftParenthesis, loopVariable, inKeyword, iterator, rightParenthesis, body);
   accept(ASTVisitor visitor) => visitor.visitForEachStatement(this);
   Token get beginToken => _forKeyword;
   /**
    * Return the body of the loop.
    * @return the body of the loop
    */
   Statement get body => _body;
   Token get endToken => _body.endToken;
   /**
    * Return the token representing the 'for' keyword.
@@ skipping 12 matching lines @@
   Expression get iterator => _iterator;
   /**
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
   /**
    * Return the declaration of the loop variable.
    * @return the declaration of the loop variable
    */
-  SimpleFormalParameter get loopParameter => _loopParameter;
+  DeclaredIdentifier get loopVariable => _loopVariable;
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Set the body of the loop to the given block.
    * @param body the body of the loop
    */
   void set body(Statement body2) {
@@ skipping 21 matching lines @@
     _iterator = becomeParentOf(expression);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
   void set leftParenthesis(Token leftParenthesis3) {
     this._leftParenthesis = leftParenthesis3;
   }
   /**
-   * Set the declaration of the loop variable to the given parameter.
-   * @param parameter the declaration of the loop variable
+   * Set the declaration of the loop variable to the given variable.
+   * @param variable the declaration of the loop variable
    */
-  void set loopParameter(SimpleFormalParameter parameter) {
-    _loopParameter = becomeParentOf(parameter);
+  void set loopVariable(DeclaredIdentifier variable) {
+    _loopVariable = becomeParentOf(variable);
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
   void set rightParenthesis(Token rightParenthesis3) {
     this._rightParenthesis = rightParenthesis3;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
-    safelyVisitChild(_loopParameter, visitor);
+    safelyVisitChild(_loopVariable, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code ForStatement} represent a for statement.
  * <pre>
  * forStatement ::=
  * 'for' '(' forLoopParts ')' {@link Statement statement}forLoopParts ::=
  * forInitializerStatement ';' {@link Expression expression}? ';' {@link Expression expressionList}?
  * forInitializerStatement ::={@link DefaultFormalParameter initializedVariableDeclaration}| {@link Expression expression}?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ForStatement extends Statement {
   /**
    * The token representing the 'for' keyword.
    */
   Token _forKeyword;
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
@@ skipping 195 matching lines @@
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * The abstract class {@code FormalParameter} defines the behavior of objects representing a
  * parameter to a function.
  * <pre>
  * formalParameter ::={@link NormalFormalParameter normalFormalParameter}| {@link DefaultFormalParameter namedFormalParameter}| {@link DefaultFormalParameter optionalFormalParameter}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class FormalParameter extends ASTNode {
   /**
    * Return the element representing this parameter, or {@code null} if this parameter has not been
    * resolved.
    * @return the element representing this parameter
    */
   ParameterElement get element {
-    SimpleIdentifier identifier11 = identifier;
-    if (identifier11 == null) {
+    SimpleIdentifier identifier12 = identifier;
+    if (identifier12 == null) {
       return null;
     }
-    return identifier11.element as ParameterElement;
+    return identifier12.element as ParameterElement;
   }
   /**
    * Return the name of the parameter being declared.
    * @return the name of the parameter being declared
    */
   SimpleIdentifier get identifier;
   /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
@@ skipping 14 matching lines @@
  * | '(' optionalFormalParameters ')'
  * normalFormalParameters ::={@link NormalFormalParameter normalFormalParameter} (',' {@link NormalFormalParameter normalFormalParameter})
  * optionalFormalParameters ::=
  * optionalPositionalFormalParameters
  * | namedFormalParameters
  * optionalPositionalFormalParameters ::=
  * '[' {@link DefaultFormalParameter positionalFormalParameter} (',' {@link DefaultFormalParameter positionalFormalParameter})* ']'
  * namedFormalParameters ::=
  * '{' {@link DefaultFormalParameter namedFormalParameter} (',' {@link DefaultFormalParameter namedFormalParameter})* '}'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class FormalParameterList extends ASTNode {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
   /**
    * The parameters associated with the method.
    */
   NodeList<FormalParameter> _parameters;
@@ skipping 111 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _parameters.accept(visitor);
   }
 }
 /**
  * The abstract class {@code FunctionBody} defines the behavior common to objects representing the
  * body of a function or method.
  * <pre>
  * functionBody ::={@link BlockFunctionBody blockFunctionBody}| {@link EmptyFunctionBody emptyFunctionBody}| {@link ExpressionFunctionBody expressionFunctionBody}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class FunctionBody extends ASTNode {
 }
 /**
  * Instances of the class {@code FunctionDeclaration} wrap a {@link FunctionExpression function
  * expression} as a top-level declaration.
  * <pre>
  * functionDeclaration ::=
  * 'external' functionSignature
  * | functionSignature {@link FunctionBody functionBody}functionSignature ::={@link Type returnType}? ('get' | 'set')? {@link SimpleIdentifier functionName} {@link FormalParameterList formalParameterList}</pre>
+ * @coverage dart.engine.ast
  */
 class FunctionDeclaration extends CompilationUnitMember {
   /**
    * The token representing the 'external' keyword, or {@code null} if this is not an external
    * function.
    */
   Token _externalKeyword;
   /**
    * The return type of the function, or {@code null} if no return type was declared.
    */
@@ skipping 119 matching lines @@
     } else if (_propertyKeyword != null) {
       return _propertyKeyword;
     } else if (_name != null) {
       return _name.beginToken;
     }
     return _functionExpression.beginToken;
   }
 }
 /**
  * Instances of the class {@code FunctionDeclarationStatement} wrap a {@link FunctionDeclarationfunction declaration} as a statement.
+ * @coverage dart.engine.ast
  */
 class FunctionDeclarationStatement extends Statement {
   /**
    * The function declaration being wrapped.
    */
   FunctionDeclaration _functionDeclaration;
   /**
    * Initialize a newly created function declaration statement.
    * @param functionDeclaration the the function declaration being wrapped
    */
@@ skipping 21 matching lines @@
     this._functionDeclaration = becomeParentOf(functionDeclaration2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionExpression} represent a function expression.
  * <pre>
  * functionExpression ::={@link FormalParameterList formalParameterList} {@link FunctionBody functionBody}</pre>
+ * @coverage dart.engine.ast
  */
 class FunctionExpression extends Expression {
   /**
    * The parameters associated with the function.
    */
   FormalParameterList _parameters;
   /**
    * The body of the function, or {@code null} if this is an external function.
    */
   FunctionBody _body;
@@ skipping 76 matching lines @@
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionExpressionInvocation} represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
  * functions are represented by {@link MethodInvocation method invocation} nodes. Invocations of
  * getters and setters are represented by either {@link PrefixedIdentifier prefixed identifier} or{@link PropertyAccess property access} nodes.
  * <pre>
  * functionExpressionInvoction ::={@link Expression function} {@link ArgumentList argumentList}</pre>
+ * @coverage dart.engine.ast
  */
 class FunctionExpressionInvocation extends Expression {
   /**
    * The expression producing the function being invoked.
    */
   Expression _function;
   /**
    * The list of arguments to the function.
    */
   ArgumentList _argumentList;
@@ skipping 62 matching lines @@
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionTypeAlias} represent a function type alias.
  * <pre>
  * functionTypeAlias ::=
  * functionPrefix {@link TypeParameterList typeParameterList}? {@link FormalParameterList formalParameterList} ';'
  * functionPrefix ::={@link TypeName returnType}? {@link SimpleIdentifier name}</pre>
+ * @coverage dart.engine.ast
  */
 class FunctionTypeAlias extends TypeAlias {
   /**
    * The name of the return type of the function type being defined, or {@code null} if no return
    * type was given.
    */
   TypeName _returnType;
   /**
    * The name of the function type being declared.
    */
@@ skipping 94 matching lines @@
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionTypedFormalParameter} represent a function-typed formal
  * parameter.
  * <pre>
  * functionSignature ::={@link TypeName returnType}? {@link SimpleIdentifier identifier} {@link FormalParameterList formalParameterList}</pre>
+ * @coverage dart.engine.ast
  */
 class FunctionTypedFormalParameter extends NormalFormalParameter {
   /**
    * The return type of the function, or {@code null} if the function does not have a return type.
    */
   TypeName _returnType;
   /**
    * The parameters of the function-typed parameter.
    */
   FormalParameterList _parameters;
@@ skipping 62 matching lines @@
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
  * Instances of the class {@code HideCombinator} represent a combinator that restricts the names
  * being imported to those that are not in a given list.
  * <pre>
  * hideCombinator ::=
  * 'hide' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class HideCombinator extends Combinator {
   /**
    * The list of names from the library that are hidden by this combinator.
    */
   NodeList<SimpleIdentifier> _hiddenNames;
   /**
    * Initialize a newly created import show combinator.
    * @param keyword the comma introducing the combinator
    * @param hiddenNames the list of names from the library that are hidden by this combinator
@@ skipping 17 matching lines @@
   NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
   void visitChildren(ASTVisitor<Object> visitor) {
     _hiddenNames.accept(visitor);
   }
 }
 /**
  * The abstract class {@code Identifier} defines the behavior common to nodes that represent an
  * identifier.
  * <pre>
  * identifier ::={@link SimpleIdentifier simpleIdentifier}| {@link PrefixedIdentifier prefixedIdentifier}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class Identifier extends Expression {
   /**
    * Return {@code true} if the given name is visible only within the library in which it is
    * declared.
    * @param name the name being tested
    * @return {@code true} if the given name is private
    */
   static bool isPrivateName(String name) => name.startsWith("_");
   /**
    * Return the element associated with this identifier, or {@code null} if the AST structure has
    * not been resolved or if this identifier could not be resolved. One example of the latter case
    * is an identifier that is not defined within the scope in which it appears.
    * @return the element associated with this identifier
    */
   Element get element;
   /**
    * Return the lexical representation of the identifier.
    * @return the lexical representation of the identifier
    */
   String get name;
   bool isAssignable() => true;
 }
 /**
  * Instances of the class {@code IfStatement} represent an if statement.
  * <pre>
  * ifStatement ::=
  * 'if' '(' {@link Expression expression} ')' {@link Statement thenStatement} ('else' {@link Statement elseStatement})?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class IfStatement extends Statement {
   /**
    * The token representing the 'if' keyword.
    */
   Token _ifKeyword;
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
@@ skipping 149 matching lines @@
     safelyVisitChild(_elseStatement, visitor);
   }
 }
 /**
  * Instances of the class {@code ImplementsClause} represent the "implements" clause in an class
  * declaration.
  * <pre>
  * implementsClause ::=
  * 'implements' {@link TypeName superclass} (',' {@link TypeName superclass})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ImplementsClause extends ASTNode {
   /**
    * The token representing the 'implements' keyword.
    */
   Token _keyword;
   /**
    * The interfaces that are being implemented.
    */
   NodeList<TypeName> _interfaces;
@@ skipping 23 matching lines @@
   NodeList<TypeName> get interfaces => _interfaces;
   /**
    * Return the token representing the 'implements' keyword.
    * @return the token representing the 'implements' keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the 'implements' keyword to the given token.
    * @param keyword the token representing the 'implements' keyword
    */
-  void set keyword(Token keyword11) {
-    this._keyword = keyword11;
+  void set keyword(Token keyword12) {
+    this._keyword = keyword12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _interfaces.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ImportDirective} represent an import directive.
  * <pre>
  * importDirective ::={@link Annotation metadata} 'import' {@link StringLiteral libraryUri} ('as' identifier)? {@link Combinator combinator}* ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ImportDirective extends NamespaceDirective {
   /**
    * The token representing the 'as' token, or {@code null} if the imported names are not prefixed.
    */
   Token _asToken;
   /**
    * The prefix to be used with the imported names, or {@code null} if the imported names are not
    * prefixed.
    */
@@ skipping 56 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code IndexExpression} represent an index expression.
  * <pre>
  * indexExpression ::={@link Expression target} '[' {@link Expression index} ']'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class IndexExpression extends Expression {
   /**
    * The expression used to compute the object being indexed, or {@code null} if this index
    * expression is part of a cascade expression.
    */
   Expression _target;
   /**
    * The period ("..") before a cascaded index expression, or {@code null} if this index expression
    * is not part of a cascade expression.
@@ skipping 17 matching lines @@
    */
   MethodElement _element;
   /**
    * Initialize a newly created index expression.
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forTarget_full(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
-    _jtd_constructor_57_impl(target3, leftBracket4, index2, rightBracket4);
+    _jtd_constructor_58_impl(target3, leftBracket4, index2, rightBracket4);
   }
   /**
    * Initialize a newly created index expression.
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forTarget({Expression target3, Token leftBracket4, Expression index2, Token rightBracket4}) : this.forTarget_full(target3, leftBracket4, index2, rightBracket4);
-  _jtd_constructor_57_impl(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
+  _jtd_constructor_58_impl(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
     this._target = becomeParentOf(target3);
     this._leftBracket = leftBracket4;
     this._index = becomeParentOf(index2);
     this._rightBracket = rightBracket4;
   }
   /**
    * Initialize a newly created index expression.
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forCascade_full(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
-    _jtd_constructor_58_impl(period7, leftBracket5, index3, rightBracket5);
+    _jtd_constructor_59_impl(period7, leftBracket5, index3, rightBracket5);
   }
   /**
    * Initialize a newly created index expression.
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forCascade({Token period7, Token leftBracket5, Expression index3, Token rightBracket5}) : this.forCascade_full(period7, leftBracket5, index3, rightBracket5);
-  _jtd_constructor_58_impl(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
+  _jtd_constructor_59_impl(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
     this._period = period7;
     this._leftBracket = leftBracket5;
     this._index = becomeParentOf(index3);
     this._rightBracket = rightBracket5;
   }
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
   /**
    * Return the expression used to compute the object being indexed, or {@code null} if this index
    * expression is part of a cascade expression.
    * @return the expression used to compute the object being indexed
@@ skipping 145 matching lines @@
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 }
 /**
  * Instances of the class {@code InstanceCreationExpression} represent an instance creation
  * expression.
  * <pre>
  * newExpression ::=
  * ('new' | 'const') {@link TypeName type} ('.' {@link SimpleIdentifier identifier})? {@link ArgumentList argumentList}</pre>
+ * @coverage dart.engine.ast
  */
 class InstanceCreationExpression extends Expression {
   /**
    * The keyword used to indicate how an object should be created.
    */
   Token _keyword;
   /**
    * The name of the constructor to be invoked.
    */
   ConstructorName _constructorName;
@@ skipping 71 matching lines @@
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
   void set element(ConstructorElement element12) {
     this._element = element12;
   }
   /**
    * Set the keyword used to indicate how an object should be created to the given keyword.
    * @param keyword the keyword used to indicate how an object should be created
    */
-  void set keyword(Token keyword12) {
-    this._keyword = keyword12;
+  void set keyword(Token keyword13) {
+    this._keyword = keyword13;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code IntegerLiteral} represent an integer literal expression.
  * <pre>
  * integerLiteral ::=
  * decimalIntegerLiteral
  * | hexidecimalIntegerLiteral
  * decimalIntegerLiteral ::=
  * decimalDigit+
  * hexidecimalIntegerLiteral ::=
  * '0x' hexidecimalDigit+
  * | '0X' hexidecimalDigit+
  * </pre>
+ * @coverage dart.engine.ast
  */
 class IntegerLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token _literal;
   /**
    * The value of the literal.
    */
   int _value = 0;
@@ skipping 39 matching lines @@
   void set value(int value6) {
     this._value = value6;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * The abstract class {@code InterpolationElement} defines the behavior common to elements within a{@link StringInterpolation string interpolation}.
  * <pre>
  * interpolationElement ::={@link InterpolationExpression interpolationExpression}| {@link InterpolationString interpolationString}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class InterpolationElement extends ASTNode {
 }
 /**
  * Instances of the class {@code InterpolationExpression} represent an expression embedded in a
  * string interpolation.
  * <pre>
  * interpolationExpression ::=
  * '$' {@link SimpleIdentifier identifier}| '$' '{' {@link Expression expression} '}'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class InterpolationExpression extends InterpolationElement {
   /**
    * The token used to introduce the interpolation expression; either '$' if the expression is a
    * simple identifier or '${' if the expression is a full expression.
    */
   Token _leftBracket;
   /**
    * The expression to be evaluated for the value to be converted into a string.
    */
@@ skipping 69 matching lines @@
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code InterpolationString} represent a non-empty substring of an
  * interpolated string.
  * <pre>
  * interpolationString ::=
  * characters
  * </pre>
+ * @coverage dart.engine.ast
  */
 class InterpolationString extends InterpolationElement {
   /**
    * The characters that will be added to the string.
    */
   Token _contents;
   /**
    * The value of the literal.
    */
   String _value;
@@ skipping 39 matching lines @@
   void set value(String string) {
     _value = string;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code IsExpression} represent an is expression.
  * <pre>
  * isExpression ::={@link Expression expression} 'is' '!'? {@link TypeName type}</pre>
+ * @coverage dart.engine.ast
  */
 class IsExpression extends Expression {
   /**
    * The expression used to compute the value whose type is being tested.
    */
   Expression _expression;
   /**
    * The is operator.
    */
   Token _isOperator;
@@ skipping 81 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
  * Instances of the class {@code Label} represent a label.
  * <pre>
  * label ::={@link SimpleIdentifier label} ':'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class Label extends ASTNode {
   /**
    * The label being associated with the statement.
    */
   SimpleIdentifier _label;
   /**
    * The colon that separates the label from the statement.
    */
   Token _colon;
@@ skipping 41 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class {@code LabeledStatement} represent a statement that has a label associated
  * with them.
  * <pre>
  * labeledStatement ::={@link Label label}+ {@link Statement statement}</pre>
+ * @coverage dart.engine.ast
  */
 class LabeledStatement extends Statement {
   /**
    * The labels being associated with the statement.
    */
   NodeList<Label> _labels;
   /**
    * The statement with which the labels are being associated.
    */
   Statement _statement;
@@ skipping 41 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 /**
  * Instances of the class {@code LibraryDirective} represent a library directive.
  * <pre>
  * libraryDirective ::={@link Annotation metadata} 'library' {@link Identifier name} ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class LibraryDirective extends Directive {
   /**
    * The token representing the 'library' token.
    */
   Token _libraryToken;
   /**
    * The name of the library being defined.
    */
   LibraryIdentifier _name;
@@ skipping 66 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _libraryToken;
 }
 /**
  * Instances of the class {@code LibraryIdentifier} represent the identifier for a library.
  * <pre>
  * libraryIdentifier ::={@link SimpleIdentifier component} ('.' {@link SimpleIdentifier component})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class LibraryIdentifier extends Identifier {
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
   /**
    * Initialize a newly created prefixed identifier.
    * @param components the components of the identifier
    */
@@ skipping 31 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     _components.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ListLiteral} represent a list literal.
  * <pre>
  * listLiteral ::=
  * 'const'? ('<' {@link TypeName type} '>')? '[' ({@link Expression expressionList} ','?)? ']'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ListLiteral extends TypedLiteral {
   /**
    * The left square bracket.
    */
   Token _leftBracket;
   /**
    * The expressions used to compute the elements of the list.
    */
   NodeList<Expression> _elements;
@@ skipping 71 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 /**
  * The abstract class {@code Literal} defines the behavior common to nodes that represent a literal
  * expression.
  * <pre>
  * literal ::={@link BooleanLiteral booleanLiteral}| {@link DoubleLiteral doubleLiteral}| {@link IntegerLiteral integerLiteral}| {@link ListLiteral listLiteral}| {@link MapLiteral mapLiteral}| {@link NullLiteral nullLiteral}| {@link StringLiteral stringLiteral}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class Literal extends Expression {
 }
 /**
  * Instances of the class {@code MapLiteral} represent a literal map.
  * <pre>
  * mapLiteral ::=
  * 'const'? ('<' {@link TypeName type} '>')? '{' ({@link MapLiteralEntry entry} (',' {@link MapLiteralEntry entry})* ','?)? '}'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class MapLiteral extends TypedLiteral {
   /**
    * The left curly bracket.
    */
   Token _leftBracket;
   /**
    * The entries in the map.
    */
   NodeList<MapLiteralEntry> _entries;
@@ skipping 71 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     _entries.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code MapLiteralEntry} represent a single key/value pair in a map
  * literal.
  * <pre>
  * mapLiteralEntry ::={@link StringLiteral key} ':' {@link Expression value}</pre>
+ * @coverage dart.engine.ast
  */
 class MapLiteralEntry extends ASTNode {
   /**
    * The key with which the value will be associated.
    */
   StringLiteral _key;
   /**
    * The colon that separates the key from the value.
    */
   Token _separator;
@@ skipping 63 matching lines @@
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 /**
  * Instances of the class {@code MethodDeclaration} represent a method declaration.
  * <pre>
  * methodDeclaration ::=
  * methodSignature {@link FunctionBody body}methodSignature ::=
  * 'external'? ('abstract' | 'static')? {@link Type returnType}? ('get' | 'set')? methodName{@link FormalParameterList formalParameterList}methodName ::={@link SimpleIdentifier name}| 'operator' {@link SimpleIdentifier operator}</pre>
+ * @coverage dart.engine.ast
  */
 class MethodDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or {@code null} if the constructor is not external.
    */
   Token _externalKeyword;
   /**
    * The token representing the 'abstract' or 'static' keyword, or {@code null} if neither modifier
    * was specified.
    */
@@ skipping 219 matching lines @@
     return _name.beginToken;
   }
 }
 /**
  * Instances of the class {@code MethodInvocation} represent the invocation of either a function or
  * a method. Invocations of functions resulting from evaluating an expression are represented by{@link FunctionExpressionInvocation function expression invocation} nodes. Invocations of getters
  * and setters are represented by either {@link PrefixedIdentifier prefixed identifier} or{@link PropertyAccess property access} nodes.
  * <pre>
  * methodInvoction ::=
  * ({@link Expression target} '.')? {@link SimpleIdentifier methodName} {@link ArgumentList argumentList}</pre>
+ * @coverage dart.engine.ast
  */
 class MethodInvocation extends Expression {
   /**
    * The expression producing the object on which the method is defined, or {@code null} if there is
    * no target (that is, the target is implicitly {@code this}).
    */
   Expression _target;
   /**
    * The period that separates the target from the method name, or {@code null} if there is no
    * target.
@@ skipping 119 matching lines @@
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_methodName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code NamedExpression} represent an expression that has a name associated
  * with it. They are used in method invocations when there are named parameters.
  * <pre>
  * namedExpression ::={@link Label name} {@link Expression expression}</pre>
+ * @coverage dart.engine.ast
  */
 class NamedExpression extends Expression {
   /**
    * The name associated with the expression.
    */
   Label _name;
   /**
    * The expression with which the name is associated.
    */
   Expression _expression;
@@ skipping 13 matching lines @@
    */
   NamedExpression({Label name, Expression expression}) : this.full(name, expression);
   accept(ASTVisitor visitor) => visitor.visitNamedExpression(this);
   Token get beginToken => _name.beginToken;
   /**
    * Return the element representing the parameter being named by this expression, or {@code null}if the AST structure has not been resolved or if there is no parameter with the same name as
    * this expression.
    * @return the element representing the parameter being named by this expression
    */
   ParameterElement get element {
-    Element element19 = _name.label.element;
-    if (element19 is ParameterElement) {
-      return element19 as ParameterElement;
+    Element element20 = _name.label.element;
+    if (element20 is ParameterElement) {
+      return element20 as ParameterElement;
     }
     return null;
   }
   Token get endToken => _expression.endToken;
   /**
    * Return the expression with which the name is associated.
    * @return the expression with which the name is associated
    */
   Expression get expression => _expression;
   /**
@@ skipping 18 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * The abstract class {@code NamespaceDirective} defines the behavior common to nodes that represent
  * a directive that impacts the namespace of a library.
  * <pre>
  * directive ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class NamespaceDirective extends UriBasedDirective {
   /**
    * The token representing the 'import' or 'export' keyword.
    */
   Token _keyword;
   /**
    * The combinators used to control which names are imported or exported.
    */
   NodeList<Combinator> _combinators;
@@ skipping 52 matching lines @@
   void set semicolon(Token semicolon12) {
     this._semicolon = semicolon12;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
  * The abstract class {@code NormalFormalParameter} defines the behavior common to formal parameters
  * that are required (are not optional).
  * <pre>
  * normalFormalParameter ::={@link FunctionTypedFormalParameter functionSignature}| {@link FieldFormalParameter fieldFormalParameter}| {@link SimpleFormalParameter simpleFormalParameter}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class NormalFormalParameter extends FormalParameter {
   /**
    * The documentation comment associated with this parameter, or {@code null} if this parameter
    * does not have a documentation comment associated with it.
    */
   Comment _comment;
   /**
    * The annotations associated with this parameter.
    */
@@ skipping 34 matching lines @@
       return ((parent6 as DefaultFormalParameter)).kind;
     }
     return ParameterKind.REQUIRED;
   }
   /**
    * Return the annotations associated with this parameter.
    * @return the annotations associated with this parameter
    */
   NodeList<Annotation> get metadata => _metadata;
   /**
-   * Return {@code true} if this parameter is a const parameter.
-   * @return {@code true} if this parameter is a const parameter
+   * Return {@code true} if this parameter was declared with the 'const' modifier.
+   * @return {@code true} if this parameter was declared with the 'const' modifier
    */
   bool isConst();
   /**
-   * Return {@code true} if this parameter is a final parameter.
-   * @return {@code true} if this parameter is a final parameter
+   * Return {@code true} if this parameter was declared with the 'final' modifier. Parameters that
+   * are declared with the 'const' modifier will return {@code false} even though they are
+   * implicitly final.
+   * @return {@code true} if this parameter was declared with the 'final' modifier
    */
   bool isFinal();
   /**
    * Set the documentation comment associated with this parameter to the given comment
    * @param comment the documentation comment to be associated with this parameter
    */
   void set documentationComment(Comment comment3) {
     this._comment = becomeParentOf(comment3);
   }
   /**
@@ skipping 38 matching lines @@
     children.sort();
     return children;
   }
 }
 /**
  * Instances of the class {@code NullLiteral} represent a null literal expression.
  * <pre>
  * nullLiteral ::=
  * 'null'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class NullLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token _literal;
   /**
    * Initialize a newly created null literal.
    * @param token the token representing the literal
    */
@@ skipping 22 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ParenthesizedExpression} represent a parenthesized expression.
  * <pre>
  * parenthesizedExpression ::=
  * '(' {@link Expression expression} ')'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ParenthesizedExpression extends Expression {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
   /**
    * The expression within the parentheses.
    */
   Expression _expression;
@@ skipping 60 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code PartDirective} represent a part directive.
  * <pre>
  * partDirective ::={@link Annotation metadata} 'part' {@link StringLiteral partUri} ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class PartDirective extends UriBasedDirective {
   /**
    * The token representing the 'part' token.
    */
   Token _partToken;
   /**
    * The semicolon terminating the directive.
    */
   Token _semicolon;
@@ skipping 45 matching lines @@
   void set semicolon(Token semicolon13) {
     this._semicolon = semicolon13;
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class {@code PartOfDirective} represent a part-of directive.
  * <pre>
  * partOfDirective ::={@link Annotation metadata} 'part' 'of' {@link Identifier libraryName} ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class PartOfDirective extends Directive {
   /**
    * The token representing the 'part' token.
    */
   Token _partToken;
   /**
    * The token representing the 'of' token.
    */
   Token _ofToken;
@@ skipping 84 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class {@code PostfixExpression} represent a postfix unary expression.
  * <pre>
  * postfixExpression ::={@link Expression operand} {@link Token operator}</pre>
+ * @coverage dart.engine.ast
  */
 class PostfixExpression extends Expression {
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
   /**
    * The postfix operator being applied to the operand.
    */
   Token _operator;
@@ skipping 59 matching lines @@
     this._operator = operator4;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 }
 /**
  * Instances of the class {@code PrefixExpression} represent a prefix unary expression.
  * <pre>
  * prefixExpression ::={@link Token operator} {@link Expression operand}</pre>
+ * @coverage dart.engine.ast
  */
 class PrefixExpression extends Expression {
   /**
    * The prefix operator being applied to the operand.
    */
   Token _operator;
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
@@ skipping 61 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 }
 /**
  * Instances of the class {@code PrefixedIdentifier} represent either an identifier that is prefixed
  * or an access to an object property where the target of the property access is a simple
  * identifier.
  * <pre>
  * prefixedIdentifier ::={@link SimpleIdentifier prefix} '.' {@link SimpleIdentifier identifier}</pre>
+ * @coverage dart.engine.ast
  */
 class PrefixedIdentifier extends Identifier {
   /**
    * The prefix associated with the library in which the identifier is defined.
    */
   SimpleIdentifier _prefix;
   /**
    * The period used to separate the prefix from the identifier.
    */
   Token _period;
@@ skipping 71 matching lines @@
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code PropertyAccess} represent the access of a property of an object.
  * <p>
  * Note, however, that accesses to properties of objects can also be represented as{@link PrefixedIdentifier prefixed identifier} nodes in cases where the target is also a simple
  * identifier.
  * <pre>
  * propertyAccess ::={@link Expression target} '.' {@link SimpleIdentifier propertyName}</pre>
+ * @coverage dart.engine.ast
  */
 class PropertyAccess extends Expression {
   /**
    * The expression computing the object defining the property being accessed.
    */
   Expression _target;
   /**
    * The property access operator.
    */
   Token _operator;
@@ skipping 98 matching lines @@
     safelyVisitChild(_propertyName, visitor);
   }
 }
 /**
  * Instances of the class {@code 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>
+ * @coverage dart.engine.ast
  */
 class RedirectingConstructorInvocation extends ConstructorInitializer {
   /**
    * The token for the 'this' keyword.
    */
   Token _keyword;
   /**
    * The token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
    */
   Token _period;
@@ skipping 82 matching lines @@
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
   void set element(ConstructorElement element15) {
     this._element = element15;
   }
   /**
    * Set the token for the 'this' keyword to the given token.
    * @param keyword the token for the 'this' keyword
    */
-  void set keyword(Token keyword13) {
-    this._keyword = keyword13;
+  void set keyword(Token keyword14) {
+    this._keyword = keyword14;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
   void set period(Token period11) {
     this._period = period11;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code ReturnStatement} represent a return statement.
  * <pre>
  * returnStatement ::=
  * 'return' {@link Expression expression}? ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ReturnStatement extends Statement {
   /**
    * The token representing the 'return' keyword.
    */
   Token _keyword;
   /**
    * The expression computing the value to be returned, or {@code null} if no explicit value was
    * provided.
    */
@@ skipping 43 matching lines @@
    * Set the expression computing the value to be returned to the given expression.
    * @param expression the expression computing the value to be returned
    */
   void set expression(Expression expression10) {
     this._expression = becomeParentOf(expression10);
   }
   /**
    * Set the token representing the 'return' keyword to the given token.
    * @param keyword the token representing the 'return' keyword
    */
-  void set keyword(Token keyword14) {
-    this._keyword = keyword14;
+  void set keyword(Token keyword15) {
+    this._keyword = keyword15;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon15) {
     this._semicolon = semicolon15;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ScriptTag} represent the script tag that can optionally occur at
  * the beginning of a compilation unit.
  * <pre>
  * scriptTag ::=
  * '#!' (~NEWLINE)* NEWLINE
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ScriptTag extends ASTNode {
   /**
    * The token representing this script tag.
    */
   Token _scriptTag;
   /**
    * Initialize a newly created script tag.
    * @param scriptTag the token representing this script tag
    */
@@ skipping 23 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ShowCombinator} represent a combinator that restricts the names
  * being imported to those in a given list.
  * <pre>
  * showCombinator ::=
  * 'show' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ShowCombinator extends Combinator {
   /**
    * The list of names from the library that are made visible by this combinator.
    */
   NodeList<SimpleIdentifier> _shownNames;
   /**
    * Initialize a newly created import show combinator.
    * @param keyword the comma introducing the combinator
    * @param shownNames the list of names from the library that are made visible by this combinator
@@ skipping 17 matching lines @@
   NodeList<SimpleIdentifier> get shownNames => _shownNames;
   void visitChildren(ASTVisitor<Object> visitor) {
     _shownNames.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code SimpleFormalParameter} represent a simple formal parameter.
  * <pre>
  * simpleFormalParameter ::=
  * ('final' {@link TypeName type} | 'var' | {@link TypeName type})? {@link SimpleIdentifier identifier}</pre>
+ * @coverage dart.engine.ast
  */
 class SimpleFormalParameter extends NormalFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or {@code null} if no
    * keyword was used.
    */
   Token _keyword;
   /**
    * The name of the declared type of the parameter, or {@code null} if the parameter does not have
    * a declared type.
@@ skipping 40 matching lines @@
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword15) {
-    this._keyword = keyword15;
+  void set keyword(Token keyword16) {
+    this._keyword = keyword16;
   }
   /**
    * Set the name of the declared type of the parameter to the given type name.
    * @param typeName the name of the declared type of the parameter
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code SimpleIdentifier} represent a simple identifier.
  * <pre>
  * simpleIdentifier ::=
  * initialCharacter internalCharacter
  * initialCharacter ::= '_' | '$' | letter
  * internalCharacter ::= '_' | '$' | letter | digit
  * </pre>
+ * @coverage dart.engine.ast
  */
 class SimpleIdentifier extends Identifier {
   /**
    * The token representing the identifier.
    */
   Token _token;
   /**
    * The element associated with this identifier, or {@code null} if the AST structure has not been
    * resolved or if this identifier could not be resolved.
    */
@@ skipping 149 matching lines @@
  * simpleStringLiteral ::=
  * multiLineStringLiteral
  * | singleLineStringLiteral
  * multiLineStringLiteral ::=
  * "'''" characters "'''"
  * | '"""' characters '"""'
  * singleLineStringLiteral ::=
  * "'" characters "'"
  * '"' characters '"'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class SimpleStringLiteral extends StringLiteral {
   /**
    * The token representing the literal.
    */
   Token _literal;
   /**
    * The value of the literal.
    */
   String _value;
@@ skipping 56 matching lines @@
     _value = string;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code Statement} defines the behavior common to nodes that represent a
  * statement.
  * <pre>
  * statement ::={@link Block block}| {@link VariableDeclarationStatement initializedVariableDeclaration ';'}| {@link ForStatement forStatement}| {@link ForEachStatement forEachStatement}| {@link WhileStatement whileStatement}| {@link DoStatement doStatement}| {@link SwitchStatement switchStatement}| {@link IfStatement ifStatement}| {@link TryStatement tryStatement}| {@link BreakStatement breakStatement}| {@link ContinueStatement continueStatement}| {@link ReturnStatement returnStatement}| {@link ExpressionStatement expressionStatement}| {@link FunctionDeclarationStatement functionSignature functionBody}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class Statement extends ASTNode {
 }
 /**
  * Instances of the class {@code StringInterpolation} represent a string interpolation literal.
  * <pre>
  * stringInterpolation ::=
  * ''' {@link InterpolationElement interpolationElement}* '''
  * | '"' {@link InterpolationElement interpolationElement}* '"'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class StringInterpolation extends StringLiteral {
   /**
    * The elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> _elements;
   /**
    * Initialize a newly created string interpolation expression.
    * @param elements the elements that will be composed to produce the resulting string
    */
@@ skipping 15 matching lines @@
   NodeList<InterpolationElement> get elements => _elements;
   Token get endToken => _elements.endToken;
   void visitChildren(ASTVisitor<Object> visitor) {
     _elements.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code StringLiteral} represent a string literal expression.
  * <pre>
  * stringLiteral ::={@link SimpleStringLiteral simpleStringLiteral}| {@link AdjacentStrings adjacentStrings}| {@link StringInterpolation stringInterpolation}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class StringLiteral extends Literal {
 }
 /**
  * Instances of the class {@code SuperConstructorInvocation} represent the invocation of a
  * superclass' constructor from within a constructor's initialization list.
  * <pre>
  * superInvocation ::=
  * 'super' ('.' {@link SimpleIdentifier name})? {@link ArgumentList argumentList}</pre>
+ * @coverage dart.engine.ast
  */
 class SuperConstructorInvocation extends ConstructorInitializer {
   /**
    * The token for the 'super' keyword.
    */
   Token _keyword;
   /**
    * The token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
    */
   Token _period;
@@ skipping 82 matching lines @@
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
   void set element(ConstructorElement element17) {
     this._element = element17;
   }
   /**
    * Set the token for the 'super' keyword to the given token.
    * @param keyword the token for the 'super' keyword
    */
-  void set keyword(Token keyword16) {
-    this._keyword = keyword16;
+  void set keyword(Token keyword17) {
+    this._keyword = keyword17;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
   void set period(Token period12) {
     this._period = period12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code SuperExpression} represent a super expression.
  * <pre>
  * superExpression ::=
  * 'super'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class SuperExpression extends Expression {
   /**
    * The token representing the keyword.
    */
   Token _keyword;
   /**
    * Initialize a newly created super expression.
    * @param keyword the token representing the keyword
    */
@@ skipping 10 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword(Token keyword17) {
-    this._keyword = keyword17;
+  void set keyword(Token keyword18) {
+    this._keyword = keyword18;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code SwitchCase} represent the case in a switch statement.
  * <pre>
  * switchCase ::={@link SimpleIdentifier label}* 'case' {@link Expression expression} ':' {@link Statement statement}</pre>
+ * @coverage dart.engine.ast
  */
 class SwitchCase extends SwitchMember {
   /**
    * The expression controlling whether the statements will be executed.
    */
   Expression _expression;
   /**
    * Initialize a newly created switch case.
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
@@ skipping 29 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code SwitchDefault} represent the default case in a switch statement.
  * <pre>
  * switchDefault ::={@link SimpleIdentifier label}* 'default' ':' {@link Statement statement}</pre>
+ * @coverage dart.engine.ast
  */
 class SwitchDefault extends SwitchMember {
   /**
    * Initialize a newly created switch default.
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
   SwitchDefault.full(List<Label> labels, Token keyword, Token colon, List<Statement> statements) : super.full(labels, keyword, colon, statements) {
@@ skipping 13 matching lines @@
   }
 }
 /**
  * The abstract class {@code SwitchMember} defines the behavior common to objects representing
  * elements within a switch statement.
  * <pre>
  * switchMember ::=
  * switchCase
  * | switchDefault
  * </pre>
+ * @coverage dart.engine.ast
  */
 abstract class SwitchMember extends ASTNode {
   /**
    * The labels associated with the switch member.
    */
   NodeList<Label> _labels;
   /**
    * The token representing the 'case' or 'default' keyword.
    */
   Token _keyword;
@@ skipping 64 matching lines @@
    * Set the colon separating the keyword or the expression from the statements to the given token.
    * @param colon the colon separating the keyword or the expression from the statements
    */
   void set colon(Token colon4) {
     this._colon = colon4;
   }
   /**
    * Set the token representing the 'case' or 'default' keyword to the given token.
    * @param keyword the token representing the 'case' or 'default' keyword
    */
-  void set keyword(Token keyword18) {
-    this._keyword = keyword18;
+  void set keyword(Token keyword19) {
+    this._keyword = keyword19;
   }
 }
 /**
  * Instances of the class {@code SwitchStatement} represent a switch statement.
  * <pre>
  * switchStatement ::=
  * 'switch' '(' {@link Expression expression} ')' '{' {@link SwitchCase switchCase}* {@link SwitchDefault defaultCase}? '}'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class SwitchStatement extends Statement {
   /**
    * The token representing the 'switch' keyword.
    */
   Token _keyword;
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
@@ skipping 91 matching lines @@
    * expression.
    * @param expression the expression used to determine which of the switch members will be selected
    */
   void set expression(Expression expression12) {
     this._expression = becomeParentOf(expression12);
   }
   /**
    * Set the token representing the 'switch' keyword to the given token.
    * @param keyword the token representing the 'switch' keyword
    */
-  void set keyword(Token keyword19) {
-    this._keyword = keyword19;
+  void set keyword(Token keyword20) {
+    this._keyword = keyword20;
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
   void set leftBracket(Token leftBracket7) {
     this._leftBracket = leftBracket7;
   }
   /**
    * Set the left parenthesis to the given token.
@@ skipping 20 matching lines @@
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ThisExpression} represent a this expression.
  * <pre>
  * thisExpression ::=
  * 'this'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ThisExpression extends Expression {
   /**
    * The token representing the keyword.
    */
   Token _keyword;
   /**
    * Initialize a newly created this expression.
    * @param keyword the token representing the keyword
    */
@@ skipping 10 matching lines @@
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword(Token keyword20) {
-    this._keyword = keyword20;
+  void set keyword(Token keyword21) {
+    this._keyword = keyword21;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ThrowExpression} represent a throw expression.
  * <pre>
  * throwExpression ::=
  * 'throw' {@link Expression expression}? ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class ThrowExpression extends Expression {
   /**
    * The token representing the 'throw' keyword.
    */
   Token _keyword;
   /**
    * The expression computing the exception to be thrown, or {@code null} if the current exception
    * is to be re-thrown. (The latter case can only occur if the throw statement is inside a catch
    * clause.)
@@ skipping 38 matching lines @@
    * Set the expression computing the exception to be thrown to the given expression.
    * @param expression the expression computing the exception to be thrown
    */
   void set expression(Expression expression13) {
     this._expression = becomeParentOf(expression13);
   }
   /**
    * Set the token representing the 'throw' keyword to the given token.
    * @param keyword the token representing the 'throw' keyword
    */
-  void set keyword(Token keyword21) {
-    this._keyword = keyword21;
+  void set keyword(Token keyword22) {
+    this._keyword = keyword22;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code TopLevelVariableDeclaration} represent the declaration of one or
  * more top-level variables of the same type.
  * <pre>
  * topLevelVariableDeclaration ::=
  * ('final' | 'const') type? staticFinalDeclarationList ';'
  * | variableDeclaration ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class TopLevelVariableDeclaration extends CompilationUnitMember {
   /**
    * The top-level variables being declared.
    */
   VariableDeclarationList _variableList;
   /**
    * The semicolon terminating the declaration.
    */
   Token _semicolon;
@@ skipping 49 matching lines @@
   }
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 }
 /**
  * Instances of the class {@code TryStatement} represent a try statement.
  * <pre>
  * tryStatement ::=
  * 'try' {@link Block block} ({@link CatchClause catchClause}+ finallyClause? | finallyClause)
  * finallyClause ::=
  * 'finally' {@link Block block}</pre>
+ * @coverage dart.engine.ast
  */
 class TryStatement extends Statement {
   /**
    * The token representing the 'try' keyword.
    */
   Token _tryKeyword;
   /**
    * The body of the statement.
    */
   Block _body;
@@ skipping 111 matching lines @@
 }
 /**
  * The abstract class {@code TypeAlias} defines the behavior common to declarations of type aliases.
  * <pre>
  * typeAlias ::=
  * 'typedef' typeAliasBody
  * typeAliasBody ::=
  * classTypeAlias
  * | functionTypeAlias
  * </pre>
+ * @coverage dart.engine.ast
  */
 abstract class TypeAlias extends CompilationUnitMember {
   /**
    * The token representing the 'typedef' keyword.
    */
   Token _keyword;
   /**
    * The semicolon terminating the declaration.
    */
   Token _semicolon;
@@ skipping 24 matching lines @@
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'typedef' keyword to the given token.
    * @param keyword the token representing the 'typedef' keyword
    */
-  void set keyword(Token keyword22) {
-    this._keyword = keyword22;
+  void set keyword(Token keyword23) {
+    this._keyword = keyword23;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
   void set semicolon(Token semicolon17) {
     this._semicolon = semicolon17;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
  * Instances of the class {@code TypeArgumentList} represent a list of type arguments.
  * <pre>
  * typeArguments ::=
  * '<' typeName (',' typeName)* '>'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class TypeArgumentList extends ASTNode {
   /**
    * The left bracket.
    */
   Token _leftBracket;
   /**
    * The type arguments associated with the type.
    */
   NodeList<TypeName> _arguments;
@@ skipping 55 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code TypeName} represent the name of a type, which can optionally
  * include type arguments.
  * <pre>
  * typeName ::={@link Identifier identifier} typeArguments?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class TypeName extends ASTNode {
   /**
    * The name of the type.
    */
   Identifier _name;
   /**
    * The type arguments associated with the type, or {@code null} if there are no type arguments.
    */
   TypeArgumentList _typeArguments;
@@ skipping 67 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
  * Instances of the class {@code TypeParameter} represent a type parameter.
  * <pre>
  * typeParameter ::={@link SimpleIdentifier name} ('extends' {@link TypeName bound})?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class TypeParameter extends Declaration {
   /**
    * The name of the type parameter.
    */
   SimpleIdentifier _name;
   /**
    * The token representing the 'extends' keyword, or {@code null} if there was no explicit upper
    * bound.
    */
@@ skipping 53 matching lines @@
    * Set the name of the upper bound for legal arguments to the given type name.
    * @param typeName the name of the upper bound for legal arguments
    */
   void set bound(TypeName typeName) {
     _bound = becomeParentOf(typeName);
   }
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
-  void set keyword(Token keyword23) {
-    this._keyword = keyword23;
+  void set keyword(Token keyword24) {
+    this._keyword = keyword24;
   }
   /**
    * Set the name of the type parameter to the given identifier.
    * @param identifier the name of the type parameter
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_bound, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
  * Instances of the class {@code TypeParameterList} represent type parameters within a declaration.
  * <pre>
  * typeParameterList ::=
  * '<' {@link TypeParameter typeParameter} (',' {@link TypeParameter typeParameter})* '>'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class TypeParameterList extends ASTNode {
   /**
    * The left angle bracket.
    */
   Token _leftBracket;
   /**
    * The type parameters in the list.
    */
   NodeList<TypeParameter> _typeParameters;
@@ skipping 40 matching lines @@
   NodeList<TypeParameter> get typeParameters => _typeParameters;
   void visitChildren(ASTVisitor<Object> visitor) {
     _typeParameters.accept(visitor);
   }
 }
 /**
  * The abstract class {@code TypedLiteral} defines the behavior common to literals that have a type
  * associated with them.
  * <pre>
  * listLiteral ::={@link ListLiteral listLiteral}| {@link MapLiteral mapLiteral}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class TypedLiteral extends Literal {
   /**
    * The const modifier associated with this literal, or {@code null} if the literal is not a
    * constant.
    */
   Token _modifier;
   /**
    * The type argument associated with this literal, or {@code null} if no type arguments were
    * declared.
@@ skipping 43 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
  * The abstract class {@code UriBasedDirective} defines the behavior common to nodes that represent
  * a directive that references a URI.
  * <pre>
  * uriBasedDirective ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link PartDirective partDirective}</pre>
+ * @coverage dart.engine.ast
  */
 abstract class UriBasedDirective extends Directive {
   /**
    * The URI referenced by this directive.
    */
   StringLiteral _uri;
   /**
    * Initialize a newly create URI-based directive.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
@@ skipping 25 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 /**
  * Instances of the class {@code VariableDeclaration} represent an identifier that has an initial
  * value associated with it. Instances of this class are always children of the class{@link VariableDeclarationList}.
  * <pre>
  * variableDeclaration ::={@link SimpleIdentifier identifier} ('=' {@link Expression initialValue})?
  * </pre>
+ * @coverage dart.engine.ast
  */
 class VariableDeclaration extends Declaration {
   /**
    * The name of the variable being declared.
    */
   SimpleIdentifier _name;
   /**
    * The equal sign separating the variable name from the initial value, or {@code null} if the
    * initial value was not specified.
    */
@@ skipping 44 matching lines @@
    * the initial value was not specified.
    * @return the expression used to compute the initial value for the variable
    */
   Expression get initializer => _initializer;
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get name => _name;
   /**
-   * Return {@code true} if this variable declaration is declared to be a const variable.
-   * @return {@code true} if this variable is declared to be a const variable
+   * Return {@code true} if this variable was declared with the 'const' modifier.
+   * @return {@code true} if this variable was declared with the 'const' modifier
    */
   bool isConst() {
     ASTNode parent10 = parent;
     return parent10 is VariableDeclarationList && ((parent10 as VariableDeclarationList)).isConst();
   }
   /**
-   * Return {@code true} if this variable declaration is declared to be a final variable.
-   * @return {@code true} if this variable is declared to be a final variable
+   * Return {@code true} if this variable was declared with the 'final' modifier. Variables that are
+   * declared with the 'const' modifier will return {@code false} even though they are implicitly
+   * final.
+   * @return {@code true} if this variable was declared with the 'final' modifier
    */
   bool isFinal() {
     ASTNode parent11 = parent;
     return parent11 is VariableDeclarationList && ((parent11 as VariableDeclarationList)).isFinal();
   }
   /**
    * Set the equal sign separating the variable name from the initial value to the given token.
    * @param equals the equal sign separating the variable name from the initial value
    */
   void set equals(Token equals6) {
@@ skipping 24 matching lines @@
  * Instances of the class {@code VariableDeclarationList} represent the declaration of one or more
  * variables of the same type.
  * <pre>
  * variableDeclarationList ::=
  * finalConstVarOrType {@link VariableDeclaration variableDeclaration} (',' {@link VariableDeclaration variableDeclaration})
  * finalConstVarOrType ::=
  * | 'final' {@link TypeName type}?
  * | 'const' {@link TypeName type}?
  * | 'var'
  * | {@link TypeName type}</pre>
+ * @coverage dart.engine.ast
  */
 class VariableDeclarationList extends ASTNode {
   /**
    * The token representing the 'final', 'const' or 'var' keyword, or {@code null} if no keyword was
    * included.
    */
   Token _keyword;
   /**
    * The type of the variables being declared, or {@code null} if no type was provided.
    */
@@ skipping 41 matching lines @@
    * Return the type of the variables being declared, or {@code null} if no type was provided.
    * @return the type of the variables being declared
    */
   TypeName get type => _type;
   /**
    * Return a list containing the individual variables being declared.
    * @return a list containing the individual variables being declared
    */
   NodeList<VariableDeclaration> get variables => _variables;
   /**
-   * Return {@code true} if the variable declarations in this list are declared to be const
-   * variables.
-   * @return {@code true} if the variables in this list are declared to be const variables
+   * Return {@code true} if the variables in this list were declared with the 'const' modifier.
+   * @return {@code true} if the variables in this list were declared with the 'const' modifier
    */
   bool isConst() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   /**
-   * Return {@code true} if the variable declarations in this list are declared to be final
-   * variables.
-   * @return {@code true} if the variables in this list are declared to be final variables
+   * Return {@code true} if the variables in this list were declared with the 'final' modifier.
+   * Variables that are declared with the 'const' modifier will return {@code false} even though
+   * they are implicitly final.
+   * @return {@code true} if the variables in this list were declared with the 'final' modifier
    */
   bool isFinal() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    */
-  void set keyword(Token keyword24) {
-    this._keyword = keyword24;
+  void set keyword(Token keyword25) {
+    this._keyword = keyword25;
   }
   /**
    * Set the type of the variables being declared to the given type name.
    * @param typeName the type of the variables being declared
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code VariableDeclarationStatement} represent a list of variables that
  * are being declared in a context where a statement is required.
  * <pre>
  * variableDeclarationStatement ::={@link VariableDeclarationList variableList} ';'
  * </pre>
+ * @coverage dart.engine.ast
  */
 class VariableDeclarationStatement extends Statement {
   /**
    * The variables being declared.
    */
   VariableDeclarationList _variableList;
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
@@ skipping 41 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 /**
  * Instances of the class {@code WhileStatement} represent a while statement.
  * <pre>
  * whileStatement ::=
  * 'while' '(' {@link Expression condition} ')' {@link Statement body}</pre>
+ * @coverage dart.engine.ast
  */
 class WhileStatement extends Statement {
   /**
    * The token representing the 'while' keyword.
    */
   Token _keyword;
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
@@ skipping 73 matching lines @@
    * expression.
    * @param expression the expression used to determine whether to execute the body of the loop
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'while' keyword to the given token.
    * @param keyword the token representing the 'while' keyword
    */
-  void set keyword(Token keyword25) {
-    this._keyword = keyword25;
+  void set keyword(Token keyword26) {
+    this._keyword = keyword26;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
   void set leftParenthesis(Token leftParenthesis7) {
     this._leftParenthesis = leftParenthesis7;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
   void set rightParenthesis(Token rightParenthesis7) {
     this._rightParenthesis = rightParenthesis7;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code WithClause} represent the with clause in a class declaration.
  * <pre>
  * withClause ::=
  * 'with' {@link TypeName mixin} (',' {@link TypeName mixin})
  * </pre>
+ * @coverage dart.engine.ast
  */
 class WithClause extends ASTNode {
   /**
    * The token representing the 'with' keyword.
    */
   Token _withKeyword;
   /**
    * The names of the mixins that were specified.
    */
   NodeList<TypeName> _mixinTypes;
@@ skipping 60 matching lines @@
  * to {@code null}.</li>
  * <li>An expression of one of the forms {@code ~e}, {@code e1 ^ e2}, {@code e1 & e2},{@code e1 | e2}, {@code e1 >> e2} or {@code e1 << e2}, where {@code e}, {@code e1} and {@code e2}are constant expressions that evaluate to an integer value or to {@code null}.</li>
  * <li>An expression of one of the forms {@code -e}, {@code e1 + e2}, {@code e1 - e2},{@code e1 * e2}, {@code e1 / e2}, {@code e1 ~/ e2}, {@code e1 > e2}, {@code e1 < e2},{@code e1 >= e2}, {@code e1 <= e2} or {@code e1 % e2}, where {@code e}, {@code e1} and {@code e2}are constant expressions that evaluate to a numeric value or to {@code null}.</li>
  * </ul>
  * </blockquote> The values returned by instances of this class are therefore {@code null} and
  * instances of the classes {@code Boolean}, {@code BigInteger}, {@code Double}, {@code String}, and{@code DartObject}.
  * <p>
  * In addition, this class defines several values that can be returned to indicate various
  * conditions encountered during evaluation. These are documented with the static field that define
  * those values.
+ * @coverage dart.engine.ast
  */
 class ConstantEvaluator extends GeneralizingASTVisitor<Object> {
   /**
    * The value returned for expressions (or non-expression nodes) that are not compile-time constant
    * expressions.
    */
   static Object NOT_A_CONSTANT = new Object();
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  ErrorReporter _errorReporter;
+  /**
+   * Initialize a newly created constant evaluator.
+   * @param errorReporter the error reporter by which errors will be reported
+   */
+  ConstantEvaluator(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
   Object visitAdjacentStrings(AdjacentStrings node) {
     JavaStringBuilder builder = new JavaStringBuilder();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.append(value);
     }
     return builder.toString();
@@ skipping 99 matching lines @@
           return ((leftOperand2 as double)) + ((rightOperand2 as double));
         }
       } else if (node.operator.type == TokenType.STAR) {
         if (leftOperand2 is int && rightOperand2 is int) {
           return ((leftOperand2 as int)) * (rightOperand2 as int);
         } else if (leftOperand2 is double && rightOperand2 is double) {
           return ((leftOperand2 as double)) * ((rightOperand2 as double));
         }
       } else if (node.operator.type == TokenType.SLASH) {
         if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+          if (rightOperand2 != 0) {
+            return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+          } else {
+            reportDivideByZeroError(node);
+            return 0;
+          }
         } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) / ((rightOperand2 as double));
+          if (rightOperand2 != 0) {
+            return ((leftOperand2 as double)) / ((rightOperand2 as double));
+          } else {
+            reportDivideByZeroError(node);
+            return 0;
+          }
         }
       } else if (node.operator.type == TokenType.TILDE_SLASH) {
         if (leftOperand2 is int && rightOperand2 is int) {
-          return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+          if (rightOperand2 != 0) {
+            return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+          } else {
+            reportDivideByZeroError(node);
+            return 0;
+          }
         } else if (leftOperand2 is double && rightOperand2 is double) {
-          return ((leftOperand2 as double)) ~/ ((rightOperand2 as double));
+          if (rightOperand2 != 0) {
+            return ((leftOperand2 as double)) ~/ ((rightOperand2 as double));
+          } else {
+            reportDivideByZeroError(node);
+            return 0;
+          }
         }
       }
       break;
     }
     return visitExpression(node);
   }
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
   Object visitDoubleLiteral(DoubleLiteral node) => node.value;
   Object visitIntegerLiteral(IntegerLiteral node) => node.value;
   Object visitInterpolationExpression(InterpolationExpression node) {
@@ skipping 81 matching lines @@
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
       FieldElement field = element as FieldElement;
       if (field.isStatic() && field.isConst()) {
       }
     }
     return NOT_A_CONSTANT;
   }
+  void reportDivideByZeroError(BinaryExpression node) {
+    _errorReporter.reportError(CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION_DIVIDE_BY_ZERO, node, []);
+  }
 }
 /**
  * Instances of the class {@code ElementLocator} locate the {@link Element Dart model element}associated with a given {@link ASTNode AST node}.
+ * @coverage dart.engine.ast
  */
 class ElementLocator {
   /**
    * Locate the {@link Element Dart model element} associated with the given {@link ASTNode AST
    * node}.
    * @param node the node (not {@code null})
    * @return the associated element, or {@code null} if none is found
    */
   static Element locate(ASTNode node) {
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
@@ skipping 32 matching lines @@
  * superclasses of that node will also be invoked. For example, using an instance of this class to
  * visit a {@link Block} will cause the method {@link #visitBlock(Block)} to be invoked but will
  * also cause the methods {@link #visitStatement(Statement)} and {@link #visitNode(ASTNode)} to be
  * subsequently invoked. This allows visitors to be written that visit all statements without
  * needing to override the visit method for each of the specific subclasses of {@link Statement}.
  * <p>
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
  * for superclasses of the node to not be invoked and will cause the children of the visited node to
  * not be visited.
+ * @coverage dart.engine.ast
  */
 class GeneralizingASTVisitor<R> implements ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) => visitStringLiteral(node);
   R visitAnnotatedNode(AnnotatedNode node) => visitNode(node);
   R visitAnnotation(Annotation node) => visitNode(node);
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => visitExpression(node);
   R visitArgumentList(ArgumentList node) => visitNode(node);
   R visitAsExpression(AsExpression node) => visitExpression(node);
   R visitAssertStatement(AssertStatement node) => visitStatement(node);
   R visitAssignmentExpression(AssignmentExpression node) => visitExpression(node);
@@ skipping 12 matching lines @@
   R visitCommentReference(CommentReference node) => visitNode(node);
   R visitCompilationUnit(CompilationUnit node) => visitNode(node);
   R visitCompilationUnitMember(CompilationUnitMember node) => visitDeclaration(node);
   R visitConditionalExpression(ConditionalExpression node) => visitExpression(node);
   R visitConstructorDeclaration(ConstructorDeclaration node) => visitClassMember(node);
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => visitConstructorInitializer(node);
   R visitConstructorInitializer(ConstructorInitializer node) => visitNode(node);
   R visitConstructorName(ConstructorName node) => visitNode(node);
   R visitContinueStatement(ContinueStatement node) => visitStatement(node);
   R visitDeclaration(Declaration node) => visitAnnotatedNode(node);
+  R visitDeclaredIdentifier(DeclaredIdentifier node) => visitDeclaration(node);
   R visitDefaultFormalParameter(DefaultFormalParameter node) => visitFormalParameter(node);
   R visitDirective(Directive node) => visitAnnotatedNode(node);
   R visitDoStatement(DoStatement node) => visitStatement(node);
   R visitDoubleLiteral(DoubleLiteral node) => visitLiteral(node);
   R visitEmptyFunctionBody(EmptyFunctionBody node) => visitFunctionBody(node);
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
   R visitExportDirective(ExportDirective node) => visitNamespaceDirective(node);
   R visitExpression(Expression node) => visitNode(node);
   R visitExpressionFunctionBody(ExpressionFunctionBody node) => visitFunctionBody(node);
   R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
@@ skipping 79 matching lines @@
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitStatement(node);
   R visitWhileStatement(WhileStatement node) => visitStatement(node);
   R visitWithClause(WithClause node) => visitNode(node);
 }
 /**
  * Instances of the class {@code NodeLocator} locate the {@link ASTNode AST node} associated with a
  * source range, given the AST structure built from the source. More specifically, they will return
  * the {@link ASTNode AST node} with the shortest length whose source range completely encompasses
  * the specified range.
+ * @coverage dart.engine.ast
  */
 class NodeLocator extends GeneralizingASTVisitor<Object> {
   /**
    * The start offset of the range used to identify the node.
    */
   int _startOffset = 0;
   /**
    * The end offset of the range used to identify the node.
    */
   int _endOffset = 0;
   /**
    * The element that was found that corresponds to the given source range, or {@code null} if there
    * is no such element.
    */
   ASTNode _foundNode;
   /**
    * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
    * the node within an AST structure that corresponds to the given offset in the source.
    * @param offset the offset used to identify the node
    */
   NodeLocator.con1(int offset) {
-    _jtd_constructor_116_impl(offset);
+    _jtd_constructor_118_impl(offset);
   }
-  _jtd_constructor_116_impl(int offset) {
-    _jtd_constructor_117_impl(offset, offset);
+  _jtd_constructor_118_impl(int offset) {
+    _jtd_constructor_119_impl(offset, offset);
   }
   /**
    * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
    * the node within an AST structure that corresponds to the given range of characters in the
    * source.
    * @param start the start offset of the range used to identify the node
    * @param end the end offset of the range used to identify the node
    */
   NodeLocator.con2(int start, int end) {
-    _jtd_constructor_117_impl(start, end);
+    _jtd_constructor_119_impl(start, end);
   }
-  _jtd_constructor_117_impl(int start, int end) {
+  _jtd_constructor_119_impl(int start, int end) {
     this._startOffset = start;
     this._endOffset = end;
   }
   /**
    * Return the node that was found that corresponds to the given source range, or {@code null} if
    * there is no such node.
    * @return the node that was found
    */
   ASTNode get foundNode => _foundNode;
   /**
@@ skipping 38 matching lines @@
   static int _serialVersionUID = 1;
 }
 /**
  * Instances of the class {@code RecursiveASTVisitor} implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure. For example, using an instance of this class to visit
  * a {@link Block} will also cause all of the statements in the block to be visited.
  * <p>
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited node to visit its children. Failure to do so will cause the children
  * of the visited node to not be visited.
+ * @coverage dart.engine.ast
  */
 class RecursiveASTVisitor<R> implements ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) {
     node.visitChildren(this);
     return null;
   }
   R visitAnnotation(Annotation node) {
     node.visitChildren(this);
     return null;
   }
@@ skipping 78 matching lines @@
     return null;
   }
   R visitConstructorName(ConstructorName node) {
     node.visitChildren(this);
     return null;
   }
   R visitContinueStatement(ContinueStatement node) {
     node.visitChildren(this);
     return null;
   }
+  R visitDeclaredIdentifier(DeclaredIdentifier node) {
+    node.visitChildren(this);
+    return null;
+  }
   R visitDefaultFormalParameter(DefaultFormalParameter node) {
     node.visitChildren(this);
     return null;
   }
   R visitDoStatement(DoStatement node) {
     node.visitChildren(this);
     return null;
   }
   R visitDoubleLiteral(DoubleLiteral node) {
     node.visitChildren(this);
@@ skipping 282 matching lines @@
   R visitWithClause(WithClause node) {
     node.visitChildren(this);
     return null;
   }
 }
 /**
  * Instances of the class {@code SimpleASTVisitor} implement an AST visitor that will do nothing
  * when visiting an AST node. It is intended to be a superclass for classes that use the visitor
  * pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a whole
  * structure) and that only need to visit a small number of node types.
+ * @coverage dart.engine.ast
  */
 class SimpleASTVisitor<R> implements ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) => null;
   R visitAnnotation(Annotation node) => null;
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => null;
   R visitArgumentList(ArgumentList node) => null;
   R visitAsExpression(AsExpression node) => null;
   R visitAssertStatement(AssertStatement node) => null;
   R visitAssignmentExpression(AssignmentExpression node) => null;
   R visitBinaryExpression(BinaryExpression node) => null;
   R visitBlock(Block node) => null;
   R visitBlockFunctionBody(BlockFunctionBody node) => null;
   R visitBooleanLiteral(BooleanLiteral node) => null;
   R visitBreakStatement(BreakStatement node) => null;
   R visitCascadeExpression(CascadeExpression node) => null;
   R visitCatchClause(CatchClause node) => null;
   R visitClassDeclaration(ClassDeclaration node) => null;
   R visitClassTypeAlias(ClassTypeAlias node) => null;
   R visitComment(Comment node) => null;
   R visitCommentReference(CommentReference node) => null;
   R visitCompilationUnit(CompilationUnit node) => null;
   R visitConditionalExpression(ConditionalExpression node) => null;
   R visitConstructorDeclaration(ConstructorDeclaration node) => null;
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => null;
   R visitConstructorName(ConstructorName node) => null;
   R visitContinueStatement(ContinueStatement node) => null;
+  R visitDeclaredIdentifier(DeclaredIdentifier node) => null;
   R visitDefaultFormalParameter(DefaultFormalParameter node) => null;
   R visitDoStatement(DoStatement node) => null;
   R visitDoubleLiteral(DoubleLiteral node) => null;
   R visitEmptyFunctionBody(EmptyFunctionBody node) => null;
   R visitEmptyStatement(EmptyStatement node) => null;
   R visitExportDirective(ExportDirective node) => null;
   R visitExpressionFunctionBody(ExpressionFunctionBody node) => null;
   R visitExpressionStatement(ExpressionStatement node) => null;
   R visitExtendsClause(ExtendsClause node) => null;
   R visitFieldDeclaration(FieldDeclaration node) => null;
@@ skipping 58 matching lines @@
   R visitTypeParameterList(TypeParameterList node) => null;
   R visitVariableDeclaration(VariableDeclaration node) => null;
   R visitVariableDeclarationList(VariableDeclarationList node) => null;
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => null;
   R visitWhileStatement(WhileStatement node) => null;
   R visitWithClause(WithClause node) => null;
 }
 /**
  * Instances of the class {@code ToSourceVisitor} write a source representation of a visited AST
  * node (and all of it's children) to a writer.
+ * @coverage dart.engine.ast
  */
 class ToSourceVisitor implements ASTVisitor<Object> {
   /**
    * The writer to which the source is to be written.
    */
   PrintWriter _writer;
   /**
    * Initialize a newly created visitor to write source code representing the visited nodes to the
    * given writer.
    * @param writer the writer to which the source is to be written
@@ skipping 162 matching lines @@
     visit(node.type);
     visit3(".", node.name);
     return null;
   }
   Object visitContinueStatement(ContinueStatement node) {
     _writer.print("continue");
     visit3(" ", node.label);
     _writer.print(";");
     return null;
   }
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    visit5(node.keyword, " ");
+    visit2(node.type, " ");
+    visit(node.identifier);
+    return null;
+  }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     visit(node.parameter);
     if (node.separator != null) {
       _writer.print(" ");
       _writer.print(node.separator.lexeme);
       visit3(" ", node.defaultValue);
     }
     return null;
   }
   Object visitDoStatement(DoStatement node) {
@@ skipping 49 matching lines @@
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     visit5(node.keyword, " ");
     visit2(node.type, " ");
     _writer.print("this.");
     visit(node.identifier);
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
     _writer.print("for (");
-    visit(node.loopParameter);
+    visit(node.loopVariable);
     _writer.print(" in ");
     visit(node.iterator);
     _writer.print(") ");
     visit(node.body);
     return null;
   }
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
     _writer.print('(');
     NodeList<FormalParameter> parameters9 = node.parameters;
@@ skipping 594 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }