API clean-up

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 45 matching lines @@
 
   /**
    * Return the strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> get strings => _strings;
 
   @override
   accept(AstVisitor visitor) => visitor.visitAdjacentStrings(this);
 
   @override
-  void appendStringValue(StringBuffer buffer) {
-    for (StringLiteral stringLiteral in strings) {
-      stringLiteral.appendStringValue(buffer);
-    }
-  }
-
-  @override
   void visitChildren(AstVisitor visitor) {
     _strings.accept(visitor);
   }
+
+  @override
+  void _appendStringValue(StringBuffer buffer) {
+    for (StringLiteral stringLiteral in strings) {
+      stringLiteral._appendStringValue(buffer);
+    }
+  }
 }
 
 /**
  * An AST node that can be annotated with both a documentation comment and a
  * list of annotations.
  */
 abstract class AnnotatedNode extends AstNode {
   /**
    * The documentation comment associated with this node, or `null` if this node
    * does not have a documentation comment associated with it.
    */
   Comment _comment;
 
   /**
    * The annotations associated with this node.
    */
   NodeList<Annotation> _metadata;
 
   /**
    * Initialize a newly created annotated node. Either or both of the [comment]
    * and [metadata] can be `null` if the node does not have the corresponding
    * attribute.
    */
   AnnotatedNode(Comment comment, List<Annotation> metadata) {
-    _comment = becomeParentOf(comment);
+    _comment = _becomeParentOf(comment);
     _metadata = new NodeList<Annotation>(this, metadata);
   }
 
   @override
   Token get beginToken {
     if (_comment == null) {
       if (_metadata.isEmpty) {
         return firstTokenAfterCommentAndMetadata;
       }
       return _metadata.beginToken;
@@ skipping 12 matching lines @@
    * Return the documentation comment associated with this node, or `null` if
    * this node does not have a documentation comment associated with it.
    */
   Comment get documentationComment => _comment;
 
   /**
    * Set the documentation comment associated with this node to the given
    * [comment].
    */
   void set documentationComment(Comment comment) {
-    _comment = becomeParentOf(comment);
+    _comment = _becomeParentOf(comment);
   }
 
   /**
    * Return the first token following the comment and metadata.
    */
   Token get firstTokenAfterCommentAndMetadata;
 
   /**
    * Return the annotations associated with this node.
    */
   NodeList<Annotation> get metadata => _metadata;
 
   /**
    * Set the metadata associated with this node to the given [metadata].
    */
+  @deprecated // Directly modify the list returned by "this.metadata"
   void set metadata(List<Annotation> metadata) {
     _metadata.clear();
     _metadata.addAll(metadata);
   }
 
   /**
    * Return a list containing the comment and annotations associated with this
    * node, sorted in lexical order.
    */
   List<AstNode> get sortedCommentAndAnnotations {
     return <AstNode>[]
         ..add(_comment)
         ..addAll(_metadata)
         ..sort(AstNode.LEXICAL_ORDER);
   }
 
+  /**
+   * Return a holder of child entities that subclasses can add to.
+   */
   ChildEntities get _childEntities {
     ChildEntities result = new ChildEntities();
     if (_commentIsBeforeAnnotations()) {
       result
           ..add(_comment)
           ..addAll(_metadata);
     } else {
       result.addAll(sortedCommentAndAnnotations);
     }
     return result;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     if (_commentIsBeforeAnnotations()) {
       _safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (AstNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
-   * Return `true` if the comment is lexically before any annotations.
+   * Return `true` if there are no annotations before the comment. Note that a
+   * result of `true` does not imply that there is a comment, nor that there are
+   * annotations associated with this node.
    */
   bool _commentIsBeforeAnnotations() {
+    // TODO(brianwilkerson) Convert this to a getter.
     if (_comment == null || _metadata.isEmpty) {
       return true;
     }
     Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 }
 
 /**
  * An annotation that can be associated with an AST node.
@@ skipping 46 matching lines @@
   ElementAnnotation elementAnnotation;
 
   /**
    * Initialize a newly created annotation. Both the [period] and the
    * [constructorName] can be `null` if the annotation is not referencing a
    * named constructor. The [arguments] can be `null` if the annotation is not
    * referencing a constructor.
    */
   Annotation(this.atSign, Identifier name, this.period,
       SimpleIdentifier constructorName, ArgumentList arguments) {
-    _name = becomeParentOf(name);
-    _constructorName = becomeParentOf(constructorName);
-    _arguments = becomeParentOf(arguments);
+    _name = _becomeParentOf(name);
+    _constructorName = _becomeParentOf(constructorName);
+    _arguments = _becomeParentOf(arguments);
   }
 
   /**
    * Return the arguments to the constructor being invoked, or `null` if this
    * annotation is not the invocation of a constructor.
    */
   ArgumentList get arguments => _arguments;
 
   /**
    * Set the arguments to the constructor being invoked to the given arguments.
    */
   void set arguments(ArgumentList arguments) {
-    _arguments = becomeParentOf(arguments);
+    _arguments = _becomeParentOf(arguments);
   }
 
   @override
   Token get beginToken => atSign;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(atSign)
       ..add(_name)
       ..add(period)
       ..add(_constructorName)
       ..add(_arguments);
 
   /**
    * Return the name of the constructor being invoked, or `null` if this
    * annotation is not the invocation of a named constructor.
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor being invoked to the given [name].
    */
   void set constructorName(SimpleIdentifier name) {
-    _constructorName = becomeParentOf(name);
+    _constructorName = _becomeParentOf(name);
   }
 
   /**
    * 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.
    */
   Element get element {
     if (_element != null) {
       return _element;
@@ skipping 24 matching lines @@
    * Return the name of the class defining the constructor that is being invoked
    * or the name of the field that is being referenced.
    */
   Identifier get name => _name;
 
   /**
    * 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].
    */
   void set name(Identifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAnnotation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_arguments, visitor);
   }
 }
 
 /**
- * A list of arguments in the invocation of an executable element: a function,
- * method, or constructor.
+ * A list of arguments in the invocation of an executable element (that is, a
+ * function, method, or constructor).
  *
  * > argumentList ::=
  * >     '(' arguments? ')'
  * >
  * > arguments ::=
  * >     [NamedExpression] (',' [NamedExpression])*
  * >   | [Expression] (',' [Expression])* (',' [NamedExpression])*
  */
 class ArgumentList extends AstNode {
   /**
@@ skipping 97 matching lines @@
   /**
    * If
    * * the given [expression] is a child of this list,
    * * the AST structure has been resolved,
    * * the function being invoked is known based on propagated type information,
    *   and
    * * the expression corresponds to one of the parameters of the function being
    *   invoked,
    * then return the parameter element representing the parameter to which the
    * value of the given expression will be bound. Otherwise, return `null`.
-   *
-   * This method is only intended to be used by
-   * [Expression.propagatedParameterElement].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement getPropagatedParameterElementFor(Expression expression) {
-    if (_correspondingPropagatedParameters == null) {
-      // Either the AST structure has not been resolved or the invocation
-      // of which this list is a part could not be resolved.
+    return _getPropagatedParameterElementFor(expression);
+  }
+
+  /**
+   * If
+   * * the given [expression] is a child of this list,
+   * * the AST structure has been resolved,
+   * * the function being invoked is known based on static type information, and
+   * * the expression corresponds to one of the parameters of the function being
+   *   invoked,
+   * then return the parameter element representing the parameter to which the
+   * value of the given expression will be bound. Otherwise, return `null`.
+   */
+  @deprecated // Use "expression.propagatedParameterElement"
+  ParameterElement getStaticParameterElementFor(Expression expression) {
+    return _getStaticParameterElementFor(expression);
+  }
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    _arguments.accept(visitor);
+  }
+
+  /**
+   * If
+   * * the given [expression] is a child of this list,
+   * * the AST structure has been resolved,
+   * * the function being invoked is known based on propagated type information,
+   *   and
+   * * the expression corresponds to one of the parameters of the function being
+   *   invoked,
+   * then return the parameter element representing the parameter to which the
+   * value of the given expression will be bound. Otherwise, return `null`.
+   */
+  ParameterElement _getPropagatedParameterElementFor(Expression expression) {
+    if (_correspondingPropagatedParameters == null ||
+        _correspondingPropagatedParameters.length != _arguments.length) {
+      // Either the AST structure has not been resolved, the invocation of which
+      // this list is a part could not be resolved, or the argument list was
+      // modified after the parameters were set.
       return null;
     }
     int index = _arguments.indexOf(expression);
     if (index < 0) {
       // The expression isn't a child of this node.
       return null;
     }
     return _correspondingPropagatedParameters[index];
   }
 
   /**
    * If
    * * the given [expression] is a child of this list,
    * * the AST structure has been resolved,
    * * the function being invoked is known based on static type information, and
    * * the expression corresponds to one of the parameters of the function being
    *   invoked,
    * then return the parameter element representing the parameter to which the
    * value of the given expression will be bound. Otherwise, return `null`.
-   *
-   * This method is only intended to be used by
-   * [Expression.staticParameterElement].
    */
-  ParameterElement getStaticParameterElementFor(Expression expression) {
-    if (_correspondingStaticParameters == null) {
-      // Either the AST structure has not been resolved or the invocation
-      // of which this list is a part could not be resolved.
+  ParameterElement _getStaticParameterElementFor(Expression expression) {
+    if (_correspondingStaticParameters == null ||
+        _correspondingStaticParameters.length != _arguments.length) {
+      // Either the AST structure has not been resolved, the invocation of which
+      // this list is a part could not be resolved, or the argument list was
+      // modified after the parameters were set.
       return null;
     }
     int index = _arguments.indexOf(expression);
     if (index < 0) {
       // The expression isn't a child of this node.
       return null;
     }
     return _correspondingStaticParameters[index];
   }
-
-  @override
-  void visitChildren(AstVisitor visitor) {
-    _arguments.accept(visitor);
-  }
 }
 
 /**
  * An as expression.
  *
  * > asExpression ::=
  * >     [Expression] 'as' [TypeName]
  */
 class AsExpression extends Expression {
   /**
    * The expression used to compute the value being cast.
    */
   Expression _expression;
 
   /**
-   * The as operator.
+   * The 'as' operator.
    */
   Token asOperator;
 
   /**
    * The name of the type being cast to.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created as expression.
    */
   AsExpression(Expression expression, this.asOperator, TypeName type) {
-    _expression = becomeParentOf(expression);
-    _type = becomeParentOf(type);
+    _expression = _becomeParentOf(expression);
+    _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_expression)
       ..add(asOperator)
       ..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value being cast.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression used to compute the value being cast to the given
    * [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 7;
 
   /**
    * Return the name of the type being cast to.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the type being cast to to the given [name].
    */
   void set type(TypeName name) {
-    _type = becomeParentOf(name);
+    _type = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAsExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
     _safelyVisitChild(_type, visitor);
   }
 }
 
 /**
  * An assert statement.
  *
  * > assertStatement ::=
  * >     'assert' '(' [Expression] ')' ';'
  */
 class AssertStatement extends Statement {
   /**
    * The token representing the 'assert' keyword.
    */
-  Token keyword;
+  Token assertKeyword;
 
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The condition that is being asserted to be `true`.
    */
   Expression _condition;
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created assert statement.
    */
-  AssertStatement(this.keyword, this.leftParenthesis, Expression condition,
+  AssertStatement(this.assertKeyword, this.leftParenthesis, Expression condition,
       this.rightParenthesis, this.semicolon) {
-    _condition = becomeParentOf(condition);
+    _condition = _becomeParentOf(condition);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => assertKeyword;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(assertKeyword)
       ..add(leftParenthesis)
       ..add(_condition)
       ..add(rightParenthesis)
       ..add(semicolon);
 
   /**
    * Return the condition that is being asserted to be `true`.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition that is being asserted to be `true` to the given
    * [expression].
    */
   void set condition(Expression condition) {
-    _condition = becomeParentOf(condition);
+    _condition = _becomeParentOf(condition);
   }
 
   @override
   Token get endToken => semicolon;
 
+  /**
+   * Return the token representing the 'assert' keyword.
+   */
+  @deprecated // Use "this.assertKeyword"
+  Token get keyword => assertKeyword;
+
+  /**
+   * Set the token representing the 'assert' keyword to the given [token].
+   */
+  @deprecated // Use "this.assertKeyword"
+  set keyword(Token token) {
+    assertKeyword = token;
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
@@ skipping 47 matching lines @@
         } 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));
     }
-    _leftHandSide = becomeParentOf(leftHandSide);
-    _rightHandSide = becomeParentOf(rightHandSide);
+    _leftHandSide = _becomeParentOf(leftHandSide);
+    _rightHandSide = _becomeParentOf(rightHandSide);
   }
 
   @override
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
@@ skipping 19 matching lines @@
   /**
    * Set the expression used to compute the left hand side to the given
    * [expression].
    */
   Expression get leftHandSide => _leftHandSide;
 
   /**
    * Return the expression used to compute the left hand side.
    */
   void set leftHandSide(Expression expression) {
-    _leftHandSide = becomeParentOf(expression);
+    _leftHandSide = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 1;
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get propagatedParameterElementForRightHandSide {
+    return _propagatedParameterElementForRightHandSide;
+  }
+
+  /**
+   * Return the expression used to compute the right hand side.
+   */
+  Expression get rightHandSide => _rightHandSide;
+
+  /**
+   * Set the expression used to compute the left hand side to the given
+   * [expression].
+   */
+  void set rightHandSide(Expression expression) {
+    _rightHandSide = _becomeParentOf(expression);
+  }
+
+  /**
+   * 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`.
+   */
+  @deprecated // Use "expression.propagatedParameterElement"
+  ParameterElement get staticParameterElementForRightHandSide {
+    return _staticParameterElementForRightHandSide;
+  }
+
+  /**
+   * 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`.
+   */
+  ParameterElement get _propagatedParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
     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;
         }
@@ skipping 11 matching lines @@
       return null;
     }
     List<ParameterElement> parameters = executableElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
-   * Return the expression used to compute the right hand side.
-   */
-  Expression get rightHandSide => _rightHandSide;
-
-  /**
-   * Set the expression used to compute the left hand side to the given
-   * [expression].
-   */
-  void set rightHandSide(Expression expression) {
-    _rightHandSide = becomeParentOf(expression);
-  }
-
-  /**
    * 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].
    */
-  ParameterElement get staticParameterElementForRightHandSide {
+  ParameterElement get _staticParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
     if (staticElement != null) {
       executableElement = staticElement;
     } else {
       if (_leftHandSide is Identifier) {
         Element leftElement = (_leftHandSide as Identifier).staticElement;
         if (leftElement is ExecutableElement) {
           executableElement = leftElement;
         }
       }
@@ skipping 34 matching lines @@
   /**
    * A flag indicating whether tokens should be cloned while cloning an AST
    * structure.
    */
   final bool cloneTokens;
 
   /**
    * Initialize a newly created AST cloner to optionally clone tokens while
    * cloning AST nodes if [cloneTokens] is `true`.
    */
-  // TODO(brianwilkerson) Change this to be a named parameter.
-  AstCloner([this.cloneTokens = false]);
+  AstCloner([this.cloneTokens = false]); // TODO(brianwilkerson) Change this to be a named parameter.
 
   /**
    * Return a clone of the given [node].
    */
   AstNode cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as AstNode;
   }
@@ skipping 55 matching lines @@
   @override
   AsExpression visitAsExpression(AsExpression node) =>
       new AsExpression(
           cloneNode(node.expression),
           cloneToken(node.asOperator),
           cloneNode(node.type));
 
   @override
   AstNode visitAssertStatement(AssertStatement node) =>
       new AssertStatement(
-          cloneToken(node.keyword),
+          cloneToken(node.assertKeyword),
           cloneToken(node.leftParenthesis),
           cloneNode(node.condition),
           cloneToken(node.rightParenthesis),
           cloneToken(node.semicolon));
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) =>
       new AssignmentExpression(
           cloneNode(node.leftHandSide),
           cloneToken(node.operator),
@@ skipping 24 matching lines @@
           cloneToken(node.star),
           cloneNode(node.block));
 
   @override
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) =>
       new BooleanLiteral(cloneToken(node.literal), node.value);
 
   @override
   BreakStatement visitBreakStatement(BreakStatement node) =>
       new BreakStatement(
-          cloneToken(node.keyword),
+          cloneToken(node.breakKeyword),
           cloneNode(node.label),
           cloneToken(node.semicolon));
 
   @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) =>
       new CascadeExpression(
           cloneNode(node.target),
           cloneNodeList(node.cascadeSections));
 
   @override
@@ skipping 26 matching lines @@
         cloneToken(node.rightBracket));
     copy.nativeClause = cloneNode(node.nativeClause);
     return copy;
   }
 
   @override
   ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) =>
       new ClassTypeAlias(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
-          cloneToken(node.keyword),
+          cloneToken(node.typedefKeyword),
           cloneNode(node.name),
           cloneNode(node.typeParameters),
           cloneToken(node.equals),
           cloneToken(node.abstractKeyword),
           cloneNode(node.superclass),
           cloneNode(node.withClause),
           cloneNode(node.implementsClause),
           cloneToken(node.semicolon));
 
   @override
@@ skipping 49 matching lines @@
           cloneNode(node.parameters),
           cloneToken(node.separator),
           cloneNodeList(node.initializers),
           cloneNode(node.redirectedConstructor),
           cloneNode(node.body));
 
   @override
   ConstructorFieldInitializer
       visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
       new ConstructorFieldInitializer(
-          cloneToken(node.keyword),
+          cloneToken(node.thisKeyword),
           cloneToken(node.period),
           cloneNode(node.fieldName),
           cloneToken(node.equals),
           cloneNode(node.expression));
 
   @override
   ConstructorName visitConstructorName(ConstructorName node) =>
       new ConstructorName(
           cloneNode(node.type),
           cloneToken(node.period),
           cloneNode(node.name));
 
   @override
   ContinueStatement visitContinueStatement(ContinueStatement node) =>
       new ContinueStatement(
-          cloneToken(node.keyword),
+          cloneToken(node.continueKeyword),
           cloneNode(node.label),
           cloneToken(node.semicolon));
 
   @override
   DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) =>
       new DeclaredIdentifier(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneToken(node.keyword),
           cloneNode(node.type),
@@ skipping 36 matching lines @@
       new EnumConstantDeclaration(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneNode(node.name));
 
   @override
   EnumDeclaration visitEnumDeclaration(EnumDeclaration node) =>
       new EnumDeclaration(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
-          cloneToken(node.keyword),
+          cloneToken(node.enumKeyword),
           cloneNode(node.name),
           cloneToken(node.leftBracket),
           cloneNodeList(node.constants),
           cloneToken(node.rightBracket));
 
   @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective directive = new ExportDirective(
         cloneNode(node.documentationComment),
         cloneNodeList(node.metadata),
@@ skipping 14 matching lines @@
           cloneToken(node.functionDefinition),
           cloneNode(node.expression),
           cloneToken(node.semicolon));
 
   @override
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) =>
       new ExpressionStatement(cloneNode(node.expression), cloneToken(node.semicolon));
 
   @override
   ExtendsClause visitExtendsClause(ExtendsClause node) =>
-      new ExtendsClause(cloneToken(node.keyword), cloneNode(node.superclass));
+      new ExtendsClause(cloneToken(node.extendsKeyword), cloneNode(node.superclass));
 
   @override
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) =>
       new FieldDeclaration(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneToken(node.staticKeyword),
           cloneNode(node.fields),
           cloneToken(node.semicolon));
 
   @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) =>
       new FieldFormalParameter(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneToken(node.keyword),
           cloneNode(node.type),
-          cloneToken(node.thisToken),
+          cloneToken(node.thisKeyword),
           cloneToken(node.period),
           cloneNode(node.identifier),
           cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
       return new ForEachStatement.con2(
           cloneToken(node.awaitKeyword),
@@ skipping 64 matching lines @@
       visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
       new FunctionExpressionInvocation(
           cloneNode(node.function),
           cloneNode(node.argumentList));
 
   @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
       new FunctionTypeAlias(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
-          cloneToken(node.keyword),
+          cloneToken(node.typedefKeyword),
           cloneNode(node.returnType),
           cloneNode(node.name),
           cloneNode(node.typeParameters),
           cloneNode(node.parameters),
           cloneToken(node.semicolon));
 
   @override
   FunctionTypedFormalParameter
       visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
       new FunctionTypedFormalParameter(
@@ skipping 13 matching lines @@
           cloneToken(node.ifKeyword),
           cloneToken(node.leftParenthesis),
           cloneNode(node.condition),
           cloneToken(node.rightParenthesis),
           cloneNode(node.thenStatement),
           cloneToken(node.elseKeyword),
           cloneNode(node.elseStatement));
 
   @override
   ImplementsClause visitImplementsClause(ImplementsClause node) =>
-      new ImplementsClause(cloneToken(node.keyword), cloneNodeList(node.interfaces));
+      new ImplementsClause(cloneToken(node.implementsKeyword), cloneNodeList(node.interfaces));
 
   @override
   ImportDirective visitImportDirective(ImportDirective node) {
     ImportDirective directive = new ImportDirective(
         cloneNode(node.documentationComment),
         cloneNodeList(node.metadata),
         cloneToken(node.keyword),
         cloneNode(node.uri),
-        cloneToken(node.deferredToken),
-        cloneToken(node.asToken),
+        cloneToken(node.deferredKeyword),
+        cloneToken(node.asKeyword),
         cloneNode(node.prefix),
         cloneNodeList(node.combinators),
         cloneToken(node.semicolon));
     directive.source = node.source;
     directive.uriContent = node.uriContent;
     return directive;
   }
 
   @override
   IndexExpression visitIndexExpression(IndexExpression node) {
@@ skipping 51 matching lines @@
 
   @override
   LabeledStatement visitLabeledStatement(LabeledStatement node) =>
       new LabeledStatement(cloneNodeList(node.labels), cloneNode(node.statement));
 
   @override
   LibraryDirective visitLibraryDirective(LibraryDirective node) =>
       new LibraryDirective(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
-          cloneToken(node.libraryToken),
+          cloneToken(node.libraryKeyword),
           cloneNode(node.name),
           cloneToken(node.semicolon));
 
   @override
   LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) =>
       new LibraryIdentifier(cloneNodeList(node.components));
 
   @override
   ListLiteral visitListLiteral(ListLiteral node) =>
       new ListLiteral(
@@ skipping 40 matching lines @@
           cloneToken(node.period),
           cloneNode(node.methodName),
           cloneNode(node.argumentList));
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) =>
       new NamedExpression(cloneNode(node.name), cloneNode(node.expression));
 
   @override
   AstNode visitNativeClause(NativeClause node) =>
-      new NativeClause(cloneToken(node.keyword), cloneNode(node.name));
+      new NativeClause(cloneToken(node.nativeKeyword), cloneNode(node.name));
 
   @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
       new NativeFunctionBody(
-          cloneToken(node.nativeToken),
+          cloneToken(node.nativeKeyword),
           cloneNode(node.stringLiteral),
           cloneToken(node.semicolon));
 
   @override
   NullLiteral visitNullLiteral(NullLiteral node) =>
       new NullLiteral(cloneToken(node.literal));
 
   @override
   ParenthesizedExpression
       visitParenthesizedExpression(ParenthesizedExpression node) =>
       new ParenthesizedExpression(
           cloneToken(node.leftParenthesis),
           cloneNode(node.expression),
           cloneToken(node.rightParenthesis));
 
   @override
   PartDirective visitPartDirective(PartDirective node) {
     PartDirective directive = new PartDirective(
         cloneNode(node.documentationComment),
         cloneNodeList(node.metadata),
-        cloneToken(node.partToken),
+        cloneToken(node.partKeyword),
         cloneNode(node.uri),
         cloneToken(node.semicolon));
     directive.source = node.source;
     directive.uriContent = node.uriContent;
     return directive;
   }
 
   @override
   PartOfDirective visitPartOfDirective(PartOfDirective node) =>
       new PartOfDirective(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
-          cloneToken(node.partToken),
-          cloneToken(node.ofToken),
+          cloneToken(node.partKeyword),
+          cloneToken(node.ofKeyword),
           cloneNode(node.libraryName),
           cloneToken(node.semicolon));
 
   @override
   PostfixExpression visitPostfixExpression(PostfixExpression node) =>
       new PostfixExpression(cloneNode(node.operand), cloneToken(node.operator));
 
   @override
   PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) =>
       new PrefixedIdentifier(
           cloneNode(node.prefix),
           cloneToken(node.period),
           cloneNode(node.identifier));
 
   @override
   PrefixExpression visitPrefixExpression(PrefixExpression node) =>
       new PrefixExpression(cloneToken(node.operator), cloneNode(node.operand));
 
   @override
   PropertyAccess visitPropertyAccess(PropertyAccess node) =>
       new PropertyAccess(
           cloneNode(node.target),
           cloneToken(node.operator),
           cloneNode(node.propertyName));
 
   @override
   RedirectingConstructorInvocation
       visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) =>
       new RedirectingConstructorInvocation(
-          cloneToken(node.keyword),
+          cloneToken(node.thisKeyword),
           cloneToken(node.period),
           cloneNode(node.constructorName),
           cloneNode(node.argumentList));
 
   @override
   RethrowExpression visitRethrowExpression(RethrowExpression node) =>
-      new RethrowExpression(cloneToken(node.keyword));
+      new RethrowExpression(cloneToken(node.rethrowKeyword));
 
   @override
   ReturnStatement visitReturnStatement(ReturnStatement node) =>
       new ReturnStatement(
-          cloneToken(node.keyword),
+          cloneToken(node.returnKeyword),
           cloneNode(node.expression),
           cloneToken(node.semicolon));
 
   @override
   ScriptTag visitScriptTag(ScriptTag node) =>
       new ScriptTag(cloneToken(node.scriptTag));
 
   @override
   ShowCombinator visitShowCombinator(ShowCombinator node) =>
       new ShowCombinator(cloneToken(node.keyword), cloneNodeList(node.shownNames));
@@ skipping 17 matching lines @@
       new SimpleStringLiteral(cloneToken(node.literal), node.value);
 
   @override
   StringInterpolation visitStringInterpolation(StringInterpolation node) =>
       new StringInterpolation(cloneNodeList(node.elements));
 
   @override
   SuperConstructorInvocation
       visitSuperConstructorInvocation(SuperConstructorInvocation node) =>
       new SuperConstructorInvocation(
-          cloneToken(node.keyword),
+          cloneToken(node.superKeyword),
           cloneToken(node.period),
           cloneNode(node.constructorName),
           cloneNode(node.argumentList));
 
   @override
   SuperExpression visitSuperExpression(SuperExpression node) =>
-      new SuperExpression(cloneToken(node.keyword));
+      new SuperExpression(cloneToken(node.superKeyword));
 
   @override
   SwitchCase visitSwitchCase(SwitchCase node) =>
       new SwitchCase(
           cloneNodeList(node.labels),
           cloneToken(node.keyword),
           cloneNode(node.expression),
           cloneToken(node.colon),
           cloneNodeList(node.statements));
 
   @override
   SwitchDefault visitSwitchDefault(SwitchDefault node) =>
       new SwitchDefault(
           cloneNodeList(node.labels),
           cloneToken(node.keyword),
           cloneToken(node.colon),
           cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) =>
       new SwitchStatement(
-          cloneToken(node.keyword),
+          cloneToken(node.switchKeyword),
           cloneToken(node.leftParenthesis),
           cloneNode(node.expression),
           cloneToken(node.rightParenthesis),
           cloneToken(node.leftBracket),
           cloneNodeList(node.members),
           cloneToken(node.rightBracket));
 
   @override
   SymbolLiteral visitSymbolLiteral(SymbolLiteral node) =>
       new SymbolLiteral(cloneToken(node.poundSign), cloneTokenList(node.components));
 
   @override
   ThisExpression visitThisExpression(ThisExpression node) =>
-      new ThisExpression(cloneToken(node.keyword));
+      new ThisExpression(cloneToken(node.thisKeyword));
 
   @override
   ThrowExpression visitThrowExpression(ThrowExpression node) =>
-      new ThrowExpression(cloneToken(node.keyword), cloneNode(node.expression));
+      new ThrowExpression(cloneToken(node.throwKeyword), cloneNode(node.expression));
 
   @override
   TopLevelVariableDeclaration
       visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) =>
       new TopLevelVariableDeclaration(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneNode(node.variables),
           cloneToken(node.semicolon));
 
@@ skipping 16 matching lines @@
   @override
   TypeName visitTypeName(TypeName node) =>
       new TypeName(cloneNode(node.name), cloneNode(node.typeArguments));
 
   @override
   TypeParameter visitTypeParameter(TypeParameter node) =>
       new TypeParameter(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneNode(node.name),
-          cloneToken(node.keyword),
+          cloneToken(node.extendsKeyword),
           cloneNode(node.bound));
 
   @override
   TypeParameterList visitTypeParameterList(TypeParameterList node) =>
       new TypeParameterList(
           cloneToken(node.leftBracket),
           cloneNodeList(node.typeParameters),
           cloneToken(node.rightBracket));
 
   @override
@@ skipping 18 matching lines @@
   @override
   VariableDeclarationStatement
       visitVariableDeclarationStatement(VariableDeclarationStatement node) =>
       new VariableDeclarationStatement(
           cloneNode(node.variables),
           cloneToken(node.semicolon));
 
   @override
   WhileStatement visitWhileStatement(WhileStatement node) =>
       new WhileStatement(
-          cloneToken(node.keyword),
+          cloneToken(node.whileKeyword),
           cloneToken(node.leftParenthesis),
           cloneNode(node.condition),
           cloneToken(node.rightParenthesis),
           cloneNode(node.body));
 
   @override
   WithClause visitWithClause(WithClause node) =>
       new WithClause(cloneToken(node.withKeyword), cloneNodeList(node.mixinTypes));
 
   @override
@@ skipping 84 matching lines @@
   bool visitAsExpression(AsExpression node) {
     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 = _other as AssertStatement;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.assertKeyword, other.assertKeyword) &&
         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 = _other as AssignmentExpression;
     return isEqualNodes(node.leftHandSide, other.leftHandSide) &&
@@ skipping 33 matching lines @@
   @override
   bool visitBooleanLiteral(BooleanLiteral node) {
     BooleanLiteral other = _other as BooleanLiteral;
     return isEqualTokens(node.literal, other.literal) &&
         node.value == other.value;
   }
 
   @override
   bool visitBreakStatement(BreakStatement node) {
     BreakStatement other = _other as BreakStatement;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.breakKeyword, other.breakKeyword) &&
         isEqualNodes(node.label, other.label) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitCascadeExpression(CascadeExpression node) {
     CascadeExpression other = _other as CascadeExpression;
     return isEqualNodes(node.target, other.target) &&
         _isEqualNodeLists(node.cascadeSections, other.cascadeSections);
   }
@@ skipping 31 matching lines @@
         isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitClassTypeAlias(ClassTypeAlias node) {
     ClassTypeAlias other = _other as ClassTypeAlias;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
-        isEqualTokens(node.keyword, other.keyword) &&
+        isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
         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);
   }
 
@@ skipping 46 matching lines @@
         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 = _other as ConstructorFieldInitializer;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.thisKeyword, other.thisKeyword) &&
         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 = _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 = _other as ContinueStatement;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.continueKeyword, other.continueKeyword) &&
         isEqualNodes(node.label, other.label) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitDeclaredIdentifier(DeclaredIdentifier node) {
     DeclaredIdentifier other = _other as DeclaredIdentifier;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
@@ skipping 53 matching lines @@
         isEqualNodes(node.name, other.name);
   }
 
   @override
   bool visitEnumDeclaration(EnumDeclaration node) {
     EnumDeclaration other = _other as EnumDeclaration;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
-        isEqualTokens(node.keyword, other.keyword) &&
+        isEqualTokens(node.enumKeyword, other.enumKeyword) &&
         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 = _other as ExportDirective;
     return isEqualNodes(
@@ skipping 17 matching lines @@
   @override
   bool visitExpressionStatement(ExpressionStatement node) {
     ExpressionStatement other = _other as ExpressionStatement;
     return isEqualNodes(node.expression, other.expression) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitExtendsClause(ExtendsClause node) {
     ExtendsClause other = _other as ExtendsClause;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.extendsKeyword, other.extendsKeyword) &&
         isEqualNodes(node.superclass, other.superclass);
   }
 
   @override
   bool visitFieldDeclaration(FieldDeclaration node) {
     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 = _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.thisKeyword, other.thisKeyword) &&
         isEqualTokens(node.period, other.period) &&
         isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitForEachStatement(ForEachStatement node) {
     ForEachStatement other = _other as ForEachStatement;
     return isEqualTokens(node.forKeyword, other.forKeyword) &&
         isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
         isEqualNodes(node.loopVariable, other.loopVariable) &&
@@ skipping 62 matching lines @@
         isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAlias other = _other as FunctionTypeAlias;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
-        isEqualTokens(node.keyword, other.keyword) &&
+        isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
         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 = _other as FunctionTypedFormalParameter;
@@ skipping 21 matching lines @@
         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 = _other as ImplementsClause;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.implementsKeyword, other.implementsKeyword) &&
         _isEqualNodeLists(node.interfaces, other.interfaces);
   }
 
   @override
   bool visitImportDirective(ImportDirective node) {
     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) &&
+        isEqualTokens(node.deferredKeyword, other.deferredKeyword) &&
+        isEqualTokens(node.asKeyword, other.asKeyword) &&
         isEqualNodes(node.prefix, other.prefix) &&
         _isEqualNodeLists(node.combinators, other.combinators) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitIndexExpression(IndexExpression node) {
     IndexExpression other = _other as IndexExpression;
     return isEqualNodes(node.target, other.target) &&
         isEqualTokens(node.leftBracket, other.leftBracket) &&
@@ skipping 54 matching lines @@
         isEqualNodes(node.statement, other.statement);
   }
 
   @override
   bool visitLibraryDirective(LibraryDirective node) {
     LibraryDirective other = _other as LibraryDirective;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
-        isEqualTokens(node.libraryToken, other.libraryToken) &&
+        isEqualTokens(node.libraryKeyword, other.libraryKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitLibraryIdentifier(LibraryIdentifier node) {
     LibraryIdentifier other = _other as LibraryIdentifier;
     return _isEqualNodeLists(node.components, other.components);
   }
 
@@ skipping 54 matching lines @@
   @override
   bool visitNamedExpression(NamedExpression node) {
     NamedExpression other = _other as NamedExpression;
     return isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitNativeClause(NativeClause node) {
     NativeClause other = _other as NativeClause;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.nativeKeyword, other.nativeKeyword) &&
         isEqualNodes(node.name, other.name);
   }
 
   @override
   bool visitNativeFunctionBody(NativeFunctionBody node) {
     NativeFunctionBody other = _other as NativeFunctionBody;
-    return isEqualTokens(node.nativeToken, other.nativeToken) &&
+    return isEqualTokens(node.nativeKeyword, other.nativeKeyword) &&
         isEqualNodes(node.stringLiteral, other.stringLiteral) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitNullLiteral(NullLiteral node) {
     NullLiteral other = _other as NullLiteral;
     return isEqualTokens(node.literal, other.literal);
   }
 
   @override
   bool visitParenthesizedExpression(ParenthesizedExpression node) {
     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 = _other as PartDirective;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
-        isEqualTokens(node.partToken, other.partToken) &&
+        isEqualTokens(node.partKeyword, other.partKeyword) &&
         isEqualNodes(node.uri, other.uri) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitPartOfDirective(PartOfDirective node) {
     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) &&
+        isEqualTokens(node.partKeyword, other.partKeyword) &&
+        isEqualTokens(node.ofKeyword, other.ofKeyword) &&
         isEqualNodes(node.libraryName, other.libraryName) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitPostfixExpression(PostfixExpression node) {
     PostfixExpression other = _other as PostfixExpression;
     return isEqualNodes(node.operand, other.operand) &&
         isEqualTokens(node.operator, other.operator);
   }
@@ skipping 19 matching lines @@
     return isEqualNodes(node.target, other.target) &&
         isEqualTokens(node.operator, other.operator) &&
         isEqualNodes(node.propertyName, other.propertyName);
   }
 
   @override
   bool
       visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation other =
         _other as RedirectingConstructorInvocation;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.thisKeyword, other.thisKeyword) &&
         isEqualTokens(node.period, other.period) &&
         isEqualNodes(node.constructorName, other.constructorName) &&
         isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitRethrowExpression(RethrowExpression node) {
     RethrowExpression other = _other as RethrowExpression;
-    return isEqualTokens(node.keyword, other.keyword);
+    return isEqualTokens(node.rethrowKeyword, other.rethrowKeyword);
   }
 
   @override
   bool visitReturnStatement(ReturnStatement node) {
     ReturnStatement other = _other as ReturnStatement;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.returnKeyword, other.returnKeyword) &&
         isEqualNodes(node.expression, other.expression) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitScriptTag(ScriptTag node) {
     ScriptTag other = _other as ScriptTag;
     return isEqualTokens(node.scriptTag, other.scriptTag);
   }
 
@@ skipping 31 matching lines @@
 
   @override
   bool visitStringInterpolation(StringInterpolation node) {
     StringInterpolation other = _other as StringInterpolation;
     return _isEqualNodeLists(node.elements, other.elements);
   }
 
   @override
   bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation other = _other as SuperConstructorInvocation;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.superKeyword, other.superKeyword) &&
         isEqualTokens(node.period, other.period) &&
         isEqualNodes(node.constructorName, other.constructorName) &&
         isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitSuperExpression(SuperExpression node) {
     SuperExpression other = _other as SuperExpression;
-    return isEqualTokens(node.keyword, other.keyword);
+    return isEqualTokens(node.superKeyword, other.superKeyword);
   }
 
   @override
   bool visitSwitchCase(SwitchCase node) {
     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 = _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 = _other as SwitchStatement;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.switchKeyword, other.switchKeyword) &&
         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 = _other as SymbolLiteral;
     return isEqualTokens(node.poundSign, other.poundSign) &&
         _isEqualTokenLists(node.components, other.components);
   }
 
   @override
   bool visitThisExpression(ThisExpression node) {
     ThisExpression other = _other as ThisExpression;
-    return isEqualTokens(node.keyword, other.keyword);
+    return isEqualTokens(node.thisKeyword, other.thisKeyword);
   }
 
   @override
   bool visitThrowExpression(ThrowExpression node) {
     ThrowExpression other = _other as ThrowExpression;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.throwKeyword, other.throwKeyword) &&
         isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     TopLevelVariableDeclaration other = _other as TopLevelVariableDeclaration;
     return isEqualNodes(
         node.documentationComment,
         other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
@@ skipping 27 matching lines @@
   }
 
   @override
   bool visitTypeParameter(TypeParameter node) {
     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) &&
+        isEqualTokens(node.extendsKeyword, other.extendsKeyword) &&
         isEqualNodes(node.bound, other.bound);
   }
 
   @override
   bool visitTypeParameterList(TypeParameterList node) {
     TypeParameterList other = _other as TypeParameterList;
     return isEqualTokens(node.leftBracket, other.leftBracket) &&
         _isEqualNodeLists(node.typeParameters, other.typeParameters) &&
         isEqualTokens(node.rightBracket, other.rightBracket);
   }
@@ skipping 25 matching lines @@
   @override
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     VariableDeclarationStatement other = _other as VariableDeclarationStatement;
     return isEqualNodes(node.variables, other.variables) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitWhileStatement(WhileStatement node) {
     WhileStatement other = _other as WhileStatement;
-    return isEqualTokens(node.keyword, other.keyword) &&
+    return isEqualTokens(node.whileKeyword, other.whileKeyword) &&
         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 = _other as WithClause;
     return isEqualTokens(node.withKeyword, other.withKeyword) &&
@@ skipping 54 matching lines @@
     AstComparator comparator = new AstComparator();
     return comparator.isEqualNodes(first, second);
   }
 }
 
 /**
  * A node in the AST structure for a Dart program.
  */
 abstract class AstNode {
   /**
-   * An empty list of ast nodes.
+   * An empty list of AST nodes.
    */
-  static const List<AstNode> EMPTY_ARRAY = const <AstNode>[];
+  @deprecated // Use "AstNode.EMPTY_LIST"
+  static const List<AstNode> EMPTY_ARRAY = EMPTY_LIST;
+
+  /**
+   * An empty list of AST nodes.
+   */
+  static const List<AstNode> EMPTY_LIST = 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
+   * the same offset, and a positive value 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;
 
   /**
    * The parent of the node, or `null` if the node is the root of an AST
    * structure.
    */
   AstNode _parent;
@@ skipping 67 matching lines @@
    * AST structure.
    *
    * Note that the relationship between an AST node and its parent node may
    * change over the lifetime of a node.
    */
   AstNode get parent => _parent;
 
   /**
    * Set the parent of this node to the [newParent].
    */
-  @deprecated
+  @deprecated // Never intended for public use.
   void set parent(AstNode newParent) {
     _parent = newParent;
   }
 
   /**
    * Return the node at the root of this node's AST structure. Note that this
    * method's performance is linear with respect to the depth of the node in the
    * AST structure (O(depth)).
    */
   AstNode get root {
     AstNode root = this;
     AstNode parent = this.parent;
     while (parent != null) {
       root = parent;
       parent = root.parent;
     }
     return root;
   }
 
   /**
    * Use the given [visitor] to visit this node. Return the value returned by
    * the visitor as a result of visiting this node.
    */
   /* <E> E */ accept(AstVisitor /*<E>*/ visitor);
 
   /**
    * Make this node the parent of the given [child] node. Return the child node.
    */
+  @deprecated // Never intended for public use.
   AstNode becomeParentOf(AstNode child) {
-    if (child != null) {
-      child._parent = this;
-    }
-    return child;
+    return _becomeParentOf(child);
   }
 
   /**
    * Return the most immediate ancestor of this node for which the [predicate]
    * returns `true`, or `null` if there is no such ancestor. Note that this node
    * will never be returned.
    */
   AstNode getAncestor(Predicate<AstNode> predicate) {
     // TODO(brianwilkerson) It is a bug that this method can return `this`.
     AstNode node = this;
@@ skipping 10 matching lines @@
   Object getProperty(String name) {
     if (_propertyMap == null) {
       return null;
     }
     return _propertyMap[name];
   }
 
   /**
    * If the given [child] is not `null`, use the given [visitor] to visit it.
    */
-  @deprecated
+  @deprecated // Never intended for public use.
   void safelyVisitChild(AstNode child, AstVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 
   /**
    * Set the value of the property with the given [name] to the given [value].
    * If the value is `null`, the property will effectively be removed.
    */
@@ skipping 27 matching lines @@
   @override
   String toString() => toSource();
 
   /**
    * Use the given [visitor] to visit all of the children of this node. The
    * children will be visited in lexical order.
    */
   void visitChildren(AstVisitor visitor);
 
   /**
+   * Make this node the parent of the given [child] node. Return the child node.
+   */
+  AstNode _becomeParentOf(AstNode child) {
+    if (child != null) {
+      child._parent = this;
+    }
+    return child;
+  }
+
+  /**
    * If the given [child] is not `null`, use the given [visitor] to visit it.
    */
   void _safelyVisitChild(AstNode child, AstVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 }
 
 /**
@@ skipping 228 matching lines @@
 
   /**
    * The expression whose value is being waited on.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created await expression.
    */
   AwaitExpression(this.awaitKeyword, Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (awaitKeyword != null) {
       return awaitKeyword;
     }
     return _expression.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(awaitKeyword)
       ..add(_expression);
 
   @override
   Token get endToken => _expression.endToken;
 
   /**
    * Return the expression whose value is being waited on.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression whose value is being waited on to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 0;
 
   @override
   accept(AstVisitor visitor) => visitor.visitAwaitExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 36 matching lines @@
    * the operator is not user definable, or if the operator could not be
    * resolved.
    */
   MethodElement propagatedElement;
 
   /**
    * Initialize a newly created binary expression.
    */
   BinaryExpression(Expression leftOperand, this.operator,
       Expression rightOperand) {
-    _leftOperand = becomeParentOf(leftOperand);
-    _rightOperand = becomeParentOf(rightOperand);
+    _leftOperand = _becomeParentOf(leftOperand);
+    _rightOperand = _becomeParentOf(rightOperand);
   }
 
   @override
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
@@ skipping 19 matching lines @@
   /**
    * Return the expression used to compute the left operand.
    */
   Expression get leftOperand => _leftOperand;
 
   /**
    * Set the expression used to compute the left operand to the given
    * [expression].
    */
   void set leftOperand(Expression expression) {
-    _leftOperand = becomeParentOf(expression);
+    _leftOperand = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => operator.type.precedence;
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get propagatedParameterElementForRightOperand {
-    if (propagatedElement == null) {
-      return null;
-    }
-    List<ParameterElement> parameters = propagatedElement.parameters;
-    if (parameters.length < 1) {
-      return null;
-    }
-    return parameters[0];
+    return _propagatedParameterElementForRightOperand;
   }
 
   /**
    * Return the expression used to compute the right operand.
    */
   Expression get rightOperand => _rightOperand;
 
   /**
    * Set the expression used to compute the right operand to the given
    * [expression].
    */
   void set rightOperand(Expression expression) {
-    _rightOperand = becomeParentOf(expression);
+    _rightOperand = _becomeParentOf(expression);
   }
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get staticParameterElementForRightOperand {
+    return _staticParameterElementForRightOperand;
+  }
+
+  /**
+   * 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`.
+   */
+  ParameterElement get _propagatedParameterElementForRightOperand {
+    if (propagatedElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = propagatedElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is
+   * known based on static type information, then return the parameter element
+   * representing the parameter to which the value of the right operand will be
+   * bound. Otherwise, return `null`.
+   */
+  ParameterElement get _staticParameterElementForRightOperand {
     if (staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
@@ skipping 86 matching lines @@
    */
   Block _block;
 
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if there is no keyword specified
    * for the block. The [star] can be `null` if there is no star following the
    * keyword (and must be `null` if there is no keyword).
    */
   BlockFunctionBody(this.keyword, this.star, Block block) {
-    _block = becomeParentOf(block);
+    _block = _becomeParentOf(block);
   }
 
   @override
   Token get beginToken => _block.beginToken;
 
   /**
    * Return the block representing the body of the function.
    */
   Block get block => _block;
 
   /**
    * Set the block representing the body of the function to the given [block].
    */
   void set block(Block block) {
-    _block = becomeParentOf(block);
+    _block = _becomeParentOf(block);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(keyword)
       ..add(star)
       ..add(_block);
 
   @override
   Token get endToken => _block.endToken;
 
   @override
-  bool get isAsynchronous {
-    if (keyword == null) {
-      return false;
-    }
-    String keywordValue = keyword.lexeme;
-    return keywordValue == Parser.ASYNC;
-  }
+  bool get isAsynchronous => keyword != null && keyword.lexeme == Parser.ASYNC;
 
   @override
   bool get isGenerator => star != null;
 
   @override
   bool get isSynchronous => keyword == null || keyword.lexeme != Parser.ASYNC;
 
   @override
   accept(AstVisitor visitor) => visitor.visitBlockFunctionBody(this);
 
@@ skipping 21 matching lines @@
   bool value = false;
 
   /**
    * Initialize a newly created boolean literal.
    */
   BooleanLiteral(this.literal, this.value);
 
   @override
   Token get beginToken => literal;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(literal);
 
   @override
   Token get endToken => literal;
 
   @override
   bool get isSynthetic => literal.isSynthetic;
 
   @override
@@ skipping 63 matching lines @@
 /**
  * A break statement.
  *
  * > breakStatement ::=
  * >     'break' [SimpleIdentifier]? ';'
  */
 class BreakStatement extends Statement {
   /**
    * The token representing the 'break' keyword.
    */
-  Token keyword;
+  Token breakKeyword;
 
   /**
    * The label associated with the statement, or `null` if there is no label.
    */
   SimpleIdentifier _label;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * The AstNode which this break statement is breaking from.  This will be
    * either a [Statement] (in the case of breaking out of a loop), a
    * [SwitchMember] (in the case of a labeled break statement whose label
    * matches a label on a switch case in an enclosing switch statement), or
    * `null` if the AST has not yet been resolved or if the target could not be
    * resolved. Note that if the source code has errors, the target might be
    * invalid (e.g. trying to break to a switch case).
    */
   AstNode target;
 
   /**
    * Initialize a newly created break statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
-  BreakStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
-    _label = becomeParentOf(label);
+  BreakStatement(this.breakKeyword, SimpleIdentifier label, this.semicolon) {
+    _label = _becomeParentOf(label);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => breakKeyword;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(breakKeyword)
       ..add(_label)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
+   * Return the token representing the 'break' keyword.
+   */
+  @deprecated // Use "this.breakKeyword"
+  Token get keyword => breakKeyword;
+
+  /**
+   * Sethe token representing the 'break' keyword to the given [token].
+   */
+  @deprecated // Use "this.breakKeyword"
+  void set keyword(Token token) {
+    breakKeyword = token;
+  }
+
+  /**
    * Return the label associated with the statement, or `null` if there is no
    * label.
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label associated with the statement to the given [identifier].
    */
   void set label(SimpleIdentifier identifier) {
-    _label = becomeParentOf(identifier);
+    _label = _becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBreakStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_label, visitor);
   }
 }
@@ skipping 23 matching lines @@
   /**
    * The cascade sections sharing the common target.
    */
   NodeList<Expression> _cascadeSections;
 
   /**
    * Initialize a newly created cascade expression. The list of
    * [cascadeSections] must contain at least one element.
    */
   CascadeExpression(Expression target, List<Expression> cascadeSections) {
-    _target = becomeParentOf(target);
+    _target = _becomeParentOf(target);
     _cascadeSections = new NodeList<Expression>(this, cascadeSections);
   }
 
   @override
   Token get beginToken => _target.beginToken;
 
   /**
    * Return the cascade sections sharing the common target.
    */
   NodeList<Expression> get cascadeSections => _cascadeSections;
@@ skipping 11 matching lines @@
 
   /**
    * Return the target of the cascade sections.
    */
   Expression get target => _target;
 
   /**
    * Set the target of the cascade sections to the given [expression].
    */
   void set target(Expression target) {
-    _target = becomeParentOf(target);
+    _target = _becomeParentOf(target);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCascadeExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
@@ skipping 22 matching lines @@
    */
   TypeName _exceptionType;
 
   /**
    * The token representing the 'catch' keyword, or `null` if there is no
    * 'catch' keyword.
    */
   Token catchKeyword;
 
   /**
-   * The left parenthesis.
+   * The left parenthesis, or `null` if there is no 'catch' keyword.
    */
   Token leftParenthesis;
 
   /**
-   * The parameter whose value will be the exception that was thrown.
+   * The parameter whose value will be the exception that was thrown, or `null`
+   * if there is no 'catch' keyword.
    */
   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.
+   * The right parenthesis, or `null` if there is no 'catch' keyword.
    */
   Token rightParenthesis;
 
   /**
    * The body of the catch block.
    */
   Block _body;
 
   /**
    * Initialize a newly created catch clause. The [onKeyword] and
    * [exceptionType] can be `null` if the clause will catch all exceptions. The
    * [comma] and [stackTraceParameter] can be `null` if the stack trace is not
    * referencable within the 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);
+    _exceptionType = _becomeParentOf(exceptionType);
+    _exceptionParameter = _becomeParentOf(exceptionParameter);
+    _stackTraceParameter = _becomeParentOf(stackTraceParameter);
+    _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
     }
     return catchKeyword;
   }
 
   /**
    * Return the body of the catch block.
    */
   Block get body => _body;
 
   /**
    * Set the body of the catch block to the given [block].
    */
   void set body(Block block) {
-    _body = becomeParentOf(block);
+    _body = _becomeParentOf(block);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(onKeyword)
       ..add(_exceptionType)
       ..add(catchKeyword)
       ..add(leftParenthesis)
       ..add(_exceptionParameter)
       ..add(comma)
       ..add(_stackTraceParameter)
       ..add(rightParenthesis)
       ..add(_body);
 
   @override
   Token get endToken => _body.endToken;
 
   /**
-   * Return the parameter whose value will be the exception that was thrown.
+   * Return the parameter whose value will be the exception that was thrown, or
+   * `null` if there is no 'catch' keyword.
    */
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
   /**
    * Set the parameter whose value will be the exception that was thrown to the
    * given [parameter].
    */
   void set exceptionParameter(SimpleIdentifier parameter) {
-    _exceptionParameter = becomeParentOf(parameter);
+    _exceptionParameter = _becomeParentOf(parameter);
   }
 
   /**
    * Return the type of exceptions caught by this catch clause, or `null` if
    * this catch clause catches every type of exception.
    */
   TypeName get exceptionType => _exceptionType;
 
   /**
    * Set the type of exceptions caught by this catch clause to the given
    * [exceptionType].
    */
   void set exceptionType(TypeName exceptionType) {
-    _exceptionType = becomeParentOf(exceptionType);
+    _exceptionType = _becomeParentOf(exceptionType);
   }
 
   /**
    * Return the parameter whose value will be the stack trace associated with
    * the exception, or `null` if there is no stack trace parameter.
    */
   SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
 
   /**
    * Set the parameter whose value will be the stack trace associated with the
    * exception to the given [parameter].
    */
   void set stackTraceParameter(SimpleIdentifier parameter) {
-    _stackTraceParameter = becomeParentOf(parameter);
+    _stackTraceParameter = _becomeParentOf(parameter);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCatchClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_exceptionType, visitor);
     _safelyVisitChild(_exceptionParameter, visitor);
     _safelyVisitChild(_stackTraceParameter, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Helper class to allow iteration of child entities of an AST node.
  */
 class ChildEntities extends Object with IterableMixin implements Iterable {
+  /**
+   * The list of child entities to be iterated over.
+   */
   List _entities = [];
 
   @override
   Iterator get iterator => _entities.iterator;
 
   /**
    * Add an AST node or token as the next child entity, if it is not null.
    */
   void add(entity) {
     if (entity != null) {
@@ skipping 91 matching lines @@
    * and [implementsClause] can be `null` if the class does not have the
    * corresponding clause. The list of [members] can be `null` if the class does
    * not have any members.
    */
   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) {
-    _name = becomeParentOf(name);
-    _typeParameters = becomeParentOf(typeParameters);
-    _extendsClause = becomeParentOf(extendsClause);
-    _withClause = becomeParentOf(withClause);
-    _implementsClause = becomeParentOf(implementsClause);
+    _name = _becomeParentOf(name);
+    _typeParameters = _becomeParentOf(typeParameters);
+    _extendsClause = _becomeParentOf(extendsClause);
+    _withClause = _becomeParentOf(withClause);
+    _implementsClause = _becomeParentOf(implementsClause);
     _members = new NodeList<ClassMember>(this, members);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(abstractKeyword)
       ..add(classKeyword)
       ..add(_name)
       ..add(_typeParameters)
       ..add(_extendsClause)
@@ skipping 14 matching lines @@
   /**
    * Return the extends clause for this class, or `null` if the class does not
    * extend any other class.
    */
   ExtendsClause get extendsClause => _extendsClause;
 
   /**
    * Set the extends clause for this class to the given [extendsClause].
    */
   void set extendsClause(ExtendsClause extendsClause) {
-    _extendsClause = becomeParentOf(extendsClause);
+    _extendsClause = _becomeParentOf(extendsClause);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (abstractKeyword != null) {
       return abstractKeyword;
     }
     return classKeyword;
   }
 
   /**
    * Return the implements clause for the class, or `null` if the class does not
    * implement any interfaces.
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
    * Set the implements clause for the class to the given [implementsClause].
    */
   void set implementsClause(ImplementsClause implementsClause) {
-    _implementsClause = becomeParentOf(implementsClause);
+    _implementsClause = _becomeParentOf(implementsClause);
   }
 
   /**
    * Return `true` if this class is declared to be an abstract class.
    */
   bool get isAbstract => abstractKeyword != null;
 
   /**
    * Return the members defined by the class.
    */
   NodeList<ClassMember> get members => _members;
 
   /**
    * Return the name of the class being declared.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the class being declared to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   /**
    * Return the native clause for this class, or `null` if the class does not
    * have a native clause.
    */
   NativeClause get nativeClause => _nativeClause;
 
   /**
    * Set the native clause for this class to the given [nativeClause].
    */
   void set nativeClause(NativeClause nativeClause) {
-    _nativeClause = becomeParentOf(nativeClause);
+    _nativeClause = _becomeParentOf(nativeClause);
   }
 
   /**
    * Return the type parameters for the class, or `null` if the class does not
    * have any type parameters.
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters for the class to the given list of [typeParameters].
    */
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters);
   }
 
   /**
    * Return the with clause for the class, or `null` if the class does not have
    * a with clause.
    */
   WithClause get withClause => _withClause;
 
   /**
    * Set the with clause for the class to the given [withClause].
    */
   void set withClause(WithClause withClause) {
-    _withClause = becomeParentOf(withClause);
+    _withClause = _becomeParentOf(withClause);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitClassDeclaration(this);
 
   /**
    * Return the constructor declared in the class with the given [name], or
    * `null` if there is no such constructor. If the [name] is `null` then the
    * default constructor will be searched for.
    */
@@ skipping 78 matching lines @@
 }
 
 /**
  * A class type alias.
  *
  * > classTypeAlias ::=
  * >     [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
  * >
  * > mixinApplication ::=
  * >     [TypeName] [WithClause] [ImplementsClause]? ';'
- *
- * Deprecated: This class captures obsolete syntax that is no longer part of the
- * Dart language.
  */
 class ClassTypeAlias extends TypeAlias {
   /**
    * The name of the class being declared.
    */
   SimpleIdentifier _name;
 
   /**
    * The type parameters for the class, or `null` if the class does not have any
    * type parameters.
@@ skipping 33 matching lines @@
    * have the corresponding attribute. The [typeParameters] can be `null` if the
    * class does not have any type parameters. The [abstractKeyword] can be
    * `null` if the class is not abstract. The [implementsClause] can be `null`
    * if the class does not implement any interfaces.
    */
   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) {
-    _name = becomeParentOf(name);
-    _typeParameters = becomeParentOf(typeParameters);
-    _superclass = becomeParentOf(superclass);
-    _withClause = becomeParentOf(withClause);
-    _implementsClause = becomeParentOf(implementsClause);
+    _name = _becomeParentOf(name);
+    _typeParameters = _becomeParentOf(typeParameters);
+    _superclass = _becomeParentOf(superclass);
+    _withClause = _becomeParentOf(withClause);
+    _implementsClause = _becomeParentOf(implementsClause);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
+      ..add(typedefKeyword)
       ..add(_name)
       ..add(_typeParameters)
       ..add(equals)
       ..add(abstractKeyword)
       ..add(_superclass)
       ..add(_withClause)
       ..add(_implementsClause)
       ..add(semicolon);
 
   @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.
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
    * Set the implements clause for this class to the given [implementsClause].
    */
   void set implementsClause(ImplementsClause implementsClause) {
-    _implementsClause = becomeParentOf(implementsClause);
+    _implementsClause = _becomeParentOf(implementsClause);
   }
 
   /**
    * Return `true` if this class is declared to be an abstract class.
    */
   bool get isAbstract => abstractKeyword != null;
 
   /**
    * Return the name of the class being declared.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the class being declared to the given [identifier].
    */
   void set name(SimpleIdentifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   /**
    * Return the name of the superclass of the class being declared.
    */
   TypeName get superclass => _superclass;
 
   /**
    * Set the name of the superclass of the class being declared to the given
    * [superclass] name.
    */
   void set superclass(TypeName superclass) {
-    _superclass = becomeParentOf(superclass);
+    _superclass = _becomeParentOf(superclass);
   }
 
   /**
    * Return the type parameters for the class, or `null` if the class does not
    * have any type parameters.
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters for the class to the given list of [typeParameters].
    */
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters);
   }
 
   /**
    * Return the with clause for this class.
    */
   WithClause get withClause => _withClause;
 
   /**
    * Set the with clause for this class to the given with [withClause].
    */
   void set withClause(WithClause withClause) {
-    _withClause = becomeParentOf(withClause);
+    _withClause = _becomeParentOf(withClause);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitClassTypeAlias(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_superclass, visitor);
     _safelyVisitChild(_withClause, visitor);
     _safelyVisitChild(_implementsClause, visitor);
   }
 }
 
 /**
  * A combinator associated with an import or export directive.
  *
  * > combinator ::=
  * >     [HideCombinator]
  * >   | [ShowCombinator]
  */
 abstract class Combinator extends AstNode {
   /**
-   * The keyword specifying what kind of processing is to be done on the
-   * imported names.
+   * The 'hide' or 'show' keyword specifying what kind of processing is to be
+   * done on the names.
    */
   Token keyword;
 
   /**
-   * Initialize a newly created import combinator.
+   * Initialize a newly created combinator.
    */
   Combinator(this.keyword);
 
   @override
   Token get beginToken => keyword;
 }
 
 /**
  * A comment within the source code.
  *
@@ skipping 120 matching lines @@
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
 
   /**
    * Initialize a newly created reference to a Dart element. The [newKeyword]
    * can be `null` if the reference is not to a constructor.
    */
   CommentReference(this.newKeyword, Identifier identifier) {
-    _identifier = becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Token get beginToken => _identifier.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(newKeyword)
       ..add(_identifier);
 
   @override
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being referenced.
    */
   Identifier get identifier => _identifier;
 
   /**
    * Set the identifier being referenced to the given [identifier].
    */
   void set identifier(Identifier identifier) {
-    _identifier = becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCommentReference(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_identifier, visitor);
   }
 }
@@ skipping 97 matching lines @@
   /**
    * Initialize a newly created compilation unit to have the given directives
    * and declarations. The [scriptTag] can be `null` if there is no script tag
    * in the compilation unit. The list of [directives] can be `null` if there
    * are no directives in the compilation unit. The list of [declarations] can
    * be `null` if there are no declarations in the compilation unit.
    */
   CompilationUnit(this.beginToken, ScriptTag scriptTag,
       List<Directive> directives, List<CompilationUnitMember> declarations,
       this.endToken) {
-    _scriptTag = becomeParentOf(scriptTag);
+    _scriptTag = _becomeParentOf(scriptTag);
     _directives = new NodeList<Directive>(this, directives);
     _declarations = new NodeList<CompilationUnitMember>(this, declarations);
   }
 
   @override
   Iterable get childEntities {
     ChildEntities result = new ChildEntities()..add(_scriptTag);
-    if (_directivesAreBeforeDeclarations()) {
+    if (_directivesAreBeforeDeclarations) {
       result
           ..addAll(_directives)
           ..addAll(_declarations);
     } else {
       result.addAll(sortedDirectivesAndDeclarations);
     }
     return result;
   }
 
   /**
@@ skipping 22 matching lines @@
    * Return the script tag at the beginning of the compilation unit, or `null`
    * if there is no script tag in this compilation unit.
    */
   ScriptTag get scriptTag => _scriptTag;
 
   /**
    * Set the script tag at the beginning of the compilation unit to the given
    * [scriptTag].
    */
   void set scriptTag(ScriptTag scriptTag) {
-    _scriptTag = becomeParentOf(scriptTag);
+    _scriptTag = _becomeParentOf(scriptTag);
   }
 
   /**
    * Return a list containing all of the directives and declarations in this
    * compilation unit, sorted in lexical order.
    */
   List<AstNode> get sortedDirectivesAndDeclarations {
     return <AstNode>[]
         ..addAll(_directives)
         ..addAll(_declarations)
         ..sort(AstNode.LEXICAL_ORDER);
   }
 
+  /**
+   * Return `true` if all of the directives are lexically before any
+   * declarations.
+   */
+  bool get _directivesAreBeforeDeclarations {
+    if (_directives.isEmpty || _declarations.isEmpty) {
+      return true;
+    }
+    Directive lastDirective = _directives[_directives.length - 1];
+    CompilationUnitMember firstDeclaration = _declarations[0];
+    return lastDirective.offset < firstDeclaration.offset;
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitCompilationUnit(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_scriptTag, visitor);
-    if (_directivesAreBeforeDeclarations()) {
+    if (_directivesAreBeforeDeclarations) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
       for (AstNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
     }
   }
-
-  /**
-   * Return `true` if all of the directives are lexically before any
-   * declarations.
-   */
-  bool _directivesAreBeforeDeclarations() {
-    if (_directives.isEmpty || _declarations.isEmpty) {
-      return true;
-    }
-    Directive lastDirective = _directives[_directives.length - 1];
-    CompilationUnitMember firstDeclaration = _declarations[0];
-    return lastDirective.offset < firstDeclaration.offset;
-  }
 }
 
 /**
  * A node that declares a name within the scope of a compilation unit.
  *
  * > compilationUnitMember ::=
  * >     [ClassDeclaration]
  * >   | [TypeAlias]
  * >   | [FunctionDeclaration]
  * >   | [MethodDeclaration]
@@ skipping 40 matching lines @@
   /**
    * The expression that is executed if the condition evaluates to `false`.
    */
   Expression _elseExpression;
 
   /**
    * Initialize a newly created conditional expression.
    */
   ConditionalExpression(Expression condition, this.question,
       Expression thenExpression, this.colon, Expression elseExpression) {
-    _condition = becomeParentOf(condition);
-    _thenExpression = becomeParentOf(thenExpression);
-    _elseExpression = becomeParentOf(elseExpression);
+    _condition = _becomeParentOf(condition);
+    _thenExpression = _becomeParentOf(thenExpression);
+    _elseExpression = _becomeParentOf(elseExpression);
   }
 
   @override
   Token get beginToken => _condition.beginToken;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_condition)
       ..add(question)
       ..add(_thenExpression)
       ..add(colon)
       ..add(_elseExpression);
 
   /**
    * Return the condition used to determine which of the expressions is executed
    * next.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition used to determine which of the expressions is executed
    * next to the given [expression].
    */
   void set condition(Expression expression) {
-    _condition = becomeParentOf(expression);
+    _condition = _becomeParentOf(expression);
   }
 
   /**
    * Return the expression that is executed if the condition evaluates to
    * `false`.
    */
   Expression get elseExpression => _elseExpression;
 
   /**
    * Set the expression that is executed if the condition evaluates to `false`
    * to the given [expression].
    */
   void set elseExpression(Expression expression) {
-    _elseExpression = becomeParentOf(expression);
+    _elseExpression = _becomeParentOf(expression);
   }
 
   @override
   Token get endToken => _elseExpression.endToken;
 
   @override
   int get precedence => 3;
 
   /**
    * Return the expression that is executed if the condition evaluates to
    * `true`.
    */
   Expression get thenExpression => _thenExpression;
 
   /**
    * Set the expression that is executed if the condition evaluates to `true` to
    * the given [expression].
    */
   void set thenExpression(Expression expression) {
-    _thenExpression = becomeParentOf(expression);
+    _thenExpression = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(_thenExpression, visitor);
     _safelyVisitChild(_elseExpression, visitor);
   }
 }
 
 /**
  * An object that can be used to evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification:
- * <blockquote>A constant expression is one of the following:
+ * <blockquote>
+ * A constant expression is one of the following:
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time
  *   constant that evaluates to a numeric, string or boolean value or to `null`.
  * * `null`.
  * * A reference to a static constant variable.
  * * An identifier expression that denotes a constant variable, a class or a
  *   type parameter.
  * * A constant constructor invocation.
  * * A constant list literal.
@@ skipping 464 matching lines @@
    * does not redirect to a different constructor. The [body] can be `null` if
    * the constructor does not have a body.
    */
   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) {
-    _returnType = becomeParentOf(returnType);
-    _name = becomeParentOf(name);
-    _parameters = becomeParentOf(parameters);
+    _returnType = _becomeParentOf(returnType);
+    _name = _becomeParentOf(name);
+    _parameters = _becomeParentOf(parameters);
     _initializers = new NodeList<ConstructorInitializer>(this, initializers);
-    _redirectedConstructor = becomeParentOf(redirectedConstructor);
-    _body = becomeParentOf(body);
+    _redirectedConstructor = _becomeParentOf(redirectedConstructor);
+    _body = _becomeParentOf(body);
   }
 
   /**
    * Return the body of the constructor, or `null` if the constructor does not
    * have a body.
    */
   FunctionBody get body => _body;
 
   /**
    * Set the body of the constructor to the given [functionBody].
    */
   void set body(FunctionBody functionBody) {
-    _body = becomeParentOf(functionBody);
+    _body = _becomeParentOf(functionBody);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(externalKeyword)
       ..add(constKeyword)
       ..add(factoryKeyword)
       ..add(_returnType)
       ..add(period)
       ..add(_name)
@@ skipping 31 matching lines @@
   /**
    * Return the name of the constructor, or `null` if the constructor being
    * declared is unnamed.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the constructor to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   /**
    * Return the parameters associated with the constructor.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters associated with the constructor to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
-    _parameters = becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   /**
    * Return the name of the constructor to which this constructor will be
    * redirected, or `null` if this is not a redirecting factory constructor.
    */
   ConstructorName get redirectedConstructor => _redirectedConstructor;
 
   /**
    * Set the name of the constructor to which this constructor will be
    * redirected to the given [redirectedConstructor] name.
    */
   void set redirectedConstructor(ConstructorName redirectedConstructor) {
-    _redirectedConstructor = becomeParentOf(redirectedConstructor);
+    _redirectedConstructor = _becomeParentOf(redirectedConstructor);
   }
 
   /**
    * Return the type of object being created. This can be different than the
    * type in which the constructor is being declared if the constructor is the
    * implementation of a factory constructor.
    */
   Identifier get returnType => _returnType;
 
   /**
    * Set the type of object being created to the given [typeName].
    */
   void set returnType(Identifier typeName) {
-    _returnType = becomeParentOf(typeName);
+    _returnType = _becomeParentOf(typeName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorDeclaration(this);
 
   @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);
   }
 }
 
 /**
  * The initialization of a field within a constructor's initialization list.
  *
  * > fieldInitializer ::=
  * >     ('this' '.')? [SimpleIdentifier] '=' [Expression]
  */
 class ConstructorFieldInitializer extends ConstructorInitializer {
   /**
    * The token for the 'this' keyword, or `null` if there is no 'this' keyword.
    */
-  Token keyword;
+  Token thisKeyword;
 
   /**
    * The token for the period after the 'this' keyword, or `null` if there is no
    * 'this' keyword.
    */
   Token period;
 
   /**
    * The name of the field being initialized.
    */
   SimpleIdentifier _fieldName;
 
   /**
    * The token for the equal sign between the field name and the expression.
    */
   Token equals;
 
   /**
    * The expression computing the value to which the field will be initialized.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created field initializer to initialize the field with
-   * the given name to the value of the given expression. The [keyword] and
+   * the given name to the value of the given expression. The [thisKeyword] and
    * [period] can be `null` if the 'this' keyword was not specified.
    */
-  ConstructorFieldInitializer(this.keyword, this.period,
+  ConstructorFieldInitializer(this.thisKeyword, this.period,
       SimpleIdentifier fieldName, this.equals, Expression expression) {
-    _fieldName = becomeParentOf(fieldName);
-    _expression = becomeParentOf(expression);
+    _fieldName = _becomeParentOf(fieldName);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
-    if (keyword != null) {
-      return keyword;
+    if (thisKeyword != null) {
+      return thisKeyword;
     }
     return _fieldName.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(thisKeyword)
       ..add(period)
       ..add(_fieldName)
       ..add(equals)
       ..add(_expression);
 
   @override
   Token get endToken => _expression.endToken;
 
   /**
    * Return the expression computing the value to which the field will be
    * initialized.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression computing the value to which the field will be
    * initialized to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   /**
    * Return the name of the field being initialized.
    */
   SimpleIdentifier get fieldName => _fieldName;
 
   /**
    * Set the name of the field being initialized to the given [identifier].
    */
   void set fieldName(SimpleIdentifier identifier) {
-    _fieldName = becomeParentOf(identifier);
+    _fieldName = _becomeParentOf(identifier);
+  }
+
+  /**
+   * Return the token for the 'this' keyword, or `null` if there is no 'this'
+   * keyword.
+   */
+  @deprecated // Use "this.thisKeyword"
+  Token get keyword => thisKeyword;
+
+  /**
+   * Set the token for the 'this' keyword to the given [token].
+   */
+  @deprecated // Use "this.thisKeyword"
+  set keyword(Token token) {
+    thisKeyword = token;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_fieldName, visitor);
     _safelyVisitChild(_expression, visitor);
   }
@@ skipping 38 matching lines @@
    * information, or `null` if the AST structure has not been resolved or if
    * this constructor name could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created constructor name. The [period] and [name] can be
    * `null` if the constructor being named is the unnamed constructor.
    */
   ConstructorName(TypeName type, this.period, SimpleIdentifier name) {
-    _type = becomeParentOf(type);
-    _name = becomeParentOf(name);
+    _type = _becomeParentOf(type);
+    _name = _becomeParentOf(name);
   }
 
   @override
   Token get beginToken => _type.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_type)
       ..add(period)
       ..add(_name);
 
   @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.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the constructor to the given [name].
    */
   void set name(SimpleIdentifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   /**
    * Return the name of the type defining the constructor.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the type defining the constructor to the given [type] name.
    */
   void set type(TypeName type) {
-    _type = becomeParentOf(type);
+    _type = _becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorName(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * A continue statement.
  *
  * > continueStatement ::=
  * >     'continue' [SimpleIdentifier]? ';'
  */
 class ContinueStatement extends Statement {
   /**
    * The token representing the 'continue' keyword.
    */
-  Token keyword;
+  Token continueKeyword;
 
   /**
    * The label associated with the statement, or `null` if there is no label.
    */
   SimpleIdentifier _label;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * The AstNode which this continue statement is continuing to.  This will be
    * either a Statement (in the case of continuing a loop) or a SwitchMember
    * (in the case of continuing from one switch case to another).  Null if the
    * AST has not yet been resolved or if the target could not be resolved.
    * Note that if the source code has errors, the target may be invalid (e.g.
    * the target may be in an enclosing function).
    */
   AstNode target;
 
   /**
    * Initialize a newly created continue statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
-  ContinueStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
-    _label = becomeParentOf(label);
+  ContinueStatement(this.continueKeyword, SimpleIdentifier label, this.semicolon) {
+    _label = _becomeParentOf(label);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => continueKeyword;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(continueKeyword)
       ..add(_label)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
+   * Return the token for the 'continue' keyword, or `null` if there is no
+   * 'continue' keyword.
+   */
+  @deprecated // Use "this.continueKeyword"
+  Token get keyword => continueKeyword;
+
+  /**
+   * Set the token for the 'continue' keyword to the given [token].
+   */
+  @deprecated // Use "this.continueKeyword"
+  set keyword(Token token) {
+    continueKeyword = token;
+  }
+
+  /**
    * Return the label associated with the statement, or `null` if there is no
    * label.
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label associated with the statement to the given [identifier].
    */
   void set label(SimpleIdentifier identifier) {
-    _label = becomeParentOf(identifier);
+    _label = _becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_label, visitor);
   }
 }
@@ skipping 45 matching lines @@
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [keyword] can be `null` if a type name is
    * given. The [type] must be `null` if the keyword is 'var'.
    */
   DeclaredIdentifier(Comment comment, List<Annotation> metadata, this.keyword,
       TypeName type, SimpleIdentifier identifier)
       : super(comment, metadata) {
-    _type = becomeParentOf(type);
-    _identifier = becomeParentOf(identifier);
+    _type = _becomeParentOf(type);
+    _identifier = _becomeParentOf(identifier);
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => super._childEntities
       ..add(keyword)
       ..add(_type)
       ..add(_identifier);
 
   @override
   LocalVariableElement get element {
     if (_identifier == null) {
       return null;
@@ skipping 16 matching lines @@
 
   /**
    * Return the name of the variable being declared.
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
    * Set the name of the variable being declared to the given [identifier].
    */
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier);
   }
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    */
   bool get isConst =>
       (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.CONST;
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return `false`
    * even though they are implicitly final.
    */
   bool get isFinal =>
       (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the
    * parameter does not have a declared type.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
   void set type(TypeName typeName) {
-    _type = becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDeclaredIdentifier(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(_identifier, visitor);
@@ skipping 33 matching lines @@
    * there is no default value.
    */
   Expression _defaultValue;
 
   /**
    * Initialize a newly created default formal parameter. The [separator] and
    * [defaultValue] can be `null` if there is no default value.
    */
   DefaultFormalParameter(NormalFormalParameter parameter, this.kind,
       this.separator, Expression defaultValue) {
-    _parameter = becomeParentOf(parameter);
-    _defaultValue = becomeParentOf(defaultValue);
+    _parameter = _becomeParentOf(parameter);
+    _defaultValue = _becomeParentOf(defaultValue);
   }
 
   @override
   Token get beginToken => _parameter.beginToken;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_parameter)
       ..add(separator)
       ..add(_defaultValue);
 
   /**
    * Return the expression computing the default value for the parameter, or
    * `null` if there is no default value.
    */
   Expression get defaultValue => _defaultValue;
 
   /**
    * Set the expression computing the default value for the parameter to the
    * given [expression].
    */
   void set defaultValue(Expression expression) {
-    _defaultValue = becomeParentOf(expression);
+    _defaultValue = _becomeParentOf(expression);
   }
 
   @override
   Token get endToken {
     if (_defaultValue != null) {
       return _defaultValue.endToken;
     }
     return _parameter.endToken;
   }
 
   @override
   SimpleIdentifier get identifier => _parameter.identifier;
 
   @override
   bool get isConst => _parameter != null && _parameter.isConst;
 
   @override
   bool get isFinal => _parameter != null && _parameter.isFinal;
 
   /**
    * Return the formal parameter with which the default value is associated.
    */
   NormalFormalParameter get parameter => _parameter;
 
   /**
    * Set the formal parameter with which the default value is associated to the
    * given [formalParameter].
    */
   void set parameter(NormalFormalParameter formalParameter) {
-    _parameter = becomeParentOf(formalParameter);
+    _parameter = _becomeParentOf(formalParameter);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDefaultFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_parameter, visitor);
     _safelyVisitChild(_defaultValue, visitor);
   }
@@ skipping 103 matching lines @@
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created do loop.
    */
   DoStatement(this.doKeyword, Statement body, this.whileKeyword,
       this.leftParenthesis, Expression condition, this.rightParenthesis,
       this.semicolon) {
-    _body = becomeParentOf(body);
-    _condition = becomeParentOf(condition);
+    _body = _becomeParentOf(body);
+    _condition = _becomeParentOf(condition);
   }
 
   @override
   Token get beginToken => doKeyword;
 
   /**
    * Return the body of the loop.
    */
   Statement get body => _body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
-    _body = becomeParentOf(statement);
+    _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(doKeyword)
       ..add(_body)
       ..add(whileKeyword)
       ..add(leftParenthesis)
       ..add(_condition)
       ..add(rightParenthesis)
       ..add(semicolon);
 
   /**
    * Return the condition that determines when the loop will terminate.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition that determines when the loop will terminate to the given
    * [expression].
    */
   void set condition(Expression expression) {
-    _condition = becomeParentOf(expression);
+    _condition = _becomeParentOf(expression);
   }
 
   @override
   Token get endToken => semicolon;
 
   @override
   accept(AstVisitor visitor) => visitor.visitDoStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 14 matching lines @@
  */
 class DoubleLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * The value of the literal.
    */
-  double value = 0.0;
+  double value;
 
   /**
    * Initialize a newly created floating point literal.
    */
   DoubleLiteral(this.literal, this.value);
 
   @override
   Token get beginToken => literal;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(literal);
 
   @override
   Token get endToken => literal;
 
   @override
   accept(AstVisitor visitor) => visitor.visitDoubleLiteral(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * An object used to locate the [Element] associated with a given [AstNode].
  */
 class ElementLocator {
   /**
    * Return the element associated with the given [node], or `null` if there is
    * no element associated with the node.
    */
   static Element locate(AstNode node) {
+    if (node == null) {
+      return null;
+    }
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
     return node.accept(mapper);
   }
 
   /**
    * Return the element associated with the given [node], or `null` if there is
    * no element associated with the node.
    */
   static Element locateWithOffset(AstNode node, int offset) {
+    // TODO(brianwilkerson) 'offset' is not used. Figure out what's going on:
+    // whether there's a bug or whether this method is unnecessary.
     if (node == null) {
       return null;
     }
     // try to get Element from node
     Element nodeElement = locate(node);
     if (nodeElement != null) {
       return nodeElement;
     }
     // no Element
     return null;
@@ skipping 123 matching lines @@
   Token semicolon;
 
   /**
    * Initialize a newly created function body.
    */
   EmptyFunctionBody(this.semicolon);
 
   @override
   Token get beginToken => semicolon;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   accept(AstVisitor visitor) => visitor.visitEmptyFunctionBody(this);
 
   @override
@@ skipping 15 matching lines @@
   Token semicolon;
 
   /**
    * Initialize a newly created empty statement.
    */
   EmptyStatement(this.semicolon);
 
   @override
   Token get beginToken => semicolon;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   accept(AstVisitor visitor) => visitor.visitEmptyStatement(this);
 
   @override
@@ skipping 13 matching lines @@
 
   /**
    * Initialize a newly created enum constant declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the constant does not have the
    * corresponding attribute. (Technically, enum constants cannot have metadata,
    * but we allow it for consistency.)
    */
   EnumConstantDeclaration(Comment comment, List<Annotation> metadata,
       SimpleIdentifier name)
       : super(comment, metadata) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => super._childEntities..add(_name);
 
   @override
   FieldElement get element =>
       _name == null ? null : (_name.staticElement as FieldElement);
 
   @override
   Token get endToken => _name.endToken;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 
   /**
    * Return the name of the constant.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the constant to the given [name].
    */
   void set name(SimpleIdentifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitEnumConstantDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * The declaration of an enumeration.
  *
  * > enumType ::=
  * >     metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
  */
 class EnumDeclaration extends CompilationUnitMember {
   /**
    * The 'enum' keyword.
    */
-  Token keyword;
+  Token enumKeyword;
 
   /**
    * The name of the enumeration.
    */
   SimpleIdentifier _name;
 
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The enumeration constants being declared.
    */
   NodeList<EnumConstantDeclaration> _constants;
 
   /**
    * The right curly bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created enumeration declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The list of [constants] must contain at least one
    * value.
    */
-  EnumDeclaration(Comment comment, List<Annotation> metadata, this.keyword,
+  EnumDeclaration(Comment comment, List<Annotation> metadata, this.enumKeyword,
       SimpleIdentifier name, this.leftBracket,
       List<EnumConstantDeclaration> constants, this.rightBracket)
       : super(comment, metadata) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
     _constants = new NodeList<EnumConstantDeclaration>(this, constants);
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
+  // TODO(brianwilkerson) Add commas?
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
+      ..add(enumKeyword)
       ..add(_name)
       ..add(leftBracket)
       ..addAll(_constants)
       ..add(rightBracket);
 
   /**
    * Return the enumeration constants being declared.
    */
   NodeList<EnumConstantDeclaration> get constants => _constants;
 
   @override
   ClassElement get element =>
       _name != null ? (_name.staticElement as ClassElement) : null;
 
   @override
   Token get endToken => rightBracket;
 
   @override
-  Token get firstTokenAfterCommentAndMetadata => keyword;
+  Token get firstTokenAfterCommentAndMetadata => enumKeyword;
+
+  /**
+   * Return the token for the 'enum' keyword, or `null` if there is no
+   * 'enum' keyword.
+   */
+  @deprecated // Use "this.enumKeyword"
+  Token get keyword => enumKeyword;
+
+  /**
+   * Set the token for the 'enum' keyword to the given [token].
+   */
+  @deprecated // Use "this.enumKeyword"
+  set keyword(Token token) {
+    enumKeyword = token;
+  }
 
   /**
    * Return the name of the enumeration.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the enumeration to the given [name].
    */
   void set name(SimpleIdentifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitEnumDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _constants.accept(visitor);
   }
 }
 
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty
  * identifier.
  */
 class EphemeralIdentifier extends SimpleIdentifier {
   EphemeralIdentifier(AstNode parent, int location)
       : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
-    parent.becomeParentOf(this);
+    parent._becomeParentOf(this);
   }
 }
 
 /**
  * An export directive.
  *
  * > exportDirective ::=
  * >     [Annotation] 'export' [StringLiteral] [Combinator]* ';'
  */
 class ExportDirective extends NamespaceDirective {
@@ skipping 39 matching lines @@
  *
  * > expression ::=
  * >     [AssignmentExpression]
  * >   | [ConditionalExpression] cascadeSection*
  * >   | [ThrowExpression]
  */
 abstract class Expression extends AstNode {
   /**
    * An empty list of expressions.
    */
-  static const List<Expression> EMPTY_ARRAY = const <Expression>[];
+  @deprecated // Use "Expression.EMPTY_LIST"
+  static const List<Expression> EMPTY_ARRAY = EMPTY_LIST;
+
+  /**
+   * An empty list of expressions.
+   */
+  static const List<Expression> EMPTY_LIST = 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.
@@ skipping 52 matching lines @@
    * If this expression is an argument to an invocation, and the AST structure
    * has been resolved, and the function being invoked is known based on
    * propagated type information, and this expression corresponds to one of the
    * parameters of the function being invoked, then return the parameter element
    * representing the parameter to which the value of this expression will be
    * bound. Otherwise, return `null`.
    */
   ParameterElement get propagatedParameterElement {
     AstNode parent = this.parent;
     if (parent is ArgumentList) {
-      return parent.getPropagatedParameterElementFor(this);
+      return parent._getPropagatedParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent;
       if (identical(indexExpression.index, this)) {
-        return indexExpression.propagatedParameterElementForIndex;
+        return indexExpression._propagatedParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent;
       if (identical(binaryExpression.rightOperand, this)) {
-        return binaryExpression.propagatedParameterElementForRightOperand;
+        return binaryExpression._propagatedParameterElementForRightOperand;
       }
     } else if (parent is AssignmentExpression) {
       AssignmentExpression assignmentExpression = parent;
       if (identical(assignmentExpression.rightHandSide, this)) {
-        return assignmentExpression.propagatedParameterElementForRightHandSide;
+        return assignmentExpression._propagatedParameterElementForRightHandSide;
       }
     } else if (parent is PrefixExpression) {
-      return parent.propagatedParameterElementForOperand;
+      return parent._propagatedParameterElementForOperand;
     } else if (parent is PostfixExpression) {
-      return parent.propagatedParameterElementForOperand;
+      return parent._propagatedParameterElementForOperand;
     }
     return null;
   }
 
   /**
    * If this expression is an argument to an invocation, and the AST structure
    * has been resolved, and the function being invoked is known based on static
    * type information, and this expression corresponds to one of the parameters
    * of the function being invoked, then return the parameter element
    * representing the parameter to which the value of this expression will be
    * bound. Otherwise, return `null`.
    */
   ParameterElement get staticParameterElement {
     AstNode parent = this.parent;
     if (parent is ArgumentList) {
-      return parent.getStaticParameterElementFor(this);
+      return parent._getStaticParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent;
       if (identical(indexExpression.index, this)) {
-        return indexExpression.staticParameterElementForIndex;
+        return indexExpression._staticParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent;
       if (identical(binaryExpression.rightOperand, this)) {
-        return binaryExpression.staticParameterElementForRightOperand;
+        return binaryExpression._staticParameterElementForRightOperand;
       }
     } else if (parent is AssignmentExpression) {
       AssignmentExpression assignmentExpression = parent;
       if (identical(assignmentExpression.rightHandSide, this)) {
-        return assignmentExpression.staticParameterElementForRightHandSide;
+        return assignmentExpression._staticParameterElementForRightHandSide;
       }
     } else if (parent is PrefixExpression) {
-      return parent.staticParameterElementForOperand;
+      return parent._staticParameterElementForOperand;
     } else if (parent is PostfixExpression) {
-      return parent.staticParameterElementForOperand;
+      return parent._staticParameterElementForOperand;
     }
     return null;
   }
 }
 
 /**
  * A function body consisting of a single expression.
  *
  * > expressionFunctionBody ::=
  * >     'async'? '=>' [Expression] ';'
@@ skipping 21 matching lines @@
    */
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if the function body is not an
    * async function body.
    */
   ExpressionFunctionBody(this.keyword, this.functionDefinition,
       Expression expression, this.semicolon) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
-  Token get beginToken => functionDefinition;
+  Token get beginToken {
+    if (keyword != null) {
+      return keyword;
+    }
+    return functionDefinition;
+  }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(keyword)
       ..add(functionDefinition)
       ..add(_expression)
       ..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression representing the body of the function.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression representing the body of the function to the given
    * [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   bool get isAsynchronous => keyword != null;
 
   @override
   bool get isSynchronous => keyword == null;
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
@@ skipping 19 matching lines @@
   /**
    * The semicolon terminating the statement, or `null` if the expression is a
    * function expression and therefore isn't followed by a semicolon.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created expression statement.
    */
   ExpressionStatement(Expression expression, this.semicolon) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_expression)
       ..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression that comprises the statement.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression that comprises the statement to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   bool get isSynthetic => _expression.isSynthetic && semicolon.isSynthetic;
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * The "extends" clause in a class declaration.
  *
  * > extendsClause ::=
  * >     'extends' [TypeName]
  */
 class ExtendsClause extends AstNode {
   /**
    * The token representing the 'extends' keyword.
    */
-  Token keyword;
+  Token extendsKeyword;
 
   /**
    * The name of the class that is being extended.
    */
   TypeName _superclass;
 
   /**
    * Initialize a newly created extends clause.
    */
-  ExtendsClause(this.keyword, TypeName superclass) {
-    _superclass = becomeParentOf(superclass);
+  ExtendsClause(this.extendsKeyword, TypeName superclass) {
+    _superclass = _becomeParentOf(superclass);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => extendsKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(extendsKeyword)
       ..add(_superclass);
 
   @override
   Token get endToken => _superclass.endToken;
 
   /**
+   * Return the token for the 'extends' keyword.
+   */
+  @deprecated // Use "this.extendsKeyword"
+  Token get keyword => extendsKeyword;
+
+  /**
+   * Set the token for the 'extends' keyword to the given [token].
+   */
+  @deprecated // Use "this.extendsKeyword"
+  set keyword(Token token) {
+    extendsKeyword = token;
+  }
+
+  /**
    * Return the name of the class that is being extended.
    */
   TypeName get superclass => _superclass;
 
   /**
    * Set the name of the class that is being extended to the given [name].
    */
   void set superclass(TypeName name) {
-    _superclass = becomeParentOf(name);
+    _superclass = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExtendsClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_superclass, visitor);
   }
 }
@@ skipping 23 matching lines @@
 
   /**
    * Initialize a newly created field declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [staticKeyword] can be `null` if the field is
    * not a static field.
    */
   FieldDeclaration(Comment comment, List<Annotation> metadata,
       this.staticKeyword, VariableDeclarationList fieldList, this.semicolon)
       : super(comment, metadata) {
-    _fieldList = becomeParentOf(fieldList);
+    _fieldList = _becomeParentOf(fieldList);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(staticKeyword)
       ..add(_fieldList)
       ..add(semicolon);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the fields being declared.
    */
   VariableDeclarationList get fields => _fieldList;
 
   /**
    * Set the fields being declared to the given list of [fields].
    */
   void set fields(VariableDeclarationList fields) {
-    _fieldList = becomeParentOf(fields);
+    _fieldList = _becomeParentOf(fields);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (staticKeyword != null) {
       return staticKeyword;
     }
     return _fieldList.beginToken;
   }
 
@@ skipping 28 matching lines @@
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter
    * does not have a declared type.
    */
   TypeName _type;
 
   /**
    * The token representing the 'this' keyword.
    */
-  Token thisToken;
+  Token thisKeyword;
 
   /**
    * The token representing the period.
    */
   Token period;
 
   /**
    * The parameters of the function-typed parameter, or `null` if this is not a
    * function-typed field formal parameter.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if there is a type.
-   * The [type] must be `null` if the keyword is 'var'. The [thisToken] and
+   * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
    * [parameters] can be `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,
+      TypeName type, this.thisKeyword, this.period, SimpleIdentifier identifier,
       FormalParameterList parameters)
       : super(comment, metadata, identifier) {
-    _type = becomeParentOf(type);
-    _parameters = becomeParentOf(parameters);
+    _type = _becomeParentOf(type);
+    _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
-    return thisToken;
+    return thisKeyword;
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(keyword)
       ..add(_type)
-      ..add(thisToken)
+      ..add(thisKeyword)
       ..add(period)
       ..add(identifier)
       ..add(_parameters);
 
   @override
   Token get endToken {
     if (_parameters != null) {
       return _parameters.endToken;
     }
     return identifier.endToken;
@@ skipping 11 matching lines @@
    * Return the parameters of the function-typed parameter, or `null` if this is
    * not a function-typed field formal parameter.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters of the function-typed parameter to the given
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
-    _parameters = becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   /**
+   * Return the token representing the 'this' keyword.
+   */
+  @deprecated // Use "this.thisKeyword"
+  Token get thisToken => thisKeyword;
+
+  /**
+   * Set the token representing the 'this' keyword to the given [token].
+   */
+  @deprecated // Use "this.thisKeyword"
+  set thisToken(Token token) {
+    thisKeyword = token;
+  }
+
+  /**
    * Return the name of the declared type of the parameter, or `null` if the
    * parameter does not have a declared type. Note that if this is a
    * function-typed field formal parameter this is the return type of the
    * function.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
   void set type(TypeName typeName) {
-    _type = becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(identifier, visitor);
@@ skipping 56 matching lines @@
    */
   Statement _body;
 
   /**
    * Initialize a newly created for-each statement. The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   ForEachStatement.con1(this.awaitKeyword, this.forKeyword,
       this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword,
       Expression iterator, this.rightParenthesis, Statement body) {
-    _loopVariable = becomeParentOf(loopVariable);
-    _iterable = becomeParentOf(iterator);
-    _body = becomeParentOf(body);
+    _loopVariable = _becomeParentOf(loopVariable);
+    _iterable = _becomeParentOf(iterator);
+    _body = _becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for-each statement. The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   ForEachStatement.con2(this.awaitKeyword, this.forKeyword,
       this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword,
       Expression iterator, this.rightParenthesis, Statement body) {
-    _identifier = becomeParentOf(identifier);
-    _iterable = becomeParentOf(iterator);
-    _body = becomeParentOf(body);
+    _identifier = _becomeParentOf(identifier);
+    _iterable = _becomeParentOf(iterator);
+    _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    */
   Statement get body => _body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
-    _body = becomeParentOf(statement);
+    _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(awaitKeyword)
       ..add(forKeyword)
       ..add(leftParenthesis)
       ..add(_loopVariable)
       ..add(_identifier)
       ..add(inKeyword)
       ..add(_iterable)
       ..add(rightParenthesis)
       ..add(_body);
 
   @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the loop variable, or `null` if the loop variable is declared in the
    * 'for'.
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
    * Set the loop variable to the given [identifier].
    */
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier);
   }
 
   /**
    * Return the expression evaluated to produce the iterator.
    */
   Expression get iterable => _iterable;
 
   /**
    * Set the expression evaluated to produce the iterator to the given
    * [expression].
    */
   void set iterable(Expression expression) {
-    _iterable = becomeParentOf(expression);
+    _iterable = _becomeParentOf(expression);
   }
 
   /**
    * Return the expression evaluated to produce the iterator.
-   *
-   * Deprecated, use [iterable] instead.
    */
-  @deprecated
+  @deprecated // Use "this.iterable"
   Expression get iterator => iterable;
 
   /**
    * Return the declaration of the loop variable, or `null` if the loop variable
    * is a simple identifier.
    */
   DeclaredIdentifier get loopVariable => _loopVariable;
 
   /**
    * Set the declaration of the loop variable to the given [variable].
    */
   void set loopVariable(DeclaredIdentifier variable) {
-    _loopVariable = becomeParentOf(variable);
+    _loopVariable = _becomeParentOf(variable);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForEachStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_loopVariable, visitor);
     _safelyVisitChild(_identifier, visitor);
     _safelyVisitChild(_iterable, visitor);
@@ skipping 83 matching lines @@
    */
   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;
 
   /**
-   * The right square bracket (']') or right curly brace ('}') introducing the
+   * The right square bracket (']') or right curly brace ('}') terminating the
    * optional parameters, or `null` if there are no optional parameters.
    */
   Token rightDelimiter;
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
@@ skipping 129 matching lines @@
   /**
    * Initialize a newly created for statement. Either the [variableList] or the
    * [initialization] must be `null`. Either the [condition] and the list of
    * [updaters] can be `null` if the loop does not have the corresponding
    * attribute.
    */
   ForStatement(this.forKeyword, this.leftParenthesis,
       VariableDeclarationList variableList, Expression initialization,
       this.leftSeparator, Expression condition, this.rightSeparator,
       List<Expression> updaters, this.rightParenthesis, Statement body) {
-    _variableList = becomeParentOf(variableList);
-    _initialization = becomeParentOf(initialization);
-    _condition = becomeParentOf(condition);
+    _variableList = _becomeParentOf(variableList);
+    _initialization = _becomeParentOf(initialization);
+    _condition = _becomeParentOf(condition);
     _updaters = new NodeList<Expression>(this, updaters);
-    _body = becomeParentOf(body);
+    _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    */
   Statement get body => _body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
-    _body = becomeParentOf(statement);
+    _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(forKeyword)
       ..add(leftParenthesis)
       ..add(_variableList)
       ..add(_initialization)
       ..add(leftSeparator)
       ..add(_condition)
       ..add(rightSeparator)
       ..addAll(_updaters)
       ..add(rightParenthesis)
       ..add(_body);
 
   /**
    * Return the condition used to determine when to terminate the loop, or
    * `null` if there is no condition.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition used to determine when to terminate the loop to the given
    * [expression].
    */
   void set condition(Expression expression) {
-    _condition = becomeParentOf(expression);
+    _condition = _becomeParentOf(expression);
   }
 
   @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the initialization expression, or `null` if there is no
    * initialization expression.
    */
   Expression get initialization => _initialization;
 
   /**
    * Set the initialization expression to the given [expression].
    */
   void set initialization(Expression initialization) {
-    _initialization = becomeParentOf(initialization);
+    _initialization = _becomeParentOf(initialization);
   }
 
   /**
    * Return the list of expressions run after each execution of the loop body.
    */
   NodeList<Expression> get updaters => _updaters;
 
   /**
    * Return the declaration of the loop variables, or `null` if there are no
    * variables.
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the declaration of the loop variables to the given [variableList].
    */
   void set variables(VariableDeclarationList variableList) {
-    _variableList = becomeParentOf(variableList);
+    _variableList = _becomeParentOf(variableList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_variableList, visitor);
     _safelyVisitChild(_initialization, visitor);
     _safelyVisitChild(_condition, visitor);
@@ skipping 82 matching lines @@
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the
    * function is not an external function. The [returnType] can be `null` if no
    * return type was specified. The [propertyKeyword] can be `null` if the
    * function is neither a getter or a setter.
    */
   FunctionDeclaration(Comment comment, List<Annotation> metadata,
       this.externalKeyword, TypeName returnType, this.propertyKeyword,
       SimpleIdentifier name, FunctionExpression functionExpression)
       : super(comment, metadata) {
-    _returnType = becomeParentOf(returnType);
-    _name = becomeParentOf(name);
-    _functionExpression = becomeParentOf(functionExpression);
+    _returnType = _becomeParentOf(returnType);
+    _name = _becomeParentOf(name);
+    _functionExpression = _becomeParentOf(functionExpression);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(externalKeyword)
       ..add(_returnType)
       ..add(propertyKeyword)
       ..add(_name)
       ..add(_functionExpression);
 
@@ skipping 21 matching lines @@
   /**
    * Return the function expression being wrapped.
    */
   FunctionExpression get functionExpression => _functionExpression;
 
   /**
    * Set the function expression being wrapped to the given
    * [functionExpression].
    */
   void set functionExpression(FunctionExpression functionExpression) {
-    _functionExpression = becomeParentOf(functionExpression);
+    _functionExpression = _becomeParentOf(functionExpression);
   }
 
   /**
    * Return `true` if this function declares a getter.
    */
   bool get isGetter =>
       propertyKeyword != null &&
           (propertyKeyword as KeywordToken).keyword == Keyword.GET;
 
   /**
    * Return `true` if this function declares a setter.
    */
   bool get isSetter =>
       propertyKeyword != null &&
           (propertyKeyword as KeywordToken).keyword == Keyword.SET;
 
   /**
    * Return the name of the function, or `null` if the function is not named.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the function to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   /**
    * Return the return type of the function, or `null` if no return type was
    * declared.
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the return type of the function to the given [returnType].
    */
   void set returnType(TypeName returnType) {
-    _returnType = becomeParentOf(returnType);
+    _returnType = _becomeParentOf(returnType);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_functionExpression, visitor);
   }
 }
 
 /**
  * A [FunctionDeclaration] used as a statement.
  */
 class FunctionDeclarationStatement extends Statement {
   /**
    * The function declaration being wrapped.
    */
   FunctionDeclaration _functionDeclaration;
 
   /**
    * Initialize a newly created function declaration statement.
    */
   FunctionDeclarationStatement(FunctionDeclaration functionDeclaration) {
-    _functionDeclaration = becomeParentOf(functionDeclaration);
+    _functionDeclaration = _becomeParentOf(functionDeclaration);
   }
 
   @override
   Token get beginToken => _functionDeclaration.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()..add(_functionDeclaration);
 
   @override
   Token get endToken => _functionDeclaration.endToken;
 
   /**
    * Return the function declaration being wrapped.
    */
   FunctionDeclaration get functionDeclaration => _functionDeclaration;
 
   /**
    * Set the function declaration being wrapped to the given
    * [functionDeclaration].
    */
   void set functionDeclaration(FunctionDeclaration functionDeclaration) {
-    _functionDeclaration = becomeParentOf(functionDeclaration);
+    _functionDeclaration = _becomeParentOf(functionDeclaration);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_functionDeclaration, visitor);
   }
 }
@@ skipping 18 matching lines @@
   /**
    * The element associated with the function, or `null` if the AST structure
    * has not been resolved.
    */
   ExecutableElement element;
 
   /**
    * Initialize a newly created function declaration.
    */
   FunctionExpression(FormalParameterList parameters, FunctionBody body) {
-    _parameters = becomeParentOf(parameters);
-    _body = becomeParentOf(body);
+    _parameters = _becomeParentOf(parameters);
+    _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken {
     if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
       return _body.beginToken;
     }
     // This should never be reached because external functions must be named,
     // hence either the body or the name should be non-null.
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
    * Return the body of the function, or `null` if this is an external function.
    */
   FunctionBody get body => _body;
 
   /**
    * Set the body of the function to the given [functionBody].
    */
   void set body(FunctionBody functionBody) {
-    _body = becomeParentOf(functionBody);
+    _body = _becomeParentOf(functionBody);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_parameters)
       ..add(_body);
 
   @override
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (_parameters != null) {
       return _parameters.endToken;
     }
     // This should never be reached because external functions must be named,
     // hence either the body or the name should be non-null.
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
    * Return the parameters associated with the function.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters associated with the function to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
-    _parameters = becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   @override
   int get precedence => 16;
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 33 matching lines @@
    * 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;
 
   /**
    * Initialize a newly created function expression invocation.
    */
   FunctionExpressionInvocation(Expression function, ArgumentList argumentList) {
-    _function = becomeParentOf(function);
-    _argumentList = becomeParentOf(argumentList);
+    _function = _becomeParentOf(function);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the method.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken => _function.beginToken;
 
   /**
    * Return the best element available for the function being invoked. If
    * resolution was able to find a better element based on type propagation,
    * that element will be returned. Otherwise, the element found using the
    * result of static analysis will be returned. If resolution has not been
    * performed, then `null` will be returned.
    */
   ExecutableElement get bestElement {
     ExecutableElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_function)
       ..add(_argumentList);
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the expression producing the function being invoked.
    */
   Expression get function => _function;
 
   /**
    * Set the expression producing the function being invoked to the given
    * [expression].
    */
   void set function(Expression expression) {
-    _function = becomeParentOf(expression);
+    _function = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 15;
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 38 matching lines @@
    * Initialize a newly created function type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified. The [typeParameters] can be `null` if the function has no
    * type parameters.
    */
   FunctionTypeAlias(Comment comment, List<Annotation> metadata, Token keyword,
       TypeName returnType, SimpleIdentifier name, TypeParameterList typeParameters,
       FormalParameterList parameters, Token semicolon)
       : super(comment, metadata, keyword, semicolon) {
-    _returnType = becomeParentOf(returnType);
-    _name = becomeParentOf(name);
-    _typeParameters = becomeParentOf(typeParameters);
-    _parameters = becomeParentOf(parameters);
+    _returnType = _becomeParentOf(returnType);
+    _name = _becomeParentOf(name);
+    _typeParameters = _becomeParentOf(typeParameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
+      ..add(typedefKeyword)
       ..add(_returnType)
       ..add(_name)
       ..add(_typeParameters)
       ..add(_parameters)
       ..add(semicolon);
 
   @override
   FunctionTypeAliasElement get element =>
       _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
    * Return the name of the function type being declared.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the function type being declared to the given [name].
    */
   void set name(SimpleIdentifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   /**
    * Return the parameters associated with the function type.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters associated with the function type to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
-    _parameters = becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   /**
    * Return the name of the return type of the function type being defined, or
    * `null` if no return type was given.
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the name of the return type of the function type being defined to the
    * given [typeName].
    */
   void set returnType(TypeName typeName) {
-    _returnType = becomeParentOf(typeName);
+    _returnType = _becomeParentOf(typeName);
   }
 
   /**
    * Return the type parameters for the function type, or `null` if the function
    * type does not have any type parameters.
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters for the function type to the given list of
    * [typeParameters].
    */
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypeAlias(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(_name, visitor);
@@ skipping 23 matching lines @@
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
   FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata,
       TypeName returnType, SimpleIdentifier identifier,
       FormalParameterList parameters)
       : super(comment, metadata, identifier) {
-    _returnType = becomeParentOf(returnType);
-    _parameters = becomeParentOf(parameters);
+    _returnType = _becomeParentOf(returnType);
+    _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => super._childEntities
       ..add(_returnType)
       ..add(identifier)
       ..add(parameters);
 
   @override
   Token get endToken => _parameters.endToken;
 
   @override
   bool get isConst => false;
 
   @override
   bool get isFinal => false;
 
   /**
    * Return the parameters of the function-typed parameter.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters of the function-typed parameter to the given
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
-    _parameters = becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   /**
    * Return the return type of the function, or `null` if the function does not
    * have a return type.
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the return type of the function to the given [type].
    */
   void set returnType(TypeName type) {
-    _returnType = becomeParentOf(type);
+    _returnType = _becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(identifier, visitor);
@@ skipping 570 matching lines @@
    */
   Statement _elseStatement;
 
   /**
    * Initialize a newly created if statement. The [elseKeyword] and
    * [elseStatement] can be `null` if there is no else clause.
    */
   IfStatement(this.ifKeyword, this.leftParenthesis, Expression condition,
       this.rightParenthesis, Statement thenStatement, this.elseKeyword,
       Statement elseStatement) {
-    _condition = becomeParentOf(condition);
-    _thenStatement = becomeParentOf(thenStatement);
-    _elseStatement = becomeParentOf(elseStatement);
+    _condition = _becomeParentOf(condition);
+    _thenStatement = _becomeParentOf(thenStatement);
+    _elseStatement = _becomeParentOf(elseStatement);
   }
 
   @override
   Token get beginToken => ifKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(ifKeyword)
       ..add(leftParenthesis)
       ..add(_condition)
       ..add(rightParenthesis)
       ..add(_thenStatement)
       ..add(elseKeyword)
       ..add(_elseStatement);
 
   /**
    * Return the condition used to determine which of the statements is executed
    * next.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition used to determine which of the statements is executed
    * next to the given [expression].
    */
   void set condition(Expression expression) {
-    _condition = becomeParentOf(expression);
+    _condition = _becomeParentOf(expression);
   }
 
   /**
    * Return the statement that is executed if the condition evaluates to
    * `false`, or `null` if there is no else statement.
    */
   Statement get elseStatement => _elseStatement;
 
   /**
    * Set the statement that is executed if the condition evaluates to `false`
    * to the given [statement].
    */
   void set elseStatement(Statement statement) {
-    _elseStatement = becomeParentOf(statement);
+    _elseStatement = _becomeParentOf(statement);
   }
 
   @override
   Token get endToken {
     if (_elseStatement != null) {
       return _elseStatement.endToken;
     }
     return _thenStatement.endToken;
   }
 
   /**
    * Return the statement that is executed if the condition evaluates to `true`.
    */
   Statement get thenStatement => _thenStatement;
 
   /**
    * Set the statement that is executed if the condition evaluates to `true` to
    * the given [statement].
    */
   void set thenStatement(Statement statement) {
-    _thenStatement = becomeParentOf(statement);
+    _thenStatement = _becomeParentOf(statement);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIfStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(_thenStatement, visitor);
     _safelyVisitChild(_elseStatement, visitor);
   }
 }
 
 /**
  * The "implements" clause in an class declaration.
  *
  * > implementsClause ::=
  * >     'implements' [TypeName] (',' [TypeName])*
  */
 class ImplementsClause extends AstNode {
   /**
    * The token representing the 'implements' keyword.
    */
-  Token keyword;
+  Token implementsKeyword;
 
   /**
    * The interfaces that are being implemented.
    */
   NodeList<TypeName> _interfaces;
 
   /**
    * Initialize a newly created implements clause.
    */
-  ImplementsClause(this.keyword, List<TypeName> interfaces) {
+  ImplementsClause(this.implementsKeyword, List<TypeName> interfaces) {
     _interfaces = new NodeList<TypeName>(this, interfaces);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => implementsKeyword;
 
   /**
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(implementsKeyword)
       ..addAll(interfaces);
 
   @override
   Token get endToken => _interfaces.endToken;
 
   /**
    * Return the list of the interfaces that are being implemented.
    */
   NodeList<TypeName> get interfaces => _interfaces;
 
+  /**
+   * Return the token representing the 'implements' keyword.
+   */
+  @deprecated // Use "this.implementsKeyword"
+  Token get keyword => implementsKeyword;
+
+  /**
+   * Set the token representing the 'implements' keyword to the given [token].
+   */
+  @deprecated // Use "this.implementsKeyword"
+  set keyword(Token token) {
+    implementsKeyword = token;
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitImplementsClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _interfaces.accept(visitor);
   }
 }
 
 /**
@@ skipping 92 matching lines @@
     if (!javaCollectionContainsAll(allHides1, allHides2)) {
       return -1;
     }
     if (!javaCollectionContainsAll(allShows1, allShows2)) {
       return -1;
     }
     return 0;
   };
 
   /**
-   * The token representing the 'deferred' token, or `null` if the imported is
+   * The token representing the 'deferred' keyword, or `null` if the imported is
    * not deferred.
    */
-  Token deferredToken;
+  Token deferredKeyword;
 
   /**
-   * The token representing the 'as' token, or `null` if the imported names are
+   * The token representing the 'as' keyword, or `null` if the imported names are
    * not prefixed.
    */
-  Token asToken;
+  Token asKeyword;
 
   /**
    * The prefix to be used with the imported names, or `null` if the imported
    * names are not prefixed.
    */
   SimpleIdentifier _prefix;
 
   /**
    * Initialize a newly created import directive. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
-   * corresponding attribute. The [deferredToken] can be `null` if the import is
-   * not deferred. The [asToken] and [prefix] can be `null` if the import does
-   * not specify a prefix. The list of [combinators] can be `null` if there are
-   * no combinators.
+   * corresponding attribute. The [deferredKeyword] can be `null` if the import
+   * is not deferred. The [asKeyword] and [prefix] can be `null` if the import
+   * does not specify a prefix. The list of [combinators] can be `null` if there
+   * are no combinators.
    */
   ImportDirective(Comment comment, List<Annotation> metadata, Token keyword,
-      StringLiteral libraryUri, this.deferredToken, this.asToken,
+      StringLiteral libraryUri, this.deferredKeyword, this.asKeyword,
       SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon)
       : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
-    _prefix = becomeParentOf(prefix);
+    _prefix = _becomeParentOf(prefix);
+  }
+
+  /**
+   * The token representing the 'as' token, or `null` if the imported names are
+   * not prefixed.
+   */
+  @deprecated // Use "this.asKeyword"
+  Token get asToken => asKeyword;
+
+  /**
+   * The token representing the 'as' token to the given token.
+   */
+  @deprecated // Use "this.asKeyword"
+  set asToken (Token token) {
+    asKeyword = token;
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(_uri)
-      ..add(deferredToken)
-      ..add(asToken)
+      ..add(deferredKeyword)
+      ..add(asKeyword)
       ..add(_prefix)
       ..addAll(combinators)
       ..add(semicolon);
 
+  /**
+   * Return the token representing the 'deferred' token, or `null` if the
+   * imported is not deferred.
+   */
+  @deprecated // Use "this.deferredKeyword"
+  Token get deferredToken => deferredKeyword;
+
+  /**
+   * Set the token representing the 'deferred' token to the given token.
+   */
+  @deprecated // Use "this.deferredKeyword"
+  set deferredToken (Token token) {
+    deferredKeyword = token;
+  }
+
   @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 not prefixed.
    */
   SimpleIdentifier get prefix => _prefix;
 
   /**
    * Set the prefix to be used with the imported names to the given [identifier].
    */
   void set prefix(SimpleIdentifier identifier) {
-    _prefix = becomeParentOf(identifier);
+    _prefix = _becomeParentOf(identifier);
   }
 
   @override
   LibraryElement get uriElement {
     ImportElement element = this.element;
     if (element == null) {
       return null;
     }
     return element.importedLibrary;
   }
@@ skipping 68 matching lines @@
         _mapToken(node.asOperator),
         _cloneNode(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AstNode visitAssertStatement(AssertStatement node) =>
       new AssertStatement(
-          _mapToken(node.keyword),
+          _mapToken(node.assertKeyword),
           _mapToken(node.leftParenthesis),
           _cloneNode(node.condition),
           _mapToken(node.rightParenthesis),
           _mapToken(node.semicolon));
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression copy = new AssignmentExpression(
         _cloneNode(node.leftHandSide),
         _mapToken(node.operator),
@@ skipping 41 matching lines @@
     BooleanLiteral copy =
         new BooleanLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   BreakStatement visitBreakStatement(BreakStatement node) =>
       new BreakStatement(
-          _mapToken(node.keyword),
+          _mapToken(node.breakKeyword),
           _cloneNode(node.label),
           _mapToken(node.semicolon));
 
   @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) {
     CascadeExpression copy = new CascadeExpression(
         _cloneNode(node.target),
         _cloneNodeList(node.cascadeSections));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
@@ skipping 30 matching lines @@
         _mapToken(node.rightBracket));
     copy.nativeClause = _cloneNode(node.nativeClause);
     return copy;
   }
 
   @override
   ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) =>
       new ClassTypeAlias(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
-          _mapToken(node.keyword),
+          _mapToken(node.typedefKeyword),
           _cloneNode(node.name),
           _cloneNode(node.typeParameters),
           _mapToken(node.equals),
           _mapToken(node.abstractKeyword),
           _cloneNode(node.superclass),
           _cloneNode(node.withClause),
           _cloneNode(node.implementsClause),
           _mapToken(node.semicolon));
 
   @override
@@ skipping 56 matching lines @@
         _cloneNode(node.redirectedConstructor),
         _cloneNode(node.body));
     copy.element = node.element;
     return copy;
   }
 
   @override
   ConstructorFieldInitializer
       visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
       new ConstructorFieldInitializer(
-          _mapToken(node.keyword),
+          _mapToken(node.thisKeyword),
           _mapToken(node.period),
           _cloneNode(node.fieldName),
           _mapToken(node.equals),
           _cloneNode(node.expression));
 
   @override
   ConstructorName visitConstructorName(ConstructorName node) {
     ConstructorName copy = new ConstructorName(
         _cloneNode(node.type),
         _mapToken(node.period),
         _cloneNode(node.name));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
   @override
   ContinueStatement visitContinueStatement(ContinueStatement node) =>
       new ContinueStatement(
-          _mapToken(node.keyword),
+          _mapToken(node.continueKeyword),
           _cloneNode(node.label),
           _mapToken(node.semicolon));
 
   @override
   DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) =>
       new DeclaredIdentifier(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _mapToken(node.keyword),
           _cloneNode(node.type),
@@ skipping 40 matching lines @@
       new EnumConstantDeclaration(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _cloneNode(node.name));
 
   @override
   AstNode visitEnumDeclaration(EnumDeclaration node) =>
       new EnumDeclaration(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
-          _mapToken(node.keyword),
+          _mapToken(node.enumKeyword),
           _cloneNode(node.name),
           _mapToken(node.leftBracket),
           _cloneNodeList(node.constants),
           _mapToken(node.rightBracket));
 
   @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective copy = new ExportDirective(
         _cloneNode(node.documentationComment),
         _cloneNodeList(node.metadata),
@@ skipping 13 matching lines @@
           _mapToken(node.functionDefinition),
           _cloneNode(node.expression),
           _mapToken(node.semicolon));
 
   @override
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) =>
       new ExpressionStatement(_cloneNode(node.expression), _mapToken(node.semicolon));
 
   @override
   ExtendsClause visitExtendsClause(ExtendsClause node) =>
-      new ExtendsClause(_mapToken(node.keyword), _cloneNode(node.superclass));
+      new ExtendsClause(_mapToken(node.extendsKeyword), _cloneNode(node.superclass));
 
   @override
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) =>
       new FieldDeclaration(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _mapToken(node.staticKeyword),
           _cloneNode(node.fields),
           _mapToken(node.semicolon));
 
   @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) =>
       new FieldFormalParameter(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _mapToken(node.keyword),
           _cloneNode(node.type),
-          _mapToken(node.thisToken),
+          _mapToken(node.thisKeyword),
           _mapToken(node.period),
           _cloneNode(node.identifier),
           _cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
       return new ForEachStatement.con2(
           _mapToken(node.awaitKeyword),
@@ skipping 76 matching lines @@
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
       new FunctionTypeAlias(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
-          _mapToken(node.keyword),
+          _mapToken(node.typedefKeyword),
           _cloneNode(node.returnType),
           _cloneNode(node.name),
           _cloneNode(node.typeParameters),
           _cloneNode(node.parameters),
           _mapToken(node.semicolon));
 
   @override
   FunctionTypedFormalParameter
       visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
       new FunctionTypedFormalParameter(
@@ skipping 13 matching lines @@
           _mapToken(node.ifKeyword),
           _mapToken(node.leftParenthesis),
           _cloneNode(node.condition),
           _mapToken(node.rightParenthesis),
           _cloneNode(node.thenStatement),
           _mapToken(node.elseKeyword),
           _cloneNode(node.elseStatement));
 
   @override
   ImplementsClause visitImplementsClause(ImplementsClause node) =>
-      new ImplementsClause(_mapToken(node.keyword), _cloneNodeList(node.interfaces));
+      new ImplementsClause(_mapToken(node.implementsKeyword), _cloneNodeList(node.interfaces));
 
   @override
   ImportDirective visitImportDirective(ImportDirective node) =>
       new ImportDirective(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _mapToken(node.keyword),
           _cloneNode(node.uri),
-          _mapToken(node.deferredToken),
-          _mapToken(node.asToken),
+          _mapToken(node.deferredKeyword),
+          _mapToken(node.asKeyword),
           _cloneNode(node.prefix),
           _cloneNodeList(node.combinators),
           _mapToken(node.semicolon));
 
   @override
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = _mapToken(node.period);
     IndexExpression copy;
     if (period == null) {
       copy = new IndexExpression.forTarget(
@@ skipping 68 matching lines @@
 
   @override
   LabeledStatement visitLabeledStatement(LabeledStatement node) =>
       new LabeledStatement(_cloneNodeList(node.labels), _cloneNode(node.statement));
 
   @override
   LibraryDirective visitLibraryDirective(LibraryDirective node) =>
       new LibraryDirective(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
-          _mapToken(node.libraryToken),
+          _mapToken(node.libraryKeyword),
           _cloneNode(node.name),
           _mapToken(node.semicolon));
 
   @override
   LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) {
     LibraryIdentifier copy =
         new LibraryIdentifier(_cloneNodeList(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
@@ skipping 62 matching lines @@
   NamedExpression visitNamedExpression(NamedExpression node) {
     NamedExpression copy =
         new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AstNode visitNativeClause(NativeClause node) =>
-      new NativeClause(_mapToken(node.keyword), _cloneNode(node.name));
+      new NativeClause(_mapToken(node.nativeKeyword), _cloneNode(node.name));
 
   @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
       new NativeFunctionBody(
-          _mapToken(node.nativeToken),
+          _mapToken(node.nativeKeyword),
           _cloneNode(node.stringLiteral),
           _mapToken(node.semicolon));
 
   @override
   NullLiteral visitNullLiteral(NullLiteral node) {
     NullLiteral copy = new NullLiteral(_mapToken(node.literal));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ParenthesizedExpression
       visitParenthesizedExpression(ParenthesizedExpression node) {
     ParenthesizedExpression copy = new ParenthesizedExpression(
         _mapToken(node.leftParenthesis),
         _cloneNode(node.expression),
         _mapToken(node.rightParenthesis));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   PartDirective visitPartDirective(PartDirective node) {
     PartDirective copy = new PartDirective(
         _cloneNode(node.documentationComment),
         _cloneNodeList(node.metadata),
-        _mapToken(node.partToken),
+        _mapToken(node.partKeyword),
         _cloneNode(node.uri),
         _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   @override
   PartOfDirective visitPartOfDirective(PartOfDirective node) {
     PartOfDirective copy = new PartOfDirective(
         _cloneNode(node.documentationComment),
         _cloneNodeList(node.metadata),
-        _mapToken(node.partToken),
-        _mapToken(node.ofToken),
+        _mapToken(node.partKeyword),
+        _mapToken(node.ofKeyword),
         _cloneNode(node.libraryName),
         _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   @override
   PostfixExpression visitPostfixExpression(PostfixExpression node) {
     PostfixExpression copy =
         new PostfixExpression(_cloneNode(node.operand), _mapToken(node.operator));
@@ skipping 35 matching lines @@
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   RedirectingConstructorInvocation
       visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation copy =
         new RedirectingConstructorInvocation(
-            _mapToken(node.keyword),
+            _mapToken(node.thisKeyword),
             _mapToken(node.period),
             _cloneNode(node.constructorName),
             _cloneNode(node.argumentList));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
   @override
   RethrowExpression visitRethrowExpression(RethrowExpression node) {
-    RethrowExpression copy = new RethrowExpression(_mapToken(node.keyword));
+    RethrowExpression copy = new RethrowExpression(_mapToken(node.rethrowKeyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ReturnStatement visitReturnStatement(ReturnStatement node) =>
       new ReturnStatement(
-          _mapToken(node.keyword),
+          _mapToken(node.returnKeyword),
           _cloneNode(node.expression),
           _mapToken(node.semicolon));
 
   @override
   ScriptTag visitScriptTag(ScriptTag node) =>
       new ScriptTag(_mapToken(node.scriptTag));
 
   @override
   ShowCombinator visitShowCombinator(ShowCombinator node) =>
       new ShowCombinator(_mapToken(node.keyword), _cloneNodeList(node.shownNames));
@@ skipping 43 matching lines @@
         new StringInterpolation(_cloneNodeList(node.elements));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   SuperConstructorInvocation
       visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation copy = new SuperConstructorInvocation(
-        _mapToken(node.keyword),
+        _mapToken(node.superKeyword),
         _mapToken(node.period),
         _cloneNode(node.constructorName),
         _cloneNode(node.argumentList));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
   @override
   SuperExpression visitSuperExpression(SuperExpression node) {
-    SuperExpression copy = new SuperExpression(_mapToken(node.keyword));
+    SuperExpression copy = new SuperExpression(_mapToken(node.superKeyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   SwitchCase visitSwitchCase(SwitchCase node) =>
       new SwitchCase(
           _cloneNodeList(node.labels),
           _mapToken(node.keyword),
           _cloneNode(node.expression),
           _mapToken(node.colon),
           _cloneNodeList(node.statements));
 
   @override
   SwitchDefault visitSwitchDefault(SwitchDefault node) =>
       new SwitchDefault(
           _cloneNodeList(node.labels),
           _mapToken(node.keyword),
           _mapToken(node.colon),
           _cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) =>
       new SwitchStatement(
-          _mapToken(node.keyword),
+          _mapToken(node.switchKeyword),
           _mapToken(node.leftParenthesis),
           _cloneNode(node.expression),
           _mapToken(node.rightParenthesis),
           _mapToken(node.leftBracket),
           _cloneNodeList(node.members),
           _mapToken(node.rightBracket));
 
   @override
   AstNode visitSymbolLiteral(SymbolLiteral node) {
     SymbolLiteral copy =
         new SymbolLiteral(_mapToken(node.poundSign), _mapTokens(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ThisExpression visitThisExpression(ThisExpression node) {
-    ThisExpression copy = new ThisExpression(_mapToken(node.keyword));
+    ThisExpression copy = new ThisExpression(_mapToken(node.thisKeyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ThrowExpression visitThrowExpression(ThrowExpression node) {
     ThrowExpression copy =
-        new ThrowExpression(_mapToken(node.keyword), _cloneNode(node.expression));
+        new ThrowExpression(_mapToken(node.throwKeyword), _cloneNode(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   TopLevelVariableDeclaration
       visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) =>
       new TopLevelVariableDeclaration(
           _cloneNode(node.documentationComment),
@@ skipping 24 matching lines @@
     copy.type = node.type;
     return copy;
   }
 
   @override
   TypeParameter visitTypeParameter(TypeParameter node) =>
       new TypeParameter(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _cloneNode(node.name),
-          _mapToken(node.keyword),
+          _mapToken(node.extendsKeyword),
           _cloneNode(node.bound));
 
   @override
   TypeParameterList visitTypeParameterList(TypeParameterList node) =>
       new TypeParameterList(
           _mapToken(node.leftBracket),
           _cloneNodeList(node.typeParameters),
           _mapToken(node.rightBracket));
 
   @override
@@ skipping 18 matching lines @@
   @override
   VariableDeclarationStatement
       visitVariableDeclarationStatement(VariableDeclarationStatement node) =>
       new VariableDeclarationStatement(
           _cloneNode(node.variables),
           _mapToken(node.semicolon));
 
   @override
   WhileStatement visitWhileStatement(WhileStatement node) =>
       new WhileStatement(
-          _mapToken(node.keyword),
+          _mapToken(node.whileKeyword),
           _mapToken(node.leftParenthesis),
           _cloneNode(node.condition),
           _mapToken(node.rightParenthesis),
           _cloneNode(node.body));
 
   @override
   WithClause visitWithClause(WithClause node) =>
       new WithClause(_mapToken(node.withKeyword), _cloneNodeList(node.mixinTypes));
 
   @override
@@ skipping 92 matching lines @@
    * information. The auxiliary element will hold onto the elements from the
    * getter context.
    */
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created index expression.
    */
   IndexExpression.forCascade(this.period, this.leftBracket, Expression index,
       this.rightBracket) {
-    _index = becomeParentOf(index);
+    _index = _becomeParentOf(index);
   }
 
   /**
    * Initialize a newly created index expression.
    */
   IndexExpression.forTarget(Expression target, this.leftBracket,
       Expression index, this.rightBracket) {
-    _target = becomeParentOf(target);
-    _index = becomeParentOf(index);
+    _target = _becomeParentOf(target);
+    _index = _becomeParentOf(index);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return period;
   }
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_target)
       ..add(period)
       ..add(leftBracket)
       ..add(_index)
       ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to compute the index.
    */
   Expression get index => _index;
 
   /**
    * Set the expression used to compute the index to the given [expression].
    */
   void set index(Expression expression) {
-    _index = becomeParentOf(expression);
+    _index = _becomeParentOf(expression);
   }
 
   @override
   bool get isAssignable => true;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of
    * this expression is not stored locally but is stored in the nearest ancestor
    * that is a [CascadeExpression].
    */
   bool get isCascaded => period != null;
 
   @override
   int get precedence => 15;
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get propagatedParameterElementForIndex {
-    if (propagatedElement == null) {
-      return null;
-    }
-    List<ParameterElement> parameters = propagatedElement.parameters;
-    if (parameters.length < 1) {
-      return null;
-    }
-    return parameters[0];
+    return _propagatedParameterElementForIndex;
   }
 
   /**
    * 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 [target]. If this index expression is part of a cascade expression, then
    * the target expression stored with the cascade expression is returned.
    */
   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;
   }
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get staticParameterElementForIndex {
-    if (staticElement == null) {
-      return null;
-    }
-    List<ParameterElement> parameters = staticElement.parameters;
-    if (parameters.length < 1) {
-      return null;
-    }
-    return parameters[0];
+    return _staticParameterElementForIndex;
   }
 
   /**
    * Return the expression used to compute the object being indexed, or `null`
    * if this index expression is part of a cascade expression.
    *
    * Use [realTarget] to get the target independent of whether this is part of a
    * cascade expression.
    */
   Expression get target => _target;
 
   /**
    * Set the expression used to compute the object being indexed to the given
    * [expression].
    */
   void set target(Expression expression) {
-    _target = becomeParentOf(expression);
+    _target = _becomeParentOf(expression);
+  }
+
+  /**
+   * 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`.
+   */
+  ParameterElement get _propagatedParameterElementForIndex {
+    if (propagatedElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = propagatedElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
+  }
+
+  /**
+   * If the AST structure has been resolved, and the function being invoked is
+   * known based on static type information, then return the parameter element
+   * representing the parameter to which the value of the index expression will
+   * be bound. Otherwise, return `null`.
+   */
+  ParameterElement get _staticParameterElementForIndex {
+    if (staticElement == null) {
+      return null;
+    }
+    List<ParameterElement> parameters = staticElement.parameters;
+    if (parameters.length < 1) {
+      return null;
+    }
+    return parameters[0];
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIndexExpression(this);
 
   /**
    * Return `true` if this expression is computing a right-hand value (that is,
    * if this expression is in a context where the operator '[]' will be
    * invoked).
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
    * are they mutually exclusive. In other words, it is possible for both
    * methods to return `true` when invoked on the same node.
    */
   bool inGetterContext() {
+    // TODO(brianwilkerson) Convert this to a getter.
     AstNode parent = this.parent;
     if (parent is AssignmentExpression) {
       AssignmentExpression assignment = parent;
       if (identical(assignment.leftHandSide, this) &&
           assignment.operator.type == TokenType.EQ) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Return `true` if this expression is computing a left-hand value (that is,
    * if this expression is in a context where the operator '[]=' will be
    * invoked).
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
    * are they mutually exclusive. In other words, it is possible for both
    * methods to return `true` when invoked on the same node.
    */
   bool inSetterContext() {
+    // TODO(brianwilkerson) Convert this to a getter.
     AstNode parent = this.parent;
     if (parent is PrefixExpression) {
       return parent.operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(parent.leftHandSide, this);
     }
     return false;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_index, visitor);
   }
 }
 
 /**
  * An instance creation expression.
  *
  * > newExpression ::=
  * >     ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
  */
 class InstanceCreationExpression extends Expression {
   /**
-   * The keyword used to indicate how an object should be created.
+   * The 'new' or 'const' keyword used to indicate how an object should be
+   * created.
    */
   Token keyword;
 
   /**
    * The name of the constructor to be invoked.
    */
   ConstructorName _constructorName;
 
   /**
    * The list of arguments to the constructor.
@@ skipping 10 matching lines @@
   /**
    * The result of evaluating this expression, if it is constant.
    */
   EvaluationResultImpl evaluationResult;
 
   /**
    * Initialize a newly created instance creation expression.
    */
   InstanceCreationExpression(this.keyword, ConstructorName constructorName,
       ArgumentList argumentList) {
-    _constructorName = becomeParentOf(constructorName);
-    _argumentList = becomeParentOf(argumentList);
+    _constructorName = _becomeParentOf(constructorName);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the constructor.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the constructor to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken => keyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(keyword)
       ..add(_constructorName)
       ..add(_argumentList);
 
   /**
    * Return the name of the constructor to be invoked.
    */
   ConstructorName get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor to be invoked to the given [name].
    */
   void set constructorName(ConstructorName name) {
-    _constructorName = becomeParentOf(name);
+    _constructorName = _becomeParentOf(name);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return `true` if this creation expression is used to invoke a constant
    * constructor.
    */
   bool get isConst =>
@@ skipping 38 matching lines @@
   int value = 0;
 
   /**
    * Initialize a newly created integer literal.
    */
   IntegerLiteral(this.literal, this.value);
 
   @override
   Token get beginToken => literal;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(literal);
 
   @override
   Token get endToken => literal;
 
   @override
   accept(AstVisitor visitor) => visitor.visitIntegerLiteral(this);
 
   @override
@@ skipping 36 matching lines @@
    * The right curly bracket, or `null` if the expression is an identifier
    * without brackets.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    */
   InterpolationExpression(this.leftBracket, Expression expression,
       this.rightBracket) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(leftBracket)
       ..add(_expression)
       ..add(rightBracket);
@@ skipping 10 matching lines @@
    * Return the expression to be evaluated for the value to be converted into a
    * string.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression to be evaluated for the value to be converted into a
    * string to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInterpolationExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
@@ skipping 19 matching lines @@
    * Initialize a newly created string of characters that are part of a string
    * interpolation.
    */
   InterpolationString(this.contents, String value) {
     _value = value;
   }
 
   @override
   Token get beginToken => contents;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(contents);
 
   /**
    * Return the offset of the after-last contents character.
    */
   int get contentsEnd {
     int end = contents.end;
     String lexeme = contents.lexeme;
     if (StringUtilities.endsWith3(lexeme, 0x22, 0x22, 0x22) ||
@@ skipping 72 matching lines @@
    * The name of the type being tested for.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
   IsExpression(Expression expression, this.isOperator, this.notOperator,
       TypeName type) {
-    _expression = becomeParentOf(expression);
-    _type = becomeParentOf(type);
+    _expression = _becomeParentOf(expression);
+    _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_expression)
       ..add(isOperator)
       ..add(notOperator)
       ..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression used to compute the value whose type is being tested to
    * the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 7;
 
   /**
    * Return the name of the type being tested for.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the type being tested for to the given [name].
    */
   void set type(TypeName name) {
-    _type = becomeParentOf(name);
+    _type = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIsExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
     _safelyVisitChild(_type, visitor);
   }
@@ skipping 13 matching lines @@
 
   /**
    * The colon that separates the label from the statement.
    */
   Token colon;
 
   /**
    * Initialize a newly created label.
    */
   Label(SimpleIdentifier label, this.colon) {
-    _label = becomeParentOf(label);
+    _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => _label.beginToken;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_label)
       ..add(colon);
 
   @override
   Token get endToken => colon;
 
   /**
    * Return the label being associated with the statement.
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label being associated with the statement to the given [label].
    */
   void set label(SimpleIdentifier label) {
-    _label = becomeParentOf(label);
+    _label = _becomeParentOf(label);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLabel(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_label, visitor);
   }
 }
@@ skipping 13 matching lines @@
   /**
    * The statement with which the labels are being associated.
    */
   Statement _statement;
 
   /**
    * Initialize a newly created labeled statement.
    */
   LabeledStatement(List<Label> labels, Statement statement) {
     _labels = new NodeList<Label>(this, labels);
-    _statement = becomeParentOf(statement);
+    _statement = _becomeParentOf(statement);
   }
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return _statement.beginToken;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..addAll(_labels)
       ..add(_statement);
 
   @override
   Token get endToken => _statement.endToken;
 
   /**
    * Return the labels being associated with the statement.
    */
   NodeList<Label> get labels => _labels;
 
   /**
    * 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].
    */
   void set statement(Statement statement) {
-    _statement = becomeParentOf(statement);
+    _statement = _becomeParentOf(statement);
   }
 
   @override
   Statement get unlabeled => _statement.unlabeled;
 
   @override
   accept(AstVisitor visitor) => visitor.visitLabeledStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _labels.accept(visitor);
     _safelyVisitChild(_statement, visitor);
   }
 }
 
 /**
  * A library directive.
  *
  * > libraryDirective ::=
  * >     [Annotation] 'library' [Identifier] ';'
  */
 class LibraryDirective extends Directive {
   /**
-   * The token representing the 'library' token.
+   * The token representing the 'library' keyword.
    */
-  Token libraryToken;
+  Token libraryKeyword;
 
   /**
    * The name of the library being defined.
    */
   LibraryIdentifier _name;
 
   /**
    * The semicolon terminating the directive.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created library directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   LibraryDirective(Comment comment, List<Annotation> metadata,
-      this.libraryToken, LibraryIdentifier name, this.semicolon)
+      this.libraryKeyword, LibraryIdentifier name, this.semicolon)
       : super(comment, metadata) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(libraryToken)
+      ..add(libraryKeyword)
       ..add(_name)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
-  Token get firstTokenAfterCommentAndMetadata => libraryToken;
+  Token get firstTokenAfterCommentAndMetadata => libraryKeyword;
 
   @override
-  Token get keyword => libraryToken;
+  Token get keyword => libraryKeyword;
+
+  /**
+   * Return the token representing the 'library' token.
+   */
+  @deprecated // Use "this.libraryKeyword"
+  Token get libraryToken => libraryKeyword;
+
+  /**
+   * Set the token representing the 'library' token to the given [token].
+   */
+  @deprecated // Use "this.libraryKeyword"
+  set libraryToken(Token token) {
+    libraryKeyword = token;
+  }
 
   /**
    * Return the name of the library being defined.
    */
   LibraryIdentifier get name => _name;
 
   /**
    * Set the name of the library being defined to the given [name].
    */
   void set name(LibraryIdentifier name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLibraryDirective(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
   }
@@ skipping 201 matching lines @@
       return constKeyword;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
     return leftBracket;
   }
 
   /**
-   * TODO(paulberry): untested.
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => super._childEntities
       ..add(leftBracket)
       ..addAll(entries)
       ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
@@ skipping 32 matching lines @@
 
   /**
    * The expression computing the value that will be associated with the key.
    */
   Expression _value;
 
   /**
    * Initialize a newly created map literal entry.
    */
   MapLiteralEntry(Expression key, this.separator, Expression value) {
-    _key = becomeParentOf(key);
-    _value = becomeParentOf(value);
+    _key = _becomeParentOf(key);
+    _value = _becomeParentOf(value);
   }
 
   @override
   Token get beginToken => _key.beginToken;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_key)
       ..add(separator)
       ..add(_value);
 
   @override
   Token get endToken => _value.endToken;
 
   /**
    * Return the expression computing the key with which the value will be
    * associated.
    */
   Expression get key => _key;
 
   /**
    * Set the expression computing the key with which the value will be
    * associated to the given [string].
    */
   void set key(Expression string) {
-    _key = becomeParentOf(string);
+    _key = _becomeParentOf(string);
   }
 
   /**
    * Return the expression computing the value that will be associated with the
    * key.
    */
   Expression get value => _value;
 
   /**
    * Set the expression computing the value that will be associated with the key
    * to the given [expression].
    */
   void set value(Expression expression) {
-    _value = becomeParentOf(expression);
+    _value = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMapLiteralEntry(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_key, visitor);
     _safelyVisitChild(_value, visitor);
   }
@@ skipping 68 matching lines @@
    * type was specified. The [propertyKeyword] can be `null` if the method is
    * neither a getter or a setter. The [operatorKeyword] can be `null` if the
    * method does not implement an operator. The [parameters] must be `null` if
    * this method declares a getter.
    */
   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) {
-    _returnType = becomeParentOf(returnType);
-    _name = becomeParentOf(name);
-    _parameters = becomeParentOf(parameters);
-    _body = becomeParentOf(body);
+    _returnType = _becomeParentOf(returnType);
+    _name = _becomeParentOf(name);
+    _parameters = _becomeParentOf(parameters);
+    _body = _becomeParentOf(body);
   }
 
   /**
    * Return the body of the method.
    */
   FunctionBody get body => _body;
 
   /**
    * Set the body of the method to the given [functionBody].
    */
   void set body(FunctionBody functionBody) {
-    _body = becomeParentOf(functionBody);
+    _body = _becomeParentOf(functionBody);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(externalKeyword)
       ..add(modifierKeyword)
       ..add(_returnType)
       ..add(propertyKeyword)
       ..add(operatorKeyword)
       ..add(_name)
@@ skipping 62 matching lines @@
 
   /**
    * Return the name of the method.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the method to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   /**
    * Return the parameters associated with the method, or `null` if this method
    * declares a getter.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters associated with the method to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
-    _parameters = becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters);
   }
 
   /**
    * Return the return type of the method, or `null` if no return type was
    * declared.
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the return type of the method to the given [typeName].
    */
   void set returnType(TypeName typeName) {
-    _returnType = becomeParentOf(typeName);
+    _returnType = _becomeParentOf(typeName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(_name, visitor);
@@ skipping 33 matching lines @@
    * The list of arguments to the method.
    */
   ArgumentList _argumentList;
 
   /**
    * Initialize a newly created method invocation. The [target] and [period] can
    * be `null` if there is no target.
    */
   MethodInvocation(Expression target, this.period, SimpleIdentifier methodName,
       ArgumentList argumentList) {
-    _target = becomeParentOf(target);
-    _methodName = becomeParentOf(methodName);
-    _argumentList = becomeParentOf(argumentList);
+    _target = _becomeParentOf(target);
+    _methodName = _becomeParentOf(methodName);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the method.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     } else if (period != null) {
       return period;
     }
     return _methodName.beginToken;
@@ skipping 19 matching lines @@
 
   /**
    * Return the name of the method being invoked.
    */
   SimpleIdentifier get methodName => _methodName;
 
   /**
    * Set the name of the method being invoked to the given [identifier].
    */
   void set methodName(SimpleIdentifier identifier) {
-    _methodName = becomeParentOf(identifier);
+    _methodName = _becomeParentOf(identifier);
   }
 
   @override
   int get precedence => 15;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If
    * this invocation is not part of a cascade expression, then this is the same
    * as [target]. If this invocation is part of a cascade expression, then the
    * target stored with the cascade expression is returned.
@@ skipping 20 matching lines @@
    * Use [realTarget] to get the target independent of whether this is part of a
    * cascade expression.
    */
   Expression get target => _target;
 
   /**
    * Set the expression producing the object on which the method is defined to
    * the given [expression].
    */
   void set target(Expression expression) {
-    _target = becomeParentOf(expression);
+    _target = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMethodInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_methodName, visitor);
     _safelyVisitChild(_argumentList, visitor);
@@ skipping 15 matching lines @@
 
   /**
    * The expression with which the name is associated.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created named expression..
    */
   NamedExpression(Label name, Expression expression) {
-    _name = becomeParentOf(name);
-    _expression = becomeParentOf(expression);
+    _name = _becomeParentOf(name);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_name)
       ..add(_expression);
 
@@ skipping 16 matching lines @@
   /**
    * Return the expression with which the name is associated.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression with which the name is associated to the given
    * [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   /**
    * Return the name associated with the expression.
    */
   Label get name => _name;
 
   /**
    * Set the name associated with the expression to the given [identifier].
    */
   void set name(Label identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   @override
   int get precedence => 0;
 
   @override
   accept(AstVisitor visitor) => visitor.visitNamedExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 55 matching lines @@
 /**
  * The "native" clause in an class declaration.
  *
  * > nativeClause ::=
  * >     'native' [StringLiteral]
  */
 class NativeClause extends AstNode {
   /**
    * The token representing the 'native' keyword.
    */
-  Token keyword;
+  Token nativeKeyword;
 
   /**
    * The name of the native object that implements the class.
    */
   StringLiteral _name;
 
   /**
    * Initialize a newly created native clause.
    */
-  NativeClause(this.keyword, StringLiteral name) {
-    _name = becomeParentOf(name);
+  NativeClause(this.nativeKeyword, StringLiteral name) {
+    _name = _becomeParentOf(name);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => nativeKeyword;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(nativeKeyword)
       ..add(_name);
 
   @override
   Token get endToken => _name.endToken;
 
   /**
+   * Get the token representing the 'native' keyword.
+   */
+  @deprecated // Use "this.nativeKeyword"
+  Token get keyword => nativeKeyword;
+
+  /**
+   * Set the token representing the 'native' keyword to the given [token].
+   */
+  @deprecated // Use "this.nativeKeyword"
+  set keyword(Token token) {
+    nativeKeyword = token;
+  }
+
+  /**
    * 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 to the given
    * [name].
    */
   void set name(StringLiteral name) {
-    _name = becomeParentOf(name);
+    _name = _becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * A function body that consists of a native keyword followed by a string
  * literal.
  *
  * > nativeFunctionBody ::=
  * >     'native' [SimpleStringLiteral] ';'
  */
 class NativeFunctionBody extends FunctionBody {
   /**
    * The token representing 'native' that marks the start of the function body.
    */
-  Token nativeToken;
+  Token nativeKeyword;
 
   /**
    * The string literal, after the 'native' token.
    */
   StringLiteral _stringLiteral;
 
   /**
    * The token representing the semicolon that marks the end of the function
    * body.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of the 'native' token,
    * a string literal, and a semicolon.
    */
-  NativeFunctionBody(this.nativeToken, StringLiteral stringLiteral,
+  NativeFunctionBody(this.nativeKeyword, StringLiteral stringLiteral,
       this.semicolon) {
-    _stringLiteral = becomeParentOf(stringLiteral);
+    _stringLiteral = _becomeParentOf(stringLiteral);
   }
 
   @override
-  Token get beginToken => nativeToken;
+  Token get beginToken => nativeKeyword;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(nativeToken)
+      ..add(nativeKeyword)
       ..add(_stringLiteral)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
+   * Return the token representing 'native' that marks the start of the function
+   * body.
+   */
+  @deprecated // Use "this.nativeKeyword"
+  Token get nativeToken => nativeKeyword;
+
+  /**
+   * Set the token representing 'native' that marks the start of the function
+   * body to the given [token].
+   */
+  @deprecated // Use "this.nativeKeyword"
+  set nativeToken(Token token) {
+    nativeKeyword = 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 [stringLiteral].
    */
   void set stringLiteral(StringLiteral stringLiteral) {
-    _stringLiteral = becomeParentOf(stringLiteral);
+    _stringLiteral = _becomeParentOf(stringLiteral);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeFunctionBody(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_stringLiteral, visitor);
   }
 }
@@ skipping 39 matching lines @@
   Token get endToken {
     int length = _elements.length;
     if (length == 0) {
       return null;
     }
     return _elements[length - 1].endToken;
   }
 
   int get length => _elements.length;
 
-  @deprecated
+  @deprecated // Never intended for public use.
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 
   E operator [](int index) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
     return _elements[index];
   }
 
   void operator []=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
-    owner.becomeParentOf(node);
+    owner._becomeParentOf(node);
     _elements[index] = node;
   }
 
   /**
    * Use the given [visitor] to visit each of the nodes in this list.
    */
   accept(AstVisitor visitor) {
     int length = _elements.length;
     for (var i = 0; i < length; i++) {
       _elements[i].accept(visitor);
     }
   }
 
   @override
   void add(E node) {
     insert(length, node);
   }
 
   @override
   bool addAll(Iterable<E> nodes) {
     if (nodes != null && !nodes.isEmpty) {
       _elements.addAll(nodes);
       for (E node in nodes) {
-        owner.becomeParentOf(node);
+        owner._becomeParentOf(node);
       }
       return true;
     }
     return false;
   }
 
   @override
   void clear() {
     _elements = <E>[];
   }
 
   @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);
+    owner._becomeParentOf(node);
     if (length == 0) {
       _elements.add(node);
     } else {
       _elements.insert(index, node);
     }
   }
 
   @override
   E removeAt(int index) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
     E removedNode = _elements[index];
     _elements.removeAt(index);
     return removedNode;
   }
 
   /**
    * Create an empty list with the given [owner].
-   *
-   * Use "new NodeList<E>(owner)"
    */
-  @deprecated
+  @deprecated // Use "new NodeList<E>(owner)"
   static NodeList create(AstNode owner) => new NodeList(owner);
 }
 
 /**
  * An object used to locate the [AstNode] associated with a source range, given
  * the AST structure built from the source. More specifically, they will return
  * the [AstNode] with the shortest length whose source range completely
  * encompasses the specified range.
  */
 class NodeLocator extends UnifyingAstVisitor<Object> {
@@ skipping 1280 matching lines @@
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute.
    */
   NormalFormalParameter(Comment comment, List<Annotation> metadata,
       SimpleIdentifier identifier) {
-    _comment = becomeParentOf(comment);
+    _comment = _becomeParentOf(comment);
     _metadata = new NodeList<Annotation>(this, metadata);
-    _identifier = becomeParentOf(identifier);
+    _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.
    */
   Comment get documentationComment => _comment;
 
   /**
    * Set the documentation comment associated with this parameter to the given
    * [comment].
    */
   void set documentationComment(Comment comment) {
-    _comment = becomeParentOf(comment);
+    _comment = _becomeParentOf(comment);
   }
 
   @override
   SimpleIdentifier get identifier => _identifier;
 
   /**
    * Set the name of the parameter being declared to the given [identifier].
    */
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier);
   }
 
   @override
   ParameterKind get kind {
     AstNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
       return parent.kind;
     }
     return ParameterKind.REQUIRED;
   }
@@ skipping 75 matching lines @@
   Token literal;
 
   /**
    * Initialize a newly created null literal.
    */
   NullLiteral(this.literal);
 
   @override
   Token get beginToken => literal;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(literal);
 
   @override
   Token get endToken => literal;
 
   @override
   accept(AstVisitor visitor) => visitor.visitNullLiteral(this);
 
   @override
@@ skipping 22 matching lines @@
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * Initialize a newly created parenthesized expression.
    */
   ParenthesizedExpression(this.leftParenthesis, Expression expression,
       this.rightParenthesis) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => leftParenthesis;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(leftParenthesis)
       ..add(_expression)
       ..add(rightParenthesis);
 
   @override
   Token get endToken => rightParenthesis;
 
   /**
    * Return the expression within the parentheses.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression within the parentheses to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 15;
 
   @override
   accept(AstVisitor visitor) => visitor.visitParenthesizedExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A part directive.
  *
  * > partDirective ::=
  * >     [Annotation] 'part' [StringLiteral] ';'
  */
 class PartDirective extends UriBasedDirective {
   /**
-   * The token representing the 'part' token.
+   * The token representing the 'part' keyword.
    */
-  Token partToken;
+  Token partKeyword;
 
   /**
    * The semicolon terminating the directive.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created part directive. Either or both of the [comment]
    * and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
-  PartDirective(Comment comment, List<Annotation> metadata, this.partToken,
+  PartDirective(Comment comment, List<Annotation> metadata, this.partKeyword,
       StringLiteral partUri, this.semicolon)
       : super(comment, metadata, partUri);
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => super._childEntities
-      ..add(partToken)
+      ..add(partKeyword)
       ..add(_uri)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
-  Token get firstTokenAfterCommentAndMetadata => partToken;
+  Token get firstTokenAfterCommentAndMetadata => partKeyword;
 
   @override
-  Token get keyword => partToken;
+  Token get keyword => partKeyword;
+
+  /**
+   * Return the token representing the 'part' token.
+   */
+  @deprecated // Use "this.partKeyword"
+  Token get partToken => partKeyword;
+
+  /**
+   * Set the token representing the 'part' token to the given [token].
+   */
+  @deprecated // Use "this.partKeyword"
+  set partToken(Token token) {
+    partKeyword = token;
+  }
 
   @override
   CompilationUnitElement get uriElement => element as CompilationUnitElement;
 
   @override
   accept(AstVisitor visitor) => visitor.visitPartDirective(this);
 }
 
 /**
  * A part-of directive.
  *
  * > partOfDirective ::=
  * >     [Annotation] 'part' 'of' [Identifier] ';'
  */
 class PartOfDirective extends Directive {
   /**
-   * The token representing the 'part' token.
+   * The token representing the 'part' keyword.
    */
-  Token partToken;
+  Token partKeyword;
 
   /**
-   * The token representing the 'of' token.
+   * The token representing the 'of' keyword.
    */
-  Token ofToken;
+  Token ofKeyword;
 
   /**
    * The name of the library that the containing compilation unit is part of.
    */
   LibraryIdentifier _libraryName;
 
   /**
    * The semicolon terminating the directive.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created part-of directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
-  PartOfDirective(Comment comment, List<Annotation> metadata, this.partToken,
-      this.ofToken, LibraryIdentifier libraryName, this.semicolon)
+  PartOfDirective(Comment comment, List<Annotation> metadata, this.partKeyword,
+      this.ofKeyword, LibraryIdentifier libraryName, this.semicolon)
       : super(comment, metadata) {
-    _libraryName = becomeParentOf(libraryName);
+    _libraryName = _becomeParentOf(libraryName);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(partToken)
-      ..add(ofToken)
+      ..add(partKeyword)
+      ..add(ofKeyword)
       ..add(_libraryName)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
-  Token get firstTokenAfterCommentAndMetadata => partToken;
+  Token get firstTokenAfterCommentAndMetadata => partKeyword;
 
   @override
-  Token get keyword => partToken;
+  Token get keyword => partKeyword;
 
   /**
    * 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 [libraryName].
    */
   void set libraryName(LibraryIdentifier libraryName) {
-    _libraryName = becomeParentOf(libraryName);
+    _libraryName = _becomeParentOf(libraryName);
+  }
+
+  /**
+   * Return the token representing the 'of' token.
+   */
+  @deprecated // Use "this.ofKeyword"
+  Token get ofToken => ofKeyword;
+
+  /**
+   * Set the token representing the 'of' token to the given [token].
+   */
+  @deprecated // Use "this.ofKeyword"
+  set ofToken(Token token) {
+    ofKeyword = token;
+  }
+
+  /**
+   * Return the token representing the 'part' token.
+   */
+  @deprecated // Use "this.partKeyword"
+  Token get partToken => partKeyword;
+
+  /**
+   * Set the token representing the 'part' token to the given [token].
+   */
+  @deprecated // Use "this.partKeyword"
+  set partToken(Token token) {
+    partKeyword = token;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPartOfDirective(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_libraryName, visitor);
   }
@@ skipping 28 matching lines @@
    * 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;
 
   /**
    * Initialize a newly created postfix expression.
    */
   PostfixExpression(Expression operand, this.operator) {
-    _operand = becomeParentOf(operand);
+    _operand = _becomeParentOf(operand);
   }
 
   @override
   Token get beginToken => _operand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_operand)
       ..add(operator);
 
   @override
   Token get endToken => operator;
 
   /**
    * Return the expression computing the operand for the operator.
    */
   Expression get operand => _operand;
 
   /**
    * Set the expression computing the operand for the operator to the given
    * [expression].
    */
   void set operand(Expression expression) {
-    _operand = becomeParentOf(expression);
+    _operand = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 15;
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get propagatedParameterElementForOperand {
+    return _propagatedParameterElementForOperand;
+  }
+
+  /**
+   * 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`.
+   */
+  @deprecated // Use "expression.propagatedParameterElement"
+  ParameterElement get staticParameterElementForOperand {
+    return _staticParameterElementForOperand;
+  }
+
+  /**
+   * 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`.
+   */
+  ParameterElement get _propagatedParameterElementForOperand {
     if (propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is
    * known based on static type information, then return the parameter element
    * representing the parameter to which the value of the operand will be bound.
    * Otherwise, return `null`.
-   *
-   * This method is only intended to be used by
-   * [Expression.staticParameterElement].
    */
-  ParameterElement get staticParameterElementForOperand {
+  ParameterElement get _staticParameterElementForOperand {
     if (staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
@@ skipping 27 matching lines @@
   /**
    * The identifier being prefixed.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created prefixed identifier.
    */
   PrefixedIdentifier(SimpleIdentifier prefix, this.period,
       SimpleIdentifier identifier) {
-    _prefix = becomeParentOf(prefix);
-    _identifier = becomeParentOf(identifier);
+    _prefix = _becomeParentOf(prefix);
+    _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Token get beginToken => _prefix.beginToken;
 
   @override
   Element get bestElement {
     if (_identifier == null) {
       return null;
     }
@@ skipping 11 matching lines @@
 
   /**
    * Return the identifier being prefixed.
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
    * Set the identifier being prefixed to the given [identifier].
    */
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier);
   }
 
   /**
    * Return `true` if this type is a deferred type. If the AST structure has not
    * been resolved, then return `false`.
    *
    * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
    * </i>p.T</i> where <i>p</i> is a deferred prefix.
    */
   bool get isDeferred {
@@ skipping 20 matching lines @@
    * Return the prefix associated with the library in which the identifier is
    * defined.
    */
   SimpleIdentifier get prefix => _prefix;
 
   /**
    * Set the prefix associated with the library in which the identifier is
    * defined to the given [identifier].
    */
   void set prefix(SimpleIdentifier identifier) {
-    _prefix = becomeParentOf(identifier);
+    _prefix = _becomeParentOf(identifier);
   }
 
   @override
   Element get propagatedElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.propagatedElement;
   }
 
@@ skipping 43 matching lines @@
    * 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;
 
   /**
    * Initialize a newly created prefix expression.
    */
   PrefixExpression(this.operator, Expression operand) {
-    _operand = becomeParentOf(operand);
+    _operand = _becomeParentOf(operand);
   }
 
   @override
   Token get beginToken => operator;
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
@@ skipping 18 matching lines @@
   /**
    * Return the expression computing the operand for the operator.
    */
   Expression get operand => _operand;
 
   /**
    * Set the expression computing the operand for the operator to the given
    * [expression].
    */
   void set operand(Expression expression) {
-    _operand = becomeParentOf(expression);
+    _operand = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 14;
 
   /**
    * 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].
    */
+  @deprecated // Use "expression.propagatedParameterElement"
   ParameterElement get propagatedParameterElementForOperand {
+    return _propagatedParameterElementForOperand;
+  }
+
+  /**
+   * 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`.
+   */
+  @deprecated // Use "expression.propagatedParameterElement"
+  ParameterElement get staticParameterElementForOperand {
+    return _staticParameterElementForOperand;
+  }
+
+  /**
+   * 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`.
+   */
+  ParameterElement get _propagatedParameterElementForOperand {
     if (propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is
    * known based on static type information, then return the parameter element
    * representing the parameter to which the value of the operand will be bound.
    * Otherwise, return `null`.
-   *
-   * This method is only intended to be used by
-   * [Expression.staticParameterElement].
    */
-  ParameterElement get staticParameterElementForOperand {
+  ParameterElement get _staticParameterElementForOperand {
     if (staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
@@ skipping 30 matching lines @@
   /**
    * The name of the property being accessed.
    */
   SimpleIdentifier _propertyName;
 
   /**
    * Initialize a newly created property access expression.
    */
   PropertyAccess(Expression target, this.operator,
       SimpleIdentifier propertyName) {
-    _target = becomeParentOf(target);
-    _propertyName = becomeParentOf(propertyName);
+    _target = _becomeParentOf(target);
+    _propertyName = _becomeParentOf(propertyName);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
   }
 
@@ skipping 22 matching lines @@
 
   /**
    * Return the name of the property being accessed.
    */
   SimpleIdentifier get propertyName => _propertyName;
 
   /**
    * Set the name of the property being accessed to the given [identifier].
    */
   void set propertyName(SimpleIdentifier identifier) {
-    _propertyName = becomeParentOf(identifier);
+    _propertyName = _becomeParentOf(identifier);
   }
 
   /**
    * Return the expression used to compute the receiver of the invocation. If
    * this invocation is not part of a cascade expression, then this is the same
    * as [target]. If this invocation is part of a cascade expression, then the
    * target stored with the cascade expression is returned.
    */
   Expression get realTarget {
     if (isCascaded) {
@@ skipping 16 matching lines @@
    * Use [realTarget] to get the target independent of whether this is part of a
    * cascade expression.
    */
   Expression get target => _target;
 
   /**
    * Set the expression computing the object defining the property being
    * accessed to the given [expression].
    */
   void set target(Expression expression) {
-    _target = becomeParentOf(expression);
+    _target = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPropertyAccess(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_propertyName, visitor);
   }
@@ skipping 652 matching lines @@
  * The invocation of a constructor in the same class from within a constructor's
  * initialization list.
  *
  * > redirectingConstructorInvocation ::=
  * >     'this' ('.' identifier)? arguments
  */
 class RedirectingConstructorInvocation extends ConstructorInitializer {
   /**
    * The token for the 'this' keyword.
    */
-  Token keyword;
+  Token thisKeyword;
 
   /**
    * The token for the period before the name of the constructor that is being
    * invoked, or `null` if the unnamed constructor is being invoked.
    */
   Token period;
 
   /**
    * The name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
@@ skipping 10 matching lines @@
    * information, or `null` if the AST structure has not been resolved or if the
    * constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor
    * with the given name with the given arguments. The [constructorName] can be
    * `null` if the constructor being invoked is the unnamed constructor.
    */
-  RedirectingConstructorInvocation(this.keyword, this.period,
+  RedirectingConstructorInvocation(this.thisKeyword, this.period,
       SimpleIdentifier constructorName, ArgumentList argumentList) {
-    _constructorName = becomeParentOf(constructorName);
-    _argumentList = becomeParentOf(argumentList);
+    _constructorName = _becomeParentOf(constructorName);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the constructor.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the constructor to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => thisKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(thisKeyword)
       ..add(period)
       ..add(_constructorName)
       ..add(_argumentList);
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the
    * unnamed constructor is being invoked.
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor that is being invoked to the given
    * [identifier].
    */
   void set constructorName(SimpleIdentifier identifier) {
-    _constructorName = becomeParentOf(identifier);
+    _constructorName = _becomeParentOf(identifier);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
+  /**
+   * Return the token for the 'this' keyword.
+   */
+  @deprecated // Use "this.thisKeyword"
+  Token get keyword => thisKeyword;
+
+  /**
+   * Set the token for the 'this' keyword to the given [token].
+   */
+  @deprecated // Use "this.thisKeyword"
+  set keyword(Token token) {
+    thisKeyword = token;
+  }
+
   @override
   accept(AstVisitor visitor) =>
       visitor.visitRedirectingConstructorInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A rethrow expression.
  *
  * > rethrowExpression ::=
  * >     'rethrow'
  */
 class RethrowExpression extends Expression {
   /**
    * The token representing the 'rethrow' keyword.
    */
-  Token keyword;
+  Token rethrowKeyword;
 
   /**
    * Initialize a newly created rethrow expression.
    */
-  RethrowExpression(this.keyword);
+  RethrowExpression(this.rethrowKeyword);
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => rethrowKeyword;
+
+  @override
+  Iterable get childEntities => new ChildEntities()..add(rethrowKeyword);
+
+  @override
+  Token get endToken => rethrowKeyword;
 
   /**
-   * TODO(paulberry): untested.
+   * Return the token representing the 'rethrow' keyword.
    */
-  @override
-  Iterable get childEntities => new ChildEntities()..add(keyword);
+  @deprecated // Use "this.rethrowKeyword"
+  Token get keyword => rethrowKeyword;
 
-  @override
-  Token get endToken => keyword;
+  /**
+   * Set the token representing the 'rethrow' keyword to the given [token].
+   */
+  @deprecated // Use "this.rethrowKeyword"
+  set keyword(Token token) {
+    rethrowKeyword = token;
+  }
 
   @override
   int get precedence => 0;
 
   @override
   accept(AstVisitor visitor) => visitor.visitRethrowExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A return statement.
  *
  * > returnStatement ::=
  * >     'return' [Expression]? ';'
  */
 class ReturnStatement extends Statement {
   /**
    * The token representing the 'return' keyword.
    */
-  Token keyword;
+  Token returnKeyword;
 
   /**
    * The expression computing the value to be returned, or `null` if no explicit
    * value was provided.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created return statement. The [expression] can be `null`
    * if no explicit value was provided.
    */
-  ReturnStatement(this.keyword, Expression expression, this.semicolon) {
-    _expression = becomeParentOf(expression);
+  ReturnStatement(this.returnKeyword, Expression expression, this.semicolon) {
+    _expression = _becomeParentOf(expression);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => returnKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(returnKeyword)
       ..add(_expression)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the expression computing the value to be returned, or `null` if no
    * explicit value was provided.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression computing the value to be returned to the given
    * [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
+  }
+
+  /**
+   * Return the token representing the 'return' keyword.
+   */
+  @deprecated // Use "this.returnKeyword"
+  Token get keyword => returnKeyword;
+
+  /**
+   * Set the token representing the 'return' keyword to the given [token].
+   */
+  @deprecated // Use "this.returnKeyword"
+  set keyword(Token token) {
+    returnKeyword = token;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitReturnStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
@@ skipping 196 matching lines @@
   Token scriptTag;
 
   /**
    * Initialize a newly created script tag.
    */
   ScriptTag(this.scriptTag);
 
   @override
   Token get beginToken => scriptTag;
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(scriptTag);
 
   @override
   Token get endToken => scriptTag;
 
   @override
   accept(AstVisitor visitor) => visitor.visitScriptTag(this);
 
   @override
@@ skipping 401 matching lines @@
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
   SimpleFormalParameter(Comment comment, List<Annotation> metadata,
       this.keyword, TypeName type, SimpleIdentifier identifier)
       : super(comment, metadata, identifier) {
-    _type = becomeParentOf(type);
+    _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken {
     NodeList<Annotation> metadata = this.metadata;
     if (!metadata.isEmpty) {
       return metadata.beginToken;
     } else if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return identifier.beginToken;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => super._childEntities
       ..add(keyword)
       ..add(_type)
       ..add(identifier);
 
   @override
   Token get endToken => identifier.endToken;
 
   @override
   bool get isConst =>
       (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.CONST;
 
   @override
   bool get isFinal =>
       (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the
    * parameter does not have a declared type.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
   void set type(TypeName typeName) {
-    _type = becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(identifier, visitor);
@@ skipping 47 matching lines @@
   Token get beginToken => token;
 
   @override
   Element get bestElement {
     if (_propagatedElement == null) {
       return _staticElement;
     }
     return _propagatedElement;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()..add(token);
 
   @override
   Token get endToken => token;
 
   /**
    * Returns `true` if this identifier is the "name" part of a prefixed
    * identifier or a method invocation.
    */
@@ skipping 45 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleIdentifier(this);
 
   /**
    * Return `true` if this identifier is the name being declared in a
    * declaration.
    */
   bool inDeclarationContext() {
+    // TODO(brianwilkerson) Convert this to a getter.
     AstNode parent = this.parent;
     if (parent is CatchClause) {
       CatchClause clause = parent;
       return identical(this, clause.exceptionParameter) ||
           identical(this, clause.stackTraceParameter);
     } else if (parent is ClassDeclaration) {
       return identical(this, parent.name);
     } else if (parent is ClassTypeAlias) {
       return identical(this, parent.name);
     } else if (parent is ConstructorDeclaration) {
@@ skipping 27 matching lines @@
   }
 
   /**
    * Return `true` if this expression is computing a right-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
    * are they mutually exclusive. In other words, it is possible for both
    * methods to return `true` when invoked on the same node.
    */
   bool inGetterContext() {
+    // TODO(brianwilkerson) Convert this to a getter.
     AstNode parent = this.parent;
     AstNode target = this;
     // skip prefix
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return true;
       }
       parent = prefixed.parent;
       target = prefixed;
@@ skipping 27 matching lines @@
   }
 
   /**
    * Return `true` if this expression is computing a left-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor
    * are they mutually exclusive. In other words, it is possible for both
    * methods to return `true` when invoked on the same node.
    */
   bool inSetterContext() {
+    // TODO(brianwilkerson) Convert this to a getter.
     AstNode parent = this.parent;
     AstNode target = this;
     // skip prefix
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       // if this is the prefix, then return false
       if (identical(prefixed.prefix, this)) {
         return false;
       }
       parent = prefixed.parent;
@@ skipping 128 matching lines @@
   Token literal;
 
   /**
    * The value of the literal.
    */
   String _value;
 
   /**
    * The toolkit specific element associated with this literal, or `null`.
    */
+  @deprecated // No replacement
   Element toolkitElement;
 
   /**
    * Initialize a newly created simple string literal.
    */
   SimpleStringLiteral(this.literal, String value) {
     _value = StringUtilities.intern(value);
   }
 
   @override
@@ skipping 68 matching lines @@
    * Set the value of the literal to the given [string].
    */
   void set value(String string) {
     _value = StringUtilities.intern(_value);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleStringLiteral(this);
 
   @override
-  void appendStringValue(StringBuffer buffer) {
-    buffer.write(value);
-  }
-
-  @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
+
+  @override
+  void _appendStringValue(StringBuffer buffer) {
+    buffer.write(value);
+  }
 }
 
 /**
  * A single string literal expression.
  *
  * > singleStringLiteral ::=
  * >     [SimpleStringLiteral]
  * >   | [StringInterpolation]
  */
 abstract class SingleStringLiteral extends StringLiteral {
@@ skipping 115 matching lines @@
   bool get isSingleQuoted {
     InterpolationString lastString = _elements.first;
     String lexeme = lastString.contents.lexeme;
     return StringUtilities.startsWithChar(lexeme, 0x27);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitStringInterpolation(this);
 
   @override
-  void appendStringValue(StringBuffer buffer) {
-    throw new IllegalArgumentException();
-  }
-
-  @override
   void visitChildren(AstVisitor visitor) {
     _elements.accept(visitor);
   }
+
+  @override
+  void _appendStringValue(StringBuffer buffer) {
+    throw new IllegalArgumentException();
+  }
 }
 
 /**
  * A string literal expression.
  *
  * > stringLiteral ::=
  * >     [SimpleStringLiteral]
  * >   | [AdjacentStrings]
  * >   | [StringInterpolation]
  */
 abstract class StringLiteral extends Literal {
   /**
    * Return the value of the string literal, or `null` if the string is not a
    * constant string without any string interpolation.
    */
   String get stringValue {
     StringBuffer buffer = new StringBuffer();
     try {
-      appendStringValue(buffer);
+      _appendStringValue(buffer);
     } on IllegalArgumentException catch (exception) {
       return null;
     }
     return buffer.toString();
   }
 
   /**
    * Append the value of this string literal to the given [buffer]. Throw an
    * [IllegalArgumentException] if the string is not a constant string without
    * any string interpolation.
    */
-  void appendStringValue(StringBuffer buffer);
+  @deprecated // Use "this.stringValue"
+  void appendStringValue(StringBuffer buffer) => _appendStringValue(buffer);
+
+  /**
+   * Append the value of this string literal to the given [buffer]. Throw an
+   * [IllegalArgumentException] if the string is not a constant string without
+   * any string interpolation.
+   */
+  void _appendStringValue(StringBuffer buffer);
 }
 
 /**
  * The invocation of a superclass' constructor from within a constructor's
  * initialization list.
  *
  * > superInvocation ::=
  * >     'super' ('.' [SimpleIdentifier])? [ArgumentList]
  */
 class SuperConstructorInvocation extends ConstructorInitializer {
   /**
    * The token for the 'super' keyword.
    */
-  Token keyword;
+  Token superKeyword;
 
   /**
    * The token for the period before the name of the constructor that is being
    * invoked, or `null` if the unnamed constructor is being invoked.
    */
   Token period;
 
   /**
    * The name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
@@ skipping 11 matching lines @@
    * constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created super invocation to invoke the inherited
    * constructor with the given name with the given arguments. The [period] and
    * [constructorName] can be `null` if the constructor being invoked is the
    * unnamed constructor.
    */
-  SuperConstructorInvocation(this.keyword, this.period,
+  SuperConstructorInvocation(this.superKeyword, this.period,
       SimpleIdentifier constructorName, ArgumentList argumentList) {
-    _constructorName = becomeParentOf(constructorName);
-    _argumentList = becomeParentOf(argumentList);
+    _constructorName = _becomeParentOf(constructorName);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the constructor.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the constructor to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => superKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(superKeyword)
       ..add(period)
       ..add(_constructorName)
       ..add(_argumentList);
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the
    * unnamed constructor is being invoked.
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor that is being invoked to the given
    * [identifier].
    */
   void set constructorName(SimpleIdentifier identifier) {
-    _constructorName = becomeParentOf(identifier);
+    _constructorName = _becomeParentOf(identifier);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
+  /**
+   * Return the token for the 'super' keyword.
+   */
+  @deprecated // Use "this.superKeyword"
+  Token get keyword => superKeyword;
+
+  /**
+   * Set the token for the 'super' keyword to the given [token].
+   */
+  @deprecated // Use "this.superKeyword"
+  set keyword(Token token) {
+    superKeyword = token;
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A super expression.
  *
  * > superExpression ::=
  * >     'super'
  */
 class SuperExpression extends Expression {
   /**
-   * The token representing the keyword.
+   * The token representing the 'super' keyword.
    */
-  Token keyword;
+  Token superKeyword;
 
   /**
    * Initialize a newly created super expression.
    */
-  SuperExpression(this.keyword);
+  SuperExpression(this.superKeyword);
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => superKeyword;
+
+  @override
+  Iterable get childEntities => new ChildEntities()..add(superKeyword);
+
+  @override
+  Token get endToken => superKeyword;
 
   /**
-   * TODO(paulberry): untested.
+   * Return the token for the 'super' keyword.
    */
-  @override
-  Iterable get childEntities => new ChildEntities()..add(keyword);
+  @deprecated // Use "this.superKeyword"
+  Token get keyword => superKeyword;
 
-  @override
-  Token get endToken => keyword;
+  /**
+   * Set the token for the 'super' keyword to the given [token].
+   */
+  @deprecated // Use "this.superKeyword"
+  set keyword(Token token) {
+    superKeyword = token;
+  }
 
   @override
   int get precedence => 16;
 
   @override
   accept(AstVisitor visitor) => visitor.visitSuperExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
@@ skipping 12 matching lines @@
    */
   Expression _expression;
 
   /**
    * Initialize a newly created switch case. The list of [labels] can be `null`
    * if there are no labels.
    */
   SwitchCase(List<Label> labels, Token keyword, Expression expression,
       Token colon, List<Statement> statements)
       : super(labels, keyword, colon, statements) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..addAll(labels)
       ..add(keyword)
       ..add(_expression)
       ..add(colon)
       ..addAll(statements);
 
   /**
    * 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].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSwitchCase(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     _safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * The default case in a switch statement.
  *
  * > switchDefault ::=
  * >     [SimpleIdentifier]* 'default' ':' [Statement]*
  */
 class SwitchDefault extends SwitchMember {
   /**
    * Initialize a newly created switch default. The list of [labels] can be
    * `null` if there are no labels.
    */
   SwitchDefault(List<Label> labels, Token keyword, Token colon,
       List<Statement> statements)
       : super(labels, keyword, colon, statements);
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..addAll(labels)
       ..add(keyword)
       ..add(colon)
       ..addAll(statements);
 
   @override
   accept(AstVisitor visitor) => visitor.visitSwitchDefault(this);
 
@@ skipping 73 matching lines @@
 /**
  * A switch statement.
  *
  * > switchStatement ::=
  * >     'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
  */
 class SwitchStatement extends Statement {
   /**
    * The token representing the 'switch' keyword.
    */
-  Token keyword;
+  Token switchKeyword;
 
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The expression used to determine which of the switch members will be
    * selected.
    */
@@ skipping 16 matching lines @@
 
   /**
    * The right curly bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created switch statement. The list of [members] can be
    * `null` if there are no switch members.
    */
-  SwitchStatement(this.keyword, this.leftParenthesis, Expression expression,
+  SwitchStatement(this.switchKeyword, this.leftParenthesis, Expression expression,
       this.rightParenthesis, this.leftBracket, List<SwitchMember> members,
       this.rightBracket) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
     _members = new NodeList<SwitchMember>(this, members);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => switchKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(switchKeyword)
       ..add(leftParenthesis)
       ..add(_expression)
       ..add(rightParenthesis)
       ..add(leftBracket)
       ..addAll(_members)
       ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to determine which of the switch members will be
    * selected.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression used to determine which of the switch members will be
    * selected to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   /**
+   * Return the token representing the 'switch' keyword.
+   */
+  @deprecated // Use "this.switchKeyword"
+  Token get keyword => switchKeyword;
+
+  /**
+   * Set the token representing the 'switch' keyword to the given [token].
+   */
+  @deprecated // Use "this.switchKeyword"
+  set keyword(Token token) {
+    switchKeyword = token;
+  }
+
+  /**
    * Return the switch members that can be selected by the expression.
    */
   NodeList<SwitchMember> get members => _members;
 
   @override
   accept(AstVisitor visitor) => visitor.visitSwitchStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
@@ skipping 20 matching lines @@
 
   /**
    * Initialize a newly created symbol literal.
    */
   SymbolLiteral(this.poundSign, this.components);
 
   @override
   Token get beginToken => poundSign;
 
   /**
-   * TODO(paulberry): untested.
    * TODO(paulberry): add "." tokens.
    */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(poundSign)
       ..addAll(components);
 
   @override
   Token get endToken => components[components.length - 1];
 
   @override
   accept(AstVisitor visitor) => visitor.visitSymbolLiteral(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A this expression.
  *
  * > thisExpression ::=
  * >     'this'
  */
 class ThisExpression extends Expression {
   /**
-   * The token representing the keyword.
+   * The token representing the 'this' keyword.
    */
-  Token keyword;
+  Token thisKeyword;
 
   /**
    * Initialize a newly created this expression.
    */
-  ThisExpression(this.keyword);
+  ThisExpression(this.thisKeyword);
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => thisKeyword;
+
+  @override
+  Iterable get childEntities => new ChildEntities()..add(thisKeyword);
+
+  @override
+  Token get endToken => thisKeyword;
 
   /**
-   * TODO(paulberry): untested.
+   * Return the token representing the 'this' keyword.
    */
-  @override
-  Iterable get childEntities => new ChildEntities()..add(keyword);
+  @deprecated // Use "this.thisKeyword"
+  Token get keyword => thisKeyword;
 
-  @override
-  Token get endToken => keyword;
+  /**
+   * Set the token representing the 'this' keyword to the given [token].
+   */
+  @deprecated // Use "this.thisKeyword"
+  set keyword(Token token) {
+    thisKeyword = token;
+  }
 
   @override
   int get precedence => 16;
 
   @override
   accept(AstVisitor visitor) => visitor.visitThisExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A throw expression.
  *
  * > throwExpression ::=
  * >     'throw' [Expression]
  */
 class ThrowExpression extends Expression {
   /**
    * The token representing the 'throw' keyword.
    */
-  Token keyword;
+  Token throwKeyword;
 
   /**
    * The expression computing the exception to be thrown.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created throw expression.
    */
-  ThrowExpression(this.keyword, Expression expression) {
-    _expression = becomeParentOf(expression);
+  ThrowExpression(this.throwKeyword, Expression expression) {
+    _expression = _becomeParentOf(expression);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => throwKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(throwKeyword)
       ..add(_expression);
 
   @override
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
-    return keyword;
+    return throwKeyword;
   }
 
   /**
    * Return the expression computing the exception to be thrown.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression computing the exception to be thrown to the given
    * [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
+  }
+
+  /**
+   * Return the token representing the 'throw' keyword.
+   */
+  @deprecated // Use "this.throwKeyword"
+  Token get keyword => throwKeyword;
+
+  /**
+   * Set the token representing the 'throw' keyword to the given [token].
+   */
+  @deprecated // Use "this.throwKeyword"
+  set keyword(Token token) {
+    throwKeyword = token;
   }
 
   @override
   int get precedence => 0;
 
   @override
   accept(AstVisitor visitor) => visitor.visitThrowExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 20 matching lines @@
   Token semicolon;
 
   /**
    * Initialize a newly created top-level variable declaration. Either or both
    * of the [comment] and [metadata] can be `null` if the variable does not have
    * the corresponding attribute.
    */
   TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata,
       VariableDeclarationList variableList, this.semicolon)
       : super(comment, metadata) {
-    _variableList = becomeParentOf(variableList);
+    _variableList = _becomeParentOf(variableList);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(_variableList)
       ..add(semicolon);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 
   /**
    * Return the top-level variables being declared.
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the top-level variables being declared to the given list of
    * [variables].
    */
   void set variables(VariableDeclarationList variables) {
-    _variableList = becomeParentOf(variables);
+    _variableList = _becomeParentOf(variables);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_variableList, visitor);
   }
@@ skipping 214 matching lines @@
     _visitNodeWithPrefix(".", node.name);
     _visitNode(node.parameters);
     _visitNodeListWithSeparatorAndPrefix(" : ", node.initializers, ", ");
     _visitNodeWithPrefix(" = ", node.redirectedConstructor);
     _visitFunctionWithPrefix(" ", node.body);
     return null;
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
-    _visitTokenWithSuffix(node.keyword, ".");
+    _visitTokenWithSuffix(node.thisKeyword, ".");
     _visitNode(node.fieldName);
     _writer.print(" = ");
     _visitNode(node.expression);
     return null;
   }
 
   @override
   Object visitConstructorName(ConstructorName node) {
     _visitNode(node.type);
     _visitNodeWithPrefix(".", node.name);
@@ skipping 271 matching lines @@
     _writer.print("implements ");
     _visitNodeListWithSeparator(node.interfaces, ", ");
     return null;
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _writer.print("import ");
     _visitNode(node.uri);
-    if (node.deferredToken != null) {
+    if (node.deferredKeyword != null) {
       _writer.print(" deferred");
     }
     _visitNodeWithPrefix(" as ", node.prefix);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
 
   @override
   Object visitIndexExpression(IndexExpression node) {
@@ skipping 618 matching lines @@
    */
   Block _finallyBlock;
 
   /**
    * Initialize a newly created try statement. The list of [catchClauses] can be
    * `null` if there are no catch clauses. The [finallyKeyword] and
    * [finallyBlock] can be `null` if there is no finally clause.
    */
   TryStatement(this.tryKeyword, Block body, List<CatchClause> catchClauses,
       this.finallyKeyword, Block finallyBlock) {
-    _body = becomeParentOf(body);
+    _body = _becomeParentOf(body);
     _catchClauses = new NodeList<CatchClause>(this, catchClauses);
-    _finallyBlock = becomeParentOf(finallyBlock);
+    _finallyBlock = _becomeParentOf(finallyBlock);
   }
 
   @override
   Token get beginToken => tryKeyword;
 
   /**
    * Return the body of the statement.
    */
   Block get body => _body;
 
   /**
    * Set the body of the statement to the given [block].
    */
   void set body(Block block) {
-    _body = becomeParentOf(block);
+    _body = _becomeParentOf(block);
   }
 
   /**
    * Return the catch clauses contained in the try statement.
    */
   NodeList<CatchClause> get catchClauses => _catchClauses;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(tryKeyword)
@@ skipping 17 matching lines @@
   /**
    * Return the finally block contained in the try statement, or `null` if the
    * statement does not contain a finally clause.
    */
   Block get finallyBlock => _finallyBlock;
 
   /**
    * Set the finally block contained in the try statement to the given [block].
    */
   void set finallyBlock(Block block) {
-    _finallyBlock = becomeParentOf(block);
+    _finallyBlock = _becomeParentOf(block);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTryStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_body, visitor);
     _catchClauses.accept(visitor);
     _safelyVisitChild(_finallyBlock, visitor);
   }
 }
 
 /**
  * The declaration of a type alias.
  *
  * > typeAlias ::=
  * >     'typedef' typeAliasBody
  * >
  * > typeAliasBody ::=
  * >     classTypeAlias
  * >   | functionTypeAlias
  */
 abstract class TypeAlias extends CompilationUnitMember {
   /**
    * The token representing the 'typedef' keyword.
    */
-  Token keyword;
+  Token typedefKeyword;
 
   /**
    * The semicolon terminating the declaration.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created type alias. Either or both of the [comment] and
    * [metadata] can be `null` if the declaration does not have the corresponding
    * attribute.
    */
-  TypeAlias(Comment comment, List<Annotation> metadata, this.keyword,
+  TypeAlias(Comment comment, List<Annotation> metadata, this.typedefKeyword,
       this.semicolon)
       : super(comment, metadata);
 
   @override
   Token get endToken => semicolon;
 
   @override
-  Token get firstTokenAfterCommentAndMetadata => keyword;
+  Token get firstTokenAfterCommentAndMetadata => typedefKeyword;
+
+  /**
+   * Return the token representing the 'typedef' keyword.
+   */
+  @deprecated // Use "this.typedefKeyword"
+  Token get keyword => typedefKeyword;
+
+  /**
+   * Set the token representing the 'typedef' keyword to the given [token].
+   */
+  @deprecated // Use "this.typedefKeyword"
+  set keyword(Token token) {
+    typedefKeyword = token;
+  }
 }
 
 /**
  * A list of type arguments.
  *
  * > typeArguments ::=
  * >     '<' typeName (',' typeName)* '>'
  */
 class TypeArgumentList extends AstNode {
   /**
@@ skipping 67 matching lines @@
    * arguments were declared.
    */
   TypeArgumentList _typeArguments;
 
   /**
    * Initialize a newly created typed literal. The [constKeyword] can be `null`\
    * if the literal is not a constant. The [typeArguments] can be `null` if no
    * type arguments were declared.
    */
   TypedLiteral(this.constKeyword, TypeArgumentList typeArguments) {
-    _typeArguments = becomeParentOf(typeArguments);
+    _typeArguments = _becomeParentOf(typeArguments);
   }
 
   /**
    * Return the type argument associated with this literal, or `null` if no type
    * arguments were declared.
    */
   TypeArgumentList get typeArguments => _typeArguments;
 
   /**
    * Set the type argument associated with this literal to the given
    * [typeArguments].
    */
   void set typeArguments(TypeArgumentList typeArguments) {
-    _typeArguments = becomeParentOf(typeArguments);
+    _typeArguments = _becomeParentOf(typeArguments);
   }
 
   ChildEntities get _childEntities => new ChildEntities()
       ..add(constKeyword)
       ..add(_typeArguments);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_typeArguments, visitor);
   }
@@ skipping 20 matching lines @@
   /**
    * The type being named, or `null` if the AST structure has not been resolved.
    */
   DartType type;
 
   /**
    * Initialize a newly created type name. The [typeArguments] can be `null` if
    * there are no type arguments.
    */
   TypeName(Identifier name, TypeArgumentList typeArguments) {
-    _name = becomeParentOf(name);
-    _typeArguments = becomeParentOf(typeArguments);
+    _name = _becomeParentOf(name);
+    _typeArguments = _becomeParentOf(typeArguments);
   }
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_name)
       ..add(_typeArguments);
 
@@ skipping 24 matching lines @@
 
   /**
    * Return the name of the type.
    */
   Identifier get name => _name;
 
   /**
    * Set the name of the type to the given [identifier].
    */
   void set name(Identifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   /**
    * Return the type arguments associated with the type, or `null` if there are
    * no type arguments.
    */
   TypeArgumentList get typeArguments => _typeArguments;
 
   /**
    * Set the type arguments associated with the type to the given
    * [typeArguments].
    */
   void set typeArguments(TypeArgumentList typeArguments) {
-    _typeArguments = becomeParentOf(typeArguments);
+    _typeArguments = _becomeParentOf(typeArguments);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeName(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * A type parameter.
  *
  * > typeParameter ::=
  * >     [SimpleIdentifier] ('extends' [TypeName])?
  */
 class TypeParameter extends Declaration {
   /**
    * The name of the type parameter.
    */
   SimpleIdentifier _name;
 
   /**
    * The token representing the 'extends' keyword, or `null` if there is no
    * explicit upper bound.
    */
-  Token keyword;
+  Token extendsKeyword;
 
   /**
    * The name of the upper bound for legal arguments, or `null` if there is no
    * explicit upper bound.
    */
   TypeName _bound;
 
   /**
    * Initialize a newly created type parameter. Either or both of the [comment]
    * and [metadata] can be `null` if the parameter does not have the
-   * corresponding attribute. The [keyword] and [bound] can be `null` if the
-   * parameter does not have an upper bound.
+   * corresponding attribute. The [extendsKeyword] and [bound] can be `null` if
+   * the parameter does not have an upper bound.
    */
   TypeParameter(Comment comment, List<Annotation> metadata,
-      SimpleIdentifier name, this.keyword, TypeName bound)
+      SimpleIdentifier name, this.extendsKeyword, TypeName bound)
       : super(comment, metadata) {
-    _name = becomeParentOf(name);
-    _bound = becomeParentOf(bound);
+    _name = _becomeParentOf(name);
+    _bound = _becomeParentOf(bound);
   }
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there
    * is no explicit upper bound.
    */
   TypeName get bound => _bound;
 
   /**
    * Set the name of the upper bound for legal arguments to the given
    * [typeName].
    */
   void set bound(TypeName typeName) {
-    _bound = becomeParentOf(typeName);
+    _bound = _becomeParentOf(typeName);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(_name)
-      ..add(keyword)
+      ..add(extendsKeyword)
       ..add(_bound);
 
   @override
   TypeParameterElement get element =>
       _name != null ? (_name.staticElement as TypeParameterElement) : null;
 
   @override
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 
   /**
+   * Return the token representing the 'extends' keyword, or `null` if there is
+   * no explicit upper bound.
+   */
+  @deprecated // Use "this.extendsKeyword"
+  Token get keyword => extendsKeyword;
+
+  /**
+   * Set the token representing the 'extends' keyword to the given [token].
+   */
+  @deprecated // Use "this.extendsKeyword"
+  set keyword(Token token) {
+    extendsKeyword = token;
+  }
+
+  /**
    * Return the name of the type parameter.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the type parameter to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_bound, visitor);
@@ skipping 436 matching lines @@
   Source source;
 
   /**
    * Initialize a newly create URI-based directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   UriBasedDirective(Comment comment, List<Annotation> metadata,
       StringLiteral uri)
       : super(comment, metadata) {
-    _uri = becomeParentOf(uri);
+    _uri = _becomeParentOf(uri);
   }
 
   /**
    * Return the URI referenced by this directive.
    */
   StringLiteral get uri => _uri;
 
   /**
    * Set the URI referenced by this directive to the given [uri].
    */
   void set uri(StringLiteral uri) {
-    _uri = becomeParentOf(uri);
+    _uri = _becomeParentOf(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.
    */
   Element get uriElement;
 
@@ skipping 82 matching lines @@
 
   /**
    * Initialize a newly created variable declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [equals] and [initializer] can be `null` if
    * there is no initializer.
    */
   VariableDeclaration(Comment comment, List<Annotation> metadata,
       SimpleIdentifier name, this.equals, Expression initializer)
       : super(comment, metadata) {
-    _name = becomeParentOf(name);
-    _initializer = becomeParentOf(initializer);
+    _name = _becomeParentOf(name);
+    _initializer = _becomeParentOf(initializer);
   }
 
   @override
   Iterable get childEntities => super._childEntities
       ..add(_name)
       ..add(equals)
       ..add(_initializer);
 
   /**
    * This overridden implementation of getDocumentationComment() looks in the
@@ skipping 33 matching lines @@
    * Return the expression used to compute the initial value for the variable,
    * or `null` if the initial value was not specified.
    */
   Expression get initializer => _initializer;
 
   /**
    * Set the expression used to compute the initial value for the variable to
    * the given [expression].
    */
   void set initializer(Expression expression) {
-    _initializer = becomeParentOf(expression);
+    _initializer = _becomeParentOf(expression);
   }
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    */
   bool get isConst {
     AstNode parent = this.parent;
     return parent is VariableDeclarationList && parent.isConst;
   }
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return `false`
    * even though they are implicitly final.
    */
   bool get isFinal {
     AstNode parent = this.parent;
     return parent is VariableDeclarationList && parent.isFinal;
   }
 
   /**
    * Return the name of the variable being declared.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the variable being declared to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_initializer, visitor);
@@ skipping 31 matching lines @@
 
   /**
    * Initialize a newly created variable declaration list. Either or both of the
    * [comment] and [metadata] can be `null` if the variable list does not have
    * the corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
   VariableDeclarationList(Comment comment, List<Annotation> metadata,
       this.keyword, TypeName type, List<VariableDeclaration> variables)
       : super(comment, metadata) {
-    _type = becomeParentOf(type);
+    _type = _becomeParentOf(type);
     _variables = new NodeList<VariableDeclaration>(this, variables);
   }
 
   /**
    * TODO(paulberry): include commas.
    */
   @override
   Iterable get childEntities => super._childEntities
       ..add(keyword)
       ..add(_type)
@@ skipping 31 matching lines @@
   /**
    * Return the type of the variables being declared, or `null` if no type was
    * provided.
    */
   TypeName get type => _type;
 
   /**
    * Set the type of the variables being declared to the given [typeName].
    */
   void set type(TypeName typeName) {
-    _type = becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName);
   }
 
   /**
    * Return a list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> get variables => _variables;
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
@@ skipping 21 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created variable declaration statement.
    */
   VariableDeclarationStatement(VariableDeclarationList variableList,
       this.semicolon) {
-    _variableList = becomeParentOf(variableList);
+    _variableList = _becomeParentOf(variableList);
   }
 
   @override
   Token get beginToken => _variableList.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(_variableList)
       ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the variables being declared.
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the variables being declared to the given list of [variables].
    */
   void set variables(VariableDeclarationList variables) {
-    _variableList = becomeParentOf(variables);
+    _variableList = _becomeParentOf(variables);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_variableList, visitor);
   }
 }
 
 /**
  * A while statement.
  *
  * > whileStatement ::=
  * >     'while' '(' [Expression] ')' [Statement]
  */
 class WhileStatement extends Statement {
   /**
    * The token representing the 'while' keyword.
    */
-  Token keyword;
+  Token whileKeyword;
 
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The expression used to determine whether to execute the body of the loop.
    */
   Expression _condition;
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * Initialize a newly created while statement.
    */
-  WhileStatement(this.keyword, this.leftParenthesis, Expression condition,
+  WhileStatement(this.whileKeyword, this.leftParenthesis, Expression condition,
       this.rightParenthesis, Statement body) {
-    _condition = becomeParentOf(condition);
-    _body = becomeParentOf(body);
+    _condition = _becomeParentOf(condition);
+    _body = _becomeParentOf(body);
   }
 
   @override
-  Token get beginToken => keyword;
+  Token get beginToken => whileKeyword;
 
   /**
    * Return the body of the loop.
    */
   Statement get body => _body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
-    _body = becomeParentOf(statement);
+    _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
+      ..add(whileKeyword)
       ..add(leftParenthesis)
       ..add(_condition)
       ..add(rightParenthesis)
       ..add(_body);
 
   /**
    * Return the expression used to determine whether to execute the body of the
    * loop.
    */
   Expression get condition => _condition;
 
   /**
    * Set the expression used to determine whether to execute the body of the
    * loop to the given [expression].
    */
   void set condition(Expression expression) {
-    _condition = becomeParentOf(expression);
+    _condition = _becomeParentOf(expression);
   }
 
   @override
   Token get endToken => _body.endToken;
 
+  /**
+   * Return the token representing the 'while' keyword.
+   */
+  @deprecated // Use "this.whileKeyword"
+  Token get keyword => whileKeyword;
+
+  /**
+   * Set the token representing the 'while' keyword to the given [token].
+   */
+  @deprecated // Use "this.whileKeyword"
+  set keyword(Token token) {
+    whileKeyword = token;
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitWhileStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
@@ skipping 30 matching lines @@
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(withKeyword)
       ..addAll(_mixinTypes);
 
   @override
   Token get endToken => _mixinTypes.endToken;
 
   /**
    * Set the token representing the 'with' keyword to the given [token].
-   *
-   * Deprecated: Use withKeyword instead.
    */
-  @deprecated
+  @deprecated // Use "this.withKeyword"
   void set mixinKeyword(Token token) {
     this.withKeyword = token;
   }
 
   /**
    * Return the names of the mixins that were specified.
    */
   NodeList<TypeName> get mixinTypes => _mixinTypes;
 
   @override
@@ skipping 31 matching lines @@
    * The semicolon following the expression.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
   YieldStatement(this.yieldKeyword, this.star, Expression expression,
       this.semicolon) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (yieldKeyword != null) {
       return yieldKeyword;
     }
     return _expression.beginToken;
   }
 
-  /**
-   * TODO(paulberry): untested.
-   */
   @override
   Iterable get childEntities => new ChildEntities()
       ..add(yieldKeyword)
       ..add(star)
       ..add(_expression)
       ..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression whose value will be yielded.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression whose value will be yielded to the given [expression].
    */
   void set expression(Expression expression) {
-    _expression = becomeParentOf(expression);
+    _expression = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }