New analyzer snapshot.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 3057 matching lines @@
 class CatchClause extends AstNode {
   /**
    * The token representing the 'on' keyword, or `null` if there is no 'on' keyword.
    */
   Token onKeyword;
 
   /**
    * The type of exceptions caught by this catch clause, or `null` if this catch clause
    * catches every type of exception.
    */
-  TypeName exceptionType;
+  TypeName _exceptionType;
 
   /**
    * The token representing the 'catch' keyword, or `null` if there is no 'catch' keyword.
    */
   Token catchKeyword;
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
@@ skipping 32 matching lines @@
    * @param exceptionType the type of exceptions caught by this catch clause
    * @param leftParenthesis the left parenthesis
    * @param exceptionParameter the parameter whose value will be the exception that was thrown
    * @param comma the comma separating the exception parameter from the stack trace parameter
    * @param stackTraceParameter the parameter whose value will be the stack trace associated with
    *          the exception
    * @param rightParenthesis the right parenthesis
    * @param body the body of the catch block
    */
   CatchClause(this.onKeyword, TypeName exceptionType, this.catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, this.comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
-    this.exceptionType = becomeParentOf(exceptionType);
+    this._exceptionType = becomeParentOf(exceptionType);
     this._leftParenthesis = leftParenthesis;
     this._exceptionParameter = becomeParentOf(exceptionParameter);
     this._stackTraceParameter = becomeParentOf(stackTraceParameter);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCatchClause(this);
 
@@ skipping 16 matching lines @@
   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
    */
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
   /**
+   * Return the type of exceptions caught by this catch clause, or `null` if this catch clause
+   * catches every type of exception.
+   *
+   * @return the type of exceptions caught by this catch clause
+   */
+  TypeName get exceptionType => _exceptionType;
+
+  /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
    * Return the right parenthesis.
    *
    * @return the right parenthesis
@@ skipping 20 matching lines @@
   /**
    * Set the parameter whose value will be the exception that was thrown to the given parameter.
    *
    * @param parameter the parameter whose value will be the exception that was thrown
    */
   void set exceptionParameter(SimpleIdentifier parameter) {
     _exceptionParameter = becomeParentOf(parameter);
   }
 
   /**
+   * Set the type of exceptions caught by this catch clause to the given type.
+   *
+   * @param exceptionType the type of exceptions caught by this catch clause
+   */
+  void set exceptionType(TypeName exceptionType) {
+    this._exceptionType = becomeParentOf(exceptionType);
+  }
+
+  /**
    * Set the left parenthesis to the given token.
    *
    * @param parenthesis the left parenthesis
    */
   void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
 
   /**
    * Set the right parenthesis to the given token.
@@ skipping 10 matching lines @@
    *
    * @param parameter the parameter whose value will be the stack trace associated with the
    *          exception
    */
   void set stackTraceParameter(SimpleIdentifier parameter) {
     _stackTraceParameter = becomeParentOf(parameter);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
-    safelyVisitChild(exceptionType, visitor);
+    safelyVisitChild(_exceptionType, visitor);
     safelyVisitChild(_exceptionParameter, visitor);
     safelyVisitChild(_stackTraceParameter, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `ClassDeclaration` represent the declaration of a class.
  *
  * <pre>
@@ skipping 17 matching lines @@
 
   /**
    * 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.
    */
-  TypeParameterList typeParameters;
+  TypeParameterList _typeParameters;
 
   /**
    * The extends clause for the class, or `null` if the class does not extend any other class.
    */
   ExtendsClause _extendsClause;
 
   /**
    * The with clause for the class, or `null` if the class does not have a with clause.
    */
   WithClause _withClause;
 
   /**
    * The implements clause for the class, or `null` if the class does not implement any
    * interfaces.
    */
   ImplementsClause _implementsClause;
 
   /**
    * The native clause for the class, or `null` if the class does not have a native clause.
    */
-  NativeClause nativeClause;
+  NativeClause _nativeClause;
 
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The members defined by the class.
    */
   NodeList<ClassMember> _members;
@@ skipping 15 matching lines @@
    * @param extendsClause the extends clause for the class
    * @param withClause the with clause for the class
    * @param implementsClause the implements clause for the class
    * @param leftBracket the left curly bracket
    * @param members the members defined by the class
    * @param rightBracket the right curly bracket
    */
   ClassDeclaration(Comment comment, List<Annotation> metadata, this.abstractKeyword, this.classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, this.leftBracket, List<ClassMember> members, this.rightBracket) : super(comment, metadata) {
     this._members = new NodeList<ClassMember>(this);
     this._name = becomeParentOf(name);
-    this.typeParameters = becomeParentOf(typeParameters);
+    this._typeParameters = becomeParentOf(typeParameters);
     this._extendsClause = becomeParentOf(extendsClause);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
     this._members.addAll(members);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitClassDeclaration(this);
 
   /**
@@ skipping 89 matching lines @@
   }
 
   /**
    * Return the name of the class being declared.
    *
    * @return the name of the class being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
+   * Return the native clause for this class, or `null` if the class does not have a native
+   * cluse.
+   *
+   * @return the native clause for this class
+   */
+  NativeClause get nativeClause => _nativeClause;
+
+  /**
+   * Return the type parameters for the class, or `null` if the class does not have any type
+   * parameters.
+   *
+   * @return the type parameters for the class
+   */
+  TypeParameterList get typeParameters => _typeParameters;
+
+  /**
    * Return the with clause for the class, or `null` if the class does not have a with clause.
    *
    * @return the with clause for the class
    */
   WithClause get withClause => _withClause;
 
   /**
    * Return `true` if this class is declared to be an abstract class.
    *
    * @return `true` if this class is declared to be an abstract class
@@ skipping 21 matching lines @@
   /**
    * Set the name of the class being declared to the given identifier.
    *
    * @param identifier the name of the class being declared
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
+   * Set the native clause for this class to the given clause.
+   *
+   * @param nativeClause the native clause for this class
+   */
+  void set nativeClause(NativeClause nativeClause) {
+    this._nativeClause = becomeParentOf(nativeClause);
+  }
+
+  /**
+   * Set the type parameters for the class to the given list of type parameters.
+   *
+   * @param typeParameters the type parameters for the class
+   */
+  void set typeParameters(TypeParameterList typeParameters) {
+    this._typeParameters = becomeParentOf(typeParameters);
+  }
+
+  /**
    * Set the with clause for the class to the given clause.
    *
    * @param withClause the with clause for the class
    */
   void set withClause(WithClause withClause) {
     this._withClause = becomeParentOf(withClause);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
-    safelyVisitChild(typeParameters, visitor);
+    safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
-    safelyVisitChild(nativeClause, visitor);
+    safelyVisitChild(_nativeClause, visitor);
     members.accept(visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (abstractKeyword != null) {
       return abstractKeyword;
     }
     return classKeyword;
   }
@@ skipping 388 matching lines @@
    * @return the identifier being referenced
    */
   Identifier get identifier => _identifier;
 
   /**
    * Set the identifier being referenced to the given identifier.
    *
    * @param identifier the identifier being referenced
    */
   void set identifier(Identifier identifier) {
-    identifier = becomeParentOf(identifier);
+    this._identifier = becomeParentOf(identifier);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * The enumeration `CommentType` encodes all the different types of comments that are
@@ skipping 1363 matching lines @@
   /**
    * Return `true` if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
    *
    * @return `true` if this variable was declared with the 'final' modifier
    */
   bool get isFinal => (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
+   * Set the name of the variable being declared to the given name.
+   *
+   * @param identifier the new name of the variable being declared
+   */
+  void set identifier(SimpleIdentifier identifier) {
+    this._identifier = becomeParentOf(identifier);
+  }
+
+  /**
    * Set the name of the declared type of the parameter to the given type name.
    *
    * @param typeName the name of the declared type of the parameter
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
@@ skipping 1105 matching lines @@
    * @return `true` if the fields are declared to be static
    */
   bool get isStatic => staticKeyword != null;
 
   /**
    * Set the fields being declared to the given list of variables.
    *
    * @param fieldList the fields being declared
    */
   void set fields(VariableDeclarationList fieldList) {
-    fieldList = becomeParentOf(fieldList);
+    this._fieldList = becomeParentOf(fieldList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 456 matching lines @@
   void set initialization(Expression initialization) {
     this._initialization = becomeParentOf(initialization);
   }
 
   /**
    * Set the declaration of the loop variables to the given parameter.
    *
    * @param variableList the declaration of the loop variables
    */
   void set variables(VariableDeclarationList variableList) {
-    variableList = becomeParentOf(variableList);
+    this._variableList = becomeParentOf(variableList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
@@ skipping 352 matching lines @@
    * @return `true` if this function declares a setter
    */
   bool get isSetter => propertyKeyword != null && (propertyKeyword as KeywordToken).keyword == Keyword.SET;
 
   /**
    * Set the function expression being wrapped to the given function expression.
    *
    * @param functionExpression the function expression being wrapped
    */
   void set functionExpression(FunctionExpression functionExpression) {
-    functionExpression = becomeParentOf(functionExpression);
+    this._functionExpression = becomeParentOf(functionExpression);
   }
 
   /**
    * Set the name of the function to the given identifier.
    *
    * @param identifier the name of the function
    */
   void set name(SimpleIdentifier identifier) {
-    _name = becomeParentOf(identifier);
+    this._name = becomeParentOf(identifier);
   }
 
   /**
    * Set the return type of the function to the given name.
    *
-   * @param name the return type of the function
+   * @param returnType the return type of the function
    */
-  void set returnType(TypeName name) {
-    _returnType = becomeParentOf(name);
+  void set returnType(TypeName returnType) {
+    this._returnType = becomeParentOf(returnType);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_functionExpression, visitor);
   }
 
@@ skipping 46 matching lines @@
    *
    * @return the function declaration being wrapped
    */
   FunctionDeclaration get functionDeclaration => _functionDeclaration;
 
   /**
    * Set the function declaration being wrapped to the given function declaration.
    *
    * @param functionDeclaration the function declaration being wrapped
    */
-  void set functionExpression(FunctionDeclaration functionDeclaration) {
+  void set functionDeclaration(FunctionDeclaration functionDeclaration) {
     this._functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
@@ skipping 207 matching lines @@
   void set argumentList(ArgumentList argumentList) {
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * Set the expression producing the function being invoked to the given expression.
    *
    * @param function the expression producing the function being invoked
    */
   void set function(Expression function) {
-    function = becomeParentOf(function);
+    this._function = becomeParentOf(function);
   }
 
   /**
    * Set the element associated with the function being invoked based on propagated type information
    * to the given element.
    *
    * @param element the element to be associated with the function being invoked
    */
   void set propagatedElement(ExecutableElement element) {
     _propagatedElement = element;
@@ skipping 2074 matching lines @@
  */
 class InstanceCreationExpression extends Expression {
   /**
    * The keyword used to indicate how an object should be created.
    */
   Token keyword;
 
   /**
    * The name of the constructor to be invoked.
    */
-  ConstructorName constructorName;
+  ConstructorName _constructorName;
 
   /**
    * The list of arguments to the constructor.
    */
   ArgumentList _argumentList;
 
   /**
    * The element associated with the constructor based on static type information, or `null`
    * if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
    * The result of evaluating this expression, if it is constant.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created instance creation expression.
    *
    * @param keyword the keyword used to indicate how an object should be created
    * @param constructorName the name of the constructor to be invoked
    * @param argumentList the list of arguments to the constructor
    */
   InstanceCreationExpression(this.keyword, ConstructorName constructorName, ArgumentList argumentList) {
-    this.constructorName = becomeParentOf(constructorName);
+    this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInstanceCreationExpression(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   @override
   Token get beginToken => keyword;
 
+  /**
+   * Return the name of the constructor to be invoked.
+   *
+   * @return the name of the constructor to be invoked
+   */
+  ConstructorName get constructorName => _constructorName;
+
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the result of evaluating this constant as a compile-time constant expression, or
    * `null` if this variable is not a 'const' expression or an error prevented the result from
    * being computed.
    *
    * @return the result of evaluating this constant
    */
@@ skipping 12 matching lines @@
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList) {
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
+   * Set the name of the constructor to be invoked to the given name.
+   *
+   * @param constructorName the name of the constructor to be invoked
+   */
+  void set constructorName(ConstructorName constructorName) {
+    this._constructorName = becomeParentOf(constructorName);
+  }
+
+  /**
    * Set the result of evaluating this expression as a compile-time constant expression to the given
    * result.
    *
    * @param result the result of evaluating this expression
    */
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
-    safelyVisitChild(constructorName, visitor);
+    safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `IntegerLiteral` represent an integer literal expression.
  *
  * <pre>
  * integerLiteral ::=
  *     decimalIntegerLiteral
@@ skipping 1447 matching lines @@
  */
 class NativeClause extends AstNode {
   /**
    * The token representing the 'native' keyword.
    */
   Token keyword;
 
   /**
    * The name of the native object that implements the class.
    */
-  StringLiteral name;
+  StringLiteral _name;
 
   /**
    * Initialize a newly created native clause.
    *
    * @param keyword the token representing the 'native' keyword
    * @param name the name of the native object that implements the class.
    */
-  NativeClause(this.keyword, this.name);
+  NativeClause(this.keyword, StringLiteral name) {
+    this._name = becomeParentOf(name);
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
-  Token get endToken => name.endToken;
+  Token get endToken => _name.endToken;
+
+  /**
+   * Return the name of the native object that implements the class.
+   *
+   * @return the name of the native object that implements the class
+   */
+  StringLiteral get name => _name;
+
+  /**
+   * Sets the name of the native object that implements the class.
+   *
+   * @param name the name of the native object that implements the class.
+   */
+  void set name(StringLiteral name) {
+    this._name = becomeParentOf(name);
+  }
 
   @override
   void visitChildren(AstVisitor visitor) {
-    safelyVisitChild(name, visitor);
+    safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  *
  * <pre>
  * nativeFunctionBody ::=
  *     'native' [SimpleStringLiteral] ';'
@@ skipping 36 matching lines @@
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the string literal representing the string after the 'native' token.
    *
    * @return the string literal representing the string after the 'native' token
    */
   StringLiteral get stringLiteral => _stringLiteral;
 
+  /**
+   * Set the string literal representing the string after the 'native' token to the given string.
+   *
+   * @param stringLiteral the string literal representing the string after the 'native' token
+   */
+  void set stringLiteral(StringLiteral stringLiteral) {
+    this._stringLiteral = becomeParentOf(stringLiteral);
+  }
+
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_stringLiteral, visitor);
   }
 }
 
 /**
  * Instances of the class `NodeLocator` locate the [AstNode] associated with a
  * source range, given the AST structure built from the source. More specifically, they will return
  * the [AstNode] with the shortest length whose source range completely encompasses
@@ skipping 94 matching lines @@
 
 /**
  * Instances of the class `NodeFoundException` are used to cancel visiting after a node has
  * been found.
  */
 class NodeLocator_NodeFoundException extends RuntimeException {
   static int _serialVersionUID = 1;
 }
 
 /**
+ * Instances of the class `NodeReplacer` implement an object that will replace one child node
+ * in an AST node with another node.
+ */
+class NodeReplacer implements AstVisitor<bool> {
+  /**
+   * Replace the old node with the new node in the AST structure containing the old node.
+   *
+   * @param oldNode
+   * @param newNode
+   * @return `true` if the replacement was successful
+   * @throws IllegalArgumentException if either node is `null`, if the old node does not have
+   *           a parent node, or if the AST structure has been corrupted
+   */
+  static bool replace(AstNode oldNode, AstNode newNode) {
+    if (oldNode == null || newNode == null) {
+      throw new IllegalArgumentException("The old and new nodes must be non-null");
+    } else if (identical(oldNode, newNode)) {
+      return true;
+    }
+    AstNode parent = oldNode.parent;
+    if (parent == null) {
+      throw new IllegalArgumentException("The old node is not a child of another node");
+    }
+    NodeReplacer replacer = new NodeReplacer(oldNode, newNode);
+    return parent.accept(replacer);
+  }
+
+  final AstNode _oldNode;
+
+  final AstNode _newNode;
+
+  NodeReplacer(this._oldNode, this._newNode);
+
+  @override
+  bool visitAdjacentStrings(AdjacentStrings node) {
+    if (_replaceInList(node.strings)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  bool visitAnnotatedNode(AnnotatedNode node) {
+    if (identical(node.documentationComment, _oldNode)) {
+      node.documentationComment = _newNode as Comment;
+      return true;
+    } else if (_replaceInList(node.metadata)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitAnnotation(Annotation node) {
+    if (identical(node.arguments, _oldNode)) {
+      node.arguments = _newNode as ArgumentList;
+      return true;
+    } else if (identical(node.constructorName, _oldNode)) {
+      node.constructorName = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.name, _oldNode)) {
+      node.name = _newNode as Identifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitArgumentList(ArgumentList node) {
+    if (_replaceInList(node.arguments)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitAsExpression(AsExpression node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    } else if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitAssertStatement(AssertStatement node) {
+    if (identical(node.condition, _oldNode)) {
+      node.condition = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitAssignmentExpression(AssignmentExpression node) {
+    if (identical(node.leftHandSide, _oldNode)) {
+      node.leftHandSide = _newNode as Expression;
+      return true;
+    } else if (identical(node.rightHandSide, _oldNode)) {
+      node.rightHandSide = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitBinaryExpression(BinaryExpression node) {
+    if (identical(node.leftOperand, _oldNode)) {
+      node.leftOperand = _newNode as Expression;
+      return true;
+    } else if (identical(node.rightOperand, _oldNode)) {
+      node.rightOperand = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitBlock(Block node) {
+    if (_replaceInList(node.statements)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitBlockFunctionBody(BlockFunctionBody node) {
+    if (identical(node.block, _oldNode)) {
+      node.block = _newNode as Block;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitBooleanLiteral(BooleanLiteral node) => visitNode(node);
+
+  @override
+  bool visitBreakStatement(BreakStatement node) {
+    if (identical(node.label, _oldNode)) {
+      node.label = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitCascadeExpression(CascadeExpression node) {
+    if (identical(node.target, _oldNode)) {
+      node.target = _newNode as Expression;
+      return true;
+    } else if (_replaceInList(node.cascadeSections)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitCatchClause(CatchClause node) {
+    if (identical(node.exceptionType, _oldNode)) {
+      node.exceptionType = _newNode as TypeName;
+      return true;
+    } else if (identical(node.exceptionParameter, _oldNode)) {
+      node.exceptionParameter = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.stackTraceParameter, _oldNode)) {
+      node.stackTraceParameter = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitClassDeclaration(ClassDeclaration node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.typeParameters, _oldNode)) {
+      node.typeParameters = _newNode as TypeParameterList;
+      return true;
+    } else if (identical(node.extendsClause, _oldNode)) {
+      node.extendsClause = _newNode as ExtendsClause;
+      return true;
+    } else if (identical(node.withClause, _oldNode)) {
+      node.withClause = _newNode as WithClause;
+      return true;
+    } else if (identical(node.implementsClause, _oldNode)) {
+      node.implementsClause = _newNode as ImplementsClause;
+      return true;
+    } else if (identical(node.nativeClause, _oldNode)) {
+      node.nativeClause = _newNode as NativeClause;
+      return true;
+    } else if (_replaceInList(node.members)) {
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitClassTypeAlias(ClassTypeAlias node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.typeParameters, _oldNode)) {
+      node.typeParameters = _newNode as TypeParameterList;
+      return true;
+    } else if (identical(node.superclass, _oldNode)) {
+      node.superclass = _newNode as TypeName;
+      return true;
+    } else if (identical(node.withClause, _oldNode)) {
+      node.withClause = _newNode as WithClause;
+      return true;
+    } else if (identical(node.implementsClause, _oldNode)) {
+      node.implementsClause = _newNode as ImplementsClause;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitComment(Comment node) {
+    if (_replaceInList(node.references)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitCommentReference(CommentReference node) {
+    if (identical(node.identifier, _oldNode)) {
+      node.identifier = _newNode as Identifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitCompilationUnit(CompilationUnit node) {
+    if (identical(node.scriptTag, _oldNode)) {
+      node.scriptTag = _newNode as ScriptTag;
+      return true;
+    } else if (_replaceInList(node.directives)) {
+      return true;
+    } else if (_replaceInList(node.declarations)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitConditionalExpression(ConditionalExpression node) {
+    if (identical(node.condition, _oldNode)) {
+      node.condition = _newNode as Expression;
+      return true;
+    } else if (identical(node.thenExpression, _oldNode)) {
+      node.thenExpression = _newNode as Expression;
+      return true;
+    } else if (identical(node.elseExpression, _oldNode)) {
+      node.elseExpression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitConstructorDeclaration(ConstructorDeclaration node) {
+    if (identical(node.returnType, _oldNode)) {
+      node.returnType = _newNode as Identifier;
+      return true;
+    } else if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    } else if (identical(node.redirectedConstructor, _oldNode)) {
+      node.redirectedConstructor = _newNode as ConstructorName;
+      return true;
+    } else if (identical(node.body, _oldNode)) {
+      node.body = _newNode as FunctionBody;
+      return true;
+    } else if (_replaceInList(node.initializers)) {
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
+    if (identical(node.fieldName, _oldNode)) {
+      node.fieldName = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitConstructorName(ConstructorName node) {
+    if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    } else if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitContinueStatement(ContinueStatement node) {
+    if (identical(node.label, _oldNode)) {
+      node.label = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitDeclaredIdentifier(DeclaredIdentifier node) {
+    if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    } else if (identical(node.identifier, _oldNode)) {
+      node.identifier = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitDefaultFormalParameter(DefaultFormalParameter node) {
+    if (identical(node.parameter, _oldNode)) {
+      node.parameter = _newNode as NormalFormalParameter;
+      return true;
+    } else if (identical(node.defaultValue, _oldNode)) {
+      node.defaultValue = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitDoStatement(DoStatement node) {
+    if (identical(node.body, _oldNode)) {
+      node.body = _newNode as Statement;
+      return true;
+    } else if (identical(node.condition, _oldNode)) {
+      node.condition = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitDoubleLiteral(DoubleLiteral node) => visitNode(node);
+
+  @override
+  bool visitEmptyFunctionBody(EmptyFunctionBody node) => visitNode(node);
+
+  @override
+  bool visitEmptyStatement(EmptyStatement node) => visitNode(node);
+
+  @override
+  bool visitExportDirective(ExportDirective node) => visitNamespaceDirective(node);
+
+  @override
+  bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitExpressionStatement(ExpressionStatement node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitExtendsClause(ExtendsClause node) {
+    if (identical(node.superclass, _oldNode)) {
+      node.superclass = _newNode as TypeName;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitFieldDeclaration(FieldDeclaration node) {
+    if (identical(node.fields, _oldNode)) {
+      node.fields = _newNode as VariableDeclarationList;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitFieldFormalParameter(FieldFormalParameter node) {
+    if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    } else if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    }
+    return visitNormalFormalParameter(node);
+  }
+
+  @override
+  bool visitForEachStatement(ForEachStatement node) {
+    if (identical(node.loopVariable, _oldNode)) {
+      node.loopVariable = _newNode as DeclaredIdentifier;
+      return true;
+    } else if (identical(node.identifier, _oldNode)) {
+      node.identifier = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.iterator, _oldNode)) {
+      node.iterator = _newNode as Expression;
+      return true;
+    } else if (identical(node.body, _oldNode)) {
+      node.body = _newNode as Statement;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitFormalParameterList(FormalParameterList node) {
+    if (_replaceInList(node.parameters)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitForStatement(ForStatement node) {
+    if (identical(node.variables, _oldNode)) {
+      node.variables = _newNode as VariableDeclarationList;
+      return true;
+    } else if (identical(node.initialization, _oldNode)) {
+      node.initialization = _newNode as Expression;
+      return true;
+    } else if (identical(node.condition, _oldNode)) {
+      node.condition = _newNode as Expression;
+      return true;
+    } else if (identical(node.body, _oldNode)) {
+      node.body = _newNode as Statement;
+      return true;
+    } else if (_replaceInList(node.updaters)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitFunctionDeclaration(FunctionDeclaration node) {
+    if (identical(node.returnType, _oldNode)) {
+      node.returnType = _newNode as TypeName;
+      return true;
+    } else if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.functionExpression, _oldNode)) {
+      node.functionExpression = _newNode as FunctionExpression;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
+    if (identical(node.functionDeclaration, _oldNode)) {
+      node.functionDeclaration = _newNode as FunctionDeclaration;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitFunctionExpression(FunctionExpression node) {
+    if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    } else if (identical(node.body, _oldNode)) {
+      node.body = _newNode as FunctionBody;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    if (identical(node.function, _oldNode)) {
+      node.function = _newNode as Expression;
+      return true;
+    } else if (identical(node.argumentList, _oldNode)) {
+      node.argumentList = _newNode as ArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitFunctionTypeAlias(FunctionTypeAlias node) {
+    if (identical(node.returnType, _oldNode)) {
+      node.returnType = _newNode as TypeName;
+      return true;
+    } else if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.typeParameters, _oldNode)) {
+      node.typeParameters = _newNode as TypeParameterList;
+      return true;
+    } else if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    if (identical(node.returnType, _oldNode)) {
+      node.returnType = _newNode as TypeName;
+      return true;
+    } else if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    }
+    return visitNormalFormalParameter(node);
+  }
+
+  @override
+  bool visitHideCombinator(HideCombinator node) {
+    if (_replaceInList(node.hiddenNames)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitIfStatement(IfStatement node) {
+    if (identical(node.condition, _oldNode)) {
+      node.condition = _newNode as Expression;
+      return true;
+    } else if (identical(node.thenStatement, _oldNode)) {
+      node.thenStatement = _newNode as Statement;
+      return true;
+    } else if (identical(node.elseStatement, _oldNode)) {
+      node.elseStatement = _newNode as Statement;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitImplementsClause(ImplementsClause node) {
+    if (_replaceInList(node.interfaces)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitImportDirective(ImportDirective node) {
+    if (identical(node.prefix, _oldNode)) {
+      node.prefix = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNamespaceDirective(node);
+  }
+
+  @override
+  bool visitIndexExpression(IndexExpression node) {
+    if (identical(node.target, _oldNode)) {
+      node.target = _newNode as Expression;
+      return true;
+    } else if (identical(node.index, _oldNode)) {
+      node.index = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitInstanceCreationExpression(InstanceCreationExpression node) {
+    if (identical(node.constructorName, _oldNode)) {
+      node.constructorName = _newNode as ConstructorName;
+      return true;
+    } else if (identical(node.argumentList, _oldNode)) {
+      node.argumentList = _newNode as ArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitIntegerLiteral(IntegerLiteral node) => visitNode(node);
+
+  @override
+  bool visitInterpolationExpression(InterpolationExpression node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitInterpolationString(InterpolationString node) => visitNode(node);
+
+  @override
+  bool visitIsExpression(IsExpression node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    } else if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitLabel(Label node) {
+    if (identical(node.label, _oldNode)) {
+      node.label = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitLabeledStatement(LabeledStatement node) {
+    if (identical(node.statement, _oldNode)) {
+      node.statement = _newNode as Statement;
+      return true;
+    } else if (_replaceInList(node.labels)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitLibraryDirective(LibraryDirective node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as LibraryIdentifier;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitLibraryIdentifier(LibraryIdentifier node) {
+    if (_replaceInList(node.components)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitListLiteral(ListLiteral node) {
+    if (_replaceInList(node.elements)) {
+      return true;
+    }
+    return visitTypedLiteral(node);
+  }
+
+  @override
+  bool visitMapLiteral(MapLiteral node) {
+    if (_replaceInList(node.entries)) {
+      return true;
+    }
+    return visitTypedLiteral(node);
+  }
+
+  @override
+  bool visitMapLiteralEntry(MapLiteralEntry node) {
+    if (identical(node.key, _oldNode)) {
+      node.key = _newNode as Expression;
+      return true;
+    } else if (identical(node.value, _oldNode)) {
+      node.value = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitMethodDeclaration(MethodDeclaration node) {
+    if (identical(node.returnType, _oldNode)) {
+      node.returnType = _newNode as TypeName;
+      return true;
+    } else if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    } else if (identical(node.body, _oldNode)) {
+      node.body = _newNode as FunctionBody;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitMethodInvocation(MethodInvocation node) {
+    if (identical(node.target, _oldNode)) {
+      node.target = _newNode as Expression;
+      return true;
+    } else if (identical(node.methodName, _oldNode)) {
+      node.methodName = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.argumentList, _oldNode)) {
+      node.argumentList = _newNode as ArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitNamedExpression(NamedExpression node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as Label;
+      return true;
+    } else if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  bool visitNamespaceDirective(NamespaceDirective node) {
+    if (_replaceInList(node.combinators)) {
+      return true;
+    }
+    return visitUriBasedDirective(node);
+  }
+
+  @override
+  bool visitNativeClause(NativeClause node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as StringLiteral;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitNativeFunctionBody(NativeFunctionBody node) {
+    if (identical(node.stringLiteral, _oldNode)) {
+      node.stringLiteral = _newNode as StringLiteral;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  bool visitNode(AstNode node) {
+    throw new IllegalArgumentException("The old node is not a child of it's parent");
+  }
+
+  bool visitNormalFormalParameter(NormalFormalParameter node) {
+    if (identical(node.documentationComment, _oldNode)) {
+      node.documentationComment = _newNode as Comment;
+      return true;
+    } else if (identical(node.identifier, _oldNode)) {
+      node.identifier = _newNode as SimpleIdentifier;
+      return true;
+    } else if (_replaceInList(node.metadata)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitNullLiteral(NullLiteral node) => visitNode(node);
+
+  @override
+  bool visitParenthesizedExpression(ParenthesizedExpression node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
+
+  @override
+  bool visitPartOfDirective(PartOfDirective node) {
+    if (identical(node.libraryName, _oldNode)) {
+      node.libraryName = _newNode as LibraryIdentifier;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitPostfixExpression(PostfixExpression node) {
+    if (identical(node.operand, _oldNode)) {
+      node.operand = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitPrefixedIdentifier(PrefixedIdentifier node) {
+    if (identical(node.prefix, _oldNode)) {
+      node.prefix = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.identifier, _oldNode)) {
+      node.identifier = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitPrefixExpression(PrefixExpression node) {
+    if (identical(node.operand, _oldNode)) {
+      node.operand = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitPropertyAccess(PropertyAccess node) {
+    if (identical(node.target, _oldNode)) {
+      node.target = _newNode as Expression;
+      return true;
+    } else if (identical(node.propertyName, _oldNode)) {
+      node.propertyName = _newNode as SimpleIdentifier;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+    if (identical(node.constructorName, _oldNode)) {
+      node.constructorName = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.argumentList, _oldNode)) {
+      node.argumentList = _newNode as ArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitRethrowExpression(RethrowExpression node) => visitNode(node);
+
+  @override
+  bool visitReturnStatement(ReturnStatement node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
+
+  @override
+  bool visitShowCombinator(ShowCombinator node) {
+    if (_replaceInList(node.shownNames)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitSimpleFormalParameter(SimpleFormalParameter node) {
+    if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    }
+    return visitNormalFormalParameter(node);
+  }
+
+  @override
+  bool visitSimpleIdentifier(SimpleIdentifier node) => visitNode(node);
+
+  @override
+  bool visitSimpleStringLiteral(SimpleStringLiteral node) => visitNode(node);
+
+  @override
+  bool visitStringInterpolation(StringInterpolation node) {
+    if (_replaceInList(node.elements)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+    if (identical(node.constructorName, _oldNode)) {
+      node.constructorName = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.argumentList, _oldNode)) {
+      node.argumentList = _newNode as ArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitSuperExpression(SuperExpression node) => visitNode(node);
+
+  @override
+  bool visitSwitchCase(SwitchCase node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitSwitchMember(node);
+  }
+
+  @override
+  bool visitSwitchDefault(SwitchDefault node) => visitSwitchMember(node);
+
+  bool visitSwitchMember(SwitchMember node) {
+    if (_replaceInList(node.labels)) {
+      return true;
+    } else if (_replaceInList(node.statements)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitSwitchStatement(SwitchStatement node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    } else if (_replaceInList(node.members)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitSymbolLiteral(SymbolLiteral node) => visitNode(node);
+
+  @override
+  bool visitThisExpression(ThisExpression node) => visitNode(node);
+
+  @override
+  bool visitThrowExpression(ThrowExpression node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as Expression;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    if (identical(node.variables, _oldNode)) {
+      node.variables = _newNode as VariableDeclarationList;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitTryStatement(TryStatement node) {
+    if (identical(node.body, _oldNode)) {
+      node.body = _newNode as Block;
+      return true;
+    } else if (identical(node.finallyBlock, _oldNode)) {
+      node.finallyBlock = _newNode as Block;
+      return true;
+    } else if (_replaceInList(node.catchClauses)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitTypeArgumentList(TypeArgumentList node) {
+    if (_replaceInList(node.arguments)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  bool visitTypedLiteral(TypedLiteral node) {
+    if (identical(node.typeArguments, _oldNode)) {
+      node.typeArguments = _newNode as TypeArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitTypeName(TypeName node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as Identifier;
+      return true;
+    } else if (identical(node.typeArguments, _oldNode)) {
+      node.typeArguments = _newNode as TypeArgumentList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitTypeParameter(TypeParameter node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.bound, _oldNode)) {
+      node.bound = _newNode as TypeName;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitTypeParameterList(TypeParameterList node) {
+    if (_replaceInList(node.typeParameters)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  bool visitUriBasedDirective(UriBasedDirective node) {
+    if (identical(node.uri, _oldNode)) {
+      node.uri = _newNode as StringLiteral;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitVariableDeclaration(VariableDeclaration node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.initializer, _oldNode)) {
+      node.initializer = _newNode as Expression;
+      return true;
+    }
+    return visitAnnotatedNode(node);
+  }
+
+  @override
+  bool visitVariableDeclarationList(VariableDeclarationList node) {
+    if (identical(node.type, _oldNode)) {
+      node.type = _newNode as TypeName;
+      return true;
+    } else if (_replaceInList(node.variables)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    if (identical(node.variables, _oldNode)) {
+      node.variables = _newNode as VariableDeclarationList;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitWhileStatement(WhileStatement node) {
+    if (identical(node.condition, _oldNode)) {
+      node.condition = _newNode as Expression;
+      return true;
+    } else if (identical(node.body, _oldNode)) {
+      node.body = _newNode as Statement;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
+  bool visitWithClause(WithClause node) {
+    if (_replaceInList(node.mixinTypes)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  bool _replaceInList(NodeList list) {
+    int count = list.length;
+    for (int i = 0; i < count; i++) {
+      if (identical(_oldNode, list[i])) {
+        javaListSet(list, i, _newNode);
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
  * The abstract class `NormalFormalParameter` defines the behavior common to formal parameters
  * that are required (are not optional).
  *
  * <pre>
  * normalFormalParameter ::=
  *     [FunctionTypedFormalParameter]
  *   | [FieldFormalParameter]
  *   | [SimpleFormalParameter]
  * </pre>
  */
@@ skipping 66 matching lines @@
 
   /**
    * Set the name of the parameter being declared to the given identifier.
    *
    * @param identifier the name of the parameter being declared
    */
   void set identifier(SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
+  /**
+   * Set the metadata associated with this node to the given metadata.
+   *
+   * @param metadata the metadata to be associated with this node
+   */
+  void set metadata(List<Annotation> metadata) {
+    this._metadata.clear();
+    this._metadata.addAll(metadata);
+  }
+
   @override
   void visitChildren(AstVisitor visitor) {
     //
     // Note that subclasses are responsible for visiting the identifier because they often need to
     // visit other nodes before visiting the identifier.
     //
     if (_commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
@@ skipping 4606 matching lines @@
    * @return the top-level variables being declared
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the top-level variables being declared to the given list of variables.
    *
    * @param variableList the top-level variables being declared
    */
   void set variables(VariableDeclarationList variableList) {
-    variableList = becomeParentOf(variableList);
+    this._variableList = becomeParentOf(variableList);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
@@ skipping 497 matching lines @@
 abstract class TypedLiteral extends Literal {
   /**
    * The token representing the 'const' keyword, or `null` if the literal is not a constant.
    */
   Token constKeyword;
 
   /**
    * The type argument associated with this literal, or `null` if no type arguments were
    * declared.
    */
-  TypeArgumentList typeArguments;
+  TypeArgumentList _typeArguments;
 
   /**
    * Initialize a newly created typed literal.
    *
    * @param constKeyword the token representing the 'const' keyword
    * @param typeArguments the type argument associated with this literal, or `null` if no type
    *          arguments were declared
    */
   TypedLiteral(this.constKeyword, TypeArgumentList typeArguments) {
-    this.typeArguments = becomeParentOf(typeArguments);
+    this._typeArguments = becomeParentOf(typeArguments);
+  }
+
+  /**
+   * Return the type argument associated with this literal, or `null` if no type arguments
+   * were declared.
+   *
+   * @return the type argument associated with this literal
+   */
+  TypeArgumentList get typeArguments => _typeArguments;
+
+  /**
+   * Set the type argument associated with this literal to the given arguments.
+   *
+   * @param typeArguments the type argument associated with this literal
+   */
+  void set typeArguments(TypeArgumentList typeArguments) {
+    this._typeArguments = becomeParentOf(typeArguments);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
-    safelyVisitChild(typeArguments, visitor);
+    safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * Instances of the class `UnifyingAstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure (like instances of the class
  * [RecursiveAstVisitor]). In addition, every node will also be visited by using a single
  * unified [visitNode] method.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
@@ skipping 1024 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }