Code clean-up and minor bug fix

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';
@@ skipping 25 matching lines @@
    * 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);
+    _strings = new NodeList<StringLiteral>(this, strings);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAdjacentStrings(this);
 
   @override
   Token get beginToken => _strings.beginToken;
 
   @override
   Token get endToken => _strings.endToken;
@@ skipping 34 matching lines @@
    */
   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);
+    _comment = becomeParentOf(comment);
+    _metadata = new NodeList<Annotation>(this, metadata);
   }
 
   @override
   Token get beginToken {
     if (_comment == null) {
       if (_metadata.isEmpty) {
         return firstTokenAfterCommentAndMetadata;
-      } else {
-        return _metadata.beginToken;
       }
+      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;
   }
@@ skipping 12 matching lines @@
    * @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);
+    _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);
+    _metadata.clear();
+    _metadata.addAll(metadata);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     if (_commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (AstNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
@@ skipping 96 matching lines @@
    * @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);
+    _name = becomeParentOf(name);
+    _constructorName = becomeParentOf(constructorName);
+    _arguments = becomeParentOf(arguments);
   }
 
   @override
   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
@@ skipping 13 matching lines @@
 
   /**
    * 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) {
+    } else if (_name != null) {
       return _name.staticElement;
     }
     return null;
   }
 
   @override
   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);
+    _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);
+    _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;
+    _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);
+    _name = becomeParentOf(name);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, 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;
+  Token leftParenthesis;
 
   /**
    * The expressions producing the values of the arguments.
    */
   NodeList<Expression> _arguments;
 
   /**
    * The right parenthesis.
    */
-  Token _rightParenthesis;
+  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;
+  ArgumentList(this.leftParenthesis, List<Expression> arguments, this.rightParenthesis) {
+    _arguments = new NodeList<Expression>(this, arguments);
   }
 
   @override
   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;
 
   @override
-  Token get beginToken => _leftParenthesis;
+  Token get beginToken => leftParenthesis;
 
   @override
-  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;
+  Token get endToken => 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) {
@@ skipping 11 matching lines @@
    *
    * @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;
-  }
-
   @override
   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.
@@ skipping 68 matching lines @@
 
   /**
    * 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 asOperator the as 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);
+  AsExpression(Expression expression, this.asOperator, TypeName type) {
+    _expression = becomeParentOf(expression);
+    _type = becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAsExpression(this);
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Token get endToken => _type.endToken;
@@ skipping 14 matching lines @@
    * @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);
+    _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);
+    _type = becomeParentOf(name);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 
 /**
@@ skipping 33 matching lines @@
   /**
    * 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);
+    _condition = becomeParentOf(condition);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
 
   @override
   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;
 
   @override
   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);
+    _condition = becomeParentOf(condition);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
  * Instances of the class `AssignmentExpression` represent an assignment expression.
@@ skipping 17 matching lines @@
   /**
    * 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;
+  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;
+  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) {
     if (leftHandSide == null || rightHandSide == null) {
       String message;
       if (leftHandSide == null) {
         if (rightHandSide == null) {
           message = "Both the left-hand and right-hand sides are null";
         } else {
           message = "The left-hand size is null";
         }
       } else {
         message = "The right-hand size is null";
       }
       AnalysisEngine.instance.logger.logError(
           message,
           new CaughtException(new AnalysisException(message), null));
     }
-    this._leftHandSide = becomeParentOf(leftHandSide);
-    this._rightHandSide = becomeParentOf(rightHandSide);
+    _leftHandSide = becomeParentOf(leftHandSide);
+    _rightHandSide = becomeParentOf(rightHandSide);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAssignmentExpression(this);
 
   @override
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
@@ skipping 18 matching lines @@
    * 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;
 
   @override
   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;
-  }
-
   @override
   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.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
-    if (_propagatedElement != null) {
-      executableElement = _propagatedElement;
+    if (propagatedElement != null) {
+      executableElement = propagatedElement;
     } else {
       if (_leftHandSide is Identifier) {
         Identifier identifier = _leftHandSide as Identifier;
         Element leftElement = identifier.propagatedElement;
         if (leftElement is ExecutableElement) {
           executableElement = leftElement;
         }
       }
       if (_leftHandSide is PropertyAccess) {
         SimpleIdentifier identifier = (_leftHandSide as PropertyAccess).propertyName;
@@ skipping 18 matching lines @@
    * 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.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
-    if (_staticElement != null) {
-      executableElement = _staticElement;
+    if (staticElement != null) {
+      executableElement = staticElement;
     } else {
       if (_leftHandSide is Identifier) {
         Element leftElement = (_leftHandSide as Identifier).staticElement;
         if (leftElement is ExecutableElement) {
           executableElement = leftElement;
         }
       }
       if (_leftHandSide is PropertyAccess) {
         Element leftElement = (_leftHandSide as PropertyAccess).propertyName.staticElement;
         if (leftElement is ExecutableElement) {
@@ skipping 941 matching lines @@
   }
 
   /**
    * 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 [isEqualNodes] is invoked).
    */
   AstNode _other;
 
   @override
   bool visitAdjacentStrings(AdjacentStrings node) {
-    AdjacentStrings other = this._other as AdjacentStrings;
+    AdjacentStrings other = _other as AdjacentStrings;
     return _isEqualNodeLists(node.strings, other.strings);
   }
 
   @override
   bool visitAnnotation(Annotation node) {
-    Annotation other = this._other as Annotation;
+    Annotation other = _other as Annotation;
     return isEqualTokens(node.atSign, other.atSign) && isEqualNodes(node.name, other.name) && isEqualTokens(node.period, other.period) && isEqualNodes(node.constructorName, other.constructorName) && isEqualNodes(node.arguments, other.arguments);
   }
 
   @override
   bool visitArgumentList(ArgumentList node) {
-    ArgumentList other = this._other as ArgumentList;
+    ArgumentList other = _other as ArgumentList;
     return isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodeLists(node.arguments, other.arguments) && isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
   @override
   bool visitAsExpression(AsExpression node) {
-    AsExpression other = this._other as AsExpression;
+    AsExpression other = _other as AsExpression;
     return isEqualNodes(node.expression, other.expression) && isEqualTokens(node.asOperator, other.asOperator) && isEqualNodes(node.type, other.type);
   }
 
   @override
   bool visitAssertStatement(AssertStatement node) {
-    AssertStatement other = this._other as AssertStatement;
+    AssertStatement other = _other as AssertStatement;
     return isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.condition, other.condition) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
-    AssignmentExpression other = this._other as AssignmentExpression;
+    AssignmentExpression other = _other as AssignmentExpression;
     return isEqualNodes(node.leftHandSide, other.leftHandSide) && isEqualTokens(node.operator, other.operator) && isEqualNodes(node.rightHandSide, other.rightHandSide);
   }
 
   @override
   bool visitAwaitExpression(AwaitExpression node) {
-    AwaitExpression other = this._other as AwaitExpression;
+    AwaitExpression other = _other as AwaitExpression;
     return isEqualTokens(node.awaitKeyword, other.awaitKeyword) && isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitBinaryExpression(BinaryExpression node) {
-    BinaryExpression other = this._other as BinaryExpression;
+    BinaryExpression other = _other as BinaryExpression;
     return isEqualNodes(node.leftOperand, other.leftOperand) && isEqualTokens(node.operator, other.operator) && isEqualNodes(node.rightOperand, other.rightOperand);
   }
 
   @override
   bool visitBlock(Block node) {
-    Block other = this._other as Block;
+    Block other = _other as Block;
     return isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.statements, other.statements) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitBlockFunctionBody(BlockFunctionBody node) {
-    BlockFunctionBody other = this._other as BlockFunctionBody;
+    BlockFunctionBody other = _other as BlockFunctionBody;
     return isEqualNodes(node.block, other.block);
   }
 
   @override
   bool visitBooleanLiteral(BooleanLiteral node) {
-    BooleanLiteral other = this._other as BooleanLiteral;
+    BooleanLiteral other = _other as BooleanLiteral;
     return isEqualTokens(node.literal, other.literal) && node.value == other.value;
   }
 
   @override
   bool visitBreakStatement(BreakStatement node) {
-    BreakStatement other = this._other as BreakStatement;
+    BreakStatement other = _other as BreakStatement;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.label, other.label) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitCascadeExpression(CascadeExpression node) {
-    CascadeExpression other = this._other as CascadeExpression;
+    CascadeExpression other = _other as CascadeExpression;
     return isEqualNodes(node.target, other.target) && _isEqualNodeLists(node.cascadeSections, other.cascadeSections);
   }
 
   @override
   bool visitCatchClause(CatchClause node) {
-    CatchClause other = this._other as CatchClause;
+    CatchClause other = _other as CatchClause;
     return isEqualTokens(node.onKeyword, other.onKeyword) && isEqualNodes(node.exceptionType, other.exceptionType) && isEqualTokens(node.catchKeyword, other.catchKeyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.exceptionParameter, other.exceptionParameter) && isEqualTokens(node.comma, other.comma) && isEqualNodes(node.stackTraceParameter, other.stackTraceParameter) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitClassDeclaration(ClassDeclaration node) {
-    ClassDeclaration other = this._other as ClassDeclaration;
+    ClassDeclaration other = _other as ClassDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.abstractKeyword, other.abstractKeyword) && isEqualTokens(node.classKeyword, other.classKeyword) && isEqualNodes(node.name, other.name) && isEqualNodes(node.typeParameters, other.typeParameters) && isEqualNodes(node.extendsClause, other.extendsClause) && isEqualNodes(node.withClause, other.withClause) && isEqualNodes(node.implementsClause, other.implementsClause) && isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.members, other.members) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitClassTypeAlias(ClassTypeAlias node) {
-    ClassTypeAlias other = this._other as ClassTypeAlias;
+    ClassTypeAlias other = _other as ClassTypeAlias;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.name, other.name) && isEqualNodes(node.typeParameters, other.typeParameters) && isEqualTokens(node.equals, other.equals) && isEqualTokens(node.abstractKeyword, other.abstractKeyword) && isEqualNodes(node.superclass, other.superclass) && isEqualNodes(node.withClause, other.withClause) && isEqualNodes(node.implementsClause, other.implementsClause) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitComment(Comment node) {
-    Comment other = this._other as Comment;
+    Comment other = _other as Comment;
     return _isEqualNodeLists(node.references, other.references);
   }
 
   @override
   bool visitCommentReference(CommentReference node) {
-    CommentReference other = this._other as CommentReference;
+    CommentReference other = _other as CommentReference;
     return isEqualTokens(node.newKeyword, other.newKeyword) && isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitCompilationUnit(CompilationUnit node) {
-    CompilationUnit other = this._other as CompilationUnit;
+    CompilationUnit other = _other as CompilationUnit;
     return isEqualTokens(node.beginToken, other.beginToken) && isEqualNodes(node.scriptTag, other.scriptTag) && _isEqualNodeLists(node.directives, other.directives) && _isEqualNodeLists(node.declarations, other.declarations) && isEqualTokens(node.endToken, other.endToken);
   }
 
   @override
   bool visitConditionalExpression(ConditionalExpression node) {
-    ConditionalExpression other = this._other as ConditionalExpression;
+    ConditionalExpression other = _other as ConditionalExpression;
     return isEqualNodes(node.condition, other.condition) && isEqualTokens(node.question, other.question) && isEqualNodes(node.thenExpression, other.thenExpression) && isEqualTokens(node.colon, other.colon) && isEqualNodes(node.elseExpression, other.elseExpression);
   }
 
   @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
-    ConstructorDeclaration other = this._other as ConstructorDeclaration;
+    ConstructorDeclaration other = _other as ConstructorDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.externalKeyword, other.externalKeyword) && isEqualTokens(node.constKeyword, other.constKeyword) && isEqualTokens(node.factoryKeyword, other.factoryKeyword) && isEqualNodes(node.returnType, other.returnType) && isEqualTokens(node.period, other.period) && isEqualNodes(node.name, other.name) && isEqualNodes(node.parameters, other.parameters) && isEqualTokens(node.separator, other.separator) && _isEqualNodeLists(node.initializers, other.initializers) && isEqualNodes(node.redirectedConstructor, other.redirectedConstructor) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
-    ConstructorFieldInitializer other = this._other as ConstructorFieldInitializer;
+    ConstructorFieldInitializer other = _other as ConstructorFieldInitializer;
     return isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.period, other.period) && isEqualNodes(node.fieldName, other.fieldName) && isEqualTokens(node.equals, other.equals) && isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitConstructorName(ConstructorName node) {
-    ConstructorName other = this._other as ConstructorName;
+    ConstructorName other = _other as ConstructorName;
     return isEqualNodes(node.type, other.type) && isEqualTokens(node.period, other.period) && isEqualNodes(node.name, other.name);
   }
 
   @override
   bool visitContinueStatement(ContinueStatement node) {
-    ContinueStatement other = this._other as ContinueStatement;
+    ContinueStatement other = _other as ContinueStatement;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.label, other.label) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitDeclaredIdentifier(DeclaredIdentifier node) {
-    DeclaredIdentifier other = this._other as DeclaredIdentifier;
+    DeclaredIdentifier other = _other as DeclaredIdentifier;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.type, other.type) && isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitDefaultFormalParameter(DefaultFormalParameter node) {
-    DefaultFormalParameter other = this._other as DefaultFormalParameter;
+    DefaultFormalParameter other = _other as DefaultFormalParameter;
     return isEqualNodes(node.parameter, other.parameter) && node.kind == other.kind && isEqualTokens(node.separator, other.separator) && isEqualNodes(node.defaultValue, other.defaultValue);
   }
 
   @override
   bool visitDoStatement(DoStatement node) {
-    DoStatement other = this._other as DoStatement;
+    DoStatement other = _other as DoStatement;
     return isEqualTokens(node.doKeyword, other.doKeyword) && isEqualNodes(node.body, other.body) && isEqualTokens(node.whileKeyword, other.whileKeyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.condition, other.condition) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitDoubleLiteral(DoubleLiteral node) {
-    DoubleLiteral other = this._other as DoubleLiteral;
+    DoubleLiteral other = _other as DoubleLiteral;
     return isEqualTokens(node.literal, other.literal) && node.value == other.value;
   }
 
   @override
   bool visitEmptyFunctionBody(EmptyFunctionBody node) {
-    EmptyFunctionBody other = this._other as EmptyFunctionBody;
+    EmptyFunctionBody other = _other as EmptyFunctionBody;
     return isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitEmptyStatement(EmptyStatement node) {
-    EmptyStatement other = this._other as EmptyStatement;
+    EmptyStatement other = _other as EmptyStatement;
     return isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitEnumConstantDeclaration(EnumConstantDeclaration node) {
-    EnumConstantDeclaration other = this._other as EnumConstantDeclaration;
+    EnumConstantDeclaration other = _other as EnumConstantDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualNodes(node.name, other.name);
   }
 
   @override
   bool visitEnumDeclaration(EnumDeclaration node) {
-    EnumDeclaration other = this._other as EnumDeclaration;
+    EnumDeclaration other = _other as EnumDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.name, other.name) && isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.constants, other.constants) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitExportDirective(ExportDirective node) {
-    ExportDirective other = this._other as ExportDirective;
+    ExportDirective other = _other as ExportDirective;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.uri, other.uri) && _isEqualNodeLists(node.combinators, other.combinators) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
-    ExpressionFunctionBody other = this._other as ExpressionFunctionBody;
+    ExpressionFunctionBody other = _other as ExpressionFunctionBody;
     return isEqualTokens(node.functionDefinition, other.functionDefinition) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitExpressionStatement(ExpressionStatement node) {
-    ExpressionStatement other = this._other as ExpressionStatement;
+    ExpressionStatement other = _other as ExpressionStatement;
     return isEqualNodes(node.expression, other.expression) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitExtendsClause(ExtendsClause node) {
-    ExtendsClause other = this._other as ExtendsClause;
+    ExtendsClause other = _other as ExtendsClause;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.superclass, other.superclass);
   }
 
   @override
   bool visitFieldDeclaration(FieldDeclaration node) {
-    FieldDeclaration other = this._other as FieldDeclaration;
+    FieldDeclaration other = _other as FieldDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.staticKeyword, other.staticKeyword) && isEqualNodes(node.fields, other.fields) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitFieldFormalParameter(FieldFormalParameter node) {
-    FieldFormalParameter other = this._other as FieldFormalParameter;
+    FieldFormalParameter other = _other as FieldFormalParameter;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.type, other.type) && isEqualTokens(node.thisToken, other.thisToken) && isEqualTokens(node.period, other.period) && isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitForEachStatement(ForEachStatement node) {
-    ForEachStatement other = this._other as ForEachStatement;
+    ForEachStatement other = _other as ForEachStatement;
     return isEqualTokens(node.forKeyword, other.forKeyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.loopVariable, other.loopVariable) && isEqualTokens(node.inKeyword, other.inKeyword) && isEqualNodes(node.iterable, other.iterable) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitFormalParameterList(FormalParameterList node) {
-    FormalParameterList other = this._other as FormalParameterList;
+    FormalParameterList other = _other as FormalParameterList;
     return isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodeLists(node.parameters, other.parameters) && isEqualTokens(node.leftDelimiter, other.leftDelimiter) && isEqualTokens(node.rightDelimiter, other.rightDelimiter) && isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
   @override
   bool visitForStatement(ForStatement node) {
-    ForStatement other = this._other as ForStatement;
+    ForStatement other = _other as ForStatement;
     return isEqualTokens(node.forKeyword, other.forKeyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.variables, other.variables) && isEqualNodes(node.initialization, other.initialization) && isEqualTokens(node.leftSeparator, other.leftSeparator) && isEqualNodes(node.condition, other.condition) && isEqualTokens(node.rightSeparator, other.rightSeparator) && _isEqualNodeLists(node.updaters, other.updaters) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitFunctionDeclaration(FunctionDeclaration node) {
-    FunctionDeclaration other = this._other as FunctionDeclaration;
+    FunctionDeclaration other = _other as FunctionDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.externalKeyword, other.externalKeyword) && isEqualNodes(node.returnType, other.returnType) && isEqualTokens(node.propertyKeyword, other.propertyKeyword) && isEqualNodes(node.name, other.name) && isEqualNodes(node.functionExpression, other.functionExpression);
   }
 
   @override
   bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
-    FunctionDeclarationStatement other = this._other as FunctionDeclarationStatement;
+    FunctionDeclarationStatement other = _other as FunctionDeclarationStatement;
     return isEqualNodes(node.functionDeclaration, other.functionDeclaration);
   }
 
   @override
   bool visitFunctionExpression(FunctionExpression node) {
-    FunctionExpression other = this._other as FunctionExpression;
+    FunctionExpression other = _other as FunctionExpression;
     return isEqualNodes(node.parameters, other.parameters) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
-    FunctionExpressionInvocation other = this._other as FunctionExpressionInvocation;
+    FunctionExpressionInvocation other = _other as FunctionExpressionInvocation;
     return isEqualNodes(node.function, other.function) && isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitFunctionTypeAlias(FunctionTypeAlias node) {
-    FunctionTypeAlias other = this._other as FunctionTypeAlias;
+    FunctionTypeAlias other = _other as FunctionTypeAlias;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.returnType, other.returnType) && isEqualNodes(node.name, other.name) && isEqualNodes(node.typeParameters, other.typeParameters) && isEqualNodes(node.parameters, other.parameters) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
-    FunctionTypedFormalParameter other = this._other as FunctionTypedFormalParameter;
+    FunctionTypedFormalParameter other = _other as FunctionTypedFormalParameter;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualNodes(node.returnType, other.returnType) && isEqualNodes(node.identifier, other.identifier) && isEqualNodes(node.parameters, other.parameters);
   }
 
   @override
   bool visitHideCombinator(HideCombinator node) {
-    HideCombinator other = this._other as HideCombinator;
+    HideCombinator other = _other as HideCombinator;
     return isEqualTokens(node.keyword, other.keyword) && _isEqualNodeLists(node.hiddenNames, other.hiddenNames);
   }
 
   @override
   bool visitIfStatement(IfStatement node) {
-    IfStatement other = this._other as IfStatement;
+    IfStatement other = _other as IfStatement;
     return isEqualTokens(node.ifKeyword, other.ifKeyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.condition, other.condition) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualNodes(node.thenStatement, other.thenStatement) && isEqualTokens(node.elseKeyword, other.elseKeyword) && isEqualNodes(node.elseStatement, other.elseStatement);
   }
 
   @override
   bool visitImplementsClause(ImplementsClause node) {
-    ImplementsClause other = this._other as ImplementsClause;
+    ImplementsClause other = _other as ImplementsClause;
     return isEqualTokens(node.keyword, other.keyword) && _isEqualNodeLists(node.interfaces, other.interfaces);
   }
 
   @override
   bool visitImportDirective(ImportDirective node) {
-    ImportDirective other = this._other as ImportDirective;
+    ImportDirective other = _other as ImportDirective;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.uri, other.uri) && isEqualTokens(node.asToken, other.asToken) && isEqualNodes(node.prefix, other.prefix) && _isEqualNodeLists(node.combinators, other.combinators) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitIndexExpression(IndexExpression node) {
-    IndexExpression other = this._other as IndexExpression;
+    IndexExpression other = _other as IndexExpression;
     return isEqualNodes(node.target, other.target) && isEqualTokens(node.leftBracket, other.leftBracket) && isEqualNodes(node.index, other.index) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitInstanceCreationExpression(InstanceCreationExpression node) {
-    InstanceCreationExpression other = this._other as InstanceCreationExpression;
+    InstanceCreationExpression other = _other as InstanceCreationExpression;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.constructorName, other.constructorName) && isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitIntegerLiteral(IntegerLiteral node) {
-    IntegerLiteral other = this._other as IntegerLiteral;
+    IntegerLiteral other = _other as IntegerLiteral;
     return isEqualTokens(node.literal, other.literal) && (node.value == other.value);
   }
 
   @override
   bool visitInterpolationExpression(InterpolationExpression node) {
-    InterpolationExpression other = this._other as InterpolationExpression;
+    InterpolationExpression other = _other as InterpolationExpression;
     return isEqualTokens(node.leftBracket, other.leftBracket) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitInterpolationString(InterpolationString node) {
-    InterpolationString other = this._other as InterpolationString;
+    InterpolationString other = _other as InterpolationString;
     return isEqualTokens(node.contents, other.contents) && node.value == other.value;
   }
 
   @override
   bool visitIsExpression(IsExpression node) {
-    IsExpression other = this._other as IsExpression;
+    IsExpression other = _other as IsExpression;
     return isEqualNodes(node.expression, other.expression) && isEqualTokens(node.isOperator, other.isOperator) && isEqualTokens(node.notOperator, other.notOperator) && isEqualNodes(node.type, other.type);
   }
 
   @override
   bool visitLabel(Label node) {
-    Label other = this._other as Label;
+    Label other = _other as Label;
     return isEqualNodes(node.label, other.label) && isEqualTokens(node.colon, other.colon);
   }
 
   @override
   bool visitLabeledStatement(LabeledStatement node) {
-    LabeledStatement other = this._other as LabeledStatement;
+    LabeledStatement other = _other as LabeledStatement;
     return _isEqualNodeLists(node.labels, other.labels) && isEqualNodes(node.statement, other.statement);
   }
 
   @override
   bool visitLibraryDirective(LibraryDirective node) {
-    LibraryDirective other = this._other as LibraryDirective;
+    LibraryDirective other = _other as LibraryDirective;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.libraryToken, other.libraryToken) && isEqualNodes(node.name, other.name) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitLibraryIdentifier(LibraryIdentifier node) {
-    LibraryIdentifier other = this._other as LibraryIdentifier;
+    LibraryIdentifier other = _other as LibraryIdentifier;
     return _isEqualNodeLists(node.components, other.components);
   }
 
   @override
   bool visitListLiteral(ListLiteral node) {
-    ListLiteral other = this._other as ListLiteral;
+    ListLiteral other = _other as ListLiteral;
     return isEqualTokens(node.constKeyword, other.constKeyword) && isEqualNodes(node.typeArguments, other.typeArguments) && isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.elements, other.elements) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitMapLiteral(MapLiteral node) {
-    MapLiteral other = this._other as MapLiteral;
+    MapLiteral other = _other as MapLiteral;
     return isEqualTokens(node.constKeyword, other.constKeyword) && isEqualNodes(node.typeArguments, other.typeArguments) && isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.entries, other.entries) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitMapLiteralEntry(MapLiteralEntry node) {
-    MapLiteralEntry other = this._other as MapLiteralEntry;
+    MapLiteralEntry other = _other as MapLiteralEntry;
     return isEqualNodes(node.key, other.key) && isEqualTokens(node.separator, other.separator) && isEqualNodes(node.value, other.value);
   }
 
   @override
   bool visitMethodDeclaration(MethodDeclaration node) {
-    MethodDeclaration other = this._other as MethodDeclaration;
+    MethodDeclaration other = _other as MethodDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.externalKeyword, other.externalKeyword) && isEqualTokens(node.modifierKeyword, other.modifierKeyword) && isEqualNodes(node.returnType, other.returnType) && isEqualTokens(node.propertyKeyword, other.propertyKeyword) && isEqualTokens(node.propertyKeyword, other.propertyKeyword) && isEqualNodes(node.name, other.name) && isEqualNodes(node.parameters, other.parameters) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitMethodInvocation(MethodInvocation node) {
-    MethodInvocation other = this._other as MethodInvocation;
+    MethodInvocation other = _other as MethodInvocation;
     return isEqualNodes(node.target, other.target) && isEqualTokens(node.period, other.period) && isEqualNodes(node.methodName, other.methodName) && isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitNamedExpression(NamedExpression node) {
-    NamedExpression other = this._other as NamedExpression;
+    NamedExpression other = _other as NamedExpression;
     return isEqualNodes(node.name, other.name) && isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitNativeClause(NativeClause node) {
-    NativeClause other = this._other as NativeClause;
+    NativeClause other = _other as NativeClause;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.name, other.name);
   }
 
   @override
   bool visitNativeFunctionBody(NativeFunctionBody node) {
-    NativeFunctionBody other = this._other as NativeFunctionBody;
+    NativeFunctionBody other = _other as NativeFunctionBody;
     return isEqualTokens(node.nativeToken, other.nativeToken) && isEqualNodes(node.stringLiteral, other.stringLiteral) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitNullLiteral(NullLiteral node) {
-    NullLiteral other = this._other as NullLiteral;
+    NullLiteral other = _other as NullLiteral;
     return isEqualTokens(node.literal, other.literal);
   }
 
   @override
   bool visitParenthesizedExpression(ParenthesizedExpression node) {
-    ParenthesizedExpression other = this._other as ParenthesizedExpression;
+    ParenthesizedExpression other = _other as ParenthesizedExpression;
     return isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
   @override
   bool visitPartDirective(PartDirective node) {
-    PartDirective other = this._other as PartDirective;
+    PartDirective other = _other as PartDirective;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.partToken, other.partToken) && isEqualNodes(node.uri, other.uri) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitPartOfDirective(PartOfDirective node) {
-    PartOfDirective other = this._other as PartOfDirective;
+    PartOfDirective other = _other as PartOfDirective;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.partToken, other.partToken) && isEqualTokens(node.ofToken, other.ofToken) && isEqualNodes(node.libraryName, other.libraryName) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitPostfixExpression(PostfixExpression node) {
-    PostfixExpression other = this._other as PostfixExpression;
+    PostfixExpression other = _other as PostfixExpression;
     return isEqualNodes(node.operand, other.operand) && isEqualTokens(node.operator, other.operator);
   }
 
   @override
   bool visitPrefixedIdentifier(PrefixedIdentifier node) {
-    PrefixedIdentifier other = this._other as PrefixedIdentifier;
+    PrefixedIdentifier other = _other as PrefixedIdentifier;
     return isEqualNodes(node.prefix, other.prefix) && isEqualTokens(node.period, other.period) && isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitPrefixExpression(PrefixExpression node) {
-    PrefixExpression other = this._other as PrefixExpression;
+    PrefixExpression other = _other as PrefixExpression;
     return isEqualTokens(node.operator, other.operator) && isEqualNodes(node.operand, other.operand);
   }
 
   @override
   bool visitPropertyAccess(PropertyAccess node) {
-    PropertyAccess other = this._other as PropertyAccess;
+    PropertyAccess other = _other as PropertyAccess;
     return isEqualNodes(node.target, other.target) && isEqualTokens(node.operator, other.operator) && isEqualNodes(node.propertyName, other.propertyName);
   }
 
   @override
   bool visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
-    RedirectingConstructorInvocation other = this._other as RedirectingConstructorInvocation;
+    RedirectingConstructorInvocation other = _other as RedirectingConstructorInvocation;
     return isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.period, other.period) && isEqualNodes(node.constructorName, other.constructorName) && isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitRethrowExpression(RethrowExpression node) {
-    RethrowExpression other = this._other as RethrowExpression;
+    RethrowExpression other = _other as RethrowExpression;
     return isEqualTokens(node.keyword, other.keyword);
   }
 
   @override
   bool visitReturnStatement(ReturnStatement node) {
-    ReturnStatement other = this._other as ReturnStatement;
+    ReturnStatement other = _other as ReturnStatement;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitScriptTag(ScriptTag node) {
-    ScriptTag other = this._other as ScriptTag;
+    ScriptTag other = _other as ScriptTag;
     return isEqualTokens(node.scriptTag, other.scriptTag);
   }
 
   @override
   bool visitShowCombinator(ShowCombinator node) {
-    ShowCombinator other = this._other as ShowCombinator;
+    ShowCombinator other = _other as ShowCombinator;
     return isEqualTokens(node.keyword, other.keyword) && _isEqualNodeLists(node.shownNames, other.shownNames);
   }
 
   @override
   bool visitSimpleFormalParameter(SimpleFormalParameter node) {
-    SimpleFormalParameter other = this._other as SimpleFormalParameter;
+    SimpleFormalParameter other = _other as SimpleFormalParameter;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.type, other.type) && isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitSimpleIdentifier(SimpleIdentifier node) {
-    SimpleIdentifier other = this._other as SimpleIdentifier;
+    SimpleIdentifier other = _other as SimpleIdentifier;
     return isEqualTokens(node.token, other.token);
   }
 
   @override
   bool visitSimpleStringLiteral(SimpleStringLiteral node) {
-    SimpleStringLiteral other = this._other as SimpleStringLiteral;
+    SimpleStringLiteral other = _other as SimpleStringLiteral;
     return isEqualTokens(node.literal, other.literal) && (node.value == other.value);
   }
 
   @override
   bool visitStringInterpolation(StringInterpolation node) {
-    StringInterpolation other = this._other as StringInterpolation;
+    StringInterpolation other = _other as StringInterpolation;
     return _isEqualNodeLists(node.elements, other.elements);
   }
 
   @override
   bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    SuperConstructorInvocation other = this._other as SuperConstructorInvocation;
+    SuperConstructorInvocation other = _other as SuperConstructorInvocation;
     return isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.period, other.period) && isEqualNodes(node.constructorName, other.constructorName) && isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitSuperExpression(SuperExpression node) {
-    SuperExpression other = this._other as SuperExpression;
+    SuperExpression other = _other as SuperExpression;
     return isEqualTokens(node.keyword, other.keyword);
   }
 
   @override
   bool visitSwitchCase(SwitchCase node) {
-    SwitchCase other = this._other as SwitchCase;
+    SwitchCase other = _other as SwitchCase;
     return _isEqualNodeLists(node.labels, other.labels) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.colon, other.colon) && _isEqualNodeLists(node.statements, other.statements);
   }
 
   @override
   bool visitSwitchDefault(SwitchDefault node) {
-    SwitchDefault other = this._other as SwitchDefault;
+    SwitchDefault other = _other as SwitchDefault;
     return _isEqualNodeLists(node.labels, other.labels) && isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.colon, other.colon) && _isEqualNodeLists(node.statements, other.statements);
   }
 
   @override
   bool visitSwitchStatement(SwitchStatement node) {
-    SwitchStatement other = this._other as SwitchStatement;
+    SwitchStatement other = _other as SwitchStatement;
     return isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.members, other.members) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitSymbolLiteral(SymbolLiteral node) {
-    SymbolLiteral other = this._other as SymbolLiteral;
+    SymbolLiteral other = _other as SymbolLiteral;
     return isEqualTokens(node.poundSign, other.poundSign) && _isEqualTokenLists(node.components, other.components);
   }
 
   @override
   bool visitThisExpression(ThisExpression node) {
-    ThisExpression other = this._other as ThisExpression;
+    ThisExpression other = _other as ThisExpression;
     return isEqualTokens(node.keyword, other.keyword);
   }
 
   @override
   bool visitThrowExpression(ThrowExpression node) {
-    ThrowExpression other = this._other as ThrowExpression;
+    ThrowExpression other = _other as ThrowExpression;
     return isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    TopLevelVariableDeclaration other = this._other as TopLevelVariableDeclaration;
+    TopLevelVariableDeclaration other = _other as TopLevelVariableDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualNodes(node.variables, other.variables) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitTryStatement(TryStatement node) {
-    TryStatement other = this._other as TryStatement;
+    TryStatement other = _other as TryStatement;
     return isEqualTokens(node.tryKeyword, other.tryKeyword) && isEqualNodes(node.body, other.body) && _isEqualNodeLists(node.catchClauses, other.catchClauses) && isEqualTokens(node.finallyKeyword, other.finallyKeyword) && isEqualNodes(node.finallyBlock, other.finallyBlock);
   }
 
   @override
   bool visitTypeArgumentList(TypeArgumentList node) {
-    TypeArgumentList other = this._other as TypeArgumentList;
+    TypeArgumentList other = _other as TypeArgumentList;
     return isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.arguments, other.arguments) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitTypeName(TypeName node) {
-    TypeName other = this._other as TypeName;
+    TypeName other = _other as TypeName;
     return isEqualNodes(node.name, other.name) && isEqualNodes(node.typeArguments, other.typeArguments);
   }
 
   @override
   bool visitTypeParameter(TypeParameter node) {
-    TypeParameter other = this._other as TypeParameter;
+    TypeParameter other = _other as TypeParameter;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualNodes(node.name, other.name) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.bound, other.bound);
   }
 
   @override
   bool visitTypeParameterList(TypeParameterList node) {
-    TypeParameterList other = this._other as TypeParameterList;
+    TypeParameterList other = _other as TypeParameterList;
     return isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.typeParameters, other.typeParameters) && isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitVariableDeclaration(VariableDeclaration node) {
-    VariableDeclaration other = this._other as VariableDeclaration;
+    VariableDeclaration other = _other as VariableDeclaration;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualNodes(node.name, other.name) && isEqualTokens(node.equals, other.equals) && isEqualNodes(node.initializer, other.initializer);
   }
 
   @override
   bool visitVariableDeclarationList(VariableDeclarationList node) {
-    VariableDeclarationList other = this._other as VariableDeclarationList;
+    VariableDeclarationList other = _other as VariableDeclarationList;
     return isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && isEqualTokens(node.keyword, other.keyword) && isEqualNodes(node.type, other.type) && _isEqualNodeLists(node.variables, other.variables);
   }
 
   @override
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
-    VariableDeclarationStatement other = this._other as VariableDeclarationStatement;
+    VariableDeclarationStatement other = _other as VariableDeclarationStatement;
     return isEqualNodes(node.variables, other.variables) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitWhileStatement(WhileStatement node) {
-    WhileStatement other = this._other as WhileStatement;
+    WhileStatement other = _other as WhileStatement;
     return isEqualTokens(node.keyword, other.keyword) && isEqualTokens(node.leftParenthesis, other.leftParenthesis) && isEqualNodes(node.condition, other.condition) && isEqualTokens(node.rightParenthesis, other.rightParenthesis) && isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitWithClause(WithClause node) {
-    WithClause other = this._other as WithClause;
+    WithClause other = _other as WithClause;
     return isEqualTokens(node.withKeyword, other.withKeyword) && _isEqualNodeLists(node.mixinTypes, other.mixinTypes);
   }
 
   @override
   bool visitYieldStatement(YieldStatement node) {
-    YieldStatement other = this._other as YieldStatement;
+    YieldStatement other = _other as YieldStatement;
     return isEqualTokens(node.yieldKeyword, other.yieldKeyword) && isEqualNodes(node.expression, other.expression) && isEqualTokens(node.semicolon, other.semicolon);
   }
 
   /**
    * Return `true` if the given lists of AST nodes have the same size and corresponding
    * elements are equal.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the given AST nodes have the same size and corresponding elements are
@@ skipping 78 matching lines @@
         && first.lexeme == second.lexeme;
   }
 }
 
 /**
  * The abstract class `AstNode` defines the behavior common to all nodes in the AST structure
  * for a Dart program.
  */
 abstract class AstNode {
   /**
-   * An empty array of ast nodes.
-   */
-  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;
 
   /**
    * 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;
 
   /**
+   * An empty array of ast nodes.
+   */
+  static const List<AstNode> EMPTY_ARRAY = const <AstNode>[];
+
+  /**
    * 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;
 
   /**
    * Use the given visitor to visit this node.
    *
@@ skipping 165 matching lines @@
   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) {
     if (child != null) {
-      AstNode node = child;
-      node.parent = this;
+      child._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) {
     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
    */
+  @deprecated
   void set parent(AstNode newParent) {
     _parent = newParent;
   }
 }
 
 /**
  * The interface `AstVisitor` defines the behavior of objects that can be used to visit an AST
  * structure.
  */
 abstract class AstVisitor<R> {
@@ skipping 224 matching lines @@
    */
   Expression _expression;
 
   /**
    * Initialize a newly created await expression.
    *
    * @param awaitKeyword the 'await' keyword
    * @param expression the expression whose value is being waited on
    */
   AwaitExpression(this.awaitKeyword, Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAwaitExpression(this);
 
   @override
   Token get beginToken {
     if (awaitKeyword != null) {
       return awaitKeyword;
     }
@@ skipping 12 matching lines @@
 
   @override
   int get precedence => 0;
 
   /**
    * Set the expression whose value is being waited on to the given expression.
    *
    * @param expression the expression whose value is being waited on
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `BinaryExpression` represent a binary (infix) expression.
@@ skipping 17 matching lines @@
   /**
    * The expression used to compute the right operand.
    */
   Expression _rightOperand;
 
   /**
    * The element associated with the operator based on the static type of the left operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
-  MethodElement _staticElement;
+  MethodElement staticElement;
 
   /**
    * The element associated with the operator based on the propagated type of the left operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
-  MethodElement _propagatedElement;
+  MethodElement propagatedElement;
 
   /**
    * Initialize a newly created binary expression.
    *
    * @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);
+    _leftOperand = becomeParentOf(leftOperand);
+    _rightOperand = becomeParentOf(rightOperand);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBinaryExpression(this);
 
   @override
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
@@ skipping 18 matching lines @@
    * Return the expression used to compute the left operand.
    *
    * @return the expression used to compute the left operand
    */
   Expression get leftOperand => _leftOperand;
 
   @override
   int get precedence => operator.type.precedence;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the left
-   * operand, or `null` if the AST structure has not been resolved, if the operator is not
-   * user definable, 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 operand.
    *
    * @return the expression used to compute the right operand
    */
   Expression get rightOperand => _rightOperand;
 
   /**
-   * Return the element associated with the operator based on the static type of the left operand,
-   * or `null` if the AST structure has not been resolved, if the operator is not user
-   * definable, 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 operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get staticElement => _staticElement;
-
-  /**
    * Set the expression used to compute the left operand to the given expression.
    *
    * @param expression the expression used to compute the left operand
    */
   void set leftOperand(Expression expression) {
     _leftOperand = becomeParentOf(expression);
   }
 
   /**
-   * Set the element associated with the operator based on the propagated type of the left operand
-   * 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 right operand to the given expression.
    *
    * @param expression the expression used to compute the right operand
    */
   void set rightOperand(Expression expression) {
     _rightOperand = becomeParentOf(expression);
   }
 
-  /**
-   * 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;
-  }
-
   @override
   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.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightOperand {
-    if (_propagatedElement == null) {
+    if (propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _propagatedElement.parameters;
+    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.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForRightOperand {
-    if (_staticElement == null) {
+    if (staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _staticElement.parameters;
+    List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 
 /**
  * Instances of the class `Block` represent a sequence of statements.
  *
@@ skipping 19 matching lines @@
   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);
+    _statements = new NodeList<Statement>(this, statements);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBlock(this);
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Token get endToken => rightBracket;
@@ skipping 38 matching lines @@
   Block _block;
 
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
    * @param keyword the token representing the 'async' or 'sync' keyword
    * @param star the star following the 'async' or 'sync' keyword
    * @param block the block representing the body of the function
    */
   BlockFunctionBody(this.keyword, this.star, Block block) {
-    this._block = becomeParentOf(block);
+    _block = becomeParentOf(block);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBlockFunctionBody(this);
 
   @override
   Token get beginToken => _block.beginToken;
 
   /**
    * Return the block representing the body of the function.
@@ skipping 19 matching lines @@
 
   @override
   bool get isSynchronous => keyword == null || keyword.lexeme != Parser.ASYNC;
 
   /**
    * Set the block representing the body of the function to the given block.
    *
    * @param block the block representing the body of the function
    */
   void set block(Block block) {
-    this._block = becomeParentOf(block);
+    _block = becomeParentOf(block);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 
 /**
  * Instances of the class `BooleanLiteral` represent a boolean literal expression.
@@ skipping 81 matching lines @@
     }
   }
 
   @override
   R visitNode(AstNode node) {
     node.visitChildren(_childVisitor);
     return null;
   }
 
   BreadthFirstVisitor() {
-    this._childVisitor = new GeneralizingAstVisitor_BreadthFirstVisitor(this);
+    _childVisitor = new GeneralizingAstVisitor_BreadthFirstVisitor(this);
   }
 }
 
 /**
  * Instances of the class `BreakStatement` represent a break statement.
  *
  * <pre>
  * breakStatement ::=
  *     'break' [SimpleIdentifier]? ';'
  * </pre>
@@ skipping 15 matching lines @@
   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);
+    _label = becomeParentOf(label);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBreakStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => semicolon;
@@ skipping 49 matching lines @@
    */
   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);
+    _target = becomeParentOf(target);
+    _cascadeSections = new NodeList<Expression>(this, cascadeSections);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCascadeExpression(this);
 
   @override
   Token get beginToken => _target.beginToken;
 
   /**
    * Return the cascade sections sharing the common target.
@@ skipping 14 matching lines @@
    * @return the target of the cascade sections
    */
   Expression get target => _target;
 
   /**
    * 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);
+    _target = becomeParentOf(target);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 
 /**
@@ skipping 21 matching lines @@
   TypeName _exceptionType;
 
   /**
    * The token representing the 'catch' keyword, or `null` if there is no 'catch' keyword.
    */
   Token catchKeyword;
 
   /**
    * The left parenthesis.
    */
-  Token _leftParenthesis;
+  Token leftParenthesis;
 
   /**
    * The parameter whose value will be the exception that was thrown.
    */
   SimpleIdentifier _exceptionParameter;
 
   /**
    * The comma separating the exception parameter from the stack trace parameter, or `null` if
    * there is no stack trace parameter.
    */
   Token comma;
 
   /**
    * The parameter whose value will be the stack trace associated with the exception, or
    * `null` if there is no stack trace parameter.
    */
   SimpleIdentifier _stackTraceParameter;
 
   /**
    * The right parenthesis.
    */
-  Token _rightParenthesis;
+  Token rightParenthesis;
 
   /**
    * The body of the catch block.
    */
   Block _body;
 
   /**
    * Initialize a newly created catch clause.
    *
    * @param onKeyword the token representing the 'on' keyword
    * @param exceptionType the type of exceptions caught by this catch clause
    * @param leftParenthesis the left parenthesis
    * @param exceptionParameter the parameter whose value will be the exception that was thrown
    * @param comma the comma separating the exception parameter from the stack trace parameter
    * @param stackTraceParameter the parameter whose value will be the stack trace associated with
    *          the exception
    * @param rightParenthesis the right parenthesis
    * @param body the body of the catch block
    */
-  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);
+  CatchClause(this.onKeyword, TypeName exceptionType, this.catchKeyword, this.leftParenthesis, SimpleIdentifier exceptionParameter, this.comma, SimpleIdentifier stackTraceParameter, this.rightParenthesis, Block body) {
+    _exceptionType = becomeParentOf(exceptionType);
+    _exceptionParameter = becomeParentOf(exceptionParameter);
+    _stackTraceParameter = becomeParentOf(stackTraceParameter);
+    _body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCatchClause(this);
 
   @override
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
     }
@@ skipping 19 matching lines @@
 
   /**
    * Return the type of exceptions caught by this catch clause, or `null` if this catch clause
    * catches every type of exception.
    *
    * @return the type of exceptions caught by this catch clause
    */
   TypeName get exceptionType => _exceptionType;
 
   /**
-   * Return the left parenthesis.
-   *
-   * @return the left parenthesis
-   */
-  Token get leftParenthesis => _leftParenthesis;
-
-  /**
-   * Return the right parenthesis.
-   *
-   * @return the right parenthesis
-   */
-  Token get rightParenthesis => _rightParenthesis;
-
-  /**
    * Return the parameter whose value will be the stack trace associated with the exception, or
    * `null` if there is no stack trace parameter.
    *
    * @return the parameter whose value will be the stack trace associated with the exception
    */
   SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
 
   /**
    * Set the body of the catch block to the given block.
    *
@@ skipping 11 matching lines @@
   void set exceptionParameter(SimpleIdentifier parameter) {
     _exceptionParameter = becomeParentOf(parameter);
   }
 
   /**
    * Set the type of exceptions caught by this catch clause to the given type.
    *
    * @param exceptionType the type of exceptions caught by this catch clause
    */
   void set exceptionType(TypeName exceptionType) {
-    this._exceptionType = becomeParentOf(exceptionType);
+    _exceptionType = becomeParentOf(exceptionType);
   }
 
   /**
-   * 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;
-  }
-
-  /**
    * 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);
   }
 
@@ skipping 85 matching lines @@
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param extendsClause the extends clause for the class
    * @param withClause the with clause for the class
    * @param implementsClause the implements clause for the class
    * @param leftBracket the left curly bracket
    * @param members the members defined by the class
    * @param rightBracket the right curly bracket
    */
   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);
+    _name = becomeParentOf(name);
+    _typeParameters = becomeParentOf(typeParameters);
+    _extendsClause = becomeParentOf(extendsClause);
+    _withClause = becomeParentOf(withClause);
+    _implementsClause = becomeParentOf(implementsClause);
+    _members = new NodeList<ClassMember>(this, members);
   }
 
   @override
   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
@@ skipping 120 matching lines @@
    * @return `true` if this class is declared to be an abstract class
    */
   bool get isAbstract => abstractKeyword != null;
 
   /**
    * Set the extends clause for this class to the given clause.
    *
    * @param extendsClause the extends clause for this class
    */
   void set extendsClause(ExtendsClause extendsClause) {
-    this._extendsClause = becomeParentOf(extendsClause);
+    _extendsClause = becomeParentOf(extendsClause);
   }
 
   /**
    * Set the implements clause for the class to the given clause.
    *
    * @param implementsClause the implements clause for the class
    */
   void set implementsClause(ImplementsClause implementsClause) {
-    this._implementsClause = becomeParentOf(implementsClause);
+    _implementsClause = becomeParentOf(implementsClause);
   }
 
   /**
    * Set the name of the class being declared to the given identifier.
    *
    * @param identifier the name of the class being declared
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the native clause for this class to the given clause.
    *
    * @param nativeClause the native clause for this class
    */
   void set nativeClause(NativeClause nativeClause) {
-    this._nativeClause = becomeParentOf(nativeClause);
+    _nativeClause = becomeParentOf(nativeClause);
   }
 
   /**
    * Set the type parameters for the class to the given list of type parameters.
    *
    * @param typeParameters the type parameters for the class
    */
   void set typeParameters(TypeParameterList typeParameters) {
-    this._typeParameters = becomeParentOf(typeParameters);
+    _typeParameters = becomeParentOf(typeParameters);
   }
 
   /**
    * 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);
+    _withClause = becomeParentOf(withClause);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
@@ skipping 82 matching lines @@
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param equals the token for the '=' separating the name from the definition
    * @param abstractKeyword the token for the 'abstract' keyword
    * @param superclass the name of the superclass of the class being declared
    * @param withClause the with clause for this class
    * @param implementsClause the implements clause for this class
    * @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);
+    _name = becomeParentOf(name);
+    _typeParameters = becomeParentOf(typeParameters);
+    _superclass = becomeParentOf(superclass);
+    _withClause = becomeParentOf(withClause);
+    _implementsClause = becomeParentOf(implementsClause);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitClassTypeAlias(this);
 
   @override
   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.
@@ skipping 37 matching lines @@
    * @return `true` if this class is declared to be an abstract class
    */
   bool get isAbstract => abstractKeyword != null;
 
   /**
    * Set the implements clause for this class to the given implements clause.
    *
    * @param implementsClause the implements clause for this class
    */
   void set implementsClause(ImplementsClause implementsClause) {
-    this._implementsClause = becomeParentOf(implementsClause);
+    _implementsClause = becomeParentOf(implementsClause);
   }
 
   /**
    * Set the name of the class being declared to the given identifier.
    *
    * @param name the name of the class being declared
    */
   void set name(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   /**
    * Set the name of the superclass of the class being declared to the given name.
    *
    * @param superclass the name of the superclass of the class being declared
    */
   void set superclass(TypeName superclass) {
-    this._superclass = becomeParentOf(superclass);
+    _superclass = becomeParentOf(superclass);
   }
 
   /**
    * Set the type parameters for the class to the given list of parameters.
    *
    * @param typeParameters the type parameters for the class
    */
   void set typeParameters(TypeParameterList typeParameters) {
-    this._typeParameters = becomeParentOf(typeParameters);
+    _typeParameters = becomeParentOf(typeParameters);
   }
 
   /**
    * 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);
+    _withClause = becomeParentOf(withClause);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
@@ skipping 99 matching lines @@
   NodeList<CommentReference> _references;
 
   /**
    * Initialize a newly created comment.
    *
    * @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, this._type, List<CommentReference> references) {
-    this._references = new NodeList<CommentReference>(this);
-    this._references.addAll(references);
+    _references = new NodeList<CommentReference>(this, references);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitComment(this);
 
   @override
   Token get beginToken => tokens[0];
 
   @override
   Token get endToken => tokens[tokens.length - 1];
@@ skipping 52 matching lines @@
    */
   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);
+    _identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCommentReference(this);
 
   @override
   Token get beginToken => _identifier.beginToken;
 
   @override
   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) {
-    this._identifier = becomeParentOf(identifier);
+    _identifier = becomeParentOf(identifier);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
- * The enumeration `CommentType` encodes all the different types of comments that are
- * recognized by the parser.
+ * The enumeration `CommentType` encodes all the different types of comments
+ * that are recognized by the parser.
  */
-class CommentType extends Enum<CommentType> {
+class CommentType {
   /**
-   * An end-of-line comment.
+   * The name of the comment type.
    */
-  static const CommentType END_OF_LINE = const CommentType('END_OF_LINE', 0);
+  final String name;
 
   /**
    * A block comment.
    */
-  static const CommentType BLOCK = const CommentType('BLOCK', 1);
+  static const CommentType BLOCK = const CommentType('BLOCK');
 
   /**
    * A documentation comment.
    */
-  static const CommentType DOCUMENTATION = const CommentType('DOCUMENTATION', 2);
+  static const CommentType DOCUMENTATION = const CommentType('DOCUMENTATION');
 
-  static const List<CommentType> values = const [END_OF_LINE, BLOCK, DOCUMENTATION];
+  /**
+   * An end-of-line comment.
+   */
+  static const CommentType END_OF_LINE = const CommentType('END_OF_LINE');
 
-  const CommentType(String name, int ordinal) : super(name, ordinal);
+  /**
+   * Initialize a newly created comment type to have the given [name].
+   */
+  const CommentType(this.name);
+
+  @override
+  String toString() => name;
 }
 
 /**
  * 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.
  *
@@ skipping 55 matching lines @@
   /**
    * Initialize a newly created compilation unit to have the given directives and declarations.
    *
    * @param beginToken the first token in the token stream
    * @param scriptTag the script tag at the beginning of the compilation unit
    * @param directives the directives contained in this compilation unit
    * @param declarations the declarations contained in this compilation unit
    * @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);
+    _scriptTag = becomeParentOf(scriptTag);
+    _directives = new NodeList<Directive>(this, directives);
+    _declarations = new NodeList<CompilationUnitMember>(this, declarations);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCompilationUnit(this);
 
   /**
    * Return the declarations contained in this compilation unit.
    *
    * @return the declarations contained in this compilation unit
    */
@@ skipping 25 matching lines @@
    * @return the script tag at the beginning of the compilation unit
    */
   ScriptTag get scriptTag => _scriptTag;
 
   /**
    * 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);
+    _scriptTag = becomeParentOf(scriptTag);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (_directivesAreBeforeDeclarations()) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
       for (AstNode child in sortedDirectivesAndDeclarations) {
@@ skipping 94 matching lines @@
    *
    * @param condition the condition used to determine which expression is executed next
    * @param question the token used to separate the condition from the then expression
    * @param thenExpression the expression that is executed if the condition evaluates to
    *          `true`
    * @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);
+    _condition = becomeParentOf(condition);
+    _thenExpression = becomeParentOf(thenExpression);
+    _elseExpression = becomeParentOf(elseExpression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
 
   @override
   Token get beginToken => _condition.beginToken;
 
   /**
    * Return the condition used to determine which of the expressions is executed next.
@@ skipping 527 matching lines @@
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    * @param parameters the parameters associated with the constructor
    * @param separator the token for the colon or equals before the initializers
    * @param initializers the initializers associated with the constructor
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    *          redirected
    * @param body the body of the constructor
    */
   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);
+    _returnType = becomeParentOf(returnType);
+    _name = becomeParentOf(name);
+    _parameters = becomeParentOf(parameters);
+    _initializers = new NodeList<ConstructorInitializer>(this, initializers);
+    _redirectedConstructor = becomeParentOf(redirectedConstructor);
+    _body = becomeParentOf(body);
   }
 
   @override
   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
    */
@@ skipping 65 matching lines @@
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the parameters associated with the constructor to the given list of parameters.
    *
    * @param parameters the parameters associated with the constructor
    */
   void set parameters(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+    _parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the name of the constructor to which this constructor will be redirected to the given
    * constructor name.
    *
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    *          redirected
    */
   void set redirectedConstructor(ConstructorName redirectedConstructor) {
-    this._redirectedConstructor = becomeParentOf(redirectedConstructor);
+    _redirectedConstructor = becomeParentOf(redirectedConstructor);
   }
 
   /**
    * 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);
   }
 
   @override
   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);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
-    Token leftMost = _leftMost([externalKeyword, constKeyword, factoryKeyword]);
+    Token leftMost = Token.lexicallyFirst([externalKeyword, constKeyword, factoryKeyword]);
     if (leftMost != null) {
       return leftMost;
     }
     return _returnType.beginToken;
   }
-
-  /**
-   * Return the left-most of the given tokens, or `null` if there are no tokens given or if
-   * all of the given tokens are `null`.
-   *
-   * @param tokens the tokens being compared to find the left-most token
-   * @return the left-most of the given tokens
-   */
-  Token _leftMost(List<Token> tokens) {
-    Token leftMost = null;
-    int offset = 2147483647;
-    for (Token token in tokens) {
-      if (token != null && token.offset < offset) {
-        leftMost = token;
-      }
-    }
-    return leftMost;
-  }
 }
 
 /**
  * Instances of the class `ConstructorFieldInitializer` represent the initialization of a
  * field within a constructor's initialization list.
  *
  * <pre>
  * fieldInitializer ::=
  *     ('this' '.')? [SimpleIdentifier] '=' [Expression]
  * </pre>
@@ skipping 29 matching lines @@
    * Initialize a newly created field initializer to initialize the field with the given name to the
    * value of the given expression.
    *
    * @param keyword the token for the 'this' keyword
    * @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);
+    _fieldName = becomeParentOf(fieldName);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
@@ skipping 17 matching lines @@
    */
   SimpleIdentifier get fieldName => _fieldName;
 
   /**
    * Set the expression computing the value to which the field will be initialized to the given
    * expression.
    *
    * @param expression the expression computing the value to which the field will be initialized
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   /**
    * 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);
   }
@@ skipping 42 matching lines @@
    * The name of the constructor, or `null` if the specified constructor is the unnamed
    * constructor.
    */
   SimpleIdentifier _name;
 
   /**
    * The element associated with this constructor name based on static type information, or
    * `null` if the AST structure has not been resolved or if this constructor name could not
    * be resolved.
    */
-  ConstructorElement _staticElement;
+  ConstructorElement staticElement;
 
   /**
    * Initialize a newly created constructor name.
    *
    * @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);
+    _type = becomeParentOf(type);
+    _name = becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorName(this);
 
   @override
   Token get beginToken => _type.beginToken;
 
   @override
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
   /**
    * Return the name of the constructor, or `null` if the specified constructor is the unnamed
    * constructor.
    *
    * @return the name of the constructor
    */
   SimpleIdentifier get name => _name;
 
   /**
-   * Return the element associated with this constructor name based on static type information, or
-   * `null` if the AST structure has not been resolved or if this constructor name could not
-   * be resolved.
-   *
-   * @return the element associated with this constructor name
-   */
-  ConstructorElement get staticElement => _staticElement;
-
-  /**
    * Return the name of the type defining the constructor.
    *
    * @return the name of the type defining the constructor
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the constructor to the given name.
    *
    * @param name the name of the constructor
    */
   void set name(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   /**
-   * Set the element associated with this constructor name based on static type information to the
-   * given element.
-   *
-   * @param element the element to be associated with this constructor name
-   */
-  void set staticElement(ConstructorElement element) {
-    _staticElement = element;
-  }
-
-  /**
    * 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);
+    _type = becomeParentOf(type);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 
 /**
@@ skipping 21 matching lines @@
   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);
+    _label = becomeParentOf(label);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => semicolon;
@@ skipping 41 matching lines @@
    */
   Element get element;
 }
 
 /**
  * Instances of the class `DeclaredIdentifier` represent the declaration of a single
  * identifier.
  *
  * <pre>
  * declaredIdentifier ::=
- *     ([Annotation] finalConstVarOrType [SimpleIdentifier]
+ *     [Annotation] finalConstVarOrType [SimpleIdentifier]
  * </pre>
  */
 class DeclaredIdentifier extends Declaration {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token keyword;
 
   /**
@@ skipping 10 matching lines @@
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
   DeclaredIdentifier(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata) {
-    this._type = becomeParentOf(type);
-    this._identifier = becomeParentOf(identifier);
+    _type = becomeParentOf(type);
+    _identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDeclaredIdentifier(this);
 
   @override
   LocalVariableElement get element {
-    SimpleIdentifier identifier = this.identifier;
-    if (identifier == null) {
+    if (_identifier == null) {
       return null;
     }
-    return identifier.staticElement as LocalVariableElement;
+    return _identifier.staticElement as LocalVariableElement;
   }
 
   @override
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the name of the variable being declared.
    *
    * @return the name of the variable being declared
    */
@@ skipping 22 matching lines @@
    * @return `true` if this variable was declared with the 'final' modifier
    */
   bool get isFinal => (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Set the name of the variable being declared to the given name.
    *
    * @param identifier the new name of the variable being declared
    */
   void set identifier(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
+    _identifier = becomeParentOf(identifier);
   }
 
   /**
    * 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);
   }
@@ skipping 54 matching lines @@
 
   /**
    * Initialize a newly created default formal parameter.
    *
    * @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);
+    _parameter = becomeParentOf(parameter);
+    _defaultValue = becomeParentOf(defaultValue);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDefaultFormalParameter(this);
 
   @override
   Token get beginToken => _parameter.beginToken;
 
   /**
    * Return the expression computing the default value for the parameter, or `null` if there
@@ skipping 62 matching lines @@
   bool _result = false;
 
   /**
    * Return `true` if the visitor found a [PrefixedIdentifier] that returned
    * `true` to the [PrefixedIdentifier.isDeferred] query.
    */
   bool get result => _result;
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
-    // If result is already true, skip.
     if (!_result) {
-      // Set result to true if isDeferred() is true
       if (node.isDeferred) {
         _result = true;
       }
     }
     return null;
   }
 }
 
 /**
  * The abstract class `Directive` defines the behavior common to nodes that represent a
  * directive.
  *
  * <pre>
  * directive ::=
  *     [ExportDirective]
  *   | [ImportDirective]
  *   | [LibraryDirective]
  *   | [PartDirective]
  *   | [PartOfDirective]
  * </pre>
  */
 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;
+  Element element;
 
   /**
    * Initialize a newly create directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    */
   Directive(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 
   /**
-   * Return the element associated with this directive, or `null` if the AST structure has not
-   * been resolved or if this directive could not be resolved. Examples of the latter case include a
-   * directive that contains an invalid URL or a URL that does not exist.
-   *
-   * @return the element associated with this directive
-   */
-  Element get element => _element;
-
-  /**
    * Return the token representing the keyword that introduces this directive ('import', 'export',
    * 'library' or 'part').
    *
    * @return the token representing the keyword that introduces this directive
    */
   Token get keyword;
-
-  /**
-   * Set the element associated with this directive to the given element.
-   *
-   * @param element the element associated with this directive
-   */
-  void set element(Element element) {
-    this._element = element;
-  }
 }
 
 /**
  * Instances of the class `DoStatement` represent a do statement.
  *
  * <pre>
  * doStatement ::=
  *     'do' [Statement] 'while' '(' [Expression] ')' ';'
  * </pre>
  */
 class DoStatement extends Statement {
   /**
    * The token representing the 'do' keyword.
    */
   Token doKeyword;
 
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * The token representing the 'while' keyword.
    */
   Token whileKeyword;
 
   /**
    * The left parenthesis.
    */
-  Token _leftParenthesis;
+  Token leftParenthesis;
 
   /**
    * The condition that determines when the loop will terminate.
    */
   Expression _condition;
 
   /**
    * The right parenthesis.
    */
-  Token _rightParenthesis;
+  Token rightParenthesis;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created do loop.
    *
    * @param doKeyword the token representing the 'do' keyword
    * @param body the body of the loop
    * @param whileKeyword the token representing the 'while' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition that determines when the loop will terminate
    * @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;
+  DoStatement(this.doKeyword, Statement body, this.whileKeyword, this.leftParenthesis, Expression condition, this.rightParenthesis, this.semicolon) {
+    _body = becomeParentOf(body);
+    _condition = becomeParentOf(condition);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDoStatement(this);
 
   @override
   Token get beginToken => doKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
   /**
    * Return the condition that determines when the loop will terminate.
    *
    * @return the condition that determines when the loop will terminate
    */
   Expression get condition => _condition;
 
   @override
   Token get endToken => semicolon;
 
   /**
-   * 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 body of the loop to the given statement.
    *
    * @param statement the body of the loop
    */
   void set body(Statement statement) {
     _body = becomeParentOf(statement);
   }
 
   /**
    * Set the condition that determines when the loop will terminate to the given expression.
    *
    * @param expression the condition that determines when the loop will terminate
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
-  /**
-   * 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;
-  }
-
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_body, visitor);
     safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
  * Instances of the class `DoubleLiteral` represent a floating point literal expression.
  *
@@ skipping 61 matching lines @@
    *
    * @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 locateWithOffset(AstNode node, int offset) {
     if (node == null) {
       return null;
     }
     // try to get Element from node
-    {
-      Element nodeElement = locate(node);
-      if (nodeElement != null) {
-        return nodeElement;
-      }
+    Element nodeElement = locate(node);
+    if (nodeElement != null) {
+      return nodeElement;
     }
-    // try to get Angular specific Element
-    {
-      Element element = null;
-      if (element != null) {
-        return element;
-      }
-    }
-    // try to get Polymer specific Element
-    {
-      Element element = null;
-      if (element != null) {
-        return element;
-      }
-    }
+    // TODO(brianwilkerson) Implement or delete the code below.
+//    // try to get Angular specific Element
+//    {
+//      Element element = null;
+//      if (element != null) {
+//        return element;
+//      }
+//    }
+//    // try to get Polymer 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> {
   @override
@@ skipping 178 matching lines @@
   SimpleIdentifier _name;
 
   /**
    * Initialize a newly created enum constant declaration.
    *
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    * @param name the name of the constant
    */
   EnumConstantDeclaration(Comment comment, List<Annotation> metadata, SimpleIdentifier name) : super(comment, metadata) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitEnumConstantDeclaration(this);
 
   @override
   FieldElement get element => _name == null ? null : (_name.staticElement as FieldElement);
 
   @override
   Token get endToken => _name.endToken;
 
   /**
    * Return the name of the constant.
    *
    * @return the name of the constant
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the constant to the given name.
    *
    * @param name the name of the constant
    */
   void set name(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
@@ skipping 38 matching lines @@
    *
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    * @param keyword the 'enum' keyword
    * @param name the name of the enumeration
    * @param leftBracket the left curly bracket
    * @param constants the enumeration constants being declared
    * @param rightBracket the right curly bracket
    */
   EnumDeclaration(Comment comment, List<Annotation> metadata, this.keyword, SimpleIdentifier name, this.leftBracket, List<EnumConstantDeclaration> constants, this.rightBracket) : super(comment, metadata) {
-    this._constants = new NodeList<EnumConstantDeclaration>(this);
-    this._name = becomeParentOf(name);
-    this._constants.addAll(constants);
+    _name = becomeParentOf(name);
+    _constants = new NodeList<EnumConstantDeclaration>(this, constants);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitEnumDeclaration(this);
 
   /**
    * Return the enumeration constants being declared.
    *
    * @return the enumeration constants being declared
    */
@@ skipping 11 matching lines @@
    * @return the name of the enumeration
    */
   SimpleIdentifier get name => _name;
 
   /**
    * set the name of the enumeration to the given identifier.
    *
    * @param name the name of the enumeration
    */
   void set name(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => keyword;
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     _constants.accept(visitor);
@@ skipping 31 matching lines @@
   ExportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
 
   @override
   accept(AstVisitor visitor) => visitor.visitExportDirective(this);
 
   @override
   ExportElement get element => super.element as ExportElement;
 
   @override
   LibraryElement get uriElement {
-    ExportElement exportElement = element;
-    if (exportElement != null) {
-      return exportElement.exportedLibrary;
+    if (element != null) {
+      return element.exportedLibrary;
     }
     return null;
   }
 
   @override
   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>
  */
 abstract class Expression extends AstNode {
   /**
-   * An empty list of expressions.
-   */
-  static const List<Expression> EMPTY_ARRAY = const <Expression>[];
-
-  /**
    * The static type of this expression, or `null` if the AST structure has not been resolved.
    */
   DartType staticType;
 
   /**
    * The propagated type of this expression, or `null` if type propagation has not been
    * performed on the AST structure.
    */
   DartType propagatedType;
 
   /**
+   * An empty list of expressions.
+   */
+  static const List<Expression> EMPTY_ARRAY = const <Expression>[];
+
+  /**
    * Return the best parameter element information available for this expression. If type
    * propagation was able to find a better parameter element than static analysis, that type will be
    * returned. Otherwise, the result of static analysis will be returned.
    *
    * @return the parameter element representing the parameter to which the value of this expression
    *         will be bound
    */
   ParameterElement get bestParameterElement {
     ParameterElement propagatedElement = propagatedParameterElement;
     if (propagatedElement != null) {
@@ skipping 148 matching lines @@
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
    * @param keyword the token representing the 'async' keyword
    * @param functionDefinition the token introducing the expression that represents the body of the
    *          function
    * @param expression the expression representing the body of the function
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionFunctionBody(this.keyword, this.functionDefinition, Expression expression, this.semicolon) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
 
   @override
   Token get beginToken => functionDefinition;
 
   @override
   Token get endToken {
@@ skipping 15 matching lines @@
 
   @override
   bool get isSynchronous => keyword == null;
 
   /**
    * Set the expression representing the body of the function to the given expression.
    *
    * @param expression the expression representing the body of the function
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ExpressionStatement` wrap an expression as a statement.
@@ skipping 15 matching lines @@
    */
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionStatement(this);
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Token get endToken {
@@ skipping 12 matching lines @@
 
   @override
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ExtendsClause` represent the "extends" clause in a class
@@ skipping 15 matching lines @@
    */
   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);
+    _superclass = becomeParentOf(superclass);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExtendsClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => _superclass.endToken;
@@ skipping 48 matching lines @@
   /**
    * Initialize a newly created field declaration.
    *
    * @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);
+    _fieldList = becomeParentOf(fieldList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFieldDeclaration(this);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
@@ skipping 11 matching lines @@
    * @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) {
-    this._fieldList = becomeParentOf(fieldList);
+    _fieldList = becomeParentOf(fieldList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 48 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 thisToken the token representing the 'this' keyword
    * @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);
+    _type = becomeParentOf(type);
+    _parameters = becomeParentOf(parameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
@@ skipping 27 matching lines @@
 
   @override
   bool get isFinal => (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    *
    * @param parameters the parameters of the function-typed parameter
    */
   void set parameters(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+    _parameters = becomeParentOf(parameters);
   }
 
   /**
    * 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);
   }
@@ skipping 68 matching lines @@
    *
    * @param awaitKeyword the token representing the 'await' keyword
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param loopVariable the declaration of the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   ForEachStatement.con1(this.awaitKeyword, this.forKeyword, this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
-    this._loopVariable = becomeParentOf(loopVariable);
-    this._iterable = becomeParentOf(iterator);
-    this._body = becomeParentOf(body);
+    _loopVariable = becomeParentOf(loopVariable);
+    _iterable = becomeParentOf(iterator);
+    _body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for-each statement.
    *
    * @param awaitKeyword the token representing the 'await' keyword
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param identifier the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   ForEachStatement.con2(this.awaitKeyword, this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
-    this._identifier = becomeParentOf(identifier);
-    this._iterable = becomeParentOf(iterator);
-    this._body = becomeParentOf(body);
+    _identifier = becomeParentOf(identifier);
+    _iterable = becomeParentOf(iterator);
+    _body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForEachStatement(this);
 
   @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
@@ skipping 26 matching lines @@
    * @return the declaration of the loop variable
    */
   DeclaredIdentifier get loopVariable => _loopVariable;
 
   /**
    * Set the body of the loop to the given block.
    *
    * @param body the body of the loop
    */
   void set body(Statement body) {
-    this._body = becomeParentOf(body);
+    _body = becomeParentOf(body);
   }
 
   /**
    * Set the loop variable to the given variable.
    *
    * @param identifier the loop variable
    */
   void set identifier(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
+    _identifier = becomeParentOf(identifier);
   }
 
   /**
    * Set the expression evaluated to produce the iterator to the given expression.
    *
    * @param expression the expression evaluated to produce the iterator
    */
   void set iterable(Expression expression) {
     _iterable = becomeParentOf(expression);
   }
@@ skipping 95 matching lines @@
    * @param variableList the declaration of the loop variables
    * @param initialization the initialization expression
    * @param leftSeparator the semicolon separating the initializer and the condition
    * @param condition the condition used to determine when to terminate the loop
    * @param rightSeparator the semicolon separating the condition and the updater
    * @param updaters the list of expressions run after each execution of the loop body
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   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);
+    _variableList = becomeParentOf(variableList);
+    _initialization = becomeParentOf(initialization);
+    _condition = becomeParentOf(condition);
+    _updaters = new NodeList<Expression>(this, updaters);
+    _body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForStatement(this);
 
   @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
@@ skipping 33 matching lines @@
    * @return the declaration of the loop variables, or `null` if there are no variables
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the body of the loop to the given statement.
    *
    * @param body the body of the loop
    */
   void set body(Statement body) {
-    this._body = becomeParentOf(body);
+    _body = becomeParentOf(body);
   }
 
   /**
    * Set the condition used to determine when to terminate the loop to the given expression.
    *
    * @param expression the condition used to determine when to terminate the loop
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
   /**
    * Set the initialization expression to the given expression.
    *
    * @param initialization the initialization expression
    */
   void set initialization(Expression initialization) {
-    this._initialization = becomeParentOf(initialization);
+    _initialization = becomeParentOf(initialization);
   }
 
   /**
    * Set the declaration of the loop variables to the given parameter.
    *
    * @param variableList the declaration of the loop variables
    */
   void set variables(VariableDeclarationList variableList) {
-    this._variableList = becomeParentOf(variableList);
+    _variableList = becomeParentOf(variableList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
@@ skipping 81 matching lines @@
  *     '[' [DefaultFormalParameter] (',' [DefaultFormalParameter])* ']'
  *
  * namedFormalParameters ::=
  *     '{' [DefaultFormalParameter] (',' [DefaultFormalParameter])* '}'
  * </pre>
  */
 class FormalParameterList extends AstNode {
   /**
    * The left parenthesis.
    */
-  Token _leftParenthesis;
+  Token leftParenthesis;
 
   /**
    * The parameters associated with the method.
    */
   NodeList<FormalParameter> _parameters;
 
   /**
    * The left square bracket ('[') or left curly brace ('{') introducing the optional parameters, or
    * `null` if there are no optional parameters.
    */
-  Token _leftDelimiter;
+  Token leftDelimiter;
 
   /**
    * The right square bracket (']') or right curly brace ('}') introducing the optional parameters,
    * or `null` if there are no optional parameters.
    */
-  Token _rightDelimiter;
+  Token rightDelimiter;
 
   /**
    * The right parenthesis.
    */
-  Token _rightParenthesis;
+  Token rightParenthesis;
 
   /**
    * Initialize a newly created parameter list.
    *
    * @param leftParenthesis the left parenthesis
    * @param parameters the parameters associated with the method
    * @param leftDelimiter the left delimiter introducing the optional parameters
    * @param rightDelimiter the right delimiter introducing the optional parameters
    * @param rightParenthesis the right parenthesis
    */
-  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;
+  FormalParameterList(this.leftParenthesis, List<FormalParameter> parameters, this.leftDelimiter, this.rightDelimiter, this.rightParenthesis) {
+    _parameters = new NodeList<FormalParameter>(this, parameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFormalParameterList(this);
 
   @override
-  Token get beginToken => _leftParenthesis;
+  Token get beginToken => leftParenthesis;
 
   @override
-  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
-   *         parameters
-   */
-  Token get leftDelimiter => _leftDelimiter;
-
-  /**
-   * Return the left parenthesis.
-   *
-   * @return the left parenthesis
-   */
-  Token get leftParenthesis => _leftParenthesis;
+  Token get endToken => rightParenthesis;
 
   /**
    * Return an array containing the elements representing the parameters in this list. The array
    * will contain `null`s if the parameters in this list have not been resolved.
    *
    * @return the elements representing the parameters in this list
    */
   List<ParameterElement> get parameterElements {
     int count = _parameters.length;
     List<ParameterElement> types = new List<ParameterElement>(count);
     for (int i = 0; i < count; i++) {
       types[i] = _parameters[i].element;
     }
     return types;
   }
 
   /**
    * Return the parameters associated with the method.
    *
    * @return the parameters associated with the method
    */
   NodeList<FormalParameter> get parameters => _parameters;
 
-  /**
-   * Return the right square bracket (']') or right curly brace ('}') introducing the optional
-   * parameters, or `null` if there are no optional parameters.
-   *
-   * @return the right square bracket (']') or right curly brace ('}') introducing the optional
-   *         parameters
-   */
-  Token get rightDelimiter => _rightDelimiter;
-
-  /**
-   * Return the right parenthesis.
-   *
-   * @return the right parenthesis
-   */
-  Token get rightParenthesis => _rightParenthesis;
-
-  /**
-   * Set the left square bracket ('[') or left curly brace ('{') introducing the optional parameters
-   * to the given token.
-   *
-   * @param bracket the left delimiter introducing the optional parameters
-   */
-  void set leftDelimiter(Token bracket) {
-    _leftDelimiter = bracket;
-  }
-
-  /**
-   * Set the left parenthesis to the given token.
-   *
-   * @param parenthesis the left parenthesis
-   */
-  void set leftParenthesis(Token parenthesis) {
-    _leftParenthesis = parenthesis;
-  }
-
-  /**
-   * Set the right square bracket (']') or right curly brace ('}') introducing the optional
-   * parameters to the given token.
-   *
-   * @param bracket the right delimiter introducing the optional parameters
-   */
-  void set rightDelimiter(Token bracket) {
-    _rightDelimiter = bracket;
-  }
-
-  /**
-   * Set the right parenthesis to the given token.
-   *
-   * @param parenthesis the right parenthesis
-   */
-  void set rightParenthesis(Token parenthesis) {
-    _rightParenthesis = parenthesis;
-  }
-
   @override
   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.
  *
@@ skipping 87 matching lines @@
    *
    * @param comment the documentation comment associated with this function
    * @param metadata the annotations associated with this function
    * @param externalKeyword the token representing the 'external' keyword
    * @param returnType the return type of the function
    * @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);
+    _returnType = becomeParentOf(returnType);
+    _name = becomeParentOf(name);
+    _functionExpression = becomeParentOf(functionExpression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
   @override
   ExecutableElement get element => _name != null ? (_name.staticElement as ExecutableElement) : null;
 
   @override
   Token get endToken => _functionExpression.endToken;
@@ skipping 32 matching lines @@
    * @return `true` if this function declares a setter
    */
   bool get isSetter => propertyKeyword != null && (propertyKeyword as KeywordToken).keyword == Keyword.SET;
 
   /**
    * Set the function expression being wrapped to the given function expression.
    *
    * @param functionExpression the function expression being wrapped
    */
   void set functionExpression(FunctionExpression functionExpression) {
-    this._functionExpression = becomeParentOf(functionExpression);
+    _functionExpression = becomeParentOf(functionExpression);
   }
 
   /**
    * Set the name of the function to the given identifier.
    *
    * @param identifier the name of the function
    */
   void set name(SimpleIdentifier identifier) {
-    this._name = becomeParentOf(identifier);
+    _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the return type of the function to the given name.
    *
    * @param returnType the return type of the function
    */
   void set returnType(TypeName returnType) {
-    this._returnType = becomeParentOf(returnType);
+    _returnType = becomeParentOf(returnType);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_functionExpression, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (externalKeyword != null) {
       return externalKeyword;
-    }
-    if (_returnType != null) {
+    } else 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.
  */
 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);
+    _functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
 
   @override
   Token get beginToken => _functionDeclaration.beginToken;
 
   @override
   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 functionDeclaration(FunctionDeclaration functionDeclaration) {
-    this._functionDeclaration = becomeParentOf(functionDeclaration);
+    _functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionExpression` represent a function expression.
@@ skipping 20 matching lines @@
    */
   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);
+    _parameters = becomeParentOf(parameters);
+    _body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpression(this);
 
   @override
   Token get beginToken {
     if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
@@ skipping 41 matching lines @@
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
    * 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);
+    _parameters = becomeParentOf(parameters);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
@@ skipping 22 matching lines @@
   /**
    * The element associated with the function being invoked based on static type information, or
    * `null` if the AST structure has not been resolved or the function could not be resolved.
    */
   ExecutableElement staticElement;
 
   /**
    * The element associated with the function being invoked based on propagated type information, or
    * `null` if the AST structure has not been resolved or the function could not be resolved.
    */
-  ExecutableElement _propagatedElement;
+  ExecutableElement propagatedElement;
 
   /**
    * 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);
+    _function = becomeParentOf(function);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
@@ skipping 25 matching lines @@
    * Return the expression producing the function being invoked.
    *
    * @return the expression producing the function being invoked
    */
   Expression get function => _function;
 
   @override
   int get precedence => 15;
 
   /**
-   * Return the element associated with the function being invoked based on propagated type
-   * information, or `null` if the AST structure has not been resolved or the function could
-   * not be resolved. One common example of the latter case is an expression whose value can change
-   * over time.
-   *
-   * @return the element associated with the function being invoked
-   */
-  ExecutableElement get propagatedElement => _propagatedElement;
-
-  /**
    * Set the list of arguments to the method to the given list.
    *
    * @param argumentList the list of arguments to the method
    */
   void set argumentList(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the expression producing the function being invoked to the given expression.
    *
    * @param function the expression producing the function being invoked
    */
   void set function(Expression function) {
-    this._function = becomeParentOf(function);
-  }
-
-  /**
-   * 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;
+    _function = becomeParentOf(function);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
@@ skipping 36 matching lines @@
    * @param comment the documentation comment associated with this type alias
    * @param metadata the annotations associated with this type alias
    * @param keyword the token representing the 'typedef' keyword
    * @param returnType the name of the return type of the function type being defined
    * @param name the name of the type being declared
    * @param typeParameters the type parameters for the type
    * @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);
+    _returnType = becomeParentOf(returnType);
+    _name = becomeParentOf(name);
+    _typeParameters = becomeParentOf(typeParameters);
+    _parameters = becomeParentOf(parameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypeAlias(this);
 
   @override
   FunctionTypeAliasElement get element => _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
    * Return the name of the function type being declared.
@@ skipping 24 matching lines @@
    * @return the type parameters for the function type
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Set the name of the function type being declared to the given identifier.
    *
    * @param name the name of the function type being declared
    */
   void set name(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   /**
    * Set the parameters associated with the function type to the given list of parameters.
    *
    * @param parameters the parameters associated with the function type
    */
   void set parameters(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+    _parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the name of the return type of the function type being defined to the given type name.
    *
    * @param typeName the name of the return type of the function type being defined
    */
   void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
   /**
    * 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);
+    _typeParameters = becomeParentOf(typeParameters);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
@@ skipping 23 matching lines @@
    * 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);
+    _returnType = becomeParentOf(returnType);
+    _parameters = becomeParentOf(parameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
 
   @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
@@ skipping 23 matching lines @@
 
   @override
   bool get isFinal => false;
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    *
    * @param parameters the parameters of the function-typed parameter
    */
   void set parameters(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+    _parameters = becomeParentOf(parameters);
   }
 
   /**
    * 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);
+    _returnType = becomeParentOf(returnType);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
@@ skipping 410 matching lines @@
    */
   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);
+    _hiddenNames = new NodeList<SimpleIdentifier>(this, hiddenNames);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitHideCombinator(this);
 
   @override
   Token get endToken => _hiddenNames.endToken;
 
   /**
    * Return the list of names from the library that are hidden by this combinator.
@@ skipping 119 matching lines @@
    *
    * @param ifKeyword the token representing the 'if' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition used to determine which of the statements is executed next
    * @param rightParenthesis the right parenthesis
    * @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);
+    _condition = becomeParentOf(condition);
+    _thenStatement = becomeParentOf(thenStatement);
+    _elseStatement = becomeParentOf(elseStatement);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIfStatement(this);
 
   @override
   Token get beginToken => ifKeyword;
 
   /**
    * Return the condition used to determine which of the statements is executed next.
@@ skipping 83 matching lines @@
    */
   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);
+    _interfaces = new NodeList<TypeName>(this, interfaces);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitImplementsClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => _interfaces.endToken;
@@ skipping 135 matching lines @@
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'import' keyword
    * @param libraryUri the URI of the library being imported
    * @param deferredToken the token representing the 'deferred' token
    * @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.deferredToken, this.asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
-    this._prefix = becomeParentOf(prefix);
+    _prefix = becomeParentOf(prefix);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitImportDirective(this);
 
   @override
   ImportElement get element => super.element as ImportElement;
 
   /**
    * Return the prefix to be used with the imported names, or `null` if the imported names are
@@ skipping 11 matching lines @@
     }
     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);
+    _prefix = becomeParentOf(prefix);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 
@@ skipping 648 matching lines @@
 
   /**
    * The period ("..") before a cascaded index expression, or `null` if this index expression
    * is not part of a cascade expression.
    */
   Token period;
 
   /**
    * The left square bracket.
    */
-  Token _leftBracket;
+  Token leftBracket;
 
   /**
    * The expression used to compute the index.
    */
   Expression _index;
 
   /**
    * The right square bracket.
    */
-  Token _rightBracket;
+  Token rightBracket;
 
   /**
    * The element associated with the operator based on the static type of the target, or
    * `null` if the AST structure has not been resolved or if the operator could not be
    * resolved.
    */
-  MethodElement _staticElement;
+  MethodElement staticElement;
 
   /**
    * The element associated with the operator based on the propagated type of the target, or
    * `null` if the AST structure has not been resolved or if the operator could not be
    * resolved.
    */
-  MethodElement _propagatedElement;
+  MethodElement propagatedElement;
 
   /**
    * If this expression is both in a getter and setter context, the [AuxiliaryElements] will
    * be set to hold onto the static and propagated information. The auxiliary element will hold onto
    * the elements from the getter context.
    */
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created index expression.
    *
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forTarget(Expression target, Token leftBracket, Expression index, Token rightBracket) {
-    this._target = becomeParentOf(target);
-    this._leftBracket = leftBracket;
-    this._index = becomeParentOf(index);
-    this._rightBracket = rightBracket;
+  IndexExpression.forTarget(Expression target, this.leftBracket, Expression index, this.rightBracket) {
+    _target = becomeParentOf(target);
+    _index = becomeParentOf(index);
   }
 
   /**
    * Initialize a newly created index expression.
    *
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forCascade(this.period, Token leftBracket, Expression index, Token rightBracket) {
-    this._leftBracket = leftBracket;
-    this._index = becomeParentOf(index);
-    this._rightBracket = rightBracket;
+  IndexExpression.forCascade(this.period, this.leftBracket, Expression index, this.rightBracket) {
+    _index = becomeParentOf(index);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIndexExpression(this);
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
@@ skipping 10 matching lines @@
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
-  Token get endToken => _rightBracket;
+  Token get endToken => rightBracket;
 
   /**
    * Return the expression used to compute the index.
    *
    * @return the expression used to compute the index
    */
   Expression get index => _index;
 
-  /**
-   * Return the left square bracket.
-   *
-   * @return the left square bracket
-   */
-  Token get leftBracket => _leftBracket;
-
   @override
   int get precedence => 15;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the target, or
-   * `null` if the AST structure has not been resolved 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
-   * target.
-   *
-   * @return the element associated with this operator
-   */
-  MethodElement get propagatedElement => _propagatedElement;
-
-  /**
    * 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 [target].
    */
   Expression get realTarget {
     if (isCascaded) {
       AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
 
   /**
-   * Return the right square bracket.
-   *
-   * @return the right square bracket
-   */
-  Token get rightBracket => _rightBracket;
-
-  /**
-   * Return the element associated with the operator based on the static type of the target, or
-   * `null` if the AST structure has not been resolved 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
-   * target.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get staticElement => _staticElement;
-
-  /**
    * Return the expression used to compute the object being indexed, or `null` if this index
    * expression is part of a cascade expression.
    *
    * @return the expression used to compute the object being indexed
    * See [realTarget].
    */
   Expression get target => _target;
 
   /**
    * Return `true` if this expression is computing a right-hand value.
@@ skipping 52 matching lines @@
   /**
    * Set the expression used to compute the index to the given expression.
    *
    * @param expression the expression used to compute the index
    */
   void set index(Expression expression) {
     _index = becomeParentOf(expression);
   }
 
   /**
-   * Set the left square bracket to the given token.
-   *
-   * @param bracket the left square bracket
-   */
-  void set leftBracket(Token bracket) {
-    _leftBracket = bracket;
-  }
-
-  /**
-   * Set the element associated with the operator based on the propagated type of the target to the
-   * given element.
-   *
-   * @param element the element to be associated with this operator
-   */
-  void set propagatedElement(MethodElement element) {
-    _propagatedElement = element;
-  }
-
-  /**
-   * Set the right square bracket to the given token.
-   *
-   * @param bracket the right square bracket
-   */
-  void set rightBracket(Token bracket) {
-    _rightBracket = bracket;
-  }
-
-  /**
-   * Set the element associated with the operator based on the static type of the target to the
-   * given element.
-   *
-   * @param element the static element to be associated with the operator
-   */
-  void set staticElement(MethodElement element) {
-    _staticElement = element;
-  }
-
-  /**
    * 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);
   }
 
   @override
   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.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the index
    *         expression will be bound
    */
   ParameterElement get propagatedParameterElementForIndex {
-    if (_propagatedElement == null) {
+    if (propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _propagatedElement.parameters;
+    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 index expression will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the index
    *         expression will be bound
    */
   ParameterElement get staticParameterElementForIndex {
-    if (_staticElement == null) {
+    if (staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _staticElement.parameters;
+    List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 
 /**
  * Instances of the class `InstanceCreationExpression` represent an instance creation
  * expression.
@@ skipping 21 matching lines @@
 
   /**
    * The element associated with the constructor based on static type information, or `null`
    * if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
    * The result of evaluating this expression, if it is constant.
    */
-  EvaluationResultImpl _result;
+  EvaluationResultImpl evaluationResult;
 
   /**
    * Initialize a newly created instance creation expression.
    *
    * @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);
+    _constructorName = becomeParentOf(constructorName);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   @override
   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;
 
   @override
   Token get beginToken => keyword;
 
   /**
    * Return the name of the constructor to be invoked.
    *
    * @return the name of the constructor to be invoked
    */
   ConstructorName get constructorName => _constructorName;
 
   @override
   Token get endToken => _argumentList.endToken;
 
-  /**
-   * Return the result of evaluating this constant as a compile-time constant expression, or
-   * `null` if this variable is not a 'const' expression or an error prevented the result from
-   * being computed.
-   *
-   * @return the result of evaluating this constant
-   */
-  EvaluationResultImpl get evaluationResult => _result;
-
   @override
   int get precedence => 16;
 
   /**
    * Return `true` if this creation expression is used to invoke a constant constructor.
    *
    * @return `true` if this creation expression is used to invoke a constant constructor
    */
   bool get isConst => keyword is KeywordToken && (keyword as KeywordToken).keyword == Keyword.CONST;
 
   /**
    * 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);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the name of the constructor to be invoked to the given name.
    *
    * @param constructorName the name of the constructor to be invoked
    */
   void set constructorName(ConstructorName constructorName) {
-    this._constructorName = becomeParentOf(constructorName);
-  }
-
-  /**
-   * Set the result of evaluating this expression as a compile-time constant expression to the given
-   * result.
-   *
-   * @param result the result of evaluating this expression
-   */
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
+    _constructorName = becomeParentOf(constructorName);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
@@ skipping 87 matching lines @@
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInterpolationExpression(this);
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Token get endToken {
@@ skipping 10 matching lines @@
    */
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   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>
  */
 class InterpolationString extends InterpolationElement {
   /**
    * The characters that will be added to the string.
    */
-  Token _contents;
+  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;
+  InterpolationString(this.contents, String value) {
+    _value = value;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInterpolationString(this);
 
   @override
-  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;
+  Token get beginToken => contents;
 
   @override
-  Token get endToken => _contents;
+  Token get endToken => contents;
 
   /**
    * Return the value of the literal.
    *
    * @return the value of the literal
    */
   String get value => _value;
 
   /**
-   * Set the characters that will be added to the string to those in the given string.
-   *
-   * @param string the characters that will be added to the string
-   */
-  void set contents(Token string) {
-    _contents = string;
-  }
-
-  /**
    * Set the value of the literal to the given string.
    *
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = string;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
   }
 
   /**
    * Return the offset of the after-last contents character.
    */
   int get contentsEnd {
-    int end = _contents.end;
-    String lexeme = _contents.lexeme;
+    int end = contents.end;
+    String lexeme = contents.lexeme;
     if (StringUtilities.endsWith3(lexeme, 0x22, 0x22, 0x22) ||
         StringUtilities.endsWith3(lexeme, 0x27, 0x27, 0x27)) {
       end -= 3;
     } else {
       end -= 1;
     }
     return end;
   }
 
   /**
    * Return the offset of the first contents character.
    */
   int get contentsOffset {
-    int offset = _contents.offset;
-    String lexeme = _contents.lexeme;
+    int offset = contents.offset;
+    String lexeme = contents.lexeme;
     if (lexeme.codeUnitAt(0) == 0x72) {
       offset += 1;
     }
     if (StringUtilities.startsWith3(lexeme, offset, 0x22, 0x22, 0x22) ||
         StringUtilities.startsWith3(lexeme, offset, 0x27, 0x27, 0x27)) {
       offset += 3;
     } else {
       offset += 1;
     }
     return offset;
@@ skipping 31 matching lines @@
 
   /**
    * Initialize a newly created is expression.
    *
    * @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);
+    _expression = becomeParentOf(expression);
+    _type = becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIsExpression(this);
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Token get endToken => _type.endToken;
@@ skipping 15 matching lines @@
    */
   TypeName get type => _type;
 
   /**
    * Set the expression used to compute the value whose type is being tested to the given
    * expression.
    *
    * @param expression the expression used to compute the value whose type is being tested
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   /**
    * 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);
+    _type = becomeParentOf(name);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 
 /**
@@ skipping 15 matching lines @@
    */
   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);
+    _label = becomeParentOf(label);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLabel(this);
 
   @override
   Token get beginToken => _label.beginToken;
 
   @override
   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);
+    _label = becomeParentOf(label);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * Instances of the class `LabeledStatement` represent a statement that has a label associated
@@ skipping 15 matching lines @@
    */
   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);
+    _labels = new NodeList<Label>(this, labels);
+    _statement = becomeParentOf(statement);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLabeledStatement(this);
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
@@ skipping 16 matching lines @@
    * @return the statement with which the labels are being associated
    */
   Statement get statement => _statement;
 
   /**
    * 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);
+    _statement = becomeParentOf(statement);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 
 /**
@@ skipping 23 matching lines @@
   /**
    * Initialize a newly created library directive.
    *
    * @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);
+    _name = becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLibraryDirective(this);
 
   @override
   Token get endToken => semicolon;
 
   @override
   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);
+    _name = becomeParentOf(name);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => libraryToken;
@@ skipping 12 matching lines @@
    * 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);
+    _components = new NodeList<SimpleIdentifier>(this, components);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLibraryIdentifier(this);
 
   @override
   Token get beginToken => _components.beginToken;
 
   @override
   Element get bestElement => staticElement;
@@ skipping 43 matching lines @@
  *
  * <pre>
  * listLiteral ::=
  *     'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  * </pre>
  */
 class ListLiteral extends TypedLiteral {
   /**
    * The left square bracket.
    */
-  Token _leftBracket;
+  Token leftBracket;
 
   /**
    * The expressions used to compute the elements of the list.
    */
   NodeList<Expression> _elements;
 
   /**
    * The right square bracket.
    */
-  Token _rightBracket;
+  Token rightBracket;
 
   /**
    * Initialize a newly created list 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
    * @param leftBracket the left square bracket
    * @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;
+  ListLiteral(Token constKeyword, TypeArgumentList typeArguments, this.leftBracket, List<Expression> elements, this.rightBracket) : super(constKeyword, typeArguments) {
+    _elements = new NodeList<Expression>(this, elements);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitListLiteral(this);
 
   @override
   Token get beginToken {
-    Token token = constKeyword;
-    if (token != null) {
-      return token;
+    if (constKeyword != null) {
+      return constKeyword;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
-    return _leftBracket;
+    return leftBracket;
   }
 
   /**
    * Return the expressions used to compute the elements of the list.
    *
    * @return the expressions used to compute the elements of the list
    */
   NodeList<Expression> get elements => _elements;
 
   @override
-  Token get endToken => _rightBracket;
-
-  /**
-   * Return the left square bracket.
-   *
-   * @return the left square bracket
-   */
-  Token get leftBracket => _leftBracket;
-
-  /**
-   * Return the right square bracket.
-   *
-   * @return the right square bracket
-   */
-  Token get rightBracket => _rightBracket;
-
-  /**
-   * Set the left square bracket to the given token.
-   *
-   * @param bracket the left square bracket
-   */
-  void set leftBracket(Token bracket) {
-    _leftBracket = bracket;
-  }
-
-  /**
-   * Set the right square bracket to the given token.
-   *
-   * @param bracket the right square bracket
-   */
-  void set rightBracket(Token bracket) {
-    _rightBracket = bracket;
-  }
+  Token get endToken => rightBracket;
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Literal` defines the behavior common to nodes that represent a literal
@@ skipping 20 matching lines @@
  *
  * <pre>
  * mapLiteral ::=
  *     'const'? ('<' [TypeName] (',' [TypeName])* '>')? '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  * </pre>
  */
 class MapLiteral extends TypedLiteral {
   /**
    * The left curly bracket.
    */
-  Token _leftBracket;
+  Token leftBracket;
 
   /**
    * The entries in the map.
    */
   NodeList<MapLiteralEntry> _entries;
 
   /**
    * The right curly bracket.
    */
-  Token _rightBracket;
+  Token rightBracket;
 
   /**
    * Initialize a newly created map 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
    * @param leftBracket the left curly bracket
    * @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;
+  MapLiteral(Token constKeyword, TypeArgumentList typeArguments, this.leftBracket, List<MapLiteralEntry> entries, this.rightBracket) : super(constKeyword, typeArguments) {
+    _entries = new NodeList<MapLiteralEntry>(this, entries);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMapLiteral(this);
 
   @override
   Token get beginToken {
-    Token token = constKeyword;
-    if (token != null) {
-      return token;
+    if (constKeyword != null) {
+      return constKeyword;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
-    return _leftBracket;
+    return leftBracket;
   }
 
   @override
-  Token get endToken => _rightBracket;
+  Token get endToken => rightBracket;
 
   /**
    * Return the entries in the map.
    *
    * @return the entries in the map
    */
   NodeList<MapLiteralEntry> get entries => _entries;
 
-  /**
-   * Return the left curly bracket.
-   *
-   * @return the left curly bracket
-   */
-  Token get leftBracket => _leftBracket;
-
-  /**
-   * Return the right curly bracket.
-   *
-   * @return the right curly bracket
-   */
-  Token get rightBracket => _rightBracket;
-
-  /**
-   * Set the left curly bracket to the given token.
-   *
-   * @param bracket the left curly bracket
-   */
-  void set leftBracket(Token bracket) {
-    _leftBracket = bracket;
-  }
-
-  /**
-   * Set the right curly bracket to the given token.
-   *
-   * @param bracket the right curly bracket
-   */
-  void set rightBracket(Token bracket) {
-    _rightBracket = bracket;
-  }
-
   @override
   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.
@@ skipping 20 matching lines @@
   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);
+    _key = becomeParentOf(key);
+    _value = becomeParentOf(value);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMapLiteralEntry(this);
 
   @override
   Token get beginToken => _key.beginToken;
 
   @override
   Token get endToken => _value.endToken;
@@ skipping 108 matching lines @@
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    * @param returnType the return type of the method
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param operatorKeyword the token representing the 'operator' keyword
    * @param name the name of the method
    * @param parameters the parameters associated with the method, or `null` if this method
    *          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);
+    _returnType = becomeParentOf(returnType);
+    _name = becomeParentOf(name);
+    _parameters = becomeParentOf(parameters);
+    _body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   /**
    * Return the body of the method.
    *
    * @return the body of the method
    */
@@ skipping 87 matching lines @@
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the parameters associated with the method to the given list of parameters.
    *
    * @param parameters the parameters associated with the method
    */
   void set parameters(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+    _parameters = becomeParentOf(parameters);
   }
 
   /**
    * 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);
   }
@@ skipping 59 matching lines @@
 
   /**
    * Initialize a newly created method invocation.
    *
    * @param target the expression producing the object on which the method is defined
    * @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);
+    _target = becomeParentOf(target);
+    _methodName = becomeParentOf(methodName);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMethodInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
@@ skipping 63 matching lines @@
    * @return `true` if this expression is cascaded
    */
   bool get isCascaded => period != null && period.type == TokenType.PERIOD_PERIOD;
 
   /**
    * Set the list of arguments to the method to the given list.
    *
    * @param argumentList the list of arguments to the method
    */
   void set argumentList(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the name of the method being invoked to the given identifier.
    *
    * @param identifier the name of the method being invoked
    */
   void set methodName(SimpleIdentifier identifier) {
     _methodName = becomeParentOf(identifier);
   }
@@ skipping 35 matching lines @@
    */
   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);
+    _name = becomeParentOf(name);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNamedExpression(this);
 
   @override
   Token get beginToken => _name.beginToken;
 
   /**
    * Return the element representing the parameter being named by this expression, or `null`
@@ skipping 29 matching lines @@
 
   @override
   int get precedence => 0;
 
   /**
    * Set the expression with which the name is associated to the given expression.
    *
    * @param expression the expression with which the name is associated
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   /**
    * 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);
   }
@@ skipping 35 matching lines @@
    * Initialize a newly created namespace directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'import' or 'export' keyword
    * @param libraryUri the URI of the library being imported or exported
    * @param combinators the combinators used to control which names are imported or exported
    * @param semicolon the semicolon terminating the directive
    */
   NamespaceDirective(Comment comment, List<Annotation> metadata, this.keyword, StringLiteral libraryUri, List<Combinator> combinators, this.semicolon) : super(comment, metadata, libraryUri) {
-    this._combinators = new NodeList<Combinator>(this);
-    this._combinators.addAll(combinators);
+    _combinators = new NodeList<Combinator>(this, combinators);
   }
 
   /**
    * Return the combinators used to control how names are imported or exported.
    *
    * @return the combinators used to control how names are imported or exported
    */
   NodeList<Combinator> get combinators => _combinators;
 
   @override
@@ skipping 26 matching lines @@
    */
   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, StringLiteral name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => _name.endToken;
 
   /**
    * Return the name of the native object that implements the class.
    *
    * @return the name of the native object that implements the class
    */
   StringLiteral get name => _name;
 
   /**
    * Sets the name of the native object that implements the class.
    *
    * @param name the name of the native object that implements the class.
    */
   void set name(StringLiteral name) {
-    this._name = becomeParentOf(name);
+    _name = becomeParentOf(name);
   }
 
   @override
   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>
  */
 class NativeFunctionBody extends FunctionBody {
   /**
    * The token representing 'native' that marks the start of the function body.
    */
-  final Token nativeToken;
+  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;
+  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);
+    _stringLiteral = becomeParentOf(stringLiteral);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeFunctionBody(this);
 
   @override
   Token get beginToken => nativeToken;
 
   @override
   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;
 
   /**
    * Set the string literal representing the string after the 'native' token to the given string.
    *
    * @param stringLiteral the string literal representing the string after the 'native' token
    */
   void set stringLiteral(StringLiteral stringLiteral) {
-    this._stringLiteral = becomeParentOf(stringLiteral);
+    _stringLiteral = becomeParentOf(stringLiteral);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_stringLiteral, visitor);
   }
 }
 
 /**
  * Instances of the class `NodeLocator` locate the [AstNode] associated with a
@@ skipping 27 matching lines @@
   NodeLocator.con1(int offset) : this.con2(offset, offset);
 
   /**
    * 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;
-  }
+  NodeLocator.con2(this._startOffset, this._endOffset);
 
   /**
    * 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;
 
   /**
@@ skipping 46 matching lines @@
     }
     return null;
   }
 }
 
 /**
  * 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 `NodeReplacer` implement an object that will replace one child node
  * in an AST node with another node.
  */
 class NodeReplacer implements AstVisitor<bool> {
   /**
    * Replace the old node with the new node in the AST structure containing the old node.
    *
@@ skipping 1169 matching lines @@
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param identifier the name of the parameter being declared
    */
   NormalFormalParameter(Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
-    this._metadata = new NodeList<Annotation>(this);
-    this._comment = becomeParentOf(comment);
-    this._metadata.addAll(metadata);
-    this._identifier = becomeParentOf(identifier);
+    _comment = becomeParentOf(comment);
+    _metadata = new NodeList<Annotation>(this, metadata);
+    _identifier = becomeParentOf(identifier);
   }
 
   /**
    * 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;
 
@@ skipping 15 matching lines @@
    * @return the annotations associated with this parameter
    */
   NodeList<Annotation> get metadata => _metadata;
 
   /**
    * Set the documentation comment associated with this parameter to the given comment
    *
    * @param comment the documentation comment to be associated with this parameter
    */
   void set documentationComment(Comment comment) {
-    this._comment = becomeParentOf(comment);
+    _comment = becomeParentOf(comment);
   }
 
   /**
    * 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);
+    _identifier = becomeParentOf(identifier);
   }
 
   /**
    * 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);
+    _metadata.clear();
+    _metadata.addAll(metadata);
   }
 
   @override
   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);
@@ skipping 45 matching lines @@
   /**
    * 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;
-  }
+  NullLiteral(this.literal);
 
   @override
   accept(AstVisitor visitor) => visitor.visitNullLiteral(this);
 
   @override
   Token get beginToken => literal;
 
   @override
   Token get endToken => literal;
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * Instances of the class `ParenthesizedExpression` represent a parenthesized expression.
  *
  * <pre>
  * parenthesizedExpression ::=
  *     '(' [Expression] ')'
  * </pre>
  */
 class ParenthesizedExpression extends Expression {
   /**
    * The left parenthesis.
    */
-  Token _leftParenthesis;
+  Token leftParenthesis;
 
   /**
    * The expression within the parentheses.
    */
   Expression _expression;
 
   /**
    * The right parenthesis.
    */
-  Token _rightParenthesis;
+  Token rightParenthesis;
 
   /**
    * Initialize a newly created parenthesized expression.
    *
    * @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;
+  ParenthesizedExpression(this.leftParenthesis, Expression expression, this.rightParenthesis) {
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitParenthesizedExpression(this);
 
   @override
-  Token get beginToken => _leftParenthesis;
+  Token get beginToken => leftParenthesis;
 
   @override
-  Token get endToken => _rightParenthesis;
+  Token get endToken => rightParenthesis;
 
   /**
    * Return the expression within the parentheses.
    *
    * @return the expression within the parentheses
    */
   Expression get expression => _expression;
 
-  /**
-   * Return the left parenthesis.
-   *
-   * @return the left parenthesis
-   */
-  Token get leftParenthesis => _leftParenthesis;
-
   @override
   int get precedence => 15;
 
   /**
-   * Return the right parenthesis.
-   *
-   * @return the right parenthesis
-   */
-  Token get rightParenthesis => _rightParenthesis;
-
-  /**
    * Set the expression within the parentheses to the given expression.
    *
    * @param expression the expression within the parentheses
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
-  }
-
-  /**
-   * 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;
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `PartDirective` represent a part directive.
@@ skipping 74 matching lines @@
    * Initialize a newly created part-of 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 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);
+    _libraryName = becomeParentOf(libraryName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPartOfDirective(this);
 
   @override
   Token get endToken => semicolon;
 
   @override
   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);
+    _libraryName = becomeParentOf(libraryName);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => partToken;
@@ skipping 16 matching lines @@
   /**
    * The postfix operator being applied to the operand.
    */
   Token operator;
 
   /**
    * The element associated with this the operator based on the propagated type of the operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
-  MethodElement _propagatedElement;
+  MethodElement propagatedElement;
 
   /**
    * The element associated with the operator based on the static type of the operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
-  MethodElement _staticElement;
+  MethodElement staticElement;
 
   /**
    * 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);
+    _operand = becomeParentOf(operand);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPostfixExpression(this);
 
   @override
   Token get beginToken => _operand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
@@ skipping 18 matching lines @@
    * Return the expression computing the operand for the operator.
    *
    * @return the expression computing the operand for the operator
    */
   Expression get operand => _operand;
 
   @override
   int get precedence => 15;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the operand, or
-   * `null` if the AST structure has not been resolved, if the operator is not user definable,
-   * 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 operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get propagatedElement => _propagatedElement;
-
-  /**
-   * Return the element associated with the operator based on the static type of the operand, or
-   * `null` if the AST structure has not been resolved, if the operator is not user definable,
-   * 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 operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get staticElement => _staticElement;
-
-  /**
    * Set the expression computing the operand for the operator to the given expression.
    *
    * @param expression the expression computing the operand for the operator
    */
   void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
 
-  /**
-   * Set the element associated with the operator based on the propagated type of the operand to the
-   * given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set propagatedElement(MethodElement element) {
-    _propagatedElement = element;
-  }
-
-  /**
-   * 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;
-  }
-
   @override
   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.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
-    if (_propagatedElement == null) {
+    if (propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _propagatedElement.parameters;
+    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 operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
-    if (_staticElement == null) {
+    if (staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _staticElement.parameters;
+    List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 
 /**
  * Instances of the class `PrefixExpression` represent a prefix unary expression.
  *
@@ skipping 11 matching lines @@
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
 
   /**
    * The element associated with the operator based on the static type of the operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
-  MethodElement _staticElement;
+  MethodElement staticElement;
 
   /**
    * The element associated with the operator based on the propagated type of the operand, or
    * `null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
-  MethodElement _propagatedElement;
+  MethodElement propagatedElement;
 
   /**
    * 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);
+    _operand = becomeParentOf(operand);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPrefixExpression(this);
 
   @override
   Token get beginToken => operator;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
@@ skipping 18 matching lines @@
    * Return the expression computing the operand for the operator.
    *
    * @return the expression computing the operand for the operator
    */
   Expression get operand => _operand;
 
   @override
   int get precedence => 14;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the operand, or
-   * `null` if the AST structure has not been resolved, if the operator is not user definable,
-   * 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 operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get propagatedElement => _propagatedElement;
-
-  /**
-   * Return the element associated with the operator based on the static type of the operand, or
-   * `null` if the AST structure has not been resolved, if the operator is not user definable,
-   * 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 operand.
-   *
-   * @return the element associated with the operator
-   */
-  MethodElement get staticElement => _staticElement;
-
-  /**
    * Set the expression computing the operand for the operator to the given expression.
    *
    * @param expression the expression computing the operand for the operator
    */
   void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
 
-  /**
-   * Set the element associated with the operator based on the propagated type of the operand to the
-   * given element.
-   *
-   * @param element the element to be associated with the operator
-   */
-  void set propagatedElement(MethodElement element) {
-    _propagatedElement = element;
-  }
-
-  /**
-   * 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;
-  }
-
   @override
   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.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
-    if (_propagatedElement == null) {
+    if (propagatedElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _propagatedElement.parameters;
+    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 operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
-    if (_staticElement == null) {
+    if (staticElement == null) {
       return null;
     }
-    List<ParameterElement> parameters = _staticElement.parameters;
+    List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 
 /**
  * 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
@@ skipping 21 matching lines @@
   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);
+    _prefix = becomeParentOf(prefix);
+    _identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPrefixedIdentifier(this);
 
   @override
   Token get beginToken => _prefix.beginToken;
 
   @override
   Element get bestElement {
@@ skipping 62 matching lines @@
     }
     return imports[0].isDeferred;
   }
 
   /**
    * Set the identifier being prefixed to the given identifier.
    *
    * @param identifier the identifier being prefixed
    */
   void set identifier(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
+    _identifier = becomeParentOf(identifier);
   }
 
   /**
    * 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);
@@ skipping 35 matching lines @@
   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);
+    _target = becomeParentOf(target);
+    _propertyName = becomeParentOf(propertyName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPropertyAccess(this);
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
@@ skipping 771 matching lines @@
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor with the given name
    * with the given arguments.
    *
    * @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);
+    _constructorName = becomeParentOf(constructorName);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitRedirectingConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
@@ skipping 12 matching lines @@
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * 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);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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);
   }
@@ skipping 70 matching lines @@
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitReturnStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Traverse the AST from initial child node to successive parents, building a collection of local
@@ skipping 229 matching lines @@
    */
   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);
+    _shownNames = new NodeList<SimpleIdentifier>(this, shownNames);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitShowCombinator(this);
 
   @override
   Token get endToken => _shownNames.endToken;
 
   /**
    * Return the list of names from the library that are made visible by this combinator.
@@ skipping 358 matching lines @@
   /**
    * 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);
+    _type = becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleFormalParameter(this);
 
   @override
   Token get beginToken {
     NodeList<Annotation> metadata = this.metadata;
     if (!metadata.isEmpty) {
       return metadata.beginToken;
@@ skipping 382 matching lines @@
   Token literal;
 
   /**
    * The value of the literal.
    */
   String _value;
 
   /**
    * The toolkit specific element associated with this literal, or `null`.
    */
-  Element _toolkitElement;
+  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);
+    _value = StringUtilities.intern(value);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleStringLiteral(this);
 
   @override
   Token get beginToken => literal;
 
   @override
   int get contentsOffset {
@@ skipping 11 matching lines @@
 
   @override
   int get contentsEnd {
     return contentsOffset + value.length;
   }
 
   @override
   Token get endToken => literal;
 
   /**
-   * Return the toolkit specific, non-Dart, element associated with this literal, or `null`.
-   *
-   * @return the element associated with this literal
-   */
-  Element get toolkitElement => _toolkitElement;
-
-  /**
    * Return the value of the literal.
    *
    * @return the value of the literal
    */
   String get value => _value;
 
   @override
   bool get isMultiline {
     String lexeme = literal.lexeme;
     if (lexeme.length < 3) {
@@ skipping 22 matching lines @@
     if (codeZero == 0x72) {
       return lexeme.length > 1 && lexeme.codeUnitAt(1) == 0x27;
     }
     return codeZero == 0x27;
   }
 
   @override
   bool get isSynthetic => literal.isSynthetic;
 
   /**
-   * Set the toolkit specific, non-Dart, element associated with this literal.
-   *
-   * @param element the toolkit specific element to be associated with this literal
-   */
-  void set toolkitElement(Element element) {
-    _toolkitElement = element;
-  }
-
-  /**
    * 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);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 45 matching lines @@
    * 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);
+    _elements = new NodeList<InterpolationElement>(this, elements);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitStringInterpolation(this);
 
   @override
   Token get beginToken => _elements.beginToken;
 
   /**
    * Return the elements that will be composed to produce the resulting string.
@@ skipping 23 matching lines @@
 
   @override
   int get contentsEnd {
     InterpolationString element = _elements.last;
     return element.contentsEnd;
   }
 
   @override
   bool get isMultiline {
     InterpolationString element = _elements.first;
-    String lexeme = element._contents.lexeme;
+    String lexeme = element.contents.lexeme;
     if (lexeme.length < 3) {
       return false;
     }
     return StringUtilities.startsWith3(lexeme, 0, 0x22, 0x22, 0x22) ||
         StringUtilities.startsWith3(lexeme, 0, 0x27, 0x27, 0x27);
   }
 
   @override
   bool get isRaw => false;
 
 
   @override
   bool get isSingleQuoted {
     InterpolationString lastString = _elements.first;
-    String lexeme = lastString._contents.lexeme;
+    String lexeme = lastString.contents.lexeme;
     return StringUtilities.startsWithChar(lexeme, 0x27);
   }
 }
 
 /**
  * Instances of the class `StringLiteral` represent a string literal expression.
  *
  * <pre>
  * stringLiteral ::=
  *     [SimpleStringLiteral]
@@ skipping 103 matching lines @@
   /**
    * Initialize a newly created super invocation to invoke the inherited constructor with the given
    * name with the given arguments.
    *
    * @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);
+    _constructorName = becomeParentOf(constructorName);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
@@ skipping 12 matching lines @@
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * 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);
+    _argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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);
   }
@@ skipping 61 matching lines @@
   /**
    * 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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 
@@ skipping 59 matching lines @@
 
   /**
    * Initialize a newly created switch member.
    *
    * @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
    */
   SwitchMember(List<Label> labels, this.keyword, this.colon, List<Statement> statements) {
-    this._labels = new NodeList<Label>(this);
-    this._statements = new NodeList<Statement>(this);
-    this._labels.addAll(labels);
-    this._statements.addAll(statements);
+    _labels = new NodeList<Label>(this, labels);
+    _statements = new NodeList<Statement>(this, statements);
   }
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return keyword;
   }
 
@@ skipping 69 matching lines @@
    *
    * @param keyword the token representing the 'switch' keyword
    * @param leftParenthesis the left parenthesis
    * @param expression the expression used to determine which of the switch members will be selected
    * @param rightParenthesis the right parenthesis
    * @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);
+    _expression = becomeParentOf(expression);
+    _members = new NodeList<SwitchMember>(this, members);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSwitchStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => rightBracket;
@@ skipping 12 matching lines @@
    */
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 
 /**
@@ skipping 96 matching lines @@
    */
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitThrowExpression(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken {
@@ skipping 12 matching lines @@
 
   @override
   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);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ToSourceVisitor` write a source representation of a visited AST
@@ skipping 1148 matching lines @@
 
   /**
    * 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);
+    _variableList = becomeParentOf(variableList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
 
   @override
   Element get element => null;
 
   @override
   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) {
-    this._variableList = becomeParentOf(variableList);
+    _variableList = becomeParentOf(variableList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
@@ skipping 41 matching lines @@
   /**
    * Initialize a newly created try statement.
    *
    * @param tryKeyword the token representing the 'try' keyword
    * @param body the body of the statement
    * @param catchClauses the catch clauses contained in the try statement
    * @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);
+    _body = becomeParentOf(body);
+    _catchClauses = new NodeList<CatchClause>(this, catchClauses);
+    _finallyBlock = becomeParentOf(finallyBlock);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTryStatement(this);
 
   @override
   Token get beginToken => tryKeyword;
 
   /**
    * Return the body of the statement.
@@ skipping 120 matching lines @@
   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);
+    _arguments = new NodeList<TypeName>(this, arguments);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeArgumentList(this);
 
   /**
    * Return the type arguments associated with the type.
    *
    * @return the type arguments associated with the type
    */
@@ skipping 37 matching lines @@
   DartType 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);
+    _name = becomeParentOf(name);
+    _typeArguments = becomeParentOf(typeArguments);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeName(this);
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Token get endToken {
@@ skipping 45 matching lines @@
   void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * 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);
+    _typeArguments = becomeParentOf(typeArguments);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
@@ skipping 25 matching lines @@
   /**
    * Initialize a newly created type parameter.
    *
    * @param comment the documentation comment associated with the type parameter
    * @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);
+    _name = becomeParentOf(name);
+    _bound = becomeParentOf(bound);
   }
 
   @override
   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
@@ skipping 72 matching lines @@
   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);
+    _typeParameters = new NodeList<TypeParameter>(this, typeParameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeParameterList(this);
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Token get endToken => rightBracket;
@@ skipping 34 matching lines @@
   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);
+    _typeArguments = becomeParentOf(typeArguments);
   }
 
   /**
    * Return the type argument associated with this literal, or `null` if no type arguments
    * were declared.
    *
    * @return the type argument associated with this literal
    */
   TypeArgumentList get typeArguments => _typeArguments;
 
   /**
    * Set the type argument associated with this literal to the given arguments.
    *
    * @param typeArguments the type argument associated with this literal
    */
   void set typeArguments(TypeArgumentList typeArguments) {
-    this._typeArguments = becomeParentOf(typeArguments);
+    _typeArguments = becomeParentOf(typeArguments);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * Instances of the class `UnifyingAstVisitor` implement an AST visitor that will recursively
@@ skipping 363 matching lines @@
   Source source;
 
   /**
    * Initialize a newly create URI-based directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param uri the URI referenced by this directive
    */
   UriBasedDirective(Comment comment, List<Annotation> metadata, StringLiteral uri) : super(comment, metadata) {
-    this._uri = becomeParentOf(uri);
+    _uri = becomeParentOf(uri);
   }
 
   /**
    * Return the URI referenced by this directive.
    *
    * @return the URI referenced by this directive
    */
   StringLiteral get uri => _uri;
 
   /**
    * Return the element associated with the URI of this directive, or `null` if the AST
    * structure has not been resolved or if the URI could not be resolved. Examples of the latter
    * case include a directive that contains an invalid URL or a URL that does not exist.
    *
    * @return the element associated with this directive
    */
   Element get uriElement;
 
   /**
    * 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);
+    _uri = becomeParentOf(uri);
   }
 
   /**
    * Validate the given directive, but do not check for existence.
    *
    * @return a code indicating the problem if there is one, or `null` no problem
    */
   UriValidationCode validate() {
     StringLiteral uriLiteral = uri;
     if (uriLiteral is StringInterpolation) {
@@ skipping 17 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 
 /**
  * Validation codes returned by [UriBasedDirective.validate].
  */
-class UriValidationCode extends Enum<UriValidationCode> {
-  static const UriValidationCode INVALID_URI = const UriValidationCode('INVALID_URI', 0);
+class UriValidationCode {
+  /**
+   * The name of the validation code.
+   */
+  final String name;
 
-  static const UriValidationCode URI_WITH_INTERPOLATION = const UriValidationCode('URI_WITH_INTERPOLATION', 1);
+  static const UriValidationCode INVALID_URI = const UriValidationCode('INVALID_URI');
 
-  static const UriValidationCode URI_WITH_DART_EXT_SCHEME = const UriValidationCode('URI_WITH_DART_EXT_SCHEME', 2);
+  static const UriValidationCode URI_WITH_INTERPOLATION = const UriValidationCode('URI_WITH_INTERPOLATION');
 
-  static const List<UriValidationCode> values = const [
-      INVALID_URI,
-      URI_WITH_INTERPOLATION,
-      URI_WITH_DART_EXT_SCHEME];
+  static const UriValidationCode URI_WITH_DART_EXT_SCHEME = const UriValidationCode('URI_WITH_DART_EXT_SCHEME');
 
-  const UriValidationCode(String name, int ordinal) : super(name, ordinal);
+  /**
+   * Initialize a newly created validation code to have the given [name].
+   */
+  const UriValidationCode(this.name);
+
+  @override
+  String toString() => name;
 }
 
 /**
  * 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])?
@@ skipping 20 matching lines @@
   /**
    * Initialize a newly created variable declaration.
    *
    * @param comment the documentation comment associated with this declaration
    * @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);
+    _name = becomeParentOf(name);
+    _initializer = becomeParentOf(initializer);
   }
 
   @override
   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.
    */
   @override
@@ skipping 57 matching lines @@
     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);
+    _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);
+    _name = becomeParentOf(name);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
 
   @override
@@ skipping 35 matching lines @@
   /**
    * Initialize a newly created variable declaration list.
    *
    * @param comment the documentation comment associated with this declaration list
    * @param metadata the annotations associated with this declaration list
    * @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);
+    _type = becomeParentOf(type);
+    _variables = new NodeList<VariableDeclaration>(this, variables);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
   @override
   Token get endToken => _variables.endToken;
 
   /**
    * Return the type of the variables being declared, or `null` if no type was provided.
@@ skipping 72 matching lines @@
    */
   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);
+    _variableList = becomeParentOf(variableList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
 
   @override
   Token get beginToken => _variableList.beginToken;
 
   @override
   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);
+    _variableList = becomeParentOf(variableList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 
 /**
  * Instances of the class `WhileStatement` represent a while statement.
@@ skipping 32 matching lines @@
   /**
    * Initialize a newly created while statement.
    *
    * @param keyword the token representing the 'while' keyword
    * @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);
+    _condition = becomeParentOf(condition);
+    _body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitWhileStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   /**
    * Return the body of the loop.
@@ skipping 43 matching lines @@
  *
  * <pre>
  * withClause ::=
  *     'with' [TypeName] (',' [TypeName])*
  * </pre>
  */
 class WithClause extends AstNode {
   /**
    * The token representing the 'with' keyword.
    */
-  Token _withKeyword;
+  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);
+  WithClause(this.withKeyword, List<TypeName> mixinTypes) {
+    _mixinTypes = new NodeList<TypeName>(this, mixinTypes);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitWithClause(this);
 
   @override
-  Token get beginToken => _withKeyword;
+  Token get beginToken => withKeyword;
 
   @override
   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
    */
+  @deprecated
   void set mixinKeyword(Token withKeyword) {
-    this._withKeyword = withKeyword;
+    this.withKeyword = withKeyword;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `YieldStatement` implement a yield statement.
@@ skipping 21 matching lines @@
 
   /**
    * Initialize a newly created yield expression.
    *
    * @param yieldKeyword the 'yield' keyword
    * @param star the star following the 'yield' keyword
    * @param expression the expression whose value will be yielded
    * @param semicolon the semicolon following the expression
    */
   YieldStatement(this.yieldKeyword, this.star, Expression expression, this.semicolon) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   Token get beginToken {
     if (yieldKeyword != null) {
       return yieldKeyword;
     }
@@ skipping 14 matching lines @@
    * @return the expression whose value will be yielded
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression whose value will be yielded to the given expression.
    *
    * @param expression the expression whose value will be yielded
    */
   void set expression(Expression expression) {
-    this._expression = becomeParentOf(expression);
+    _expression = becomeParentOf(expression);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
+
 /**
- * Instances of the class {@code NodeList} represent a list of AST nodes that have a common parent.
+ * Instances of the class `NodeList` represent a list of AST nodes that have a
+ * common parent.
  */
 class NodeList<E extends AstNode> extends Object with ListMixin<E> {
   /**
-   * Create an empty list with the given owner. This is a convenience method that allows the
-   * compiler to determine the correct value of the type argument [E] without needing to
-   * explicitly specify it.
+   * Create an empty list with the given [owner].
    *
-   * @param owner the node that is the parent of each of the elements in the list
-   * @return the list that was created
+   * Use "new NodeList<E>(owner)"
    */
+  @deprecated
   static NodeList create(AstNode owner) => new NodeList(owner);
 
   /**
    * The node that is the parent of each of the elements in the list.
    */
   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
+   * Initialize a newly created list of nodes such that all of the nodes that
+   * are added to the list will have their parent set to the given [owner]. The
+   * list will initially be populated with the given [elements].
    */
-  NodeList(this.owner);
+  NodeList(this.owner, [List<E> elements]) {
+    addAll(elements);
+  }
 
   /**
-   * 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
+   * Use the given [visitor] to visit each of the nodes in this list.
    */
   accept(AstVisitor visitor) {
-    var length = _elements.length;
+    int length = _elements.length;
     for (var i = 0; i < length; i++) {
       _elements[i].accept(visitor);
     }
   }
+
+  @override
   void add(E node) {
     insert(length, node);
   }
+
+  @override
   void insert(int index, E node) {
     int length = _elements.length;
     if (index < 0 || index > length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
     owner.becomeParentOf(node);
     if (length == 0) {
-      _elements = <E> [node];
+      _elements.add(node);
     } else {
       _elements.insert(index, node);
     }
   }
+
+  @override
   bool addAll(Iterable<E> nodes) {
     if (nodes != null && !nodes.isEmpty) {
       _elements.addAll(nodes);
       for (E node in nodes) {
         owner.becomeParentOf(node);
       }
       return true;
     }
     return false;
   }
+
   E operator[](int index) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
-    return _elements[index] as E;
+    return _elements[index];
   }
 
   /**
-   * Return the first token included in this node's source range.
-   *
-   * @return the first token included in this node's source range
+   * Return the first token included in this node list's source range, or `null`
+   * if the list is empty.
    */
   Token get beginToken {
     if (_elements.length == 0) {
       return null;
     }
     return _elements[0].beginToken;
   }
 
   /**
-   * Return the last token included in this node list's source range.
-   *
-   * @return the last token included in this node list's source range
+   * Return the last token included in this node list's source range, or `null`
+   * if the list is empty.
    */
   Token get endToken {
-    if (_elements.length == 0) {
+    int length = _elements.length;
+    if (length == 0) {
       return null;
     }
-    return _elements[_elements.length - 1].endToken;
+    return _elements[length - 1].endToken;
   }
+
+  @override
   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;
-      return removedNode;
-    }
+    E removedNode = _elements[index];
     _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;
   }
+
+  @override
   void clear() {
     _elements = <E>[];
   }
+
   int get length => _elements.length;
+
+  @deprecated
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }