Update and analyzer snapshot with AST -> Ast rename.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_dart.dart';
 import 'utilities_collection.dart' show TokenMap;
 import 'element.dart';
 
 /**
- * The abstract class `ASTNode` defines the behavior common to all nodes in the AST structure
+ * Instances of the class `AdjacentStrings` represents two or more string literals that are
+ * implicitly concatenated because of being adjacent (separated only by whitespace).
+ *
+ * While the grammar only allows adjacent strings when all of the strings are of the same kind
+ * (single line or multi-line), this class doesn't enforce that restriction.
+ *
+ * <pre>
+ * adjacentStrings ::=
+ *     [StringLiteral] [StringLiteral]+
+ * </pre>
+ */
+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
+   */
+  AdjacentStrings(List<StringLiteral> strings) {
+    this._strings = new NodeList<StringLiteral>(this);
+    this._strings.addAll(strings);
+  }
+
+  accept(AstVisitor visitor) => visitor.visitAdjacentStrings(this);
+
+  Token get beginToken => _strings.beginToken;
+
+  Token get endToken => _strings.endToken;
+
+  /**
+   * Return the strings that are implicitly concatenated.
+   *
+   * @return the strings that are implicitly concatenated
+   */
+  NodeList<StringLiteral> get strings => _strings;
+
+  void visitChildren(AstVisitor visitor) {
+    _strings.accept(visitor);
+  }
+
+  void appendStringValue(JavaStringBuilder builder) {
+    for (StringLiteral stringLiteral in strings) {
+      stringLiteral.appendStringValue(builder);
+    }
+  }
+}
+
+/**
+ * The abstract class `AnnotatedNode` defines the behavior of nodes that can be annotated with
+ * both a comment and metadata.
+ */
+abstract class AnnotatedNode extends AstNode {
+  /**
+   * The documentation comment associated with this node, or `null` if this node does not have
+   * a documentation comment associated with it.
+   */
+  Comment _comment;
+
+  /**
+   * The annotations associated with this node.
+   */
+  NodeList<Annotation> _metadata;
+
+  /**
+   * Initialize a newly created node.
+   *
+   * @param comment the documentation comment associated with this node
+   * @param metadata the annotations associated with this node
+   */
+  AnnotatedNode(Comment comment, List<Annotation> metadata) {
+    this._metadata = new NodeList<Annotation>(this);
+    this._comment = becomeParentOf(comment);
+    this._metadata.addAll(metadata);
+  }
+
+  Token get beginToken {
+    if (_comment == null) {
+      if (_metadata.isEmpty) {
+        return firstTokenAfterCommentAndMetadata;
+      } else {
+        return _metadata.beginToken;
+      }
+    } else if (_metadata.isEmpty) {
+      return _comment.beginToken;
+    }
+    Token commentToken = _comment.beginToken;
+    Token metadataToken = _metadata.beginToken;
+    if (commentToken.offset < metadataToken.offset) {
+      return commentToken;
+    }
+    return metadataToken;
+  }
+
+  /**
+   * Return the documentation comment associated with this node, or `null` if this node does
+   * not have a documentation comment associated with it.
+   *
+   * @return the documentation comment associated with this node
+   */
+  Comment get documentationComment => _comment;
+
+  /**
+   * Return the annotations associated with this node.
+   *
+   * @return the annotations associated with this node
+   */
+  NodeList<Annotation> get metadata => _metadata;
+
+  /**
+   * Set the documentation comment associated with this node to the given comment.
+   *
+   * @param comment the documentation comment to be associated with this node
+   */
+  void set documentationComment(Comment comment) {
+    this._comment = becomeParentOf(comment);
+  }
+
+  /**
+   * Set the metadata associated with this node to the given metadata.
+   *
+   * @param metadata the metadata to be associated with this node
+   */
+  void set metadata(List<Annotation> metadata) {
+    this._metadata.clear();
+    this._metadata.addAll(metadata);
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    if (commentIsBeforeAnnotations()) {
+      safelyVisitChild(_comment, visitor);
+      _metadata.accept(visitor);
+    } else {
+      for (AstNode child in sortedCommentAndAnnotations) {
+        child.accept(visitor);
+      }
+    }
+  }
+
+  /**
+   * Return the first token following the comment and metadata.
+   *
+   * @return the first token following the comment and metadata
+   */
+  Token get firstTokenAfterCommentAndMetadata;
+
+  /**
+   * Return `true` if the comment is lexically before any annotations.
+   *
+   * @return `true` if the comment is lexically before any annotations
+   */
+  bool commentIsBeforeAnnotations() {
+    if (_comment == null || _metadata.isEmpty) {
+      return true;
+    }
+    Annotation firstAnnotation = _metadata[0];
+    return _comment.offset < firstAnnotation.offset;
+  }
+
+  /**
+   * Return an array containing the comment and annotations associated with this node, sorted in
+   * lexical order.
+   *
+   * @return the comment and annotations associated with this node in the order in which they
+   *         appeared in the original source
+   */
+  List<AstNode> get sortedCommentAndAnnotations {
+    List<AstNode> childList = new List<AstNode>();
+    childList.add(_comment);
+    childList.addAll(_metadata);
+    List<AstNode> children = new List.from(childList);
+    children.sort(AstNode.LEXICAL_ORDER);
+    return children;
+  }
+}
+
+/**
+ * Instances of the class `Annotation` represent an annotation that can be associated with an
+ * AST node.
+ *
+ * <pre>
+ * metadata ::=
+ *     annotation*
+ *
+ * annotation ::=
+ *     '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
+ * </pre>
+ */
+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.
+   */
+  Identifier _name;
+
+  /**
+   * The period before the constructor name, or `null` if this annotation is not the
+   * invocation of a named constructor.
+   */
+  Token period;
+
+  /**
+   * The name of the constructor being invoked, or `null` if this annotation is not the
+   * invocation of a named constructor.
+   */
+  SimpleIdentifier _constructorName;
+
+  /**
+   * The arguments to the constructor being invoked, or `null` if this annotation is not the
+   * invocation of a constructor.
+   */
+  ArgumentList _arguments;
+
+  /**
+   * The element associated with this annotation, or `null` if the AST structure has not been
+   * resolved or if this annotation could not be resolved.
+   */
+  Element _element;
+
+  /**
+   * Initialize a newly created annotation.
+   *
+   * @param atSign the at sign that introduced the annotation
+   * @param name the name of the class defining the constructor that is being invoked or the name of
+   *          the field that is being referenced
+   * @param period the period before the constructor name, or `null` if this annotation is not
+   *          the invocation of a named constructor
+   * @param constructorName the name of the constructor being invoked, or `null` if this
+   *          annotation is not the invocation of a named constructor
+   * @param arguments the arguments to the constructor being invoked, or `null` if this
+   *          annotation is not the invocation of a constructor
+   */
+  Annotation(this.atSign, Identifier name, this.period, SimpleIdentifier constructorName, ArgumentList arguments) {
+    this._name = becomeParentOf(name);
+    this._constructorName = becomeParentOf(constructorName);
+    this._arguments = becomeParentOf(arguments);
+  }
+
+  accept(AstVisitor visitor) => visitor.visitAnnotation(this);
+
+  /**
+   * Return the arguments to the constructor being invoked, or `null` if this annotation is
+   * not the invocation of a constructor.
+   *
+   * @return the arguments to the constructor being invoked
+   */
+  ArgumentList get arguments => _arguments;
+
+  Token get beginToken => atSign;
+
+  /**
+   * Return the name of the constructor being invoked, or `null` if this annotation is not the
+   * invocation of a named constructor.
+   *
+   * @return the name of the constructor being invoked
+   */
+  SimpleIdentifier get constructorName => _constructorName;
+
+  /**
+   * Return the element associated with this annotation, or `null` if the AST structure has
+   * not been resolved or if this annotation could not be resolved.
+   *
+   * @return the element associated with this annotation
+   */
+  Element get element {
+    if (_element != null) {
+      return _element;
+    }
+    if (_name != null) {
+      return _name.staticElement;
+    }
+    return null;
+  }
+
+  Token get endToken {
+    if (_arguments != null) {
+      return _arguments.endToken;
+    } else if (_constructorName != null) {
+      return _constructorName.endToken;
+    }
+    return _name.endToken;
+  }
+
+  /**
+   * Return the name of the class defining the constructor that is being invoked or the name of the
+   * field that is being referenced.
+   *
+   * @return the name of the constructor being invoked or the name of the field being referenced
+   */
+  Identifier get name => _name;
+
+  /**
+   * Set the arguments to the constructor being invoked to the given arguments.
+   *
+   * @param arguments the arguments to the constructor being invoked
+   */
+  void set arguments(ArgumentList arguments) {
+    this._arguments = becomeParentOf(arguments);
+  }
+
+  /**
+   * Set the name of the constructor being invoked to the given name.
+   *
+   * @param constructorName the name of the constructor being invoked
+   */
+  void set constructorName(SimpleIdentifier constructorName) {
+    this._constructorName = becomeParentOf(constructorName);
+  }
+
+  /**
+   * Set the element associated with this annotation based.
+   *
+   * @param element the element to be associated with this identifier
+   */
+  void set element(Element element) {
+    this._element = element;
+  }
+
+  /**
+   * Set the name of the class defining the constructor that is being invoked or the name of the
+   * field that is being referenced to the given name.
+   *
+   * @param name the name of the constructor being invoked or the name of the field being referenced
+   */
+  void set name(Identifier name) {
+    this._name = becomeParentOf(name);
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_name, visitor);
+    safelyVisitChild(_constructorName, visitor);
+    safelyVisitChild(_arguments, visitor);
+  }
+}
+
+/**
+ * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
+ *
+ * <pre>
+ * argumentDefinitionTest ::=
+ *     '?' [SimpleIdentifier]
+ * </pre>
+ */
+class ArgumentDefinitionTest extends Expression {
+  /**
+   * The token representing the question mark.
+   */
+  Token question;
+
+  /**
+   * The identifier representing the argument being tested.
+   */
+  SimpleIdentifier _identifier;
+
+  /**
+   * Initialize a newly created argument definition test.
+   *
+   * @param question the token representing the question mark
+   * @param identifier the identifier representing the argument being tested
+   */
+  ArgumentDefinitionTest(this.question, SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
+  }
+
+  accept(AstVisitor visitor) => visitor.visitArgumentDefinitionTest(this);
+
+  Token get beginToken => question;
+
+  Token get endToken => _identifier.endToken;
+
+  /**
+   * Return the identifier representing the argument being tested.
+   *
+   * @return the identifier representing the argument being tested
+   */
+  SimpleIdentifier get identifier => _identifier;
+
+  int get precedence => 15;
+
+  /**
+   * Set the identifier representing the argument being tested to the given identifier.
+   *
+   * @param identifier the identifier representing the argument being tested
+   */
+  void set identifier(SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_identifier, visitor);
+  }
+}
+
+/**
+ * Instances of the class `ArgumentList` represent a list of arguments in the invocation of a
+ * executable element: a function, method, or constructor.
+ *
+ * <pre>
+ * argumentList ::=
+ *     '(' arguments? ')'
+ *
+ * arguments ::=
+ *     [NamedExpression] (',' [NamedExpression])*
+ *   | [Expression] (',' [NamedExpression])*
+ * </pre>
+ */
+class ArgumentList extends AstNode {
+  /**
+   * The left parenthesis.
+   */
+  Token _leftParenthesis;
+
+  /**
+   * The expressions producing the values of the arguments.
+   */
+  NodeList<Expression> _arguments;
+
+  /**
+   * The right parenthesis.
+   */
+  Token _rightParenthesis;
+
+  /**
+   * An array containing the elements representing the parameters corresponding to each of the
+   * arguments in this list, or `null` if the AST has not been resolved or if the function or
+   * method being invoked could not be determined based on static type information. The array must
+   * be the same length as the number of arguments, but can contain `null` entries if a given
+   * argument does not correspond to a formal parameter.
+   */
+  List<ParameterElement> _correspondingStaticParameters;
+
+  /**
+   * An array containing the elements representing the parameters corresponding to each of the
+   * arguments in this list, or `null` if the AST has not been resolved or if the function or
+   * method being invoked could not be determined based on propagated type information. The array
+   * must be the same length as the number of arguments, but can contain `null` entries if a
+   * given argument does not correspond to a formal parameter.
+   */
+  List<ParameterElement> _correspondingPropagatedParameters;
+
+  /**
+   * Initialize a newly created list of arguments.
+   *
+   * @param leftParenthesis the left parenthesis
+   * @param arguments the expressions producing the values of the arguments
+   * @param rightParenthesis the right parenthesis
+   */
+  ArgumentList(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
+    this._arguments = new NodeList<Expression>(this);
+    this._leftParenthesis = leftParenthesis;
+    this._arguments.addAll(arguments);
+    this._rightParenthesis = rightParenthesis;
+  }
+
+  accept(AstVisitor visitor) => visitor.visitArgumentList(this);
+
+  /**
+   * Return the expressions producing the values of the arguments. Although the language requires
+   * that positional arguments appear before named arguments, this class allows them to be
+   * intermixed.
+   *
+   * @return the expressions producing the values of the arguments
+   */
+  NodeList<Expression> get arguments => _arguments;
+
+  Token get beginToken => _leftParenthesis;
+
+  Token get endToken => _rightParenthesis;
+
+  /**
+   * Return the left parenthesis.
+   *
+   * @return the left parenthesis
+   */
+  Token get leftParenthesis => _leftParenthesis;
+
+  /**
+   * Return the right parenthesis.
+   *
+   * @return the right parenthesis
+   */
+  Token get rightParenthesis => _rightParenthesis;
+
+  /**
+   * Set the parameter elements corresponding to each of the arguments in this list to the given
+   * array of parameters. The array of parameters must be the same length as the number of
+   * arguments, but can contain `null` entries if a given argument does not correspond to a
+   * formal parameter.
+   *
+   * @param parameters the parameter elements corresponding to the arguments
+   */
+  void set correspondingPropagatedParameters(List<ParameterElement> parameters) {
+    if (parameters.length != _arguments.length) {
+      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
+    }
+    _correspondingPropagatedParameters = parameters;
+  }
+
+  /**
+   * Set the parameter elements corresponding to each of the arguments in this list to the given
+   * array of parameters. The array of parameters must be the same length as the number of
+   * arguments, but can contain `null` entries if a given argument does not correspond to a
+   * formal parameter.
+   *
+   * @param parameters the parameter elements corresponding to the arguments
+   */
+  void set correspondingStaticParameters(List<ParameterElement> parameters) {
+    if (parameters.length != _arguments.length) {
+      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
+    }
+    _correspondingStaticParameters = parameters;
+  }
+
+  /**
+   * Set the left parenthesis to the given token.
+   *
+   * @param parenthesis the left parenthesis
+   */
+  void set leftParenthesis(Token parenthesis) {
+    _leftParenthesis = parenthesis;
+  }
+
+  /**
+   * Set the right parenthesis to the given token.
+   *
+   * @param parenthesis the right parenthesis
+   */
+  void set rightParenthesis(Token parenthesis) {
+    _rightParenthesis = parenthesis;
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    _arguments.accept(visitor);
+  }
+
+  /**
+   * If the given expression is a child of this list, and the AST structure has been resolved, and
+   * the function being invoked is known based on propagated type information, and the expression
+   * corresponds to one of the parameters of the function being invoked, then return the parameter
+   * element representing the parameter to which the value of the given expression will be bound.
+   * Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   *
+   * @param expression the expression corresponding to the parameter to be returned
+   * @return the parameter element representing the parameter to which the value of the expression
+   *         will be bound
+   */
+  ParameterElement getPropagatedParameterElementFor(Expression expression) {
+    if (_correspondingPropagatedParameters == null) {
+      // Either the AST structure has not been resolved or the invocation of which this list is a
+      // part could not be resolved.
+      return null;
+    }
+    int index = _arguments.indexOf(expression);
+    if (index < 0) {
+      // The expression isn't a child of this node.
+      return null;
+    }
+    return _correspondingPropagatedParameters[index];
+  }
+
+  /**
+   * If the given expression is a child of this list, and the AST structure has been resolved, and
+   * the function being invoked is known based on static type information, and the expression
+   * corresponds to one of the parameters of the function being invoked, then return the parameter
+   * element representing the parameter to which the value of the given expression will be bound.
+   * Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   *
+   * @param expression the expression corresponding to the parameter to be returned
+   * @return the parameter element representing the parameter to which the value of the expression
+   *         will be bound
+   */
+  ParameterElement getStaticParameterElementFor(Expression expression) {
+    if (_correspondingStaticParameters == null) {
+      // Either the AST structure has not been resolved or the invocation of which this list is a
+      // part could not be resolved.
+      return null;
+    }
+    int index = _arguments.indexOf(expression);
+    if (index < 0) {
+      // The expression isn't a child of this node.
+      return null;
+    }
+    return _correspondingStaticParameters[index];
+  }
+}
+
+/**
+ * Instances of the class `AsExpression` represent an 'as' expression.
+ *
+ * <pre>
+ * asExpression ::=
+ *     [Expression] 'as' [TypeName]
+ * </pre>
+ */
+class AsExpression extends Expression {
+  /**
+   * The expression used to compute the value being cast.
+   */
+  Expression _expression;
+
+  /**
+   * The as operator.
+   */
+  Token asOperator;
+
+  /**
+   * The name of the type being cast to.
+   */
+  TypeName _type;
+
+  /**
+   * Initialize a newly created as expression.
+   *
+   * @param expression the expression used to compute the value being cast
+   * @param isOperator the is operator
+   * @param type the name of the type being cast to
+   */
+  AsExpression(Expression expression, Token isOperator, TypeName type) {
+    this._expression = becomeParentOf(expression);
+    this.asOperator = isOperator;
+    this._type = becomeParentOf(type);
+  }
+
+  accept(AstVisitor visitor) => visitor.visitAsExpression(this);
+
+  Token get beginToken => _expression.beginToken;
+
+  Token get endToken => _type.endToken;
+
+  /**
+   * Return the expression used to compute the value being cast.
+   *
+   * @return the expression used to compute the value being cast
+   */
+  Expression get expression => _expression;
+
+  int get precedence => 7;
+
+  /**
+   * Return the name of the type being cast to.
+   *
+   * @return the name of the type being cast to
+   */
+  TypeName get type => _type;
+
+  /**
+   * Set the expression used to compute the value being cast to the given expression.
+   *
+   * @param expression the expression used to compute the value being cast
+   */
+  void set expression(Expression expression) {
+    this._expression = becomeParentOf(expression);
+  }
+
+  /**
+   * Set the name of the type being cast to to the given name.
+   *
+   * @param name the name of the type being cast to
+   */
+  void set type(TypeName name) {
+    this._type = becomeParentOf(name);
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_expression, visitor);
+    safelyVisitChild(_type, visitor);
+  }
+}
+
+/**
+ * Instances of the class `AssertStatement` represent an assert statement.
+ *
+ * <pre>
+ * assertStatement ::=
+ *     'assert' '(' [Expression] ')' ';'
+ * </pre>
+ */
+class AssertStatement extends Statement {
+  /**
+   * The token representing the 'assert' keyword.
+   */
+  Token keyword;
+
+  /**
+   * The left parenthesis.
+   */
+  Token leftParenthesis;
+
+  /**
+   * The condition that is being asserted to be `true`.
+   */
+  Expression _condition;
+
+  /**
+   * The right parenthesis.
+   */
+  Token rightParenthesis;
+
+  /**
+   * The semicolon terminating the statement.
+   */
+  Token semicolon;
+
+  /**
+   * Initialize a newly created assert statement.
+   *
+   * @param keyword the token representing the 'assert' keyword
+   * @param leftParenthesis the left parenthesis
+   * @param condition the condition that is being asserted to be `true`
+   * @param rightParenthesis the right parenthesis
+   * @param semicolon the semicolon terminating the statement
+   */
+  AssertStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, this.semicolon) {
+    this._condition = becomeParentOf(condition);
+  }
+
+  accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
+
+  Token get beginToken => keyword;
+
+  /**
+   * Return the condition that is being asserted to be `true`.
+   *
+   * @return the condition that is being asserted to be `true`
+   */
+  Expression get condition => _condition;
+
+  Token get endToken => semicolon;
+
+  /**
+   * Set the condition that is being asserted to be `true` to the given expression.
+   *
+   * @param the condition that is being asserted to be `true`
+   */
+  void set condition(Expression condition) {
+    this._condition = becomeParentOf(condition);
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_condition, visitor);
+  }
+}
+
+/**
+ * Instances of the class `AssignmentExpression` represent an assignment expression.
+ *
+ * <pre>
+ * assignmentExpression ::=
+ *     [Expression] [Token] [Expression]
+ * </pre>
+ */
+class AssignmentExpression extends Expression {
+  /**
+   * The expression used to compute the left hand side.
+   */
+  Expression _leftHandSide;
+
+  /**
+   * The assignment operator being applied.
+   */
+  Token operator;
+
+  /**
+   * The expression used to compute the right hand side.
+   */
+  Expression _rightHandSide;
+
+  /**
+   * The element associated with the operator based on the static type of the left-hand-side, or
+   * `null` if the AST structure has not been resolved, if the operator is not a compound
+   * operator, or if the operator could not be resolved.
+   */
+  MethodElement _staticElement;
+
+  /**
+   * The element associated with the operator based on the propagated type of the left-hand-side, or
+   * `null` if the AST structure has not been resolved, if the operator is not a compound
+   * operator, or if the operator could not be resolved.
+   */
+  MethodElement _propagatedElement;
+
+  /**
+   * Initialize a newly created assignment expression.
+   *
+   * @param leftHandSide the expression used to compute the left hand side
+   * @param operator the assignment operator being applied
+   * @param rightHandSide the expression used to compute the right hand side
+   */
+  AssignmentExpression(Expression leftHandSide, this.operator, Expression rightHandSide) {
+    this._leftHandSide = becomeParentOf(leftHandSide);
+    this._rightHandSide = becomeParentOf(rightHandSide);
+  }
+
+  accept(AstVisitor visitor) => visitor.visitAssignmentExpression(this);
+
+  Token get beginToken => _leftHandSide.beginToken;
+
+  /**
+   * Return the best element available for this operator. If resolution was able to find a better
+   * element based on type propagation, that element will be returned. Otherwise, the element found
+   * using the result of static analysis will be returned. If resolution has not been performed,
+   * then `null` will be returned.
+   *
+   * @return the best element available for this operator
+   */
+  MethodElement get bestElement {
+    MethodElement element = propagatedElement;
+    if (element == null) {
+      element = staticElement;
+    }
+    return element;
+  }
+
+  Token get endToken => _rightHandSide.endToken;
+
+  /**
+   * Set the expression used to compute the left hand side to the given expression.
+   *
+   * @return the expression used to compute the left hand side
+   */
+  Expression get leftHandSide => _leftHandSide;
+
+  int get precedence => 1;
+
+  /**
+   * Return the element associated with the operator based on the propagated type of the
+   * left-hand-side, or `null` if the AST structure has not been resolved, if the operator is
+   * not a compound operator, or if the operator could not be resolved. One example of the latter
+   * case is an operator that is not defined for the type of the left-hand operand.
+   *
+   * @return the element associated with the operator
+   */
+  MethodElement get propagatedElement => _propagatedElement;
+
+  /**
+   * Return the expression used to compute the right hand side.
+   *
+   * @return the expression used to compute the right hand side
+   */
+  Expression get rightHandSide => _rightHandSide;
+
+  /**
+   * Return the element associated with the operator based on the static type of the left-hand-side,
+   * or `null` if the AST structure has not been resolved, if the operator is not a compound
+   * operator, or if the operator could not be resolved. One example of the latter case is an
+   * operator that is not defined for the type of the left-hand operand.
+   *
+   * @return the element associated with the operator
+   */
+  MethodElement get staticElement => _staticElement;
+
+  /**
+   * Return the expression used to compute the left hand side.
+   *
+   * @param expression the expression used to compute the left hand side
+   */
+  void set leftHandSide(Expression expression) {
+    _leftHandSide = becomeParentOf(expression);
+  }
+
+  /**
+   * Set the element associated with the operator based on the propagated type of the left-hand-side
+   * to the given element.
+   *
+   * @param element the element to be associated with the operator
+   */
+  void set propagatedElement(MethodElement element) {
+    _propagatedElement = element;
+  }
+
+  /**
+   * Set the expression used to compute the left hand side to the given expression.
+   *
+   * @param expression the expression used to compute the left hand side
+   */
+  void set rightHandSide(Expression expression) {
+    _rightHandSide = becomeParentOf(expression);
+  }
+
+  /**
+   * Set the element associated with the operator based on the static type of the left-hand-side to
+   * the given element.
+   *
+   * @param element the static element to be associated with the operator
+   */
+  void set staticElement(MethodElement element) {
+    _staticElement = element;
+  }
+
+  void visitChildren(AstVisitor visitor) {
+    safelyVisitChild(_leftHandSide, visitor);
+    safelyVisitChild(_rightHandSide, visitor);
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on
+   * propagated type information, then return the parameter element representing the parameter to
+   * which the value of the right operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   *
+   * @return the parameter element representing the parameter to which the value of the right
+   *         operand will be bound
+   */
+  ParameterElement get propagatedParameterElementForRightHandSide {
+    if (_propagatedElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = _propagatedElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is known based on static
+   * type information, then return the parameter element representing the parameter to which the
+   * value of the right operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   *
+   * @return the parameter element representing the parameter to which the value of the right
+   *         operand will be bound
+   */
+  ParameterElement get staticParameterElementForRightHandSide {
+    if (_staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = _staticElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
+  }
+}
+
+/**
+ * The abstract class `AstNode` defines the behavior common to all nodes in the AST structure
  * for a Dart program.
- *
- * @coverage dart.engine.ast
  */
-abstract class ASTNode {
+abstract class AstNode {
   /**
    * An empty array of ast nodes.
    */
-  static List<ASTNode> EMPTY_ARRAY = new List<ASTNode>(0);
+  static List<AstNode> EMPTY_ARRAY = new List<AstNode>(0);
 
   /**
    * The parent of the node, or `null` if the node is the root of an AST structure.
    */
-  ASTNode _parent;
+  AstNode _parent;
 
   /**
    * A table mapping the names of properties to their values, or `null` if this node does not
    * have any properties associated with it.
    */
   Map<String, Object> _propertyMap;
 
   /**
    * A comparator that can be used to sort AST nodes in lexical order. In other words,
    * `compare` will return a negative value if the offset of the first node is less than the
    * offset of the second node, zero (0) if the nodes have the same offset, and a positive value if
    * if the offset of the first node is greater than the offset of the second node.
    */
-  static Comparator<ASTNode> LEXICAL_ORDER = (ASTNode first, ASTNode second) => second.offset - first.offset;
+  static Comparator<AstNode> LEXICAL_ORDER = (AstNode first, AstNode second) => second.offset - first.offset;
 
   /**
    * Use the given visitor to visit this node.
    *
    * @param visitor the visitor that will visit this node
    * @return the value returned by the visitor as a result of visiting this node
    */
-  accept(ASTVisitor visitor);
+  accept(AstVisitor visitor);
 
   /**
    * Return the node of the given class that most immediately encloses this node, or `null` if
    * there is no enclosing node of the given class.
    *
    * @param nodeClass the class of the node to be returned
    * @return the node of the given type that encloses this node
    */
-  ASTNode getAncestor(Type enclosingClass) {
-    ASTNode node = this;
+  AstNode getAncestor(Type enclosingClass) {
+    AstNode node = this;
     while (node != null && !isInstanceOf(node, enclosingClass)) {
       node = node.parent;
     }
     return node;
   }
 
   /**
    * Return the first token included in this node's source range.
    *
    * @return the first token included in this node's source range
@@ skipping 47 matching lines @@
   }
 
   /**
    * Return this node's parent node, or `null` if this node is the root of an AST structure.
    *
    * Note that the relationship between an AST node and its parent node may change over the lifetime
    * of a node.
    *
    * @return the parent of this node, or `null` if none
    */
-  ASTNode get parent => _parent;
+  AstNode get parent => _parent;
 
   /**
    * Return the value of the property with the given name, or `null` if this node does not
    * have a property with the given name.
    *
    * @return the value of the property with the given name
    */
   Object getProperty(String propertyName) {
     if (_propertyMap == null) {
       return null;
     }
     return _propertyMap[propertyName];
   }
 
   /**
    * Return the node at the root of this node's AST structure. Note that this method's performance
    * is linear with respect to the depth of the node in the AST structure (O(depth)).
    *
    * @return the node at the root of this node's AST structure
    */
-  ASTNode get root {
-    ASTNode root = this;
-    ASTNode parent = this.parent;
+  AstNode get root {
+    AstNode root = this;
+    AstNode parent = this.parent;
     while (parent != null) {
       root = parent;
       parent = root.parent;
     }
     return root;
   }
 
   /**
    * Return `true` if this node is a synthetic node. A synthetic node is a node that was
    * introduced by the parser in order to recover from an error in the code. Synthetic nodes always
@@ skipping 39 matching lines @@
   }
 
   String toString() => toSource();
 
   /**
    * Use the given visitor to visit all of the children of this node. The children will be visited
    * in source order.
    *
    * @param visitor the visitor that will be used to visit the children of this node
    */
-  void visitChildren(ASTVisitor visitor);
+  void visitChildren(AstVisitor visitor);
 
   /**
    * Make this node the parent of the given child node.
    *
    * @param child the node that will become a child of this node
    * @return the node that was made a child of this node
    */
-  ASTNode becomeParentOf(ASTNode child) {
+  AstNode becomeParentOf(AstNode child) {
     if (child != null) {
-      ASTNode node = child;
+      AstNode node = child;
       node.parent = this;
     }
     return child;
   }
 
   /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
    * @param child the child to be visited
    * @param visitor the visitor that will be used to visit the child
    */
-  void safelyVisitChild(ASTNode child, ASTVisitor visitor) {
+  void safelyVisitChild(AstNode child, AstVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 
   /**
    * Set the parent of this node to the given node.
    *
    * @param newParent the node that is to be made the parent of this node
    */
-  void set parent(ASTNode newParent) {
+  void set parent(AstNode newParent) {
     _parent = newParent;
   }
-
-  static int _hashCodeGenerator = 0;
-
-  final int hashCode = ++_hashCodeGenerator;
 }
 
 /**
- * The interface `ASTVisitor` defines the behavior of objects that can be used to visit an AST
+ * The interface `AstVisitor` defines the behavior of objects that can be used to visit an AST
  * structure.
- *
- * @coverage dart.engine.ast
  */
-abstract class ASTVisitor<R> {
+abstract class AstVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node);
 
   R visitAnnotation(Annotation node);
 
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node);
 
   R visitArgumentList(ArgumentList node);
 
   R visitAsExpression(AsExpression node);
 
@@ skipping 188 matching lines @@
   R visitVariableDeclarationList(VariableDeclarationList node);
 
   R visitVariableDeclarationStatement(VariableDeclarationStatement node);
 
   R visitWhileStatement(WhileStatement node);
 
   R visitWithClause(WithClause node);
 }
 
 /**
- * Instances of the class `AdjacentStrings` represents two or more string literals that are
- * implicitly concatenated because of being adjacent (separated only by whitespace).
- *
- * While the grammar only allows adjacent strings when all of the strings are of the same kind
- * (single line or multi-line), this class doesn't enforce that restriction.
- *
- * <pre>
- * adjacentStrings ::=
- *     [StringLiteral] [StringLiteral]+
- * </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
-   */
-  AdjacentStrings(List<StringLiteral> strings) {
-    this._strings = new NodeList<StringLiteral>(this);
-    this._strings.addAll(strings);
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitAdjacentStrings(this);
-
-  Token get beginToken => _strings.beginToken;
-
-  Token get endToken => _strings.endToken;
-
-  /**
-   * Return the strings that are implicitly concatenated.
-   *
-   * @return the strings that are implicitly concatenated
-   */
-  NodeList<StringLiteral> get strings => _strings;
-
-  void visitChildren(ASTVisitor visitor) {
-    _strings.accept(visitor);
-  }
-
-  void appendStringValue(JavaStringBuilder builder) {
-    for (StringLiteral stringLiteral in strings) {
-      stringLiteral.appendStringValue(builder);
-    }
-  }
-}
-
-/**
- * The abstract class `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 `null` if this node does not have
-   * a documentation comment associated with it.
-   */
-  Comment _comment;
-
-  /**
-   * The annotations associated with this node.
-   */
-  NodeList<Annotation> _metadata;
-
-  /**
-   * Initialize a newly created node.
-   *
-   * @param comment the documentation comment associated with this node
-   * @param metadata the annotations associated with this node
-   */
-  AnnotatedNode(Comment comment, List<Annotation> metadata) {
-    this._metadata = new NodeList<Annotation>(this);
-    this._comment = becomeParentOf(comment);
-    this._metadata.addAll(metadata);
-  }
-
-  Token get beginToken {
-    if (_comment == null) {
-      if (_metadata.isEmpty) {
-        return firstTokenAfterCommentAndMetadata;
-      } else {
-        return _metadata.beginToken;
-      }
-    } else if (_metadata.isEmpty) {
-      return _comment.beginToken;
-    }
-    Token commentToken = _comment.beginToken;
-    Token metadataToken = _metadata.beginToken;
-    if (commentToken.offset < metadataToken.offset) {
-      return commentToken;
-    }
-    return metadataToken;
-  }
-
-  /**
-   * Return the documentation comment associated with this node, or `null` if this node does
-   * not have a documentation comment associated with it.
-   *
-   * @return the documentation comment associated with this node
-   */
-  Comment get documentationComment => _comment;
-
-  /**
-   * Return the annotations associated with this node.
-   *
-   * @return the annotations associated with this node
-   */
-  NodeList<Annotation> get metadata => _metadata;
-
-  /**
-   * Set the documentation comment associated with this node to the given comment.
-   *
-   * @param comment the documentation comment to be associated with this node
-   */
-  void set documentationComment(Comment comment) {
-    this._comment = becomeParentOf(comment);
-  }
-
-  /**
-   * Set the metadata associated with this node to the given metadata.
-   *
-   * @param metadata the metadata to be associated with this node
-   */
-  void set metadata(List<Annotation> metadata) {
-    this._metadata.clear();
-    this._metadata.addAll(metadata);
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    if (commentIsBeforeAnnotations()) {
-      safelyVisitChild(_comment, visitor);
-      _metadata.accept(visitor);
-    } else {
-      for (ASTNode child in sortedCommentAndAnnotations) {
-        child.accept(visitor);
-      }
-    }
-  }
-
-  /**
-   * Return the first token following the comment and metadata.
-   *
-   * @return the first token following the comment and metadata
-   */
-  Token get firstTokenAfterCommentAndMetadata;
-
-  /**
-   * Return `true` if the comment is lexically before any annotations.
-   *
-   * @return `true` if the comment is lexically before any annotations
-   */
-  bool commentIsBeforeAnnotations() {
-    if (_comment == null || _metadata.isEmpty) {
-      return true;
-    }
-    Annotation firstAnnotation = _metadata[0];
-    return _comment.offset < firstAnnotation.offset;
-  }
-
-  /**
-   * Return an array containing the comment and annotations associated with this node, sorted in
-   * lexical order.
-   *
-   * @return the comment and annotations associated with this node in the order in which they
-   *         appeared in the original source
-   */
-  List<ASTNode> get sortedCommentAndAnnotations {
-    List<ASTNode> childList = new List<ASTNode>();
-    childList.add(_comment);
-    childList.addAll(_metadata);
-    List<ASTNode> children = new List.from(childList);
-    children.sort(ASTNode.LEXICAL_ORDER);
-    return children;
-  }
-}
-
-/**
- * Instances of the class `Annotation` represent an annotation that can be associated with an
- * AST node.
- *
- * <pre>
- * metadata ::=
- *     annotation*
- *
- * annotation ::=
- *     '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
- * </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.
-   */
-  Identifier _name;
-
-  /**
-   * The period before the constructor name, or `null` if this annotation is not the
-   * invocation of a named constructor.
-   */
-  Token period;
-
-  /**
-   * The name of the constructor being invoked, or `null` if this annotation is not the
-   * invocation of a named constructor.
-   */
-  SimpleIdentifier _constructorName;
-
-  /**
-   * The arguments to the constructor being invoked, or `null` if this annotation is not the
-   * invocation of a constructor.
-   */
-  ArgumentList _arguments;
-
-  /**
-   * The element associated with this annotation, or `null` if the AST structure has not been
-   * resolved or if this annotation could not be resolved.
-   */
-  Element _element;
-
-  /**
-   * Initialize a newly created annotation.
-   *
-   * @param atSign the at sign that introduced the annotation
-   * @param name the name of the class defining the constructor that is being invoked or the name of
-   *          the field that is being referenced
-   * @param period the period before the constructor name, or `null` if this annotation is not
-   *          the invocation of a named constructor
-   * @param constructorName the name of the constructor being invoked, or `null` if this
-   *          annotation is not the invocation of a named constructor
-   * @param arguments the arguments to the constructor being invoked, or `null` if this
-   *          annotation is not the invocation of a constructor
-   */
-  Annotation(this.atSign, Identifier name, this.period, SimpleIdentifier constructorName, ArgumentList arguments) {
-    this._name = becomeParentOf(name);
-    this._constructorName = becomeParentOf(constructorName);
-    this._arguments = becomeParentOf(arguments);
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitAnnotation(this);
-
-  /**
-   * Return the arguments to the constructor being invoked, or `null` if this annotation is
-   * not the invocation of a constructor.
-   *
-   * @return the arguments to the constructor being invoked
-   */
-  ArgumentList get arguments => _arguments;
-
-  Token get beginToken => atSign;
-
-  /**
-   * Return the name of the constructor being invoked, or `null` if this annotation is not the
-   * invocation of a named constructor.
-   *
-   * @return the name of the constructor being invoked
-   */
-  SimpleIdentifier get constructorName => _constructorName;
-
-  /**
-   * Return the element associated with this annotation, or `null` if the AST structure has
-   * not been resolved or if this annotation could not be resolved.
-   *
-   * @return the element associated with this annotation
-   */
-  Element get element {
-    if (_element != null) {
-      return _element;
-    }
-    if (_name != null) {
-      return _name.staticElement;
-    }
-    return null;
-  }
-
-  Token get endToken {
-    if (_arguments != null) {
-      return _arguments.endToken;
-    } else if (_constructorName != null) {
-      return _constructorName.endToken;
-    }
-    return _name.endToken;
-  }
-
-  /**
-   * Return the name of the class defining the constructor that is being invoked or the name of the
-   * field that is being referenced.
-   *
-   * @return the name of the constructor being invoked or the name of the field being referenced
-   */
-  Identifier get name => _name;
-
-  /**
-   * Set the arguments to the constructor being invoked to the given arguments.
-   *
-   * @param arguments the arguments to the constructor being invoked
-   */
-  void set arguments(ArgumentList arguments) {
-    this._arguments = becomeParentOf(arguments);
-  }
-
-  /**
-   * Set the name of the constructor being invoked to the given name.
-   *
-   * @param constructorName the name of the constructor being invoked
-   */
-  void set constructorName(SimpleIdentifier constructorName) {
-    this._constructorName = becomeParentOf(constructorName);
-  }
-
-  /**
-   * Set the element associated with this annotation based.
-   *
-   * @param element the element to be associated with this identifier
-   */
-  void set element(Element element) {
-    this._element = element;
-  }
-
-  /**
-   * Set the name of the class defining the constructor that is being invoked or the name of the
-   * field that is being referenced to the given name.
-   *
-   * @param name the name of the constructor being invoked or the name of the field being referenced
-   */
-  void set name(Identifier name) {
-    this._name = becomeParentOf(name);
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(_name, visitor);
-    safelyVisitChild(_constructorName, visitor);
-    safelyVisitChild(_arguments, visitor);
-  }
-}
-
-/**
- * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
- *
- * <pre>
- * argumentDefinitionTest ::=
- *     '?' [SimpleIdentifier]
- * </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;
-
-  /**
-   * Initialize a newly created argument definition test.
-   *
-   * @param question the token representing the question mark
-   * @param identifier the identifier representing the argument being tested
-   */
-  ArgumentDefinitionTest(this.question, SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitArgumentDefinitionTest(this);
-
-  Token get beginToken => question;
-
-  Token get endToken => _identifier.endToken;
-
-  /**
-   * Return the identifier representing the argument being tested.
-   *
-   * @return the identifier representing the argument being tested
-   */
-  SimpleIdentifier get identifier => _identifier;
-
-  int get precedence => 15;
-
-  /**
-   * Set the identifier representing the argument being tested to the given identifier.
-   *
-   * @param identifier the identifier representing the argument being tested
-   */
-  void set identifier(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(_identifier, visitor);
-  }
-}
-
-/**
- * Instances of the class `ArgumentList` represent a list of arguments in the invocation of a
- * executable element: a function, method, or constructor.
- *
- * <pre>
- * argumentList ::=
- *     '(' arguments? ')'
- *
- * arguments ::=
- *     [NamedExpression] (',' [NamedExpression])*
- *   | [Expression] (',' [NamedExpression])*
- * </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;
-
-  /**
-   * The right parenthesis.
-   */
-  Token _rightParenthesis;
-
-  /**
-   * An array containing the elements representing the parameters corresponding to each of the
-   * arguments in this list, or `null` if the AST has not been resolved or if the function or
-   * method being invoked could not be determined based on static type information. The array must
-   * be the same length as the number of arguments, but can contain `null` entries if a given
-   * argument does not correspond to a formal parameter.
-   */
-  List<ParameterElement> _correspondingStaticParameters;
-
-  /**
-   * An array containing the elements representing the parameters corresponding to each of the
-   * arguments in this list, or `null` if the AST has not been resolved or if the function or
-   * method being invoked could not be determined based on propagated type information. The array
-   * must be the same length as the number of arguments, but can contain `null` entries if a
-   * given argument does not correspond to a formal parameter.
-   */
-  List<ParameterElement> _correspondingPropagatedParameters;
-
-  /**
-   * Initialize a newly created list of arguments.
-   *
-   * @param leftParenthesis the left parenthesis
-   * @param arguments the expressions producing the values of the arguments
-   * @param rightParenthesis the right parenthesis
-   */
-  ArgumentList(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
-    this._arguments = new NodeList<Expression>(this);
-    this._leftParenthesis = leftParenthesis;
-    this._arguments.addAll(arguments);
-    this._rightParenthesis = rightParenthesis;
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitArgumentList(this);
-
-  /**
-   * Return the expressions producing the values of the arguments. Although the language requires
-   * that positional arguments appear before named arguments, this class allows them to be
-   * intermixed.
-   *
-   * @return the expressions producing the values of the arguments
-   */
-  NodeList<Expression> get arguments => _arguments;
-
-  Token get beginToken => _leftParenthesis;
-
-  Token get endToken => _rightParenthesis;
-
-  /**
-   * Return the left parenthesis.
-   *
-   * @return the left parenthesis
-   */
-  Token get leftParenthesis => _leftParenthesis;
-
-  /**
-   * Return the right parenthesis.
-   *
-   * @return the right parenthesis
-   */
-  Token get rightParenthesis => _rightParenthesis;
-
-  /**
-   * Set the parameter elements corresponding to each of the arguments in this list to the given
-   * array of parameters. The array of parameters must be the same length as the number of
-   * arguments, but can contain `null` entries if a given argument does not correspond to a
-   * formal parameter.
-   *
-   * @param parameters the parameter elements corresponding to the arguments
-   */
-  void set correspondingPropagatedParameters(List<ParameterElement> parameters) {
-    if (parameters.length != _arguments.length) {
-      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
-    }
-    _correspondingPropagatedParameters = parameters;
-  }
-
-  /**
-   * Set the parameter elements corresponding to each of the arguments in this list to the given
-   * array of parameters. The array of parameters must be the same length as the number of
-   * arguments, but can contain `null` entries if a given argument does not correspond to a
-   * formal parameter.
-   *
-   * @param parameters the parameter elements corresponding to the arguments
-   */
-  void set correspondingStaticParameters(List<ParameterElement> parameters) {
-    if (parameters.length != _arguments.length) {
-      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
-    }
-    _correspondingStaticParameters = parameters;
-  }
-
-  /**
-   * Set the left parenthesis to the given token.
-   *
-   * @param parenthesis the left parenthesis
-   */
-  void set leftParenthesis(Token parenthesis) {
-    _leftParenthesis = parenthesis;
-  }
-
-  /**
-   * Set the right parenthesis to the given token.
-   *
-   * @param parenthesis the right parenthesis
-   */
-  void set rightParenthesis(Token parenthesis) {
-    _rightParenthesis = parenthesis;
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    _arguments.accept(visitor);
-  }
-
-  /**
-   * If the given expression is a child of this list, and the AST structure has been resolved, and
-   * the function being invoked is known based on propagated type information, and the expression
-   * corresponds to one of the parameters of the function being invoked, then return the parameter
-   * element representing the parameter to which the value of the given expression will be bound.
-   * Otherwise, return `null`.
-   *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
-   *
-   * @param expression the expression corresponding to the parameter to be returned
-   * @return the parameter element representing the parameter to which the value of the expression
-   *         will be bound
-   */
-  ParameterElement getPropagatedParameterElementFor(Expression expression) {
-    if (_correspondingPropagatedParameters == null) {
-      // Either the AST structure has not been resolved or the invocation of which this list is a
-      // part could not be resolved.
-      return null;
-    }
-    int index = _arguments.indexOf(expression);
-    if (index < 0) {
-      // The expression isn't a child of this node.
-      return null;
-    }
-    return _correspondingPropagatedParameters[index];
-  }
-
-  /**
-   * If the given expression is a child of this list, and the AST structure has been resolved, and
-   * the function being invoked is known based on static type information, and the expression
-   * corresponds to one of the parameters of the function being invoked, then return the parameter
-   * element representing the parameter to which the value of the given expression will be bound.
-   * Otherwise, return `null`.
-   *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
-   *
-   * @param expression the expression corresponding to the parameter to be returned
-   * @return the parameter element representing the parameter to which the value of the expression
-   *         will be bound
-   */
-  ParameterElement getStaticParameterElementFor(Expression expression) {
-    if (_correspondingStaticParameters == null) {
-      // Either the AST structure has not been resolved or the invocation of which this list is a
-      // part could not be resolved.
-      return null;
-    }
-    int index = _arguments.indexOf(expression);
-    if (index < 0) {
-      // The expression isn't a child of this node.
-      return null;
-    }
-    return _correspondingStaticParameters[index];
-  }
-}
-
-/**
- * Instances of the class `AsExpression` represent an 'as' expression.
- *
- * <pre>
- * asExpression ::=
- *     [Expression] 'as' [TypeName]
- * </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;
-
-  /**
-   * The name of the type being cast to.
-   */
-  TypeName _type;
-
-  /**
-   * Initialize a newly created as expression.
-   *
-   * @param expression the expression used to compute the value being cast
-   * @param isOperator the is operator
-   * @param type the name of the type being cast to
-   */
-  AsExpression(Expression expression, Token isOperator, TypeName type) {
-    this._expression = becomeParentOf(expression);
-    this.asOperator = isOperator;
-    this._type = becomeParentOf(type);
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitAsExpression(this);
-
-  Token get beginToken => _expression.beginToken;
-
-  Token get endToken => _type.endToken;
-
-  /**
-   * Return the expression used to compute the value being cast.
-   *
-   * @return the expression used to compute the value being cast
-   */
-  Expression get expression => _expression;
-
-  int get precedence => 7;
-
-  /**
-   * Return the name of the type being cast to.
-   *
-   * @return the name of the type being cast to
-   */
-  TypeName get type => _type;
-
-  /**
-   * Set the expression used to compute the value being cast to the given expression.
-   *
-   * @param expression the expression used to compute the value being cast
-   */
-  void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
-  }
-
-  /**
-   * Set the name of the type being cast to to the given name.
-   *
-   * @param name the name of the type being cast to
-   */
-  void set type(TypeName name) {
-    this._type = becomeParentOf(name);
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(_expression, visitor);
-    safelyVisitChild(_type, visitor);
-  }
-}
-
-/**
- * Instances of the class `AssertStatement` represent an assert statement.
- *
- * <pre>
- * assertStatement ::=
- *     'assert' '(' [Expression] ')' ';'
- * </pre>
- *
- * @coverage dart.engine.ast
- */
-class AssertStatement extends Statement {
-  /**
-   * The token representing the 'assert' keyword.
-   */
-  Token keyword;
-
-  /**
-   * The left parenthesis.
-   */
-  Token leftParenthesis;
-
-  /**
-   * The condition that is being asserted to be `true`.
-   */
-  Expression _condition;
-
-  /**
-   * The right parenthesis.
-   */
-  Token rightParenthesis;
-
-  /**
-   * The semicolon terminating the statement.
-   */
-  Token semicolon;
-
-  /**
-   * Initialize a newly created assert statement.
-   *
-   * @param keyword the token representing the 'assert' keyword
-   * @param leftParenthesis the left parenthesis
-   * @param condition the condition that is being asserted to be `true`
-   * @param rightParenthesis the right parenthesis
-   * @param semicolon the semicolon terminating the statement
-   */
-  AssertStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, this.semicolon) {
-    this._condition = becomeParentOf(condition);
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitAssertStatement(this);
-
-  Token get beginToken => keyword;
-
-  /**
-   * Return the condition that is being asserted to be `true`.
-   *
-   * @return the condition that is being asserted to be `true`
-   */
-  Expression get condition => _condition;
-
-  Token get endToken => semicolon;
-
-  /**
-   * Set the condition that is being asserted to be `true` to the given expression.
-   *
-   * @param the condition that is being asserted to be `true`
-   */
-  void set condition(Expression condition) {
-    this._condition = becomeParentOf(condition);
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(_condition, visitor);
-  }
-}
-
-/**
- * Instances of the class `AssignmentExpression` represent an assignment expression.
- *
- * <pre>
- * assignmentExpression ::=
- *     [Expression] [Token] [Expression]
- * </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;
-
-  /**
-   * The expression used to compute the right hand side.
-   */
-  Expression _rightHandSide;
-
-  /**
-   * The element associated with the operator based on the static type of the left-hand-side, or
-   * `null` if the AST structure has not been resolved, if the operator is not a compound
-   * operator, or if the operator could not be resolved.
-   */
-  MethodElement _staticElement;
-
-  /**
-   * The element associated with the operator based on the propagated type of the left-hand-side, or
-   * `null` if the AST structure has not been resolved, if the operator is not a compound
-   * operator, or if the operator could not be resolved.
-   */
-  MethodElement _propagatedElement;
-
-  /**
-   * Initialize a newly created assignment expression.
-   *
-   * @param leftHandSide the expression used to compute the left hand side
-   * @param operator the assignment operator being applied
-   * @param rightHandSide the expression used to compute the right hand side
-   */
-  AssignmentExpression(Expression leftHandSide, this.operator, Expression rightHandSide) {
-    this._leftHandSide = becomeParentOf(leftHandSide);
-    this._rightHandSide = becomeParentOf(rightHandSide);
-  }
-
-  accept(ASTVisitor visitor) => visitor.visitAssignmentExpression(this);
-
-  Token get beginToken => _leftHandSide.beginToken;
-
-  /**
-   * Return the best element available for this operator. If resolution was able to find a better
-   * element based on type propagation, that element will be returned. Otherwise, the element found
-   * using the result of static analysis will be returned. If resolution has not been performed,
-   * then `null` will be returned.
-   *
-   * @return the best element available for this operator
-   */
-  MethodElement get bestElement {
-    MethodElement element = propagatedElement;
-    if (element == null) {
-      element = staticElement;
-    }
-    return element;
-  }
-
-  Token get endToken => _rightHandSide.endToken;
-
-  /**
-   * Set the expression used to compute the left hand side to the given expression.
-   *
-   * @return the expression used to compute the left hand side
-   */
-  Expression get leftHandSide => _leftHandSide;
-
-  int get precedence => 1;
-
-  /**
-   * Return the element associated with the operator based on the propagated type of the
-   * left-hand-side, or `null` if the AST structure has not been resolved, if the operator is
-   * not a compound operator, or if the operator could not be resolved. One example of the latter
-   * case is an operator that is not defined for the type of the left-hand operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get propagatedElement => _propagatedElement;
-
-  /**
-   * Return the expression used to compute the right hand side.
-   *
-   * @return the expression used to compute the right hand side
-   */
-  Expression get rightHandSide => _rightHandSide;
-
-  /**
-   * Return the element associated with the operator based on the static type of the left-hand-side,
-   * or `null` if the AST structure has not been resolved, if the operator is not a compound
-   * operator, or if the operator could not be resolved. One example of the latter case is an
-   * operator that is not defined for the type of the left-hand operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get staticElement => _staticElement;
-
-  /**
-   * Return the expression used to compute the left hand side.
-   *
-   * @param expression the expression used to compute the left hand side
-   */
-  void set leftHandSide(Expression expression) {
-    _leftHandSide = becomeParentOf(expression);
-  }
-
-  /**
-   * Set the element associated with the operator based on the propagated type of the left-hand-side
-   * to the given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set propagatedElement(MethodElement element) {
-    _propagatedElement = element;
-  }
-
-  /**
-   * Set the expression used to compute the left hand side to the given expression.
-   *
-   * @param expression the expression used to compute the left hand side
-   */
-  void set rightHandSide(Expression expression) {
-    _rightHandSide = becomeParentOf(expression);
-  }
-
-  /**
-   * Set the element associated with the operator based on the static type of the left-hand-side to
-   * the given element.
-   *
-   * @param element the static element to be associated with the operator
-   */
-  void set staticElement(MethodElement element) {
-    _staticElement = element;
-  }
-
-  void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(_leftHandSide, visitor);
-    safelyVisitChild(_rightHandSide, visitor);
-  }
-
-  /**
-   * If the AST structure has been resolved, and the function being invoked is known based on
-   * propagated type information, then return the parameter element representing the parameter to
-   * which the value of the right operand will be bound. Otherwise, return `null`.
-   *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
-   *
-   * @return the parameter element representing the parameter to which the value of the right
-   *         operand will be bound
-   */
-  ParameterElement get propagatedParameterElementForRightHandSide {
-    if (_propagatedElement == null) {
-      return null;
-    }
-    List<ParameterElement> parameters = _propagatedElement.parameters;
-    if (parameters.length < 1) {
-      return null;
-    }
-    return parameters[0];
-  }
-
-  /**
-   * If the AST structure has been resolved, and the function being invoked is known based on static
-   * type information, then return the parameter element representing the parameter to which the
-   * value of the right operand will be bound. Otherwise, return `null`.
-   *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
-   *
-   * @return the parameter element representing the parameter to which the value of the right
-   *         operand will be bound
-   */
-  ParameterElement get staticParameterElementForRightHandSide {
-    if (_staticElement == null) {
-      return null;
-    }
-    List<ParameterElement> parameters = _staticElement.parameters;
-    if (parameters.length < 1) {
-      return null;
-    }
-    return parameters[0];
-  }
-}
-
-/**
  * Instances of the class `BinaryExpression` represent a binary (infix) expression.
  *
  * <pre>
  * binaryExpression ::=
  *     [Expression] [Token] [Expression]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class BinaryExpression extends Expression {
   /**
    * The expression used to compute the left operand.
    */
   Expression _leftOperand;
 
   /**
    * The binary operator being applied.
    */
@@ skipping 23 matching lines @@
    *
    * @param leftOperand the expression used to compute the left operand
    * @param operator the binary operator being applied
    * @param rightOperand the expression used to compute the right operand
    */
   BinaryExpression(Expression leftOperand, this.operator, Expression rightOperand) {
     this._leftOperand = becomeParentOf(leftOperand);
     this._rightOperand = becomeParentOf(rightOperand);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitBinaryExpression(this);
+  accept(AstVisitor visitor) => visitor.visitBinaryExpression(this);
 
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
@@ skipping 75 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the left operand to
    * the given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the right operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 34 matching lines @@
   }
 }
 
 /**
  * Instances of the class `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;
 
   /**
    * The right curly bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created block of code.
    *
    * @param leftBracket the left curly bracket
    * @param statements the statements contained in the block
    * @param rightBracket the right curly bracket
    */
   Block(this.leftBracket, List<Statement> statements, this.rightBracket) {
     this._statements = new NodeList<Statement>(this);
     this._statements.addAll(statements);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitBlock(this);
+  accept(AstVisitor visitor) => visitor.visitBlock(this);
 
   Token get beginToken => leftBracket;
 
   Token get endToken => rightBracket;
 
   /**
    * Return the statements contained in the block.
    *
    * @return the statements contained in the block
    */
   NodeList<Statement> get statements => _statements;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _statements.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BlockFunctionBody` represent a function body that consists of a
  * block of statements.
  *
  * <pre>
  * blockFunctionBody ::=
  *     [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
    */
   BlockFunctionBody(Block block) {
     this._block = becomeParentOf(block);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitBlockFunctionBody(this);
+  accept(AstVisitor visitor) => visitor.visitBlockFunctionBody(this);
 
   Token get beginToken => _block.beginToken;
 
   /**
    * Return the block representing the body of the function.
    *
    * @return the block representing the body of the function
    */
   Block get block => _block;
 
   Token get endToken => _block.endToken;
 
   /**
    * Set the block representing the body of the function to the given block.
    *
    * @param block the block representing the body of the function
    */
   void set block(Block block) {
     this._block = becomeParentOf(block);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 
 /**
  * Instances of the class `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;
 
   /**
    * Initialize a newly created boolean literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   BooleanLiteral(this.literal, this.value);
 
-  accept(ASTVisitor visitor) => visitor.visitBooleanLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitBooleanLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   bool get isSynthetic => literal.isSynthetic;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `BreakStatement` represent a break statement.
  *
  * <pre>
  * breakStatement ::=
  *     'break' [SimpleIdentifier]? ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class BreakStatement extends Statement {
   /**
    * The token representing the 'break' keyword.
    */
   Token keyword;
 
   /**
    * The label associated with the statement, or `null` if there is no label.
    */
   SimpleIdentifier _label;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created break statement.
    *
    * @param keyword the token representing the 'break' keyword
    * @param label the label associated with the statement
    * @param semicolon the semicolon terminating the statement
    */
   BreakStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
     this._label = becomeParentOf(label);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitBreakStatement(this);
+  accept(AstVisitor visitor) => visitor.visitBreakStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => semicolon;
 
   /**
    * Return the label associated with the statement, or `null` if there is no label.
    *
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label associated with the statement to the given identifier.
    *
    * @param identifier the label associated with the statement
    */
   void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * Instances of the class `CascadeExpression` represent a sequence of cascaded expressions:
  * expressions that share a common target. There are three kinds of expressions that can be used in
  * a cascade expression: [IndexExpression], [MethodInvocation] and
  * [PropertyAccess].
  *
  * <pre>
  * cascadeExpression ::=
  *     [Expression] 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;
 
   /**
    * Initialize a newly created cascade expression.
    *
    * @param target the target of the cascade sections
    * @param cascadeSections the cascade sections sharing the common target
    */
   CascadeExpression(Expression target, List<Expression> cascadeSections) {
     this._cascadeSections = new NodeList<Expression>(this);
     this._target = becomeParentOf(target);
     this._cascadeSections.addAll(cascadeSections);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitCascadeExpression(this);
+  accept(AstVisitor visitor) => visitor.visitCascadeExpression(this);
 
   Token get beginToken => _target.beginToken;
 
   /**
    * Return the cascade sections sharing the common target.
    *
    * @return the cascade sections sharing the common target
    */
   NodeList<Expression> get cascadeSections => _cascadeSections;
 
@@ skipping 10 matching lines @@
 
   /**
    * Set the target of the cascade sections to the given expression.
    *
    * @param target the target of the cascade sections
    */
   void set target(Expression target) {
     this._target = becomeParentOf(target);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `CatchClause` represent a catch clause within a try statement.
  *
  * <pre>
  * onPart ::=
  *     catchPart [Block]
  *   | 'on' type catchPart? [Block]
  *
  * catchPart ::=
  *     'catch' '(' [SimpleIdentifier] (',' [SimpleIdentifier])? ')'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class CatchClause extends ASTNode {
+class CatchClause extends AstNode {
   /**
    * The token representing the 'on' keyword, or `null` if there is no 'on' keyword.
    */
   Token onKeyword;
 
   /**
    * The type of exceptions caught by this catch clause, or `null` if this catch clause
    * catches every type of exception.
    */
   TypeName exceptionType;
@@ skipping 50 matching lines @@
    */
   CatchClause(this.onKeyword, TypeName exceptionType, this.catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, this.comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
     this.exceptionType = becomeParentOf(exceptionType);
     this._leftParenthesis = leftParenthesis;
     this._exceptionParameter = becomeParentOf(exceptionParameter);
     this._stackTraceParameter = becomeParentOf(stackTraceParameter);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitCatchClause(this);
+  accept(AstVisitor visitor) => visitor.visitCatchClause(this);
 
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
     }
     return catchKeyword;
   }
 
   /**
    * Return the body of the catch block.
@@ skipping 73 matching lines @@
    * Set the parameter whose value will be the stack trace associated with the exception to the
    * given parameter.
    *
    * @param parameter the parameter whose value will be the stack trace associated with the
    *          exception
    */
   void set stackTraceParameter(SimpleIdentifier parameter) {
     _stackTraceParameter = becomeParentOf(parameter);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(exceptionType, visitor);
     safelyVisitChild(_exceptionParameter, visitor);
     safelyVisitChild(_stackTraceParameter, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `ClassDeclaration` represent the declaration of a class.
  *
  * <pre>
  * classDeclaration ::=
  *     'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
  *     ([ExtendsClause] [WithClause]?)?
  *     [ImplementsClause]?
  *     '{' [ClassMember]* '}'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ClassDeclaration extends CompilationUnitMember {
   /**
    * The 'abstract' keyword, or `null` if the keyword was absent.
    */
   Token abstractKeyword;
 
   /**
    * The token representing the 'class' keyword.
    */
@@ skipping 65 matching lines @@
   ClassDeclaration(Comment comment, List<Annotation> metadata, this.abstractKeyword, this.classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, this.leftBracket, List<ClassMember> members, this.rightBracket) : super(comment, metadata) {
     this._members = new NodeList<ClassMember>(this);
     this._name = becomeParentOf(name);
     this.typeParameters = becomeParentOf(typeParameters);
     this._extendsClause = becomeParentOf(extendsClause);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
     this._members.addAll(members);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitClassDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitClassDeclaration(this);
 
   /**
    * Return the constructor declared in the class with the given name.
    *
    * @param name the name of the constructor to find, `null` for default
    * @return the found constructor or `null` if not found
    */
   ConstructorDeclaration getConstructor(String name) {
     for (ClassMember classMember in _members) {
       if (classMember is ConstructorDeclaration) {
@@ skipping 121 matching lines @@
 
   /**
    * Set the with clause for the class to the given clause.
    *
    * @param withClause the with clause for the class
    */
   void set withClause(WithClause withClause) {
     this._withClause = becomeParentOf(withClause);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
     safelyVisitChild(nativeClause, visitor);
     members.accept(visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (abstractKeyword != null) {
       return abstractKeyword;
     }
     return classKeyword;
   }
 }
 
 /**
  * The abstract class `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(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 }
 
 /**
  * Instances of the class `ClassTypeAlias` represent a class type alias.
  *
  * <pre>
  * classTypeAlias ::=
  *     [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
  *
  * mixinApplication ::=
  *     [TypeName] [WithClause] [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 `null` if the class does not have any type
    * parameters.
@@ skipping 42 matching lines @@
    * @param semicolon the semicolon terminating the declaration
    */
   ClassTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, this.equals, this.abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super(comment, metadata, keyword, semicolon) {
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
     this._superclass = becomeParentOf(superclass);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitClassTypeAlias(this);
+  accept(AstVisitor visitor) => visitor.visitClassTypeAlias(this);
 
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
 
   /**
    * Return the implements clause for this class, or `null` if there is no implements clause.
    *
    * @return the implements clause for this class
    */
   ImplementsClause get implementsClause => _implementsClause;
 
@@ skipping 64 matching lines @@
 
   /**
    * Set the with clause for this class to the given with clause.
    *
    * @param withClause the with clause for this class
    */
   void set withClause(WithClause withClause) {
     this._withClause = becomeParentOf(withClause);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
 
 /**
  * Instances of the class `Combinator` represent the combinator associated with an import
  * directive.
  *
  * <pre>
  * combinator ::=
  *     [HideCombinator]
  *   | [ShowCombinator]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class Combinator extends ASTNode {
+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 15 matching lines @@
  * endOfLineComment ::=
  *     '//' (CHARACTER - EOL)* EOL
  *
  * blockComment ::=
  *     '/ *' CHARACTER* '&#42;/'
  *
  * documentationComment ::=
  *     '/ **' (CHARACTER | [CommentReference])* '&#42;/'
  *   | ('///' (CHARACTER - EOL)* EOL)+
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class Comment extends ASTNode {
+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(tokens, CommentType.BLOCK, null);
 
   /**
    * Create a documentation comment.
@@ skipping 42 matching lines @@
    * @param tokens the tokens representing the comment
    * @param type the type of the comment
    * @param references the references embedded within the documentation comment
    */
   Comment(this.tokens, CommentType type, List<CommentReference> references) {
     this._references = new NodeList<CommentReference>(this);
     this._type = type;
     this._references.addAll(references);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitComment(this);
+  accept(AstVisitor visitor) => visitor.visitComment(this);
 
   Token get beginToken => tokens[0];
 
   Token get endToken => tokens[tokens.length - 1];
 
   /**
    * Return the references embedded within the documentation comment.
    *
    * @return the references embedded within the documentation comment
    */
@@ skipping 13 matching lines @@
    */
   bool get isDocumentation => identical(_type, CommentType.DOCUMENTATION);
 
   /**
    * Return `true` if this is an end-of-line comment.
    *
    * @return `true` if this is an end-of-line comment
    */
   bool get isEndOfLine => identical(_type, CommentType.END_OF_LINE);
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _references.accept(visitor);
   }
 }
 
 /**
  * The enumeration `CommentType` encodes all the different types of comments that are
  * recognized by the parser.
  */
 class CommentType extends Enum<CommentType> {
   /**
@@ skipping 17 matching lines @@
 }
 
 /**
  * Instances of the class `CommentReference` represent a reference to a Dart element that is
  * found within a documentation comment.
  *
  * <pre>
  * commentReference ::=
  *     '[' 'new'? [Identifier] ']'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class CommentReference extends ASTNode {
+class CommentReference extends AstNode {
   /**
    * The token representing the 'new' keyword, or `null` if there was no 'new' keyword.
    */
   Token newKeyword;
 
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
 
   /**
    * Initialize a newly created reference to a Dart element.
    *
    * @param newKeyword the token representing the 'new' keyword
    * @param identifier the identifier being referenced
    */
   CommentReference(this.newKeyword, Identifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitCommentReference(this);
+  accept(AstVisitor visitor) => visitor.visitCommentReference(this);
 
   Token get beginToken => _identifier.beginToken;
 
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being referenced.
    *
    * @return the identifier being referenced
    */
   Identifier get identifier => _identifier;
 
   /**
    * Set the identifier being referenced to the given identifier.
    *
    * @param identifier the identifier being referenced
    */
   void set identifier(Identifier identifier) {
     identifier = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `CompilationUnit` represent a compilation unit.
  *
  * 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 ::=
  *     [ScriptTag]? [LibraryDirective]? namespaceDirective* [PartDirective]*
  *   | [PartOfDirective]
  *
  * namespaceDirective ::=
  *     [ImportDirective]
  *   | [ExportDirective]
  *
  * declarations ::=
  *     [CompilationUnitMember]*
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class CompilationUnit extends ASTNode {
+class CompilationUnit extends AstNode {
   /**
    * The first token in the token stream that was parsed to form this compilation unit.
    */
   final Token beginToken;
 
   /**
    * The script tag at the beginning of the compilation unit, or `null` if there is no script
    * tag in this compilation unit.
    */
   ScriptTag _scriptTag;
@@ skipping 35 matching lines @@
    * @param endToken the last token in the token stream
    */
   CompilationUnit(this.beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, this.endToken) {
     this._directives = new NodeList<Directive>(this);
     this._declarations = new NodeList<CompilationUnitMember>(this);
     this._scriptTag = becomeParentOf(scriptTag);
     this._directives.addAll(directives);
     this._declarations.addAll(declarations);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitCompilationUnit(this);
+  accept(AstVisitor visitor) => visitor.visitCompilationUnit(this);
 
   /**
    * Return the declarations contained in this compilation unit.
    *
    * @return the declarations contained in this compilation unit
    */
   NodeList<CompilationUnitMember> get declarations => _declarations;
 
   /**
    * Return the directives contained in this compilation unit.
@@ skipping 22 matching lines @@
 
   /**
    * Set the script tag at the beginning of the compilation unit to the given script tag.
    *
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
   void set scriptTag(ScriptTag scriptTag) {
     this._scriptTag = becomeParentOf(scriptTag);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (directivesAreBeforeDeclarations()) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
-      for (ASTNode child in sortedDirectivesAndDeclarations) {
+      for (AstNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Return `true` if all of the directives are lexically before any declarations.
    *
    * @return `true` if all of the directives are lexically before any declarations
    */
   bool directivesAreBeforeDeclarations() {
     if (_directives.isEmpty || _declarations.isEmpty) {
       return true;
     }
     Directive lastDirective = _directives[_directives.length - 1];
     CompilationUnitMember firstDeclaration = _declarations[0];
     return lastDirective.offset < firstDeclaration.offset;
   }
 
   /**
    * Return an array containing all of the directives and declarations in this compilation unit,
    * sorted in lexical order.
    *
    * @return the directives and declarations in this compilation unit in the order in which they
    *         appeared in the original source
    */
-  List<ASTNode> get sortedDirectivesAndDeclarations {
-    List<ASTNode> childList = new List<ASTNode>();
+  List<AstNode> get sortedDirectivesAndDeclarations {
+    List<AstNode> childList = new List<AstNode>();
     childList.addAll(_directives);
     childList.addAll(_declarations);
-    List<ASTNode> children = new List.from(childList);
-    children.sort(ASTNode.LEXICAL_ORDER);
+    List<AstNode> children = new List.from(childList);
+    children.sort(AstNode.LEXICAL_ORDER);
     return children;
   }
 }
 
 /**
  * Instances of the class `CompilationUnitMember` defines the behavior common to nodes that
  * declare a name within the scope of a compilation unit.
  *
  * <pre>
  * compilationUnitMember ::=
  *     [ClassDeclaration]
  *   | [TypeAlias]
  *   | [FunctionDeclaration]
  *   | [MethodDeclaration]
  *   | [VariableDeclaration]
  *   | [VariableDeclaration]
  * </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(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 }
 
 /**
  * Instances of the class `ConditionalExpression` represent a conditional expression.
  *
  * <pre>
  * conditionalExpression ::=
  *     [Expression] '?' [Expression] ':' [Expression]
  * </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.
    */
@@ skipping 24 matching lines @@
    * @param colon the token used to separate the then expression from the else expression
    * @param elseExpression the expression that is executed if the condition evaluates to
    *          `false`
    */
   ConditionalExpression(Expression condition, this.question, Expression thenExpression, this.colon, Expression elseExpression) {
     this._condition = becomeParentOf(condition);
     this._thenExpression = becomeParentOf(thenExpression);
     this._elseExpression = becomeParentOf(elseExpression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitConditionalExpression(this);
+  accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
 
   Token get beginToken => _condition.beginToken;
 
   /**
    * Return the condition used to determine which of the expressions is executed next.
    *
    * @return the condition used to determine which expression is executed next
    */
   Expression get condition => _condition;
 
@@ skipping 38 matching lines @@
   /**
    * Set the expression that is executed if the condition evaluates to `true` to the given
    * expression.
    *
    * @param expression the expression that is executed if the condition evaluates to `true`
    */
   void set thenExpression(Expression expression) {
     _thenExpression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenExpression, visitor);
     safelyVisitChild(_elseExpression, visitor);
   }
 }
 
 /**
  * Instances of the class `ConstructorDeclaration` represent a constructor declaration.
  *
  * <pre>
  * constructorDeclaration ::=
  *     constructorSignature [FunctionBody]?
  *   | constructorName formalParameterList ':' 'this' ('.' [SimpleIdentifier])? arguments
  *
  * constructorSignature ::=
  *     'external'? constructorName formalParameterList initializerList?
  *   | 'external'? 'factory' factoryName formalParameterList initializerList?
  *   | 'external'? 'const'  constructorName formalParameterList initializerList?
  *
  * constructorName ::=
  *     [SimpleIdentifier] ('.' [SimpleIdentifier])?
  *
  * factoryName ::=
  *     [Identifier] ('.' [SimpleIdentifier])?
  *
  * initializerList ::=
  *     ':' [ConstructorInitializer] (',' [ConstructorInitializer])*
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ConstructorDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or `null` if the constructor is not external.
    */
   Token externalKeyword;
 
   /**
    * The token for the 'const' keyword, or `null` if the constructor is not a const
    * constructor.
@@ skipping 77 matching lines @@
   ConstructorDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, this.constKeyword, this.factoryKeyword, Identifier returnType, this.period, SimpleIdentifier name, FormalParameterList parameters, this.separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body) : super(comment, metadata) {
     this._initializers = new NodeList<ConstructorInitializer>(this);
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._initializers.addAll(initializers);
     this._redirectedConstructor = becomeParentOf(redirectedConstructor);
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitConstructorDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitConstructorDeclaration(this);
 
   /**
    * Return the body of the constructor, or `null` if the constructor does not have a body.
    *
    * @return the body of the constructor
    */
   FunctionBody get body => _body;
 
   Token get endToken {
     if (_body != null) {
@@ skipping 83 matching lines @@
 
   /**
    * Set the type of object being created to the given type name.
    *
    * @param typeName the type of object being created
    */
   void set returnType(Identifier typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     _initializers.accept(visitor);
     safelyVisitChild(_redirectedConstructor, visitor);
     safelyVisitChild(_body, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 24 matching lines @@
 }
 
 /**
  * Instances of the class `ConstructorFieldInitializer` represent the initialization of a
  * field within a constructor's initialization list.
  *
  * <pre>
  * fieldInitializer ::=
  *     ('this' '.')? [SimpleIdentifier] '=' [Expression]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ConstructorFieldInitializer extends ConstructorInitializer {
   /**
    * The token for the 'this' keyword, or `null` if there is no 'this' keyword.
    */
   Token keyword;
 
   /**
    * The token for the period after the 'this' keyword, or `null` if there is no 'this'
    * keyword.
@@ skipping 23 matching lines @@
    * @param period the token for the period after the 'this' keyword
    * @param fieldName the name of the field being initialized
    * @param equals the token for the equal sign between the field name and the expression
    * @param expression the expression computing the value to which the field will be initialized
    */
   ConstructorFieldInitializer(this.keyword, this.period, SimpleIdentifier fieldName, this.equals, Expression expression) {
     this._fieldName = becomeParentOf(fieldName);
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
+  accept(AstVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
 
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
     return _fieldName.beginToken;
   }
 
   Token get endToken => _expression.endToken;
 
@@ skipping 23 matching lines @@
 
   /**
    * Set the name of the field being initialized to the given identifier.
    *
    * @param identifier the name of the field being initialized
    */
   void set fieldName(SimpleIdentifier identifier) {
     _fieldName = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_fieldName, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ConstructorInitializer` defines the behavior of nodes that can
  * occur in the initializer list of a constructor declaration.
  *
  * <pre>
  * constructorInitializer ::=
  *     [SuperConstructorInvocation]
  *   | [ConstructorFieldInitializer]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class ConstructorInitializer extends ASTNode {
+abstract class ConstructorInitializer extends AstNode {
 }
 
 /**
  * Instances of the class `ConstructorName` represent the name of the constructor.
  *
  * <pre>
  * constructorName:
  *     type ('.' identifier)?
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class ConstructorName extends ASTNode {
+class ConstructorName extends AstNode {
   /**
    * The name of the type defining the constructor.
    */
   TypeName _type;
 
   /**
    * The token for the period before the constructor name, or `null` if the specified
    * constructor is the unnamed constructor.
    */
   Token period;
@@ skipping 16 matching lines @@
    *
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
   ConstructorName(TypeName type, this.period, SimpleIdentifier name) {
     this._type = becomeParentOf(type);
     this._name = becomeParentOf(name);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitConstructorName(this);
+  accept(AstVisitor visitor) => visitor.visitConstructorName(this);
 
   Token get beginToken => _type.beginToken;
 
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
@@ skipping 42 matching lines @@
 
   /**
    * Set the name of the type defining the constructor to the given type name.
    *
    * @param type the name of the type defining the constructor
    */
   void set type(TypeName type) {
     this._type = becomeParentOf(type);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * Instances of the class `ContinueStatement` represent a continue statement.
  *
  * <pre>
  * continueStatement ::=
  *     'continue' [SimpleIdentifier]? ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ContinueStatement extends Statement {
   /**
    * The token representing the 'continue' keyword.
    */
   Token keyword;
 
   /**
    * The label associated with the statement, or `null` if there is no label.
    */
   SimpleIdentifier _label;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created continue statement.
    *
    * @param keyword the token representing the 'continue' keyword
    * @param label the label associated with the statement
    * @param semicolon the semicolon terminating the statement
    */
   ContinueStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
     this._label = becomeParentOf(label);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitContinueStatement(this);
+  accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => semicolon;
 
   /**
    * Return the label associated with the statement, or `null` if there is no label.
    *
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label associated with the statement to the given label.
    *
    * @param identifier the label associated with the statement
    */
   void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * The abstract class `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(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 
   /**
    * Return the element associated with this declaration, or `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 `DeclaredIdentifier` represent the declaration of a single
  * identifier.
  *
  * <pre>
  * declaredIdentifier ::=
  *     ([Annotation] finalConstVarOrType [SimpleIdentifier]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class DeclaredIdentifier extends Declaration {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter does not have
@@ skipping 13 matching lines @@
    * @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, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata) {
     this._type = becomeParentOf(type);
     this._identifier = becomeParentOf(identifier);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitDeclaredIdentifier(this);
+  accept(AstVisitor visitor) => visitor.visitDeclaredIdentifier(this);
 
   LocalVariableElement get element {
     SimpleIdentifier identifier = this.identifier;
     if (identifier == null) {
       return null;
     }
     return identifier.staticElement as LocalVariableElement;
   }
 
   Token get endToken => _identifier.endToken;
@@ skipping 31 matching lines @@
 
   /**
    * 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 visitor) {
+  void visitChildren(AstVisitor 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 `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 ::=
  *     [NormalFormalParameter] ('=' [Expression])?
  *
  * defaultNamedParameter ::=
  *     [NormalFormalParameter] (':' [Expression])?
  * </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.
    */
@@ skipping 17 matching lines @@
    * @param parameter the formal parameter with which the default value is associated
    * @param kind the kind of this parameter
    * @param separator the token separating the parameter from the default value
    * @param defaultValue the expression computing the default value for the parameter
    */
   DefaultFormalParameter(NormalFormalParameter parameter, this.kind, this.separator, Expression defaultValue) {
     this._parameter = becomeParentOf(parameter);
     this._defaultValue = becomeParentOf(defaultValue);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitDefaultFormalParameter(this);
+  accept(AstVisitor visitor) => visitor.visitDefaultFormalParameter(this);
 
   Token get beginToken => _parameter.beginToken;
 
   /**
    * Return the expression computing the default value for the parameter, or `null` if there
    * is no default value.
    *
    * @return the expression computing the default value for the parameter
    */
   Expression get defaultValue => _defaultValue;
@@ skipping 29 matching lines @@
 
   /**
    * Set the formal parameter with which the default value is associated to the given parameter.
    *
    * @param formalParameter the formal parameter with which the default value is associated
    */
   void set parameter(NormalFormalParameter formalParameter) {
     _parameter = becomeParentOf(formalParameter);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 
 /**
  * The abstract class `Directive` defines the behavior common to nodes that represent a
  * directive.
  *
  * <pre>
  * directive ::=
  *     [ExportDirective]
  *   | [ImportDirective]
  *   | [LibraryDirective]
  *   | [PartDirective]
  *   | [PartOfDirective]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 abstract class Directive extends AnnotatedNode {
   /**
    * The element associated with this directive, or `null` if the AST structure has not been
    * resolved or if this directive could not be resolved.
    */
   Element _element;
 
   /**
    * Initialize a newly create directive.
@@ skipping 30 matching lines @@
   }
 }
 
 /**
  * Instances of the class `DoStatement` represent a do statement.
  *
  * <pre>
  * doStatement ::=
  *     'do' [Statement] 'while' '(' [Expression] ')' ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class DoStatement extends Statement {
   /**
    * The token representing the 'do' keyword.
    */
   Token doKeyword;
 
   /**
    * The body of the loop.
    */
@@ skipping 35 matching lines @@
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
   DoStatement(this.doKeyword, Statement body, this.whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, this.semicolon) {
     this._body = becomeParentOf(body);
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitDoStatement(this);
+  accept(AstVisitor visitor) => visitor.visitDoStatement(this);
 
   Token get beginToken => doKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
@@ skipping 49 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_body, visitor);
     safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
  * Instances of the class `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;
 
   /**
    * Initialize a newly created floating point literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   DoubleLiteral(this.literal, this.value);
 
-  accept(ASTVisitor visitor) => visitor.visitDoubleLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitDoubleLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `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
    */
   EmptyFunctionBody(this.semicolon);
 
-  accept(ASTVisitor visitor) => visitor.visitEmptyFunctionBody(this);
+  accept(AstVisitor visitor) => visitor.visitEmptyFunctionBody(this);
 
   Token get beginToken => semicolon;
 
   Token get endToken => semicolon;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `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
    */
   EmptyStatement(this.semicolon);
 
-  accept(ASTVisitor visitor) => visitor.visitEmptyStatement(this);
+  accept(AstVisitor visitor) => visitor.visitEmptyStatement(this);
 
   Token get beginToken => semicolon;
 
   Token get endToken => semicolon;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
- *
- * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
-  EphemeralIdentifier(ASTNode parent, int location) : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
+  EphemeralIdentifier(AstNode parent, int location) : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
     parent.becomeParentOf(this);
   }
 }
 
 /**
  * Instances of the class `ExportDirective` represent an export directive.
  *
  * <pre>
  * exportDirective ::=
  *     [Annotation] 'export' [StringLiteral] [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
    */
   ExportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
 
-  accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
+  accept(AstVisitor visitor) => visitor.visitExportDirective(this);
 
   LibraryElement get uriElement {
     Element element = this.element;
     if (element is ExportElement) {
       return element.exportedLibrary;
     }
     return null;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `Expression` defines the behavior common to nodes that represent an
  * expression.
  *
  * <pre>
  * expression ::=
  *     [AssignmentExpression]
  *   | [ConditionalExpression] cascadeSection*
  *   | [ThrowExpression]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class Expression extends ASTNode {
+abstract class Expression extends AstNode {
   /**
    * An empty array of expressions.
    */
   static List<Expression> EMPTY_ARRAY = new List<Expression>(0);
 
   /**
    * The static type of this expression, or `null` if the AST structure has not been resolved.
    */
   Type2 staticType;
 
@@ skipping 53 matching lines @@
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on propagated type information, and this
    * expression corresponds to one of the parameters of the function being invoked, then return the
    * parameter element representing the parameter to which the value of this expression will be
    * bound. Otherwise, return `null`.
    *
    * @return the parameter element representing the parameter to which the value of this expression
    *         will be bound
    */
   ParameterElement get propagatedParameterElement {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is ArgumentList) {
       return parent.getPropagatedParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent;
       if (identical(indexExpression.index, this)) {
         return indexExpression.propagatedParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent;
       if (identical(binaryExpression.rightOperand, this)) {
@@ skipping 16 matching lines @@
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on static type information, and this expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of this expression will be bound.
    * Otherwise, return `null`.
    *
    * @return the parameter element representing the parameter to which the value of this expression
    *         will be bound
    */
   ParameterElement get staticParameterElement {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is ArgumentList) {
       return parent.getStaticParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent;
       if (identical(indexExpression.index, this)) {
         return indexExpression.staticParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent;
       if (identical(binaryExpression.rightOperand, this)) {
@@ skipping 22 matching lines @@
 }
 
 /**
  * Instances of the class `ExpressionFunctionBody` represent a function body consisting of a
  * single expression.
  *
  * <pre>
  * expressionFunctionBody ::=
  *     '=>' [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;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
    * @param functionDefinition the token introducing the expression that represents the body of the
    *          function
    * @param expression the expression representing the body of the function
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionFunctionBody(this.functionDefinition, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitExpressionFunctionBody(this);
+  accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
 
   Token get beginToken => functionDefinition;
 
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression representing the body of the function.
    *
    * @return the expression representing the body of the function
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression representing the body of the function to the given expression.
    *
    * @param expression the expression representing the body of the function
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ExpressionStatement` wrap an expression as a statement.
  *
  * <pre>
  * expressionStatement ::=
  *     [Expression]? ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ExpressionStatement extends Statement {
   /**
    * The expression that comprises the statement.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement, or `null` if the expression is a function
    * expression and therefore isn't followed by a semicolon.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created expression statement.
    *
    * @param expression the expression that comprises the statement
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionStatement(Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitExpressionStatement(this);
+  accept(AstVisitor visitor) => visitor.visitExpressionStatement(this);
 
   Token get beginToken => _expression.beginToken;
 
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression that comprises the statement.
    *
    * @return the expression that comprises the statement
    */
   Expression get expression => _expression;
 
   bool get isSynthetic => _expression.isSynthetic && semicolon.isSynthetic;
 
   /**
    * Set the expression that comprises the statement to the given expression.
    *
    * @param expression the expression that comprises the statement
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ExtendsClause` represent the "extends" clause in a class
  * declaration.
  *
  * <pre>
  * extendsClause ::=
  *     'extends' [TypeName]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class ExtendsClause extends ASTNode {
+class ExtendsClause extends AstNode {
   /**
    * The token representing the 'extends' keyword.
    */
   Token keyword;
 
   /**
    * The name of the class that is being extended.
    */
   TypeName _superclass;
 
   /**
    * Initialize a newly created extends clause.
    *
    * @param keyword the token representing the 'extends' keyword
    * @param superclass the name of the class that is being extended
    */
   ExtendsClause(this.keyword, TypeName superclass) {
     this._superclass = becomeParentOf(superclass);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitExtendsClause(this);
+  accept(AstVisitor visitor) => visitor.visitExtendsClause(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => _superclass.endToken;
 
   /**
    * 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 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 visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_superclass, visitor);
   }
 }
 
 /**
  * Instances of the class `FieldDeclaration` represent the declaration of one or more fields
  * of the same type.
  *
  * <pre>
  * fieldDeclaration ::=
  *     'static'? [VariableDeclarationList] ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class FieldDeclaration extends ClassMember {
   /**
    * The token representing the 'static' keyword, or `null` if the fields are not static.
    */
   Token staticKeyword;
 
   /**
    * The fields being declared.
    */
@@ skipping 10 matching lines @@
    * @param comment the documentation comment associated with this field
    * @param metadata the annotations associated with this field
    * @param staticKeyword the token representing the 'static' keyword
    * @param fieldList the fields being declared
    * @param semicolon the semicolon terminating the declaration
    */
   FieldDeclaration(Comment comment, List<Annotation> metadata, this.staticKeyword, VariableDeclarationList fieldList, this.semicolon) : super(comment, metadata) {
     this._fieldList = becomeParentOf(fieldList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFieldDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitFieldDeclaration(this);
 
   Element get element => null;
 
   Token get endToken => semicolon;
 
   /**
    * Return the fields being declared.
    *
    * @return the fields being declared
    */
   VariableDeclarationList get fields => _fieldList;
 
   /**
    * Return `true` if the fields are static.
    *
    * @return `true` if the fields are declared to be static
    */
   bool get isStatic => staticKeyword != null;
 
   /**
    * 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);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (staticKeyword != null) {
       return staticKeyword;
     }
     return _fieldList.beginToken;
   }
 }
 
 /**
  * Instances of the class `FieldFormalParameter` represent a field formal parameter.
  *
  * <pre>
  * fieldFormalParameter ::=
  *     ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])? 'this' '.' [SimpleIdentifier] [FormalParameterList]?
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class FieldFormalParameter extends NormalFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter does not have
@@ skipping 28 matching lines @@
    * @param period the token representing the period
    * @param identifier the name of the parameter being declared
    * @param parameters the parameters of the function-typed parameter, or `null` if this is
    *          not a function-typed field formal parameter
    */
   FieldFormalParameter(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, this.thisToken, this.period, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
     this._type = becomeParentOf(type);
     this._parameters = becomeParentOf(parameters);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFieldFormalParameter(this);
+  accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return thisToken;
   }
 
@@ skipping 31 matching lines @@
 
   /**
    * 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 visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `ForEachStatement` represent a for-each statement.
  *
  * <pre>
  * forEachStatement ::=
  *     'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
  *   | 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ForEachStatement extends Statement {
   /**
    * The token representing the 'for' keyword.
    */
   Token forKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 55 matching lines @@
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   ForEachStatement.con2(this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
     this._identifier = becomeParentOf(identifier);
     this._iterator = becomeParentOf(iterator);
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitForEachStatement(this);
+  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;
 
@@ skipping 50 matching lines @@
 
   /**
    * Set the declaration of the loop variable to the given variable.
    *
    * @param variable the declaration of the loop variable
    */
   void set loopVariable(DeclaredIdentifier variable) {
     _loopVariable = becomeParentOf(variable);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_loopVariable, visitor);
     safelyVisitChild(_identifier, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `ForStatement` represent a for statement.
  *
  * <pre>
  * forStatement ::=
  *     'for' '(' forLoopParts ')' [Statement]
  *
  * forLoopParts ::=
  *     forInitializerStatement ';' [Expression]? ';' [Expression]?
  *
  * forInitializerStatement ::=
  *     [DefaultFormalParameter]
  *   | [Expression]?
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ForStatement extends Statement {
   /**
    * The token representing the 'for' keyword.
    */
   Token forKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 60 matching lines @@
    */
   ForStatement(this.forKeyword, this.leftParenthesis, VariableDeclarationList variableList, Expression initialization, this.leftSeparator, Expression condition, this.rightSeparator, List<Expression> updaters, this.rightParenthesis, Statement body) {
     this._updaters = new NodeList<Expression>(this);
     this._variableList = becomeParentOf(variableList);
     this._initialization = becomeParentOf(initialization);
     this._condition = becomeParentOf(condition);
     this._updaters.addAll(updaters);
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitForStatement(this);
+  accept(AstVisitor visitor) => visitor.visitForStatement(this);
 
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
@@ skipping 57 matching lines @@
 
   /**
    * Set the declaration of the loop variables to the given parameter.
    *
    * @param variableList the declaration of the loop variables
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * The abstract class `FormalParameter` defines the behavior of objects representing a
  * parameter to a function.
  *
  * <pre>
  * formalParameter ::=
  *     [NormalFormalParameter]
  *   | [DefaultFormalParameter]
  *   | [DefaultFormalParameter]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class FormalParameter extends ASTNode {
+abstract class FormalParameter extends AstNode {
   /**
    * Return the element representing this parameter, or `null` if this parameter has not been
    * resolved.
    *
    * @return the element representing this parameter
    */
   ParameterElement get element {
     SimpleIdentifier identifier = this.identifier;
     if (identifier == null) {
       return null;
@@ skipping 53 matching lines @@
  * optionalFormalParameters ::=
  *     optionalPositionalFormalParameters
  *   | namedFormalParameters
  *
  * optionalPositionalFormalParameters ::=
  *     '[' [DefaultFormalParameter] (',' [DefaultFormalParameter])* ']'
  *
  * namedFormalParameters ::=
  *     '{' [DefaultFormalParameter] (',' [DefaultFormalParameter])* '}'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class FormalParameterList extends ASTNode {
+class FormalParameterList extends AstNode {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The parameters associated with the method.
    */
   NodeList<FormalParameter> _parameters;
 
@@ skipping 25 matching lines @@
    */
   FormalParameterList(Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis) {
     this._parameters = new NodeList<FormalParameter>(this);
     this._leftParenthesis = leftParenthesis;
     this._parameters.addAll(parameters);
     this._leftDelimiter = leftDelimiter;
     this._rightDelimiter = rightDelimiter;
     this._rightParenthesis = rightParenthesis;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFormalParameterList(this);
+  accept(AstVisitor visitor) => visitor.visitFormalParameterList(this);
 
   Token get beginToken => _leftParenthesis;
 
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the left square bracket ('[') or left curly brace ('{') introducing the optional
    * parameters, or `null` if there are no optional parameters.
    *
    * @return the left square bracket ('[') or left curly brace ('{') introducing the optional
@@ skipping 77 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _parameters.accept(visitor);
   }
 }
 
 /**
  * The abstract class `FunctionBody` defines the behavior common to objects representing the
  * body of a function or method.
  *
  * <pre>
  * functionBody ::=
  *     [BlockFunctionBody]
  *   | [EmptyFunctionBody]
  *   | [ExpressionFunctionBody]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class FunctionBody extends ASTNode {
+abstract class FunctionBody extends AstNode {
 }
 
 /**
  * Instances of the class `FunctionDeclaration` wrap a [FunctionExpression] as a top-level declaration.
  *
  * <pre>
  * functionDeclaration ::=
  *     'external' functionSignature
  *   | functionSignature [FunctionBody]
  *
  * functionSignature ::=
  *     [Type]? ('get' | 'set')? [SimpleIdentifier] [FormalParameterList]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class FunctionDeclaration extends CompilationUnitMember {
   /**
    * The token representing the 'external' keyword, or `null` if this is not an external
    * function.
    */
   Token externalKeyword;
 
   /**
    * The return type of the function, or `null` if no return type was declared.
@@ skipping 26 matching lines @@
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param name the name of the function
    * @param functionExpression the function expression being wrapped
    */
   FunctionDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, TypeName returnType, this.propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super(comment, metadata) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._functionExpression = becomeParentOf(functionExpression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFunctionDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
   ExecutableElement get element => _name != null ? (_name.staticElement as ExecutableElement) : null;
 
   Token get endToken => _functionExpression.endToken;
 
   /**
    * Return the function expression being wrapped.
    *
    * @return the function expression being wrapped
    */
@@ skipping 47 matching lines @@
 
   /**
    * Set the return type of the function to the given name.
    *
    * @param name the return type of the function
    */
   void set returnType(TypeName name) {
     _returnType = becomeParentOf(name);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_functionExpression, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (externalKeyword != null) {
       return externalKeyword;
     }
     if (_returnType != null) {
       return _returnType.beginToken;
     } else if (propertyKeyword != null) {
       return propertyKeyword;
     } else if (_name != null) {
       return _name.beginToken;
     }
     return _functionExpression.beginToken;
   }
 }
 
 /**
  * Instances of the class `FunctionDeclarationStatement` wrap a [FunctionDeclaration
  ] 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
    */
   FunctionDeclarationStatement(FunctionDeclaration functionDeclaration) {
     this._functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
+  accept(AstVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
 
   Token get beginToken => _functionDeclaration.beginToken;
 
   Token get endToken => _functionDeclaration.endToken;
 
   /**
    * Return the function declaration being wrapped.
    *
    * @return the function declaration being wrapped
    */
   FunctionDeclaration get functionDeclaration => _functionDeclaration;
 
   /**
    * Set the function declaration being wrapped to the given function declaration.
    *
    * @param functionDeclaration the function declaration being wrapped
    */
   void set functionExpression(FunctionDeclaration functionDeclaration) {
     this._functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionExpression` represent a function expression.
  *
  * <pre>
  * functionExpression ::=
  *     [FormalParameterList] [FunctionBody]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class FunctionExpression extends Expression {
   /**
    * The parameters associated with the function.
    */
   FormalParameterList _parameters;
 
   /**
    * The body of the function, or `null` if this is an external function.
    */
   FunctionBody _body;
 
   /**
    * The element associated with the function, or `null` if the AST structure has not been
    * resolved.
    */
   ExecutableElement element;
 
   /**
    * Initialize a newly created function declaration.
    *
    * @param parameters the parameters associated with the function
    * @param body the body of the function
    */
   FunctionExpression(FormalParameterList parameters, FunctionBody body) {
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFunctionExpression(this);
+  accept(AstVisitor visitor) => visitor.visitFunctionExpression(this);
 
   Token get beginToken {
     if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
       return _body.beginToken;
     }
     // This should never be reached because external functions must be named, hence either the body
     // or the name should be non-null.
     throw new IllegalStateException("Non-external functions must have a body");
@@ skipping 37 matching lines @@
 
   /**
    * Set the parameters associated with the function to the given list of parameters.
    *
    * @param parameters the parameters associated with the function
    */
   void set parameters(FormalParameterList parameters) {
     this._parameters = becomeParentOf(parameters);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionExpressionInvocation` represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
  * functions are represented by [MethodInvocation] nodes. Invocations of
  * getters and setters are represented by either [PrefixedIdentifier] or
  * [PropertyAccess] nodes.
  *
  * <pre>
  * functionExpressionInvoction ::=
  *     [Expression] [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.
    */
@@ skipping 15 matching lines @@
    * Initialize a newly created function expression invocation.
    *
    * @param function the expression producing the function being invoked
    * @param argumentList the list of arguments to the method
    */
   FunctionExpressionInvocation(Expression function, ArgumentList argumentList) {
     this._function = becomeParentOf(function);
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
+  accept(AstVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => _function.beginToken;
 
@@ skipping 55 matching lines @@
   /**
    * Set the element associated with the function being invoked based on propagated type information
    * to the given element.
    *
    * @param element the element to be associated with the function being invoked
    */
   void set propagatedElement(ExecutableElement element) {
     _propagatedElement = element;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionTypeAlias` represent a function type alias.
  *
  * <pre>
  * functionTypeAlias ::=
  *      functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  *
  * functionPrefix ::=
  *     [TypeName]? [SimpleIdentifier]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class FunctionTypeAlias extends TypeAlias {
   /**
    * The name of the return type of the function type being defined, or `null` if no return
    * type was given.
    */
   TypeName _returnType;
 
   /**
    * The name of the function type being declared.
@@ skipping 23 matching lines @@
    * @param parameters the parameters associated with the function
    * @param semicolon the semicolon terminating the declaration
    */
   FunctionTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, TypeName returnType, SimpleIdentifier name, TypeParameterList typeParameters, FormalParameterList parameters, Token semicolon) : super(comment, metadata, keyword, semicolon) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
     this._parameters = becomeParentOf(parameters);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFunctionTypeAlias(this);
+  accept(AstVisitor visitor) => visitor.visitFunctionTypeAlias(this);
 
   FunctionTypeAliasElement get element => _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
    * Return the name of the function type being declared.
    *
    * @return the name of the function type being declared
    */
   SimpleIdentifier get name => _name;
 
@@ skipping 49 matching lines @@
 
   /**
    * Set the type parameters for the function type to the given list of parameters.
    *
    * @param typeParameters the type parameters for the function type
    */
   void set typeParameters(TypeParameterList typeParameters) {
     this._typeParameters = becomeParentOf(typeParameters);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionTypedFormalParameter` represent a function-typed formal
  * parameter.
  *
  * <pre>
  * functionSignature ::=
  *     [TypeName]? [SimpleIdentifier] [FormalParameterList]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class FunctionTypedFormalParameter extends NormalFormalParameter {
   /**
    * The return type of the function, or `null` if the function does not have a return type.
    */
   TypeName _returnType;
 
   /**
    * The parameters of the function-typed parameter.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param returnType the return type of the function, or `null` if the function does not
    *          have a return type
    * @param identifier the name of the function-typed parameter
    * @param parameters the parameters of the function-typed parameter
    */
   FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
     this._returnType = becomeParentOf(returnType);
     this._parameters = becomeParentOf(parameters);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
+  accept(AstVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
 
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
 
   Token get endToken => _parameters.endToken;
 
@@ skipping 27 matching lines @@
 
   /**
    * Set the return type of the function to the given type.
    *
    * @param returnType the return type of the function
    */
   void set returnType(TypeName returnType) {
     this._returnType = becomeParentOf(returnType);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `HideCombinator` represent a combinator that restricts the names
  * being imported to those that are not in a given list.
  *
  * <pre>
  * hideCombinator ::=
  *     'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  * </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
    */
   HideCombinator(Token keyword, List<SimpleIdentifier> hiddenNames) : super(keyword) {
     this._hiddenNames = new NodeList<SimpleIdentifier>(this);
     this._hiddenNames.addAll(hiddenNames);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitHideCombinator(this);
+  accept(AstVisitor visitor) => visitor.visitHideCombinator(this);
 
   Token get endToken => _hiddenNames.endToken;
 
   /**
    * Return the list of names from the library that are hidden by this combinator.
    *
    * @return the list of names from the library that are hidden by this combinator
    */
   NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _hiddenNames.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Identifier` defines the behavior common to nodes that represent an
  * identifier.
  *
  * <pre>
  * identifier ::=
  *     [SimpleIdentifier]
  *   | [PrefixedIdentifier]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 abstract class Identifier extends Expression {
   /**
    * Return `true` if the given name is visible only within the library in which it is
    * declared.
    *
    * @param name the name being tested
    * @return `true` if the given name is private
    */
   static bool isPrivateName(String name) => StringUtilities.startsWithChar(name, 0x5F);
@@ skipping 38 matching lines @@
   bool get isAssignable => true;
 }
 
 /**
  * Instances of the class `IfStatement` represent an if statement.
  *
  * <pre>
  * ifStatement ::=
  *     'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class IfStatement extends Statement {
   /**
    * The token representing the 'if' keyword.
    */
   Token ifKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 35 matching lines @@
    * @param thenStatement the statement that is executed if the condition evaluates to `true`
    * @param elseKeyword the token representing the 'else' keyword
    * @param elseStatement the statement that is executed if the condition evaluates to `false`
    */
   IfStatement(this.ifKeyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement thenStatement, this.elseKeyword, Statement elseStatement) {
     this._condition = becomeParentOf(condition);
     this._thenStatement = becomeParentOf(thenStatement);
     this._elseStatement = becomeParentOf(elseStatement);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitIfStatement(this);
+  accept(AstVisitor visitor) => visitor.visitIfStatement(this);
 
   Token get beginToken => ifKeyword;
 
   /**
    * Return the condition used to determine which of the statements is executed next.
    *
    * @return the condition used to determine which statement is executed next
    */
   Expression get condition => _condition;
 
@@ skipping 42 matching lines @@
   /**
    * Set the statement that is executed if the condition evaluates to `true` to the given
    * statement.
    *
    * @param statement the statement that is executed if the condition evaluates to `true`
    */
   void set thenStatement(Statement statement) {
     _thenStatement = becomeParentOf(statement);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenStatement, visitor);
     safelyVisitChild(_elseStatement, visitor);
   }
 }
 
 /**
  * Instances of the class `ImplementsClause` represent the "implements" clause in an class
  * declaration.
  *
  * <pre>
  * implementsClause ::=
  *     'implements' [TypeName] (',' [TypeName])*
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class ImplementsClause extends ASTNode {
+class ImplementsClause extends AstNode {
   /**
    * The token representing the 'implements' keyword.
    */
   Token keyword;
 
   /**
    * The interfaces that are being implemented.
    */
   NodeList<TypeName> _interfaces;
 
   /**
    * Initialize a newly created implements clause.
    *
    * @param keyword the token representing the 'implements' keyword
    * @param interfaces the interfaces that are being implemented
    */
   ImplementsClause(this.keyword, List<TypeName> interfaces) {
     this._interfaces = new NodeList<TypeName>(this);
     this._interfaces.addAll(interfaces);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitImplementsClause(this);
+  accept(AstVisitor visitor) => visitor.visitImplementsClause(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => _interfaces.endToken;
 
   /**
    * Return the list of the interfaces that are being implemented.
    *
    * @return the list of the interfaces that are being implemented
    */
   NodeList<TypeName> get interfaces => _interfaces;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _interfaces.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `ImportDirective` represent an import directive.
  *
  * <pre>
  * importDirective ::=
  *     [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ImportDirective extends NamespaceDirective {
   static Comparator<ImportDirective> COMPARATOR = (ImportDirective import1, ImportDirective import2) {
     //
     // uri
     //
     StringLiteral uri1 = import1.uri;
     StringLiteral uri2 = import2.uri;
     String uriStr1 = uri1.stringValue;
     String uriStr2 = uri2.stringValue;
@@ skipping 100 matching lines @@
    * @param libraryUri the URI of the library being imported
    * @param asToken the token representing the 'as' token
    * @param prefix the prefix to be used with the imported names
    * @param combinators the combinators used to control how names are imported
    * @param semicolon the semicolon terminating the directive
    */
   ImportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, this.asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
     this._prefix = becomeParentOf(prefix);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitImportDirective(this);
+  accept(AstVisitor visitor) => visitor.visitImportDirective(this);
 
   ImportElement get element => super.element as ImportElement;
 
   /**
    * Return the prefix to be used with the imported names, or `null` if the imported names are
    * not prefixed.
    *
    * @return the prefix to be used with the imported names
    */
   SimpleIdentifier get prefix => _prefix;
 
   LibraryElement get uriElement {
     ImportElement element = this.element;
     if (element == null) {
       return null;
     }
     return element.importedLibrary;
   }
 
   /**
    * Set the prefix to be used with the imported names to the given identifier.
    *
    * @param prefix the prefix to be used with the imported names
    */
   void set prefix(SimpleIdentifier prefix) {
     this._prefix = becomeParentOf(prefix);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `IndexExpression` represent an index expression.
  *
  * <pre>
  * indexExpression ::=
  *     [Expression] '[' [Expression] ']'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class IndexExpression extends Expression {
   /**
    * The expression used to compute the object being indexed, or `null` if this index
    * expression is part of a cascade expression.
    */
   Expression _target;
 
   /**
    * The period ("..") before a cascaded index expression, or `null` if this index expression
@@ skipping 59 matching lines @@
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forCascade(this.period, Token leftBracket, Expression index, Token rightBracket) {
     this._leftBracket = leftBracket;
     this._index = becomeParentOf(index);
     this._rightBracket = rightBracket;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
+  accept(AstVisitor visitor) => visitor.visitIndexExpression(this);
 
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return period;
   }
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
@@ skipping 43 matching lines @@
    * Return the expression used to compute the object being indexed. If this index expression is not
    * part of a cascade expression, then this is the same as [getTarget]. If this index
    * expression is part of a cascade expression, then the target expression stored with the cascade
    * expression is returned.
    *
    * @return the expression used to compute the object being indexed
    * @see #getTarget()
    */
   Expression get realTarget {
     if (isCascaded) {
-      ASTNode ancestor = parent;
+      AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
@@ skipping 27 matching lines @@
   /**
    * Return `true` if this expression is computing a right-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where the operator '[]' will be invoked
    */
   bool inGetterContext() {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is AssignmentExpression) {
       AssignmentExpression assignment = parent;
       if (identical(assignment.leftHandSide, this) && identical(assignment.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Return `true` if this expression is computing a left-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where the operator '[]=' will be
    *         invoked
    */
   bool inSetterContext() {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is PrefixExpression) {
       return parent.operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(parent.leftHandSide, this);
     }
     return false;
   }
 
@@ skipping 57 matching lines @@
 
   /**
    * Set the expression used to compute the object being indexed to the given expression.
    *
    * @param expression the expression used to compute the object being indexed
    */
   void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the index expression will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 35 matching lines @@
 }
 
 /**
  * Instances of the class `InstanceCreationExpression` represent an instance creation
  * expression.
  *
  * <pre>
  * newExpression ::=
  *     ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [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.
    */
@@ skipping 15 matching lines @@
    *
    * @param keyword the keyword used to indicate how an object should be created
    * @param constructorName the name of the constructor to be invoked
    * @param argumentList the list of arguments to the constructor
    */
   InstanceCreationExpression(this.keyword, ConstructorName constructorName, ArgumentList argumentList) {
     this.constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitInstanceCreationExpression(this);
+  accept(AstVisitor visitor) => visitor.visitInstanceCreationExpression(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
 
@@ skipping 10 matching lines @@
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList) {
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `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;
 
   /**
    * Initialize a newly created integer literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   IntegerLiteral(this.literal, this.value);
 
-  accept(ASTVisitor visitor) => visitor.visitIntegerLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitIntegerLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * The abstract class `InterpolationElement` defines the behavior common to elements within a
  * [StringInterpolation].
  *
  * <pre>
  * interpolationElement ::=
  *     [InterpolationExpression]
  *   | [InterpolationString]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class InterpolationElement extends ASTNode {
+abstract class InterpolationElement extends AstNode {
 }
 
 /**
  * Instances of the class `InterpolationExpression` represent an expression embedded in a
  * string interpolation.
  *
  * <pre>
  * interpolationExpression ::=
  *     '$' [SimpleIdentifier]
  *   | '$' '{' [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.
    */
   Expression _expression;
 
   /**
    * The right curly bracket, or `null` if the expression is an identifier without brackets.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    *
    * @param leftBracket the left curly bracket
    * @param expression the expression to be evaluated for the value to be converted into a string
    * @param rightBracket the right curly bracket
    */
   InterpolationExpression(this.leftBracket, Expression expression, this.rightBracket) {
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitInterpolationExpression(this);
+  accept(AstVisitor visitor) => visitor.visitInterpolationExpression(this);
 
   Token get beginToken => leftBracket;
 
   Token get endToken {
     if (rightBracket != null) {
       return rightBracket;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression to be evaluated for the value to be converted into a string.
    *
    * @return the expression to be evaluated for the value to be converted into a string
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression to be evaluated for the value to be converted into a string to the given
    * expression.
    *
    * @param expression the expression to be evaluated for the value to be converted into a string
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `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;
 
   /**
    * Initialize a newly created string of characters that are part of a string interpolation.
    *
    * @param the characters that will be added to the string
    * @param value the value of the literal
    */
   InterpolationString(Token contents, String value) {
     this._contents = contents;
     this._value = value;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitInterpolationString(this);
+  accept(AstVisitor visitor) => visitor.visitInterpolationString(this);
 
   Token get beginToken => _contents;
 
   /**
    * Return the characters that will be added to the string.
    *
    * @return the characters that will be added to the string
    */
   Token get contents => _contents;
 
@@ skipping 17 matching lines @@
 
   /**
    * Set the value of the literal to the given string.
    *
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = string;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `IsExpression` represent an is expression.
  *
  * <pre>
  * isExpression ::=
  *     [Expression] 'is' '!'? [TypeName]
  * </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.
    */
@@ skipping 15 matching lines @@
    * @param expression the expression used to compute the value whose type is being tested
    * @param isOperator the is operator
    * @param notOperator the not operator, or `null` if the sense of the test is not negated
    * @param type the name of the type being tested for
    */
   IsExpression(Expression expression, this.isOperator, this.notOperator, TypeName type) {
     this._expression = becomeParentOf(expression);
     this._type = becomeParentOf(type);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitIsExpression(this);
+  accept(AstVisitor visitor) => visitor.visitIsExpression(this);
 
   Token get beginToken => _expression.beginToken;
 
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    *
    * @return the expression used to compute the value whose type is being tested
    */
@@ skipping 20 matching lines @@
 
   /**
    * Set the name of the type being tested for to the given name.
    *
    * @param name the name of the type being tested for
    */
   void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 
 /**
  * Instances of the class `Label` represent a label.
  *
  * <pre>
  * label ::=
  *     [SimpleIdentifier] ':'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class Label extends ASTNode {
+class Label extends AstNode {
   /**
    * The label being associated with the statement.
    */
   SimpleIdentifier _label;
 
   /**
    * The colon that separates the label from the statement.
    */
   Token colon;
 
   /**
    * Initialize a newly created label.
    *
    * @param label the label being applied
    * @param colon the colon that separates the label from whatever follows
    */
   Label(SimpleIdentifier label, this.colon) {
     this._label = becomeParentOf(label);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitLabel(this);
+  accept(AstVisitor visitor) => visitor.visitLabel(this);
 
   Token get beginToken => _label.beginToken;
 
   Token get endToken => colon;
 
   /**
    * Return the label being associated with the statement.
    *
    * @return the label being associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label being associated with the statement to the given label.
    *
    * @param label the label being associated with the statement
    */
   void set label(SimpleIdentifier label) {
     this._label = becomeParentOf(label);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * Instances of the class `LabeledStatement` represent a statement that has a label associated
  * with them.
  *
  * <pre>
  * labeledStatement ::=
  *    [Label]+ [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;
 
   /**
    * Initialize a newly created labeled statement.
    *
    * @param labels the labels being associated with the statement
    * @param statement the statement with which the labels are being associated
    */
   LabeledStatement(List<Label> labels, Statement statement) {
     this._labels = new NodeList<Label>(this);
     this._labels.addAll(labels);
     this._statement = becomeParentOf(statement);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitLabeledStatement(this);
+  accept(AstVisitor visitor) => visitor.visitLabeledStatement(this);
 
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return _statement.beginToken;
   }
 
   Token get endToken => _statement.endToken;
 
@@ skipping 13 matching lines @@
 
   /**
    * Set the statement with which the labels are being associated to the given statement.
    *
    * @param statement the statement with which the labels are being associated
    */
   void set statement(Statement statement) {
     this._statement = becomeParentOf(statement);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 
 /**
  * Instances of the class `LibraryDirective` represent a library directive.
  *
  * <pre>
  * libraryDirective ::=
  *     [Annotation] 'library' [Identifier] ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class LibraryDirective extends Directive {
   /**
    * The token representing the 'library' token.
    */
   Token libraryToken;
 
   /**
    * The name of the library being defined.
    */
@@ skipping 10 matching lines @@
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param libraryToken the token representing the 'library' token
    * @param name the name of the library being defined
    * @param semicolon the semicolon terminating the directive
    */
   LibraryDirective(Comment comment, List<Annotation> metadata, this.libraryToken, LibraryIdentifier name, this.semicolon) : super(comment, metadata) {
     this._name = becomeParentOf(name);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitLibraryDirective(this);
+  accept(AstVisitor visitor) => visitor.visitLibraryDirective(this);
 
   Token get endToken => semicolon;
 
   Token get keyword => libraryToken;
 
   /**
    * Return the name of the library being defined.
    *
    * @return the name of the library being defined
    */
   LibraryIdentifier get name => _name;
 
   /**
    * Set the name of the library being defined to the given name.
    *
    * @param name the name of the library being defined
    */
   void set name(LibraryIdentifier name) {
     this._name = becomeParentOf(name);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata => libraryToken;
 }
 
 /**
  * Instances of the class `LibraryIdentifier` represent the identifier for a library.
  *
  * <pre>
  * libraryIdentifier ::=
  *     [SimpleIdentifier] ('.' [SimpleIdentifier])*
  * </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
    */
   LibraryIdentifier(List<SimpleIdentifier> components) {
     this._components = new NodeList<SimpleIdentifier>(this);
     this._components.addAll(components);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitLibraryIdentifier(this);
+  accept(AstVisitor visitor) => visitor.visitLibraryIdentifier(this);
 
   Token get beginToken => _components.beginToken;
 
   Element get bestElement => staticElement;
 
   /**
    * Return the components of the identifier.
    *
    * @return the components of the identifier
    */
@@ skipping 14 matching lines @@
     }
     return builder.toString();
   }
 
   int get precedence => 15;
 
   Element get propagatedElement => null;
 
   Element get staticElement => null;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _components.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `ListLiteral` represent a list literal.
  *
  * <pre>
  * listLiteral ::=
  *     'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  * </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.
    */
@@ skipping 14 matching lines @@
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super(constKeyword, typeArguments) {
     this._elements = new NodeList<Expression>(this);
     this._leftBracket = leftBracket;
     this._elements.addAll(elements);
     this._rightBracket = rightBracket;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitListLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitListLiteral(this);
 
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
@@ skipping 34 matching lines @@
 
   /**
    * Set the right square bracket to the given token.
    *
    * @param bracket the right square bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Literal` defines the behavior common to nodes that represent a literal
  * expression.
  *
  * <pre>
  * literal ::=
  *     [BooleanLiteral]
  *   | [DoubleLiteral]
  *   | [IntegerLiteral]
  *   | [ListLiteral]
  *   | [MapLiteral]
  *   | [NullLiteral]
  *   | [StringLiteral]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 abstract class Literal extends Expression {
   int get precedence => 16;
 }
 
 /**
  * Instances of the class `MapLiteral` represent a literal map.
  *
  * <pre>
  * mapLiteral ::=
  *     'const'? ('<' [TypeName] (',' [TypeName])* '>')? '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class MapLiteral extends TypedLiteral {
   /**
    * The left curly bracket.
    */
   Token _leftBracket;
 
   /**
    * The entries in the map.
    */
@@ skipping 14 matching lines @@
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super(constKeyword, typeArguments) {
     this._entries = new NodeList<MapLiteralEntry>(this);
     this._leftBracket = leftBracket;
     this._entries.addAll(entries);
     this._rightBracket = rightBracket;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitMapLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitMapLiteral(this);
 
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
@@ skipping 34 matching lines @@
 
   /**
    * Set the right curly bracket to the given token.
    *
    * @param bracket the right curly bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _entries.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `MapLiteralEntry` represent a single key/value pair in a map
  * literal.
  *
  * <pre>
  * mapLiteralEntry ::=
  *     [Expression] ':' [Expression]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class MapLiteralEntry extends ASTNode {
+class MapLiteralEntry extends AstNode {
   /**
    * The expression computing the key with which the value will be associated.
    */
   Expression _key;
 
   /**
    * The colon that separates the key from the value.
    */
   Token separator;
 
   /**
    * The expression computing the value that will be associated with the key.
    */
   Expression _value;
 
   /**
    * Initialize a newly created map literal entry.
    *
    * @param key the expression computing the key with which the value will be associated
    * @param separator the colon that separates the key from the value
    * @param value the expression computing the value that will be associated with the key
    */
   MapLiteralEntry(Expression key, this.separator, Expression value) {
     this._key = becomeParentOf(key);
     this._value = becomeParentOf(value);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitMapLiteralEntry(this);
+  accept(AstVisitor visitor) => visitor.visitMapLiteralEntry(this);
 
   Token get beginToken => _key.beginToken;
 
   Token get endToken => _value.endToken;
 
   /**
    * Return the expression computing the key with which the value will be associated.
    *
    * @return the expression computing the key with which the value will be associated
    */
@@ skipping 19 matching lines @@
   /**
    * Set the expression computing the value that will be associated with the key to the given
    * expression.
    *
    * @param expression the expression computing the value that will be associated with the key
    */
   void set value(Expression expression) {
     _value = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 
 /**
  * Instances of the class `MethodDeclaration` represent a method declaration.
  *
  * <pre>
  * methodDeclaration ::=
  *     methodSignature [FunctionBody]
  *
  * methodSignature ::=
  *     'external'? ('abstract' | 'static')? [Type]? ('get' | 'set')? methodName
  *     [FormalParameterList]
  *
  * methodName ::=
  *     [SimpleIdentifier]
  *   | 'operator' [SimpleIdentifier]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class MethodDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or `null` if the constructor is not external.
    */
   Token externalKeyword;
 
   /**
    * The token representing the 'abstract' or 'static' keyword, or `null` if neither modifier
    * was specified.
@@ skipping 47 matching lines @@
    *          declares a getter
    * @param body the body of the method
    */
   MethodDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, this.modifierKeyword, TypeName returnType, this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super(comment, metadata) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitMethodDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   /**
    * Return the body of the method.
    *
    * @return the body of the method
    */
   FunctionBody get body => _body;
 
   /**
    * Return the element associated with this method, or `null` if the AST structure has not
@@ skipping 93 matching lines @@
 
   /**
    * Set the return type of the method to the given type name.
    *
    * @param typeName the return type of the method
    */
   void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (modifierKeyword != null) {
       return modifierKeyword;
@@ skipping 12 matching lines @@
  * Instances of the class `MethodInvocation` represent the invocation of either a function or
  * a method. Invocations of functions resulting from evaluating an expression are represented by
  * [FunctionExpressionInvocation] nodes. Invocations of getters
  * and setters are represented by either [PrefixedIdentifier] or
  * [PropertyAccess] nodes.
  *
  * <pre>
  * methodInvoction ::=
  *     ([Expression] '.')? [SimpleIdentifier] [ArgumentList]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class MethodInvocation extends Expression {
   /**
    * The expression producing the object on which the method is defined, or `null` if there is
    * no target (that is, the target is implicitly `this`).
    */
   Expression _target;
 
   /**
    * The period that separates the target from the method name, or `null` if there is no
@@ skipping 18 matching lines @@
    * @param period the period that separates the target from the method name
    * @param methodName the name of the method being invoked
    * @param argumentList the list of arguments to the method
    */
   MethodInvocation(Expression target, this.period, SimpleIdentifier methodName, ArgumentList argumentList) {
     this._target = becomeParentOf(target);
     this._methodName = becomeParentOf(methodName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitMethodInvocation(this);
+  accept(AstVisitor visitor) => visitor.visitMethodInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken {
     if (_target != null) {
@@ skipping 19 matching lines @@
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    *
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
     if (isCascaded) {
-      ASTNode ancestor = parent;
+      AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
@@ skipping 37 matching lines @@
 
   /**
    * Set the expression producing the object on which the method is defined to the given expression.
    *
    * @param expression the expression producing the object on which the method is defined
    */
   void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_methodName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `NamedExpression` represent an expression that has a name associated
  * with it. They are used in method invocations when there are named parameters.
  *
  * <pre>
  * namedExpression ::=
  *     [Label] [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;
 
   /**
    * Initialize a newly created named expression.
    *
    * @param name the name associated with the expression
    * @param expression the expression with which the name is associated
    */
   NamedExpression(Label name, Expression expression) {
     this._name = becomeParentOf(name);
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitNamedExpression(this);
+  accept(AstVisitor visitor) => visitor.visitNamedExpression(this);
 
   Token get beginToken => _name.beginToken;
 
   /**
    * Return the element representing the parameter being named by this expression, or `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
    */
@@ skipping 34 matching lines @@
 
   /**
    * Set the name associated with the expression to the given identifier.
    *
    * @param identifier the name associated with the expression
    */
   void set name(Label identifier) {
     _name = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * The abstract class `NamespaceDirective` defines the behavior common to nodes that represent
  * a directive that impacts the namespace of a library.
  *
  * <pre>
  * directive ::=
  *     [ExportDirective]
  *   | [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.
    */
@@ skipping 34 matching lines @@
 }
 
 /**
  * Instances of the class `NativeClause` represent the "native" clause in an class
  * declaration.
  *
  * <pre>
  * nativeClause ::=
  *     'native' [StringLiteral]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class NativeClause extends ASTNode {
+class NativeClause extends AstNode {
   /**
    * The token representing the 'native' keyword.
    */
   Token keyword;
 
   /**
    * The name of the native object that implements the class.
    */
   StringLiteral name;
 
   /**
    * Initialize a newly created native clause.
    *
    * @param keyword the token representing the 'native' keyword
    * @param name the name of the native object that implements the class.
    */
   NativeClause(this.keyword, this.name);
 
-  accept(ASTVisitor visitor) => visitor.visitNativeClause(this);
+  accept(AstVisitor visitor) => visitor.visitNativeClause(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => name.endToken;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(name, visitor);
   }
 }
 
 /**
  * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  *
  * <pre>
  * nativeFunctionBody ::=
  *     'native' [SimpleStringLiteral] ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class NativeFunctionBody extends FunctionBody {
   /**
    * The token representing 'native' that marks the start of the function body.
    */
   final Token nativeToken;
 
   /**
    * The string literal, after the 'native' token.
    */
   StringLiteral _stringLiteral;
 
   /**
    * The token representing the semicolon that marks the end of the function body.
    */
   final Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of the 'native' token, a string literal,
    * and a semicolon.
    *
    * @param nativeToken the token representing 'native' that marks the start of the function body
    * @param stringLiteral the string literal
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
   NativeFunctionBody(this.nativeToken, StringLiteral stringLiteral, this.semicolon) {
     this._stringLiteral = becomeParentOf(stringLiteral);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitNativeFunctionBody(this);
+  accept(AstVisitor visitor) => visitor.visitNativeFunctionBody(this);
 
   Token get beginToken => nativeToken;
 
   Token get endToken => semicolon;
 
   /**
    * Return the string literal representing the string after the 'native' token.
    *
    * @return the string literal representing the string after the 'native' token
    */
   StringLiteral get stringLiteral => _stringLiteral;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_stringLiteral, visitor);
   }
 }
 
 /**
  * The abstract class `NormalFormalParameter` defines the behavior common to formal parameters
  * that are required (are not optional).
  *
  * <pre>
  * normalFormalParameter ::=
  *     [FunctionTypedFormalParameter]
  *   | [FieldFormalParameter]
  *   | [SimpleFormalParameter]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 abstract class NormalFormalParameter extends FormalParameter {
   /**
    * The documentation comment associated with this parameter, or `null` if this parameter
    * does not have a documentation comment associated with it.
    */
   Comment _comment;
 
   /**
    * The annotations associated with this parameter.
@@ skipping 23 matching lines @@
    * Return the documentation comment associated with this parameter, or `null` if this
    * parameter does not have a documentation comment associated with it.
    *
    * @return the documentation comment associated with this parameter
    */
   Comment get documentationComment => _comment;
 
   SimpleIdentifier get identifier => _identifier;
 
   ParameterKind get kind {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
       return parent.kind;
     }
     return ParameterKind.REQUIRED;
   }
 
   /**
    * Return the annotations associated with this parameter.
    *
    * @return the annotations associated with this parameter
@@ skipping 11 matching lines @@
 
   /**
    * Set the name of the parameter being declared to the given identifier.
    *
    * @param identifier the name of the parameter being declared
    */
   void set identifier(SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     //
     // Note that subclasses are responsible for visiting the identifier because they often need to
     // visit other nodes before visiting the identifier.
     //
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
-      for (ASTNode child in sortedCommentAndAnnotations) {
+      for (AstNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Return `true` if the comment is lexically before any annotations.
    *
    * @return `true` if the comment is lexically before any annotations
    */
   bool commentIsBeforeAnnotations() {
     if (_comment == null || _metadata.isEmpty) {
       return true;
     }
     Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 
   /**
    * Return an array containing the comment and annotations associated with this parameter, sorted
    * in lexical order.
    *
    * @return the comment and annotations associated with this parameter in the order in which they
    *         appeared in the original source
    */
-  List<ASTNode> get sortedCommentAndAnnotations {
-    List<ASTNode> childList = new List<ASTNode>();
+  List<AstNode> get sortedCommentAndAnnotations {
+    List<AstNode> childList = new List<AstNode>();
     childList.add(_comment);
     childList.addAll(_metadata);
-    List<ASTNode> children = new List.from(childList);
-    children.sort(ASTNode.LEXICAL_ORDER);
+    List<AstNode> children = new List.from(childList);
+    children.sort(AstNode.LEXICAL_ORDER);
     return children;
   }
 }
 
 /**
  * Instances of the class `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
    */
   NullLiteral(Token token) {
     this.literal = token;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitNullLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitNullLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ParenthesizedExpression` represent a parenthesized expression.
  *
  * <pre>
  * parenthesizedExpression ::=
  *     '(' [Expression] ')'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class ParenthesizedExpression extends Expression {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The expression within the parentheses.
    */
@@ skipping 10 matching lines @@
    * @param leftParenthesis the left parenthesis
    * @param expression the expression within the parentheses
    * @param rightParenthesis the right parenthesis
    */
   ParenthesizedExpression(Token leftParenthesis, Expression expression, Token rightParenthesis) {
     this._leftParenthesis = leftParenthesis;
     this._expression = becomeParentOf(expression);
     this._rightParenthesis = rightParenthesis;
   }
 
-  accept(ASTVisitor visitor) => visitor.visitParenthesizedExpression(this);
+  accept(AstVisitor visitor) => visitor.visitParenthesizedExpression(this);
 
   Token get beginToken => _leftParenthesis;
 
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the expression within the parentheses.
    *
    * @return the expression within the parentheses
    */
@@ skipping 35 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `PartDirective` represent a part directive.
  *
  * <pre>
  * partDirective ::=
  *     [Annotation] 'part' [StringLiteral] ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class PartDirective extends UriBasedDirective {
   /**
    * The token representing the 'part' token.
    */
   Token partToken;
 
   /**
    * The semicolon terminating the directive.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created part directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param partToken the token representing the 'part' token
    * @param partUri the URI of the part being included
    * @param semicolon the semicolon terminating the directive
    */
   PartDirective(Comment comment, List<Annotation> metadata, this.partToken, StringLiteral partUri, this.semicolon) : super(comment, metadata, partUri);
 
-  accept(ASTVisitor visitor) => visitor.visitPartDirective(this);
+  accept(AstVisitor visitor) => visitor.visitPartDirective(this);
 
   Token get endToken => semicolon;
 
   Token get keyword => partToken;
 
   CompilationUnitElement get uriElement => element as CompilationUnitElement;
 
   Token get firstTokenAfterCommentAndMetadata => partToken;
 }
 
 /**
  * Instances of the class `PartOfDirective` represent a part-of directive.
  *
  * <pre>
  * partOfDirective ::=
  *     [Annotation] 'part' 'of' [Identifier] ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class PartOfDirective extends Directive {
   /**
    * The token representing the 'part' token.
    */
   Token partToken;
 
   /**
    * The token representing the 'of' token.
    */
@@ skipping 16 matching lines @@
    * @param metadata the annotations associated with the directive
    * @param partToken the token representing the 'part' token
    * @param ofToken the token representing the 'of' token
    * @param libraryName the name of the library that the containing compilation unit is part of
    * @param semicolon the semicolon terminating the directive
    */
   PartOfDirective(Comment comment, List<Annotation> metadata, this.partToken, this.ofToken, LibraryIdentifier libraryName, this.semicolon) : super(comment, metadata) {
     this._libraryName = becomeParentOf(libraryName);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitPartOfDirective(this);
+  accept(AstVisitor visitor) => visitor.visitPartOfDirective(this);
 
   Token get endToken => semicolon;
 
   Token get keyword => partToken;
 
   /**
    * Return the name of the library that the containing compilation unit is part of.
    *
    * @return the name of the library that the containing compilation unit is part of
    */
   LibraryIdentifier get libraryName => _libraryName;
 
   /**
    * Set the name of the library that the containing compilation unit is part of to the given name.
    *
    * @param libraryName the name of the library that the containing compilation unit is part of
    */
   void set libraryName(LibraryIdentifier libraryName) {
     this._libraryName = becomeParentOf(libraryName);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata => partToken;
 }
 
 /**
  * Instances of the class `PostfixExpression` represent a postfix unary expression.
  *
  * <pre>
  * postfixExpression ::=
  *     [Expression] [Token]
  * </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.
    */
@@ skipping 16 matching lines @@
   /**
    * Initialize a newly created postfix expression.
    *
    * @param operand the expression computing the operand for the operator
    * @param operator the postfix operator being applied to the operand
    */
   PostfixExpression(Expression operand, this.operator) {
     this._operand = becomeParentOf(operand);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitPostfixExpression(this);
+  accept(AstVisitor visitor) => visitor.visitPostfixExpression(this);
 
   Token get beginToken => _operand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
@@ skipping 59 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    *
    * @param element the element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
@@ skipping 33 matching lines @@
   }
 }
 
 /**
  * Instances of the class `PrefixExpression` represent a prefix unary expression.
  *
  * <pre>
  * prefixExpression ::=
  *     [Token] [Expression]
  * </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.
    */
@@ skipping 16 matching lines @@
   /**
    * Initialize a newly created prefix expression.
    *
    * @param operator the prefix operator being applied to the operand
    * @param operand the expression computing the operand for the operator
    */
   PrefixExpression(this.operator, Expression operand) {
     this._operand = becomeParentOf(operand);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitPrefixExpression(this);
+  accept(AstVisitor visitor) => visitor.visitPrefixExpression(this);
 
   Token get beginToken => operator;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
@@ skipping 59 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
@@ skipping 35 matching lines @@
 
 /**
  * Instances of the class `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 ::=
  *     [SimpleIdentifier] '.' [SimpleIdentifier]
  * </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;
 
   /**
    * The identifier being prefixed.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created prefixed identifier.
    *
    * @param prefix the identifier being prefixed
    * @param period the period used to separate the prefix from the identifier
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
   PrefixedIdentifier(SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
     this._prefix = becomeParentOf(prefix);
     this._identifier = becomeParentOf(identifier);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitPrefixedIdentifier(this);
+  accept(AstVisitor visitor) => visitor.visitPrefixedIdentifier(this);
 
   Token get beginToken => _prefix.beginToken;
 
   Element get bestElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.bestElement;
   }
 
@@ skipping 43 matching lines @@
   /**
    * Set the prefix associated with the library in which the identifier is defined to the given
    * identifier.
    *
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
   void set prefix(SimpleIdentifier identifier) {
     _prefix = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_prefix, visitor);
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `PropertyAccess` represent the access of a property of an object.
  *
  * Note, however, that accesses to properties of objects can also be represented as
  * [PrefixedIdentifier] nodes in cases where the target is also a simple
  * identifier.
  *
  * <pre>
  * propertyAccess ::=
  *     [Expression] '.' [SimpleIdentifier]
  * </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;
 
   /**
    * The name of the property being accessed.
    */
   SimpleIdentifier _propertyName;
 
   /**
    * Initialize a newly created property access expression.
    *
    * @param target the expression computing the object defining the property being accessed
    * @param operator the property access operator
    * @param propertyName the name of the property being accessed
    */
   PropertyAccess(Expression target, this.operator, SimpleIdentifier propertyName) {
     this._target = becomeParentOf(target);
     this._propertyName = becomeParentOf(propertyName);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitPropertyAccess(this);
+  accept(AstVisitor visitor) => visitor.visitPropertyAccess(this);
 
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
   }
 
   Token get endToken => _propertyName.endToken;
 
@@ skipping 10 matching lines @@
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    *
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
     if (isCascaded) {
-      ASTNode ancestor = parent;
+      AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
@@ skipping 30 matching lines @@
   /**
    * Set the expression computing the object defining the property being accessed to the given
    * expression.
    *
    * @param expression the expression computing the object defining the property being accessed
    */
   void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_propertyName, visitor);
   }
 }
 
 /**
  * Instances of the class `RedirectingConstructorInvocation` represent the invocation of a
  * another constructor in the same class from within a constructor's initialization list.
  *
  * <pre>
  * redirectingConstructorInvocation ::=
  *     'this' ('.' identifier)? arguments
  * </pre>
- *
- * @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
    * `null` if the unnamed constructor is being invoked.
@@ skipping 24 matching lines @@
    * @param keyword the token for the 'this' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
   RedirectingConstructorInvocation(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitRedirectingConstructorInvocation(this);
+  accept(AstVisitor visitor) => visitor.visitRedirectingConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
 
@@ skipping 18 matching lines @@
 
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    *
    * @param identifier the name of the constructor that is being invoked
    */
   void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `RethrowExpression` represent a rethrow expression.
  *
  * <pre>
  * rethrowExpression ::=
  *     'rethrow'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class RethrowExpression extends Expression {
   /**
    * The token representing the 'rethrow' keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created rethrow expression.
    *
    * @param keyword the token representing the 'rethrow' keyword
    */
   RethrowExpression(this.keyword);
 
-  accept(ASTVisitor visitor) => visitor.visitRethrowExpression(this);
+  accept(AstVisitor visitor) => visitor.visitRethrowExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
   int get precedence => 0;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ReturnStatement` represent a return statement.
  *
  * <pre>
  * returnStatement ::=
  *     'return' [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 `null` if no explicit value was
    * provided.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created return statement.
    *
    * @param keyword the token representing the 'return' keyword
    * @param expression the expression computing the value to be returned
    * @param semicolon the semicolon terminating the statement
    */
   ReturnStatement(this.keyword, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitReturnStatement(this);
+  accept(AstVisitor visitor) => visitor.visitReturnStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => semicolon;
 
   /**
    * Return the expression computing the value to be returned, or `null` if no explicit value
    * was provided.
    *
    * @return the expression computing the value to be returned
    */
   Expression get expression => _expression;
 
   /**
    * 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 expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `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 {
+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
    */
   ScriptTag(this.scriptTag);
 
-  accept(ASTVisitor visitor) => visitor.visitScriptTag(this);
+  accept(AstVisitor visitor) => visitor.visitScriptTag(this);
 
   Token get beginToken => scriptTag;
 
   Token get endToken => scriptTag;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ShowCombinator` represent a combinator that restricts the names
  * being imported to those in a given list.
  *
  * <pre>
  * showCombinator ::=
  *     'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
  * </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
    */
   ShowCombinator(Token keyword, List<SimpleIdentifier> shownNames) : super(keyword) {
     this._shownNames = new NodeList<SimpleIdentifier>(this);
     this._shownNames.addAll(shownNames);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitShowCombinator(this);
+  accept(AstVisitor visitor) => visitor.visitShowCombinator(this);
 
   Token get endToken => _shownNames.endToken;
 
   /**
    * Return the list of names from the library that are made visible by this combinator.
    *
    * @return the list of names from the library that are made visible by this combinator
    */
   NodeList<SimpleIdentifier> get shownNames => _shownNames;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _shownNames.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SimpleFormalParameter` represent a simple formal parameter.
  *
  * <pre>
  * simpleFormalParameter ::=
  *     ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class SimpleFormalParameter extends NormalFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter does not have
    * a declared type.
    */
   TypeName _type;
 
   /**
    * 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
    */
   SimpleFormalParameter(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata, identifier) {
     this._type = becomeParentOf(type);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitSimpleFormalParameter(this);
+  accept(AstVisitor visitor) => visitor.visitSimpleFormalParameter(this);
 
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return identifier.beginToken;
   }
 
@@ skipping 13 matching lines @@
 
   /**
    * 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 visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `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 based on static type information, or `null`
    * if the AST structure has not been resolved or if this identifier could not be resolved.
@@ skipping 14 matching lines @@
    */
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created identifier.
    *
    * @param token the token representing the identifier
    */
   SimpleIdentifier(this.token);
 
-  accept(ASTVisitor visitor) => visitor.visitSimpleIdentifier(this);
+  accept(AstVisitor visitor) => visitor.visitSimpleIdentifier(this);
 
   Token get beginToken => token;
 
   Element get bestElement {
     if (_propagatedElement == null) {
       return _staticElement;
     }
     return _propagatedElement;
   }
 
   Token get endToken => token;
 
   String get name => token.lexeme;
 
   int get precedence => 16;
 
   Element get propagatedElement => _propagatedElement;
 
   Element get staticElement => _staticElement;
 
   /**
    * Return `true` if this identifier is the name being declared in a declaration.
    *
    * @return `true` if this identifier is the name being declared in a declaration
    */
   bool inDeclarationContext() {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is CatchClause) {
       CatchClause clause = parent;
       return identical(this, clause.exceptionParameter) || identical(this, clause.stackTraceParameter);
     } else if (parent is ClassDeclaration) {
       return identical(this, parent.name);
     } else if (parent is ClassTypeAlias) {
       return identical(this, parent.name);
     } else if (parent is ConstructorDeclaration) {
       return identical(this, parent.name);
     } else if (parent is DeclaredIdentifier) {
@@ skipping 19 matching lines @@
   /**
    * Return `true` if this expression is computing a right-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where a getter will be invoked
    */
   bool inGetterContext() {
-    ASTNode parent = this.parent;
-    ASTNode target = this;
+    AstNode parent = this.parent;
+    AstNode target = this;
     // skip prefix
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return true;
       }
       parent = prefixed.parent;
       target = prefixed;
     } else if (parent is PropertyAccess) {
       PropertyAccess access = parent as PropertyAccess;
@@ skipping 20 matching lines @@
   /**
    * Return `true` if this expression is computing a left-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
    * @return `true` if this expression is in a context where a setter will be invoked
    */
   bool inSetterContext() {
-    ASTNode parent = this.parent;
-    ASTNode target = this;
+    AstNode parent = this.parent;
+    AstNode target = this;
     // skip prefix
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       // if this is the prefix, then return false
       if (identical(prefixed.prefix, this)) {
         return false;
       }
       parent = prefixed.parent;
       target = prefixed;
     } else if (parent is PropertyAccess) {
@@ skipping 30 matching lines @@
   /**
    * Set the element associated with this identifier based on static type information to the given
    * element.
    *
    * @param element the element to be associated with this identifier
    */
   void set staticElement(Element element) {
     _staticElement = validateElement2(element);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 
   /**
    * Return the given element if it is an appropriate element based on the parent of this
    * identifier, or `null` if it is not appropriate.
    *
    * @param element the element to be associated with this identifier
    * @return the element to be associated with this identifier
    */
-  Element validateElement(ASTNode parent, Type expectedClass, Element element) {
+  Element validateElement(AstNode parent, Type expectedClass, Element element) {
     if (!isInstanceOf(element, expectedClass)) {
       AnalysisEngine.instance.logger.logInformation3("Internal error: attempting to set the name of a ${parent.runtimeType.toString()} to a ${element.runtimeType.toString()}", new JavaException());
       return null;
     }
     return element;
   }
 
   /**
    * Return the given element if it is an appropriate element based on the parent of this
    * identifier, or `null` if it is not appropriate.
    *
    * @param element the element to be associated with this identifier
    * @return the element to be associated with this identifier
    */
   Element validateElement2(Element element) {
     if (element == null) {
       return null;
     }
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     if (parent is ClassDeclaration && identical(parent.name, this)) {
       return validateElement(parent, ClassElement, element);
     } else if (parent is ClassTypeAlias && identical(parent.name, this)) {
       return validateElement(parent, ClassElement, element);
     } else if (parent is DeclaredIdentifier && identical(parent.identifier, this)) {
       return validateElement(parent, LocalVariableElement, element);
     } else if (parent is FormalParameter && identical(parent.identifier, this)) {
       return validateElement(parent, ParameterElement, element);
     } else if (parent is FunctionDeclaration && identical(parent.name, this)) {
       return validateElement(parent, ExecutableElement, element);
@@ skipping 27 matching lines @@
  *   | 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;
 
   /**
    * The toolkit specific element associated with this literal, or `null`.
    */
   Element _toolkitElement;
 
   /**
    * Initialize a newly created simple string literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   SimpleStringLiteral(this.literal, String value) {
     this._value = StringUtilities.intern(value);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitSimpleStringLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitSimpleStringLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   /**
    * Return the toolkit specific, non-Dart, element associated with this literal, or `null`.
    *
    * @return the element associated with this literal
    */
@@ skipping 57 matching lines @@
 
   /**
    * Set the value of the literal to the given string.
    *
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = StringUtilities.intern(_value);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 
   void appendStringValue(JavaStringBuilder builder) {
     builder.append(value);
   }
 }
 
 /**
  * Instances of the class `Statement` defines the behavior common to nodes that represent a
  * statement.
  *
  * <pre>
  * statement ::=
  *     [Block]
  *   | [VariableDeclarationStatement]
  *   | [ForStatement]
  *   | [ForEachStatement]
  *   | [WhileStatement]
  *   | [DoStatement]
  *   | [SwitchStatement]
  *   | [IfStatement]
  *   | [TryStatement]
  *   | [BreakStatement]
  *   | [ContinueStatement]
  *   | [ReturnStatement]
  *   | [ExpressionStatement]
  *   | [FunctionDeclarationStatement]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-abstract class Statement extends ASTNode {
+abstract class Statement extends AstNode {
 }
 
 /**
  * Instances of the class `StringInterpolation` represent a string interpolation literal.
  *
  * <pre>
  * stringInterpolation ::=
  *     ''' [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
    */
   StringInterpolation(List<InterpolationElement> elements) {
     this._elements = new NodeList<InterpolationElement>(this);
     this._elements.addAll(elements);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitStringInterpolation(this);
+  accept(AstVisitor visitor) => visitor.visitStringInterpolation(this);
 
   Token get beginToken => _elements.beginToken;
 
   /**
    * Return the elements that will be composed to produce the resulting string.
    *
    * @return the elements that will be composed to produce the resulting string
    */
   NodeList<InterpolationElement> get elements => _elements;
 
   Token get endToken => _elements.endToken;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _elements.accept(visitor);
   }
 
   void appendStringValue(JavaStringBuilder builder) {
     throw new IllegalArgumentException();
   }
 }
 
 /**
  * Instances of the class `StringLiteral` represent a string literal expression.
  *
  * <pre>
  * stringLiteral ::=
  *     [SimpleStringLiteral]
  *   | [AdjacentStrings]
  *   | [StringInterpolation]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 abstract class StringLiteral extends Literal {
   /**
    * Return the value of the string literal, or `null` if the string is not a constant string
    * without any string interpolation.
    *
    * @return the value of the string literal
    */
   String get stringValue {
     JavaStringBuilder builder = new JavaStringBuilder();
@@ skipping 16 matching lines @@
 }
 
 /**
  * Instances of the class `SuperConstructorInvocation` represent the invocation of a
  * superclass' constructor from within a constructor's initialization list.
  *
  * <pre>
  * superInvocation ::=
  *     'super' ('.' [SimpleIdentifier])? [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
    * `null` if the unnamed constructor is being invoked.
@@ skipping 24 matching lines @@
    * @param keyword the token for the 'super' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
   SuperConstructorInvocation(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
+  accept(AstVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
 
@@ skipping 18 matching lines @@
 
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    *
    * @param identifier the name of the constructor that is being invoked
    */
   void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `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
    */
   SuperExpression(this.keyword);
 
-  accept(ASTVisitor visitor) => visitor.visitSuperExpression(this);
+  accept(AstVisitor visitor) => visitor.visitSuperExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
   int get precedence => 16;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `SwitchCase` represent the case in a switch statement.
  *
  * <pre>
  * switchCase ::=
  *     [SimpleIdentifier]* 'case' [Expression] ':' [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
    * @param expression the expression controlling whether the statements will be executed
    * @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
    */
   SwitchCase(List<Label> labels, Token keyword, Expression expression, Token colon, List<Statement> statements) : super(labels, keyword, colon, statements) {
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitSwitchCase(this);
+  accept(AstVisitor visitor) => visitor.visitSwitchCase(this);
 
   /**
    * Return the expression controlling whether the statements will be executed.
    *
    * @return the expression controlling whether the statements will be executed
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression controlling whether the statements will be executed to the given expression.
    *
    * @param expression the expression controlling whether the statements will be executed
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SwitchDefault` represent the default case in a switch statement.
  *
  * <pre>
  * switchDefault ::=
  *     [SimpleIdentifier]* 'default' ':' [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(List<Label> labels, Token keyword, Token colon, List<Statement> statements) : super(labels, keyword, colon, statements);
 
-  accept(ASTVisitor visitor) => visitor.visitSwitchDefault(this);
+  accept(AstVisitor visitor) => visitor.visitSwitchDefault(this);
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `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 {
+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 51 matching lines @@
   NodeList<Statement> get statements => _statements;
 }
 
 /**
  * Instances of the class `SwitchStatement` represent a switch statement.
  *
  * <pre>
  * switchStatement ::=
  *     'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class SwitchStatement extends Statement {
   /**
    * The token representing the 'switch' keyword.
    */
   Token keyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 34 matching lines @@
    * @param leftBracket the left curly bracket
    * @param members the switch members that can be selected by the expression
    * @param rightBracket the right curly bracket
    */
   SwitchStatement(this.keyword, this.leftParenthesis, Expression expression, this.rightParenthesis, this.leftBracket, List<SwitchMember> members, this.rightBracket) {
     this._members = new NodeList<SwitchMember>(this);
     this._expression = becomeParentOf(expression);
     this._members.addAll(members);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitSwitchStatement(this);
+  accept(AstVisitor visitor) => visitor.visitSwitchStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to determine which of the switch members will be selected.
    *
    * @return the expression used to determine which of the switch members will be selected
    */
   Expression get expression => _expression;
 
   /**
    * Return the switch members that can be selected by the expression.
    *
    * @return the switch members that can be selected by the expression
    */
   NodeList<SwitchMember> get members => _members;
 
   /**
    * Set the expression used to determine which of the switch members will be selected to the given
    * expression.
    *
    * @param expression the expression used to determine which of the switch members will be selected
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SymbolLiteral` represent a symbol literal expression.
  *
  * <pre>
  * symbolLiteral ::=
  *     '#' (operator | (identifier ('.' identifier)*))
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class SymbolLiteral extends Literal {
   /**
    * The token introducing the literal.
    */
   Token poundSign;
 
   /**
    * The components of the literal.
    */
   final List<Token> components;
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
   SymbolLiteral(this.poundSign, this.components);
 
-  accept(ASTVisitor visitor) => visitor.visitSymbolLiteral(this);
+  accept(AstVisitor visitor) => visitor.visitSymbolLiteral(this);
 
   Token get beginToken => poundSign;
 
   Token get endToken => components[components.length - 1];
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `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
    */
   ThisExpression(this.keyword);
 
-  accept(ASTVisitor visitor) => visitor.visitThisExpression(this);
+  accept(AstVisitor visitor) => visitor.visitThisExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
   int get precedence => 16;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ThrowExpression` represent a throw expression.
  *
  * <pre>
  * throwExpression ::=
  *     'throw' [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.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created throw expression.
    *
    * @param keyword the token representing the 'throw' keyword
    * @param expression the expression computing the exception to be thrown
    */
   ThrowExpression(this.keyword, Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitThrowExpression(this);
+  accept(AstVisitor visitor) => visitor.visitThrowExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
     return keyword;
   }
 
   /**
    * Return the expression computing the exception to be thrown.
    *
    * @return the expression computing the exception to be thrown
    */
   Expression get expression => _expression;
 
   int get precedence => 0;
 
   /**
    * 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 expression) {
     this._expression = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `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;
 
   /**
    * Initialize a newly created top-level variable declaration.
    *
    * @param comment the documentation comment associated with this variable
    * @param metadata the annotations associated with this variable
    * @param variableList the top-level variables being declared
    * @param semicolon the semicolon terminating the declaration
    */
   TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, this.semicolon) : super(comment, metadata) {
     this._variableList = becomeParentOf(variableList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
 
   Element get element => null;
 
   Token get endToken => semicolon;
 
   /**
    * Return the top-level variables being declared.
    *
    * @return the top-level variables being declared
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the top-level variables being declared to the given list of variables.
    *
    * @param variableList the top-level variables being declared
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 }
 
 /**
  * Instances of the class `TryStatement` represent a try statement.
  *
  * <pre>
  * tryStatement ::=
  *     'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
  *
  * finallyClause ::=
  *     'finally' [Block]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class TryStatement extends Statement {
   /**
    * The token representing the 'try' keyword.
    */
   Token tryKeyword;
 
   /**
    * The body of the statement.
    */
@@ skipping 25 matching lines @@
    * @param finallyKeyword the token representing the 'finally' keyword
    * @param finallyBlock the finally block contained in the try statement
    */
   TryStatement(this.tryKeyword, Block body, List<CatchClause> catchClauses, this.finallyKeyword, Block finallyBlock) {
     this._catchClauses = new NodeList<CatchClause>(this);
     this._body = becomeParentOf(body);
     this._catchClauses.addAll(catchClauses);
     this._finallyBlock = becomeParentOf(finallyBlock);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitTryStatement(this);
+  accept(AstVisitor visitor) => visitor.visitTryStatement(this);
 
   Token get beginToken => tryKeyword;
 
   /**
    * Return the body of the statement.
    *
    * @return the body of the statement
    */
   Block get body => _body;
 
@@ skipping 34 matching lines @@
 
   /**
    * Set the finally block contained in the try statement to the given block.
    *
    * @param block the finally block contained in the try statement
    */
   void set finallyBlock(Block block) {
     _finallyBlock = becomeParentOf(block);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_body, visitor);
     _catchClauses.accept(visitor);
     safelyVisitChild(_finallyBlock, visitor);
   }
 }
 
 /**
  * The abstract class `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.
    */
@@ skipping 14 matching lines @@
   Token get firstTokenAfterCommentAndMetadata => keyword;
 }
 
 /**
  * Instances of the class `TypeArgumentList` represent a list of type arguments.
  *
  * <pre>
  * typeArguments ::=
  *     '<' typeName (',' typeName)* '>'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class TypeArgumentList extends ASTNode {
+class TypeArgumentList extends AstNode {
   /**
    * The left bracket.
    */
   Token leftBracket;
 
   /**
    * The type arguments associated with the type.
    */
   NodeList<TypeName> _arguments;
 
   /**
    * The right bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created list of type arguments.
    *
    * @param leftBracket the left bracket
    * @param arguments the type arguments associated with the type
    * @param rightBracket the right bracket
    */
   TypeArgumentList(this.leftBracket, List<TypeName> arguments, this.rightBracket) {
     this._arguments = new NodeList<TypeName>(this);
     this._arguments.addAll(arguments);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitTypeArgumentList(this);
+  accept(AstVisitor visitor) => visitor.visitTypeArgumentList(this);
 
   /**
    * Return the type arguments associated with the type.
    *
    * @return the type arguments associated with the type
    */
   NodeList<TypeName> get arguments => _arguments;
 
   Token get beginToken => leftBracket;
 
   Token get endToken => rightBracket;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _arguments.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `TypeName` represent the name of a type, which can optionally
  * include type arguments.
  *
  * <pre>
  * typeName ::=
  *     [Identifier] typeArguments?
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class TypeName extends ASTNode {
+class TypeName extends AstNode {
   /**
    * The name of the type.
    */
   Identifier _name;
 
   /**
    * The type arguments associated with the type, or `null` if there are no type arguments.
    */
   TypeArgumentList _typeArguments;
 
   /**
    * The type being named, or `null` if the AST structure has not been resolved.
    */
   Type2 type;
 
   /**
    * Initialize a newly created type name.
    *
    * @param name the name of the type
    * @param typeArguments the type arguments associated with the type, or `null` if there are
    *          no type arguments
    */
   TypeName(Identifier name, TypeArgumentList typeArguments) {
     this._name = becomeParentOf(name);
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitTypeName(this);
+  accept(AstVisitor visitor) => visitor.visitTypeName(this);
 
   Token get beginToken => _name.beginToken;
 
   Token get endToken {
     if (_typeArguments != null) {
       return _typeArguments.endToken;
     }
     return _name.endToken;
   }
 
@@ skipping 25 matching lines @@
 
   /**
    * Set the type arguments associated with the type to the given type arguments.
    *
    * @param typeArguments the type arguments associated with the type
    */
   void set typeArguments(TypeArgumentList typeArguments) {
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * Instances of the class `TypeParameter` represent a type parameter.
  *
  * <pre>
  * typeParameter ::=
  *     [SimpleIdentifier] ('extends' [TypeName])?
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class TypeParameter extends Declaration {
   /**
    * The name of the type parameter.
    */
   SimpleIdentifier _name;
 
   /**
    * The token representing the 'extends' keyword, or `null` if there was no explicit upper
    * bound.
@@ skipping 13 matching lines @@
    * @param metadata the annotations associated with the type parameter
    * @param name the name of the type parameter
    * @param keyword the token representing the 'extends' keyword
    * @param bound the name of the upper bound for legal arguments
    */
   TypeParameter(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.keyword, TypeName bound) : super(comment, metadata) {
     this._name = becomeParentOf(name);
     this._bound = becomeParentOf(bound);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitTypeParameter(this);
+  accept(AstVisitor visitor) => visitor.visitTypeParameter(this);
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there was no
    * explicit upper bound.
    *
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
 
   TypeParameterElement get element => _name != null ? (_name.staticElement as TypeParameterElement) : null;
@@ skipping 23 matching lines @@
 
   /**
    * 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 visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_bound, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 
 /**
  * Instances of the class `TypeParameterList` represent type parameters within a declaration.
  *
  * <pre>
  * typeParameterList ::=
  *     '<' [TypeParameter] (',' [TypeParameter])* '>'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class TypeParameterList extends ASTNode {
+class TypeParameterList extends AstNode {
   /**
    * The left angle bracket.
    */
   final Token leftBracket;
 
   /**
    * The type parameters in the list.
    */
   NodeList<TypeParameter> _typeParameters;
 
   /**
    * The right angle bracket.
    */
   final Token rightBracket;
 
   /**
    * Initialize a newly created list of type parameters.
    *
    * @param leftBracket the left angle bracket
    * @param typeParameters the type parameters in the list
    * @param rightBracket the right angle bracket
    */
   TypeParameterList(this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
     this._typeParameters = new NodeList<TypeParameter>(this);
     this._typeParameters.addAll(typeParameters);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitTypeParameterList(this);
+  accept(AstVisitor visitor) => visitor.visitTypeParameterList(this);
 
   Token get beginToken => leftBracket;
 
   Token get endToken => rightBracket;
 
   /**
    * Return the type parameters for the type.
    *
    * @return the type parameters for the type
    */
   NodeList<TypeParameter> get typeParameters => _typeParameters;
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _typeParameters.accept(visitor);
   }
 }
 
 /**
  * The abstract class `TypedLiteral` defines the behavior common to literals that have a type
  * associated with them.
  *
  * <pre>
  * listLiteral ::=
  *     [ListLiteral]
  *   | [MapLiteral]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 abstract class TypedLiteral extends Literal {
   /**
    * The token representing the 'const' keyword, or `null` if the literal is not a constant.
    */
   Token constKeyword;
 
   /**
    * The type argument associated with this literal, or `null` if no type arguments were
    * declared.
    */
   TypeArgumentList typeArguments;
 
   /**
    * Initialize a newly created typed literal.
    *
    * @param constKeyword the token representing the 'const' keyword
    * @param typeArguments the type argument associated with this literal, or `null` if no type
    *          arguments were declared
    */
   TypedLiteral(this.constKeyword, TypeArgumentList typeArguments) {
     this.typeArguments = becomeParentOf(typeArguments);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(typeArguments, visitor);
   }
 }
 
 /**
  * The abstract class `UriBasedDirective` defines the behavior common to nodes that represent
  * a directive that references a URI.
  *
  * <pre>
  * uriBasedDirective ::=
  *     [ExportDirective]
  *   | [ImportDirective]
  *   | [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.
    *
@@ skipping 23 matching lines @@
 
   /**
    * Set the URI referenced by this directive to the given URI.
    *
    * @param uri the URI referenced by this directive
    */
   void set uri(StringLiteral uri) {
     this._uri = becomeParentOf(uri);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 
 /**
  * Instances of the class `VariableDeclaration` represent an identifier that has an initial
  * value associated with it. Instances of this class are always children of the class
  * [VariableDeclarationList].
  *
  * <pre>
  * variableDeclaration ::=
  *     [SimpleIdentifier] ('=' [Expression])?
  * </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 `null` if the
    * initial value was not specified.
@@ skipping 13 matching lines @@
    * @param metadata the annotations associated with this member
    * @param name the name of the variable being declared
    * @param equals the equal sign separating the variable name from the initial value
    * @param initializer the expression used to compute the initial value for the variable
    */
   VariableDeclaration(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.equals, Expression initializer) : super(comment, metadata) {
     this._name = becomeParentOf(name);
     this._initializer = becomeParentOf(initializer);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitVariableDeclaration(this);
+  accept(AstVisitor visitor) => visitor.visitVariableDeclaration(this);
 
   /**
    * This overridden implementation of getDocumentationComment() looks in the grandparent node for
    * dartdoc comments if no documentation is specifically available on the node.
    */
   Comment get documentationComment {
     Comment comment = super.documentationComment;
     if (comment == null) {
       if (parent != null && parent.parent != null) {
-        ASTNode node = parent.parent;
+        AstNode node = parent.parent;
         if (node is AnnotatedNode) {
           return node.documentationComment;
         }
       }
     }
     return comment;
   }
 
   VariableElement get element => _name != null ? (_name.staticElement as VariableElement) : null;
 
@@ skipping 18 matching lines @@
    * @return the name of the variable being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    *
    * @return `true` if this variable was declared with the 'const' modifier
    */
   bool get isConst {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     return parent is VariableDeclarationList && parent.isConst;
   }
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
    *
    * @return `true` if this variable was declared with the 'final' modifier
    */
   bool get isFinal {
-    ASTNode parent = this.parent;
+    AstNode parent = this.parent;
     return parent is VariableDeclarationList && parent.isFinal;
   }
 
   /**
    * Set the expression used to compute the initial value for the variable to the given expression.
    *
    * @param initializer the expression used to compute the initial value for the variable
    */
   void set initializer(Expression initializer) {
     this._initializer = becomeParentOf(initializer);
   }
 
   /**
    * Set the name of the variable being declared to the given identifier.
    *
    * @param name the name of the variable being declared
    */
   void set name(SimpleIdentifier name) {
     this._name = becomeParentOf(name);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 
 /**
  * Instances of the class `VariableDeclarationList` represent the declaration of one or more
  * variables of the same type.
  *
  * <pre>
  * variableDeclarationList ::=
  *     finalConstVarOrType [VariableDeclaration] (',' [VariableDeclaration])*
  *
  * finalConstVarOrType ::=
  *   | 'final' [TypeName]?
  *   | 'const' [TypeName]?
  *   | 'var'
  *   | [TypeName]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class VariableDeclarationList extends AnnotatedNode {
   /**
    * The token representing the 'final', 'const' or 'var' keyword, or `null` if no keyword was
    * included.
    */
   Token keyword;
 
   /**
    * The type of the variables being declared, or `null` if no type was provided.
@@ skipping 13 matching lines @@
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    * @param type the type of the variables being declared
    * @param variables a list containing the individual variables being declared
    */
   VariableDeclarationList(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, List<VariableDeclaration> variables) : super(comment, metadata) {
     this._variables = new NodeList<VariableDeclaration>(this);
     this._type = becomeParentOf(type);
     this._variables.addAll(variables);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitVariableDeclarationList(this);
+  accept(AstVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
   Token get endToken => _variables.endToken;
 
   /**
    * Return the type of the variables being declared, or `null` if no type was provided.
    *
    * @return the type of the variables being declared
    */
   TypeName get type => _type;
 
@@ skipping 22 matching lines @@
 
   /**
    * 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 visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _variables.beginToken;
   }
 }
 
 /**
  * Instances of the class `VariableDeclarationStatement` represent a list of variables that
  * are being declared in a context where a statement is required.
  *
  * <pre>
  * variableDeclarationStatement ::=
  *     [VariableDeclarationList] ';'
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class VariableDeclarationStatement extends Statement {
   /**
    * The variables being declared.
    */
   VariableDeclarationList _variableList;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created variable declaration statement.
    *
    * @param variableList the fields being declared
    * @param semicolon the semicolon terminating the statement
    */
   VariableDeclarationStatement(VariableDeclarationList variableList, this.semicolon) {
     this._variableList = becomeParentOf(variableList);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
+  accept(AstVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
 
   Token get beginToken => _variableList.beginToken;
 
   Token get endToken => semicolon;
 
   /**
    * Return the variables being declared.
    *
    * @return the variables being declared
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the variables being declared to the given list of variables.
    *
    * @param variableList the variables being declared
    */
   void set variables(VariableDeclarationList variableList) {
     this._variableList = becomeParentOf(variableList);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 
 /**
  * Instances of the class `WhileStatement` represent a while statement.
  *
  * <pre>
  * whileStatement ::=
  *     'while' '(' [Expression] ')' [Statement]
  * </pre>
- *
- * @coverage dart.engine.ast
  */
 class WhileStatement extends Statement {
   /**
    * The token representing the 'while' keyword.
    */
   Token keyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 21 matching lines @@
    * @param leftParenthesis the left parenthesis
    * @param condition the expression used to determine whether to execute the body of the loop
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   WhileStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement body) {
     this._condition = becomeParentOf(condition);
     this._body = becomeParentOf(body);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitWhileStatement(this);
+  accept(AstVisitor visitor) => visitor.visitWhileStatement(this);
 
   Token get beginToken => keyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
@@ skipping 18 matching lines @@
   /**
    * Set the expression used to determine whether to execute the body of the loop to the given
    * expression.
    *
    * @param expression the expression used to determine whether to execute the body of the loop
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `WithClause` represent the with clause in a class declaration.
  *
  * <pre>
  * withClause ::=
  *     'with' [TypeName] (',' [TypeName])*
  * </pre>
- *
- * @coverage dart.engine.ast
  */
-class WithClause extends ASTNode {
+class WithClause extends AstNode {
   /**
    * The token representing the 'with' keyword.
    */
   Token _withKeyword;
 
   /**
    * The names of the mixins that were specified.
    */
   NodeList<TypeName> _mixinTypes;
 
   /**
    * Initialize a newly created with clause.
    *
    * @param withKeyword the token representing the 'with' keyword
    * @param mixinTypes the names of the mixins that were specified
    */
   WithClause(Token withKeyword, List<TypeName> mixinTypes) {
     this._mixinTypes = new NodeList<TypeName>(this);
     this._withKeyword = withKeyword;
     this._mixinTypes.addAll(mixinTypes);
   }
 
-  accept(ASTVisitor visitor) => visitor.visitWithClause(this);
+  accept(AstVisitor visitor) => visitor.visitWithClause(this);
 
   Token get beginToken => _withKeyword;
 
   Token get endToken => _mixinTypes.endToken;
 
   /**
    * Return the names of the mixins that were specified.
    *
    * @return the names of the mixins that were specified
    */
   NodeList<TypeName> get mixinTypes => _mixinTypes;
 
   /**
    * Return the token representing the 'with' keyword.
    *
    * @return the token representing the 'with' keyword
    */
   Token get withKeyword => _withKeyword;
 
   /**
    * Set the token representing the 'with' keyword to the given token.
    *
    * @param withKeyword the token representing the 'with' keyword
    */
   void set mixinKeyword(Token withKeyword) {
     this._withKeyword = withKeyword;
   }
 
-  void visitChildren(ASTVisitor visitor) {
+  void visitChildren(AstVisitor visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BreadthFirstVisitor` implement an AST visitor that will recursively
- * visit all of the nodes in an AST structure, similar to [GeneralizingASTVisitor]. This
+ * visit all of the nodes in an AST structure, similar to [GeneralizingAstVisitor]. This
  * visitor uses a breadth-first ordering rather than the depth-first ordering of
- * [GeneralizingASTVisitor].
+ * [GeneralizingAstVisitor].
  *
  * 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.
  *
  * In addition, subclasses should <b>not</b> explicitly visit the children of a node, but should
  * ensure that the method [visitNode] is used to visit the children (either directly
  * or indirectly). Failure to do will break the order in which nodes are visited.
- *
- * @coverage dart.engine.ast
  */
-class BreadthFirstVisitor<R> extends GeneralizingASTVisitor<R> {
+class BreadthFirstVisitor<R> extends GeneralizingAstVisitor<R> {
   /**
    * A queue holding the nodes that have not yet been visited in the order in which they ought to be
    * visited.
    */
-  Queue<ASTNode> _queue = new Queue<ASTNode>();
+  Queue<AstNode> _queue = new Queue<AstNode>();
 
   /**
    * A visitor, used to visit the children of the current node, that will add the nodes it visits to
    * the [queue].
    */
-  GeneralizingASTVisitor<Object> _childVisitor;
+  GeneralizingAstVisitor<Object> _childVisitor;
 
   /**
    * Visit all nodes in the tree starting at the given `root` node, in breadth-first order.
    *
    * @param root the root of the AST structure to be visited
    */
-  void visitAllNodes(ASTNode root) {
+  void visitAllNodes(AstNode root) {
     _queue.add(root);
     while (!_queue.isEmpty) {
-      ASTNode next = _queue.removeFirst();
+      AstNode next = _queue.removeFirst();
       next.accept(this);
     }
   }
 
-  R visitNode(ASTNode node) {
+  R visitNode(AstNode node) {
     node.visitChildren(_childVisitor);
     return null;
   }
 
   BreadthFirstVisitor() {
-    this._childVisitor = new GeneralizingASTVisitor_BreadthFirstVisitor(this);
+    this._childVisitor = new GeneralizingAstVisitor_BreadthFirstVisitor(this);
   }
 }
 
-class GeneralizingASTVisitor_BreadthFirstVisitor extends GeneralizingASTVisitor<Object> {
+class GeneralizingAstVisitor_BreadthFirstVisitor extends GeneralizingAstVisitor<Object> {
   final BreadthFirstVisitor BreadthFirstVisitor_this;
 
-  GeneralizingASTVisitor_BreadthFirstVisitor(this.BreadthFirstVisitor_this) : super();
+  GeneralizingAstVisitor_BreadthFirstVisitor(this.BreadthFirstVisitor_this) : super();
 
-  Object visitNode(ASTNode node) {
+  Object visitNode(AstNode node) {
     BreadthFirstVisitor_this._queue.add(node);
     return null;
   }
 }
 
 /**
  * Instances of the class `ConstantEvaluator` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
- *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to `null`.
  * * `null`.
  * * A reference to a static constant variable.
  * * An identifier expression that denotes a constant variable, a class or a type parameter.
  * * A constant constructor invocation.
  * * A constant list literal.
  * * A constant map literal.
  * * A simple or qualified identifier denoting a top-level function or a static method.
  * * A parenthesized expression `(e)` where `e` is a constant expression.
  * * An expression of one of the forms `identical(e1, e2)`, `e1 == e2`,
  * `e1 != e2` where `e1` and `e2` are constant expressions that evaluate to a
  * numeric, string or boolean value or to `null`.
  * * An expression of one of the forms `!e`, `e1 && e2` or `e1 || e2`, where
  * `e`, `e1` and `e2` are constant expressions that evaluate to a boolean value or
  * to `null`.
  * * An expression of one of the forms `~e`, `e1 ^ e2`, `e1 & e2`,
  * `e1 | e2`, `e1 >> e2` or `e1 << e2`, where `e`, `e1` and `e2`
  * are constant expressions that evaluate to an integer value or to `null`.
  * * An expression of one of the forms `-e`, `e1 + e2`, `e1 - e2`,
  * `e1 * e2`, `e1 / e2`, `e1 ~/ e2`, `e1 > e2`, `e1 < e2`,
  * `e1 >= e2`, `e1 <= e2` or `e1 % e2`, where `e`, `e1` and `e2`
  * are constant expressions that evaluate to a numeric value or to `null`.
- *
  * </blockquote> The values returned by instances of this class are therefore `null` and
  * instances of the classes `Boolean`, `BigInteger`, `Double`, `String`, and
  * `DartObject`.
  *
  * 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> {
+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();
 
   Object visitAdjacentStrings(AdjacentStrings node) {
     JavaStringBuilder builder = new JavaStringBuilder();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
@@ skipping 194 matching lines @@
       if (key is! String || identical(value, NOT_A_CONSTANT)) {
         return NOT_A_CONSTANT;
       }
       map[(key as String)] = value;
     }
     return map;
   }
 
   Object visitMethodInvocation(MethodInvocation node) => visitNode(node);
 
-  Object visitNode(ASTNode node) => NOT_A_CONSTANT;
+  Object visitNode(AstNode node) => NOT_A_CONSTANT;
 
   Object visitNullLiteral(NullLiteral node) => null;
 
   Object visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) => getConstantValue(null);
 
   Object visitPrefixExpression(PrefixExpression node) {
     Object operand = node.operand.accept(this);
     if (identical(operand, NOT_A_CONSTANT)) {
@@ skipping 67 matching lines @@
       FieldElement field = element;
       if (field.isStatic && field.isConst) {
       }
     }
     return NOT_A_CONSTANT;
   }
 }
 
 /**
  * Instances of the class `ElementLocator` locate the [Element]
- * associated with a given [ASTNode].
- *
- * @coverage dart.engine.ast
+ * associated with a given [AstNode].
  */
 class ElementLocator {
   /**
-   * Locate the [Element] associated with the given [ASTNode].
+   * Locate the [Element] associated with the given [AstNode].
    *
    * @param node the node (not `null`)
    * @return the associated element, or `null` if none is found
    */
-  static Element locate(ASTNode node) {
+  static Element locate(AstNode node) {
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
     return node.accept(mapper);
   }
 
   /**
-   * Locate the [Element] associated with the given [ASTNode] and offset.
+   * Locate the [Element] associated with the given [AstNode] and offset.
    *
    * @param node the node (not `null`)
    * @param offset the offset relative to source
    * @return the associated element, or `null` if none is found
    */
-  static Element locate2(ASTNode node, int offset) {
+  static Element locate2(AstNode node, int offset) {
     // try to get Element from node
     {
       Element nodeElement = locate(node);
       if (nodeElement != null) {
         return nodeElement;
       }
     }
     // try to get Angular specific Element
     {
       Element element = null;
       if (element != null) {
         return element;
       }
     }
     // no Element
     return null;
   }
 }
 
 /**
  * Visitor that maps nodes to elements.
  */
-class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
+class ElementLocator_ElementMapper extends GeneralizingAstVisitor<Element> {
   Element visitAssignmentExpression(AssignmentExpression node) => node.bestElement;
 
   Element visitBinaryExpression(BinaryExpression node) => node.bestElement;
 
   Element visitClassDeclaration(ClassDeclaration node) => node.element;
 
   Element visitCompilationUnit(CompilationUnit node) => node.element;
 
   Element visitConstructorDeclaration(ConstructorDeclaration node) => node.element;
 
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
 
   Element visitIdentifier(Identifier node) {
-    ASTNode parent = node.parent;
+    AstNode parent = node.parent;
     // Type name in InstanceCreationExpression
     {
-      ASTNode typeNameCandidate = parent;
+      AstNode typeNameCandidate = parent;
       // new prefix.node[.constructorName]()
       if (typeNameCandidate is PrefixedIdentifier) {
         PrefixedIdentifier prefixedIdentifier = typeNameCandidate as PrefixedIdentifier;
         if (identical(prefixedIdentifier.identifier, node)) {
           typeNameCandidate = prefixedIdentifier.parent;
         }
       }
       // new typeName[.constructorName]()
       if (typeNameCandidate is TypeName) {
         TypeName typeName = typeNameCandidate as TypeName;
@@ skipping 12 matching lines @@
         if (name != null) {
           return name.bestElement;
         }
         Element element = node.bestElement;
         if (element is ClassElement) {
           return element.unnamedConstructor;
         }
       }
     }
     if (parent is LibraryIdentifier) {
-      ASTNode grandParent = parent.parent;
+      AstNode grandParent = parent.parent;
       if (grandParent is PartOfDirective) {
         Element element = grandParent.element;
         if (element is LibraryElement) {
           return element.definingCompilationUnit;
         }
       }
     }
     Element element = node.bestElement;
     if (element == null) {
       element = node.staticElement;
@@ skipping 13 matching lines @@
 
   Element visitMethodInvocation(MethodInvocation node) => node.methodName.bestElement;
 
   Element visitPostfixExpression(PostfixExpression node) => node.bestElement;
 
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.bestElement;
 
   Element visitPrefixExpression(PrefixExpression node) => node.bestElement;
 
   Element visitStringLiteral(StringLiteral node) {
-    ASTNode parent = node.parent;
+    AstNode parent = node.parent;
     if (parent is UriBasedDirective) {
       return parent.uriElement;
     }
     return null;
   }
 
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 
 /**
- * Instances of the class `GeneralizingASTVisitor` implement an AST visitor that will
+ * Instances of the class `GeneralizingAstVisitor` implement an AST visitor that will
  * recursively visit all of the nodes in an AST structure (like instances of the class
- * [RecursiveASTVisitor]). In addition, when a node of a specific type is visited not only
+ * [RecursiveAstVisitor]). In addition, when a node of a specific type is visited not only
  * will the visit method for that specific type of node be invoked, but additional methods for the
  * superclasses of that node will also be invoked. For example, using an instance of this class to
  * visit a [Block] will cause the method [visitBlock] to be invoked but will
  * also cause the methods [visitStatement] and [visitNode] 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 [Statement].
  *
  * 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> {
+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);
 
@@ skipping 142 matching lines @@
   R visitMethodInvocation(MethodInvocation node) => visitExpression(node);
 
   R visitNamedExpression(NamedExpression node) => visitExpression(node);
 
   R visitNamespaceDirective(NamespaceDirective node) => visitUriBasedDirective(node);
 
   R visitNativeClause(NativeClause node) => visitNode(node);
 
   R visitNativeFunctionBody(NativeFunctionBody node) => visitFunctionBody(node);
 
-  R visitNode(ASTNode node) {
+  R visitNode(AstNode node) {
     node.visitChildren(this);
     return null;
   }
 
   R visitNormalFormalParameter(NormalFormalParameter node) => visitFormalParameter(node);
 
   R visitNullLiteral(NullLiteral node) => visitLiteral(node);
 
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitExpression(node);
 
@@ skipping 72 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 `NodeLocator` locate the [ASTNode] associated with a
+ * Instances of the class `NodeLocator` locate the [AstNode] associated with a
  * source range, given the AST structure built from the source. More specifically, they will return
- * the [ASTNode] with the shortest length whose source range completely encompasses
+ * the [AstNode] with the shortest length whose source range completely encompasses
  * the specified range.
- *
- * @coverage dart.engine.ast
  */
-class NodeLocator extends UnifyingASTVisitor<Object> {
+class NodeLocator extends UnifyingAstVisitor<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 `null` if there
    * is no such element.
    */
-  ASTNode _foundNode;
+  AstNode _foundNode;
 
   /**
-   * Initialize a newly created locator to locate one or more [ASTNode] by locating
+   * Initialize a newly created locator to locate one or more [AstNode] 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) : this.con2(offset, offset);
 
   /**
-   * Initialize a newly created locator to locate one or more [ASTNode] by locating
+   * Initialize a newly created locator to locate one or more [AstNode] 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) {
     this._startOffset = start;
     this._endOffset = end;
   }
 
   /**
    * Return the node that was found that corresponds to the given source range, or `null` if
    * there is no such node.
    *
    * @return the node that was found
    */
-  ASTNode get foundNode => _foundNode;
+  AstNode get foundNode => _foundNode;
 
   /**
    * Search within the given AST node for an identifier representing a [DartElement] in the specified source range. Return the element that was found, or `null` if
    * no element was found.
    *
    * @param node the AST node within which to search
    * @return the element that was found
    */
-  ASTNode searchWithin(ASTNode node) {
+  AstNode searchWithin(AstNode node) {
     if (node == null) {
       return null;
     }
     try {
       node.accept(this);
     } on NodeLocator_NodeFoundException catch (exception) {
     } on JavaException catch (exception) {
       AnalysisEngine.instance.logger.logInformation3("Unable to locate element at offset (${_startOffset} - ${_endOffset})", exception);
       return null;
     }
     return _foundNode;
   }
 
-  Object visitNode(ASTNode node) {
+  Object visitNode(AstNode node) {
     int start = node.offset;
     int end = start + node.length;
     if (end < _startOffset) {
       return null;
     }
     if (start > _endOffset) {
       return null;
     }
     try {
       node.visitChildren(this);
@@ skipping 13 matching lines @@
 
 /**
  * Instances of the class `NodeFoundException` are used to cancel visiting after a node has
  * been found.
  */
 class NodeLocator_NodeFoundException extends RuntimeException {
   static int _serialVersionUID = 1;
 }
 
 /**
- * Instances of the class `RecursiveASTVisitor` implement an AST visitor that will recursively
+ * Instances of the class `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 [Block] will also cause all of the statements in the block to be visited.
  *
  * 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> {
+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 497 matching lines @@
     return null;
   }
 
   R visitWithClause(WithClause node) {
     node.visitChildren(this);
     return null;
   }
 }
 
 /**
- * Instances of the class `SimpleASTVisitor` implement an AST visitor that will do nothing
+ * Instances of the class `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> {
+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;
 
@@ skipping 190 matching lines @@
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => null;
 
   R visitWhileStatement(WhileStatement node) => null;
 
   R visitWithClause(WithClause node) => null;
 }
 
 /**
  * Instances of the class `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> {
+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 808 matching lines @@
     _writer.print("with ");
     visitList2(node.mixinTypes, ", ");
     return null;
   }
 
   /**
    * Safely visit the given node.
    *
    * @param node the node to be visited
    */
-  void visit(ASTNode node) {
+  void visit(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
   /**
    * Safely visit the given node, printing the suffix after the node if it is non-`null`.
    *
    * @param suffix the suffix to be printed if there is a node to visit
    * @param node the node to be visited
    */
-  void visit2(ASTNode node, String suffix) {
+  void visit2(AstNode node, String suffix) {
     if (node != null) {
       node.accept(this);
       _writer.print(suffix);
     }
   }
 
   /**
    * Safely visit the given node, printing the prefix before the node if it is non-`null`.
    *
    * @param prefix the prefix to be printed if there is a node to visit
    * @param node the node to be visited
    */
-  void visit3(String prefix, ASTNode node) {
+  void visit3(String prefix, AstNode node) {
     if (node != null) {
       _writer.print(prefix);
       node.accept(this);
     }
   }
 
   /**
    * Visit the given function body, printing the prefix before if given body is not empty.
    *
    * @param prefix the prefix to be printed if there is a node to visit
@@ skipping 18 matching lines @@
       _writer.print(suffix);
     }
   }
 
   /**
    * Print a list of nodes without any separation.
    *
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    */
-  void visitList(NodeList<ASTNode> nodes) {
+  void visitList(NodeList<AstNode> nodes) {
     visitList2(nodes, "");
   }
 
   /**
    * Print a list of nodes, separated by the given separator.
    *
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    */
-  void visitList2(NodeList<ASTNode> nodes, String separator) {
+  void visitList2(NodeList<AstNode> nodes, String separator) {
     if (nodes != null) {
       int size = nodes.length;
       for (int i = 0; i < size; i++) {
         if (i > 0) {
           _writer.print(separator);
         }
         nodes[i].accept(this);
       }
     }
   }
 
   /**
    * Print a list of nodes, separated by the given separator.
    *
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    * @param suffix the suffix to be printed if the list is not empty
    */
-  void visitList3(NodeList<ASTNode> nodes, String separator, String suffix) {
+  void visitList3(NodeList<AstNode> nodes, String separator, String suffix) {
     if (nodes != null) {
       int size = nodes.length;
       if (size > 0) {
         for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
         _writer.print(suffix);
       }
     }
   }
 
   /**
    * Print a list of nodes, separated by the given separator.
    *
    * @param prefix the prefix to be printed if the list is not empty
    * @param nodes the nodes to be printed
    * @param separator the separator to be printed between adjacent nodes
    */
-  void visitList4(String prefix, NodeList<ASTNode> nodes, String separator) {
+  void visitList4(String prefix, NodeList<AstNode> nodes, String separator) {
     if (nodes != null) {
       int size = nodes.length;
       if (size > 0) {
         _writer.print(prefix);
         for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }
 
 /**
- * Instances of the class `UnifyingASTVisitor` implement an AST visitor that will recursively
+ * Instances of the class `UnifyingAstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure (like instances of the class
- * [RecursiveASTVisitor]). In addition, every node will also be visited by using a single
+ * [RecursiveAstVisitor]). In addition, every node will also be visited by using a single
  * unified [visitNode] method.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general [visitNode] method. Failure to do so will
  * cause the children of the visited node to not be visited.
- *
- * @coverage dart.engine.ast
  */
-class UnifyingASTVisitor<R> implements ASTVisitor<R> {
+class UnifyingAstVisitor<R> implements AstVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) => visitNode(node);
 
   R visitAnnotation(Annotation node) => visitNode(node);
 
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => visitNode(node);
 
   R visitArgumentList(ArgumentList node) => visitNode(node);
 
   R visitAsExpression(AsExpression node) => visitNode(node);
 
@@ skipping 114 matching lines @@
   R visitMethodDeclaration(MethodDeclaration node) => visitNode(node);
 
   R visitMethodInvocation(MethodInvocation node) => visitNode(node);
 
   R visitNamedExpression(NamedExpression node) => visitNode(node);
 
   R visitNativeClause(NativeClause node) => visitNode(node);
 
   R visitNativeFunctionBody(NativeFunctionBody node) => visitNode(node);
 
-  R visitNode(ASTNode node) {
+  R visitNode(AstNode node) {
     node.visitChildren(this);
     return null;
   }
 
   R visitNullLiteral(NullLiteral node) => visitNode(node);
 
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitNode(node);
 
   R visitPartDirective(PartDirective node) => visitNode(node);
 
@@ skipping 58 matching lines @@
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
 
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitNode(node);
 
   R visitWhileStatement(WhileStatement node) => visitNode(node);
 
   R visitWithClause(WithClause node) => visitNode(node);
 }
 
 /**
- * Instances of the class `ASTCloner` implement an object that will clone any AST structure
+ * Instances of the class `AstCloner` implement an object that will clone any AST structure
  * that it visits. The cloner will only clone the structure, it will not preserve any resolution
  * results or properties associated with the nodes.
  */
-class ASTCloner implements ASTVisitor<ASTNode> {
+class AstCloner implements AstVisitor<AstNode> {
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(clone3(node.strings));
 
   Annotation visitAnnotation(Annotation node) => new Annotation(node.atSign, clone2(node.name), node.period, clone2(node.constructorName), clone2(node.arguments));
 
   ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest(node.question, clone2(node.identifier));
 
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(node.leftParenthesis, clone3(node.arguments), node.rightParenthesis);
 
   AsExpression visitAsExpression(AsExpression node) => new AsExpression(clone2(node.expression), node.asOperator, clone2(node.type));
 
-  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
+  AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
 
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression(clone2(node.leftHandSide), node.operator, clone2(node.rightHandSide));
 
   BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression(clone2(node.leftOperand), node.operator, clone2(node.rightOperand));
 
   Block visitBlock(Block node) => new Block(node.leftBracket, clone3(node.statements), node.rightBracket);
 
   BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(clone2(node.block));
 
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral(node.literal, node.value);
@@ skipping 127 matching lines @@
   MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral(node.constKeyword, clone2(node.typeArguments), node.leftBracket, clone3(node.entries), node.rightBracket);
 
   MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry(clone2(node.key), node.separator, clone2(node.value));
 
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, node.modifierKeyword, clone2(node.returnType), node.propertyKeyword, node.operatorKeyword, clone2(node.name), clone2(node.parameters), clone2(node.body));
 
   MethodInvocation visitMethodInvocation(MethodInvocation node) => new MethodInvocation(clone2(node.target), node.period, clone2(node.methodName), clone2(node.argumentList));
 
   NamedExpression visitNamedExpression(NamedExpression node) => new NamedExpression(clone2(node.name), clone2(node.expression));
 
-  ASTNode visitNativeClause(NativeClause node) => new NativeClause(node.keyword, clone2(node.name));
+  AstNode visitNativeClause(NativeClause node) => new NativeClause(node.keyword, clone2(node.name));
 
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody(node.nativeToken, clone2(node.stringLiteral), node.semicolon);
 
   NullLiteral visitNullLiteral(NullLiteral node) => new NullLiteral(node.literal);
 
   ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) => new ParenthesizedExpression(node.leftParenthesis, clone2(node.expression), node.rightParenthesis);
 
   PartDirective visitPartDirective(PartDirective node) => new PartDirective(clone2(node.documentationComment), clone3(node.metadata), node.partToken, clone2(node.uri), node.semicolon);
 
   PartOfDirective visitPartOfDirective(PartOfDirective node) => new PartOfDirective(clone2(node.documentationComment), clone3(node.metadata), node.partToken, node.ofToken, clone2(node.libraryName), node.semicolon);
@@ skipping 27 matching lines @@
   SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) => new SuperConstructorInvocation(node.keyword, node.period, clone2(node.constructorName), clone2(node.argumentList));
 
   SuperExpression visitSuperExpression(SuperExpression node) => new SuperExpression(node.keyword);
 
   SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(clone3(node.labels), node.keyword, clone2(node.expression), node.colon, clone3(node.statements));
 
   SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(clone3(node.labels), node.keyword, node.colon, clone3(node.statements));
 
   SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(node.keyword, node.leftParenthesis, clone2(node.expression), node.rightParenthesis, node.leftBracket, clone3(node.members), node.rightBracket);
 
-  ASTNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(node.poundSign, node.components);
+  AstNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(node.poundSign, node.components);
 
   ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression(node.keyword);
 
   ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression(node.keyword, clone2(node.expression));
 
   TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(clone2(node.documentationComment), clone3(node.metadata), clone2(node.variables), node.semicolon);
 
   TryStatement visitTryStatement(TryStatement node) => new TryStatement(node.tryKeyword, clone2(node.body), clone3(node.catchClauses), node.finallyKeyword, clone2(node.finallyBlock));
 
   TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList(node.leftBracket, clone3(node.arguments), node.rightBracket);
 
   TypeName visitTypeName(TypeName node) => new TypeName(clone2(node.name), clone2(node.typeArguments));
 
   TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(clone2(node.documentationComment), clone3(node.metadata), clone2(node.name), node.keyword, clone2(node.bound));
 
   TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList(node.leftBracket, clone3(node.typeParameters), node.rightBracket);
 
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration(null, clone3(node.metadata), clone2(node.name), node.equals, clone2(node.initializer));
 
   VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList(null, clone3(node.metadata), node.keyword, clone2(node.type), clone3(node.variables));
 
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(clone2(node.variables), node.semicolon);
 
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.body));
 
   WithClause visitWithClause(WithClause node) => new WithClause(node.withKeyword, clone3(node.mixinTypes));
 
-  ASTNode clone2(ASTNode node) {
+  AstNode clone2(AstNode node) {
     if (node == null) {
       return null;
     }
-    return node.accept(this) as ASTNode;
+    return node.accept(this) as AstNode;
   }
 
   List clone3(NodeList nodes) {
     int count = nodes.length;
     List clonedNodes = new List();
     for (int i = 0; i < count; i++) {
-      clonedNodes.add((nodes[i]).accept(this) as ASTNode);
+      clonedNodes.add((nodes[i]).accept(this) as AstNode);
     }
     return clonedNodes;
   }
 }
 
 /**
- * Instances of the class `ASTComparator` compare the structure of two ASTNodes to see whether
+ * Instances of the class `AstComparator` compare the structure of two ASTNodes to see whether
  * they are equal.
  */
-class ASTComparator implements ASTVisitor<bool> {
+class AstComparator implements AstVisitor<bool> {
   /**
    * Return `true` if the two AST nodes are equal.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the two AST nodes are equal
    */
   static bool equals4(CompilationUnit first, CompilationUnit second) {
-    ASTComparator comparator = new ASTComparator();
+    AstComparator comparator = new AstComparator();
     return comparator.isEqual(first, second);
   }
 
   /**
    * The AST node with which the node being visited is to be compared. This is only valid at the
    * beginning of each visit method (until [isEqual] is invoked).
    */
-  ASTNode _other;
+  AstNode _other;
 
   bool visitAdjacentStrings(AdjacentStrings node) {
     AdjacentStrings other = this._other as AdjacentStrings;
     return isEqual5(node.strings, other.strings);
   }
 
   bool visitAnnotation(Annotation node) {
     Annotation other = this._other as Annotation;
     return isEqual6(node.atSign, other.atSign) && isEqual(node.name, other.name) && isEqual6(node.period, other.period) && isEqual(node.constructorName, other.constructorName) && isEqual(node.arguments, other.arguments);
   }
@@ skipping 503 matching lines @@
     return isEqual6(node.withKeyword, other.withKeyword) && isEqual5(node.mixinTypes, other.mixinTypes);
   }
 
   /**
    * Return `true` if the given AST nodes have the same structure.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the given AST nodes have the same structure
    */
-  bool isEqual(ASTNode first, ASTNode second) {
+  bool isEqual(AstNode first, AstNode second) {
     if (first == null) {
       return second == null;
     } else if (second == null) {
       return false;
     } else if (first.runtimeType != second.runtimeType) {
       return false;
     }
     _other = second;
     return first.accept(this);
   }
@@ skipping 58 matching lines @@
     for (int i = 0; i < length; i++) {
       if (isEqual6(first[i], second[i])) {
         return false;
       }
     }
     return true;
   }
 }
 
 /**
- * Instances of the class `IncrementalASTCloner` implement an object that will clone any AST
+ * Instances of the class `IncrementalAstCloner` implement an object that will clone any AST
  * structure that it visits. The cloner will clone the structure, replacing the specified ASTNode
  * with a new ASTNode, mapping the old token stream to a new token stream, and preserving resolution
  * results.
  */
-class IncrementalASTCloner implements ASTVisitor<ASTNode> {
+class IncrementalAstCloner implements AstVisitor<AstNode> {
   /**
    * The node to be replaced during the cloning process.
    */
-  ASTNode _oldNode;
+  AstNode _oldNode;
 
   /**
    * The replacement node used during the cloning process.
    */
-  ASTNode _newNode;
+  AstNode _newNode;
 
   /**
    * A mapping of old tokens to new tokens used during the cloning process.
    */
   TokenMap _tokenMap;
 
   /**
    * Construct a new instance that will replace `oldNode` with `newNode` in the process
    * of cloning an existing AST structure.
    *
    * @param oldNode the node to be replaced
    * @param newNode the replacement node
    * @param tokenMap a mapping of old tokens to new tokens (not `null`)
    */
-  IncrementalASTCloner(ASTNode oldNode, ASTNode newNode, TokenMap tokenMap) {
+  IncrementalAstCloner(AstNode oldNode, AstNode newNode, TokenMap tokenMap) {
     this._oldNode = oldNode;
     this._newNode = newNode;
     this._tokenMap = tokenMap;
   }
 
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(clone5(node.strings));
 
   Annotation visitAnnotation(Annotation node) {
     Annotation copy = new Annotation(map(node.atSign), clone4(node.name), map(node.period), clone4(node.constructorName), clone4(node.arguments));
     copy.element = node.element;
     return copy;
   }
 
   ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     ArgumentDefinitionTest copy = new ArgumentDefinitionTest(map(node.question), clone4(node.identifier));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(map(node.leftParenthesis), clone5(node.arguments), map(node.rightParenthesis));
 
   AsExpression visitAsExpression(AsExpression node) {
     AsExpression copy = new AsExpression(clone4(node.expression), map(node.asOperator), clone4(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), map(node.semicolon));
+  AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), map(node.semicolon));
 
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression copy = new AssignmentExpression(clone4(node.leftHandSide), map(node.operator), clone4(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
@@ skipping 235 matching lines @@
     return copy;
   }
 
   NamedExpression visitNamedExpression(NamedExpression node) {
     NamedExpression copy = new NamedExpression(clone4(node.name), clone4(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  ASTNode visitNativeClause(NativeClause node) => new NativeClause(map(node.keyword), clone4(node.name));
+  AstNode visitNativeClause(NativeClause node) => new NativeClause(map(node.keyword), clone4(node.name));
 
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody(map(node.nativeToken), clone4(node.stringLiteral), map(node.semicolon));
 
   NullLiteral visitNullLiteral(NullLiteral node) {
     NullLiteral copy = new NullLiteral(map(node.literal));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
@@ skipping 113 matching lines @@
     copy.staticType = node.staticType;
     return copy;
   }
 
   SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(clone5(node.labels), map(node.keyword), clone4(node.expression), map(node.colon), clone5(node.statements));
 
   SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(clone5(node.labels), map(node.keyword), map(node.colon), clone5(node.statements));
 
   SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.expression), map(node.rightParenthesis), map(node.leftBracket), clone5(node.members), map(node.rightBracket));
 
-  ASTNode visitSymbolLiteral(SymbolLiteral node) {
+  AstNode visitSymbolLiteral(SymbolLiteral node) {
     SymbolLiteral copy = new SymbolLiteral(map(node.poundSign), map2(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ThisExpression visitThisExpression(ThisExpression node) {
     ThisExpression copy = new ThisExpression(map(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
@@ skipping 26 matching lines @@
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration(null, clone5(node.metadata), clone4(node.name), map(node.equals), clone4(node.initializer));
 
   VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList(null, clone5(node.metadata), map(node.keyword), clone4(node.type), clone5(node.variables));
 
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(clone4(node.variables), map(node.semicolon));
 
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), clone4(node.body));
 
   WithClause visitWithClause(WithClause node) => new WithClause(map(node.withKeyword), clone5(node.mixinTypes));
 
-  ASTNode clone4(ASTNode node) {
+  AstNode clone4(AstNode node) {
     if (node == null) {
       return null;
     }
     if (identical(node, _oldNode)) {
       return _newNode;
     }
-    return node.accept(this) as ASTNode;
+    return node.accept(this) as AstNode;
   }
 
   List clone5(NodeList nodes) {
     List clonedNodes = new List();
-    for (ASTNode node in nodes) {
+    for (AstNode node in nodes) {
       clonedNodes.add(clone4(node));
     }
     return clonedNodes;
   }
 
   Token map(Token oldToken) {
     if (oldToken == null) {
       return null;
     }
     return _tokenMap.get(oldToken);
   }
 
   List<Token> map2(List<Token> oldTokens) {
     List<Token> newTokens = new List<Token>(oldTokens.length);
     for (int index = 0; index < newTokens.length; index++) {
       newTokens[index] = map(oldTokens[index]);
     }
     return newTokens;
   }
 }
 
 /**
  * Traverse the AST from initial child node to successive parents, building a collection of local
  * variable and parameter names visible to the initial child node. In case of name shadowing, the
  * first name seen is the most specific one so names are not redefined.
  *
  * Completion test code coverage is 95%. The two basic blocks that are not executed cannot be
  * executed. They are included for future reference.
- *
- * @coverage com.google.dart.engine.services.completion
  */
-class ScopedNameFinder extends GeneralizingASTVisitor<Object> {
+class ScopedNameFinder extends GeneralizingAstVisitor<Object> {
   Declaration _declarationNode;
 
-  ASTNode _immediateChild;
+  AstNode _immediateChild;
 
   Map<String, SimpleIdentifier> _locals = new Map<String, SimpleIdentifier>();
 
   int _position = 0;
 
   bool _referenceIsWithinLocalFunction = false;
 
   ScopedNameFinder(int position) {
     this._position = position;
   }
@@ skipping 65 matching lines @@
     _declarationNode = node;
     if (node.parameters == null) {
       return null;
     }
     if (_immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
     return null;
   }
 
-  Object visitNode(ASTNode node) {
+  Object visitNode(AstNode node) {
     _immediateChild = node;
-    ASTNode parent = node.parent;
+    AstNode parent = node.parent;
     if (parent != null) {
       parent.accept(this);
     }
     return null;
   }
 
   Object visitSwitchMember(SwitchMember node) {
     checkStatements(node.statements);
     return super.visitSwitchMember(node);
   }
@@ skipping 40 matching lines @@
         return;
       }
       if (stmt is VariableDeclarationStatement) {
         addVariables(stmt.variables.variables);
       } else if (stmt is FunctionDeclarationStatement && !_referenceIsWithinLocalFunction) {
         addToScope(stmt.functionDeclaration.name);
       }
     }
   }
 
-  bool isInRange(ASTNode node) {
+  bool isInRange(AstNode node) {
     if (_position < 0) {
       // if source position is not set then all nodes are in range
       return true;
     }
     return node.end < _position;
   }
 }
 /**
  * Instances of the class {@code NodeList} represent a list of AST nodes that have a common parent.
  */
-class NodeList<E extends ASTNode> extends Object with ListMixin<E> {
+class NodeList<E extends AstNode> extends Object with ListMixin<E> {
   /**
    * Create an empty list with the given owner. This is a convenience method that allows the
    * compiler to determine the correct value of the type argument [E] without needing to
    * explicitly specify it.
    *
    * @param owner the node that is the parent of each of the elements in the list
    * @return the list that was created
    */
-  static NodeList create(ASTNode owner) => new NodeList(owner);
+  static NodeList create(AstNode owner) => new NodeList(owner);
 
   /**
    * The node that is the parent of each of the elements in the list.
    */
-  ASTNode owner;
+  AstNode owner;
 
   /**
    * The elements contained in the list.
    */
   List<E> _elements = <E> [];
 
   /**
    * Initialize a newly created list of nodes to be empty.
    *
    * @param owner the node that is the parent of each of the elements in the list
    */
   NodeList(this.owner);
 
   /**
    * Use the given visitor to visit each of the nodes in this list.
    *
    * @param visitor the visitor to be used to visit the elements of this list
    */
-  accept(ASTVisitor visitor) {
+  accept(AstVisitor visitor) {
     var length = _elements.length;
     for (var i = 0; i < length; i++) {
       _elements[i].accept(visitor);
     }
   }
   void add(E node) {
     insert(length, node);
   }
   void insert(int index, E node) {
     int length = _elements.length;
@@ skipping 47 matching lines @@
     }
     return _elements[_elements.length - 1].endToken;
   }
   E removeAt(int index) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: ${index}, Size: ${_elements.length}");
     }
     E removedNode = _elements[index] as E;
     int length = _elements.length;
     if (length == 1) {
-      _elements = ASTNode.EMPTY_ARRAY;
+      _elements = AstNode.EMPTY_ARRAY;
       return removedNode;
     }
     _elements.removeAt(index);
     return removedNode;
   }
   void operator[]=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: ${index}, Size: ${_elements.length}");
     }
     owner.becomeParentOf(node);
     _elements[index] = node;
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }