Add support for assert statements with messages to the analyzer.

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.
 
 library engine.ast;
 
 import 'dart:collection';
 
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 640 matching lines @@
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The condition that is being asserted to be `true`.
    */
   Expression _condition;
 
   /**
+   * The comma, if a message expression was supplied.  Otherwise `null`.
+   */
+  Token comma;
+
+  /**
+   * The message to report if the assertion fails.  `null` if no message was
+   * supplied.
+   */
+  Expression _message;
+
+  /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created assert statement.
    */
   AssertStatement(this.assertKeyword, this.leftParenthesis,
-      Expression condition, this.rightParenthesis, this.semicolon) {
+      Expression condition, this.rightParenthesis, this.semicolon,
+      {this.comma, Expression message}) {

[Brian Wilkerson, 2015/09/02 15:49:15]

None of the other AST node constructors take optional arguments, and I would
prefer to be consistent. Also, please put them in their lexical position.

[Paul Berry, 2015/09/02 17:20:03]

If I do so, will this constitute a breaking change to the analyzer API?  Or are
we assuming that clients aren't supposed to call the AST constructors directly?

[Brian Wilkerson, 2015/09/02 17:35:26]

I wish I could answer that question definitively, but here are my thoughts. The
AST structure is clearly part of the public API. While I would like to define
all of the node types as interfaces and make the current classes be
implementations of those interfaces and provide a factory (or builder) interface
for clients to use when creating instances, that isn't the current state of the
code base. So, I don't have any reason to think that clients are not using the
constructors (even though I'm fairly sure that very few if any clients are
creating AST structures directly).

If we're being conservative, which seems to be wise, then yes, this is a
breaking change.

That isn't necessarily a bad thing. Almost all of the uses of the constructor in
our code needed to be examined and updated and changing the constructor's
signature would have forced that (and several comments pointed out places that
were missed because the signature wasn't changed). I suspect that the same is
true of client code and that we might actually be doing clients a favor to force
them to examine their code carefully instead of allowing them to assume that
everything is fine.

[Paul Berry, 2015/09/07 19:44:29]

Thinking back to our discussions with the Seattle folks last time we made a
breaking change to Analyzer, one strategy that was recommended (and which was
very compelling IMO) was: as a backwards compatible change, make a new API
(possibly with an ugly name) and deprecate the old one.  Then, at a later date
when enough backwards compatible changes have accumulated, make a single
backwards-breaking change that deletes the deprecated API and renames the new
one to the old name.  I've tried doing that here.

     _condition = _becomeParentOf(condition);
+    _message = _becomeParentOf(message);
   }
 
   @override
   Token get beginToken => assertKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(assertKeyword)
     ..add(leftParenthesis)
     ..add(_condition)
+    ..add(comma)
+    ..add(_message)
     ..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
@@ skipping 13 matching lines @@
   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;
   }
 
+  /**
+   * Return the messasge to report if the assertion fails.
+   */
+  Expression get message => _message;
+
   @override
   accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
+    _safelyVisitChild(message, visitor);
   }
 }
 
 /**
  * An assignment expression.
  *
  * > assignmentExpression ::=
  * >     [Expression] operator [Expression]
  */
 class AssignmentExpression extends Expression {
@@ skipping 221 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`.
    */
   AstCloner(
-      [this.cloneTokens = false]); // TODO(brianwilkerson) Change this to be a named parameter.
+      [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 31 matching lines @@
     }
     return tokens;
   }
 
   @override
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) =>
       new AdjacentStrings(cloneNodeList(node.strings));
 
   @override
   Annotation visitAnnotation(Annotation node) => new Annotation(
-      cloneToken(node.atSign), cloneNode(node.name), cloneToken(node.period),
-      cloneNode(node.constructorName), cloneNode(node.arguments));
+      cloneToken(node.atSign),
+      cloneNode(node.name),
+      cloneToken(node.period),
+      cloneNode(node.constructorName),
+      cloneNode(node.arguments));
 
   @override
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(
-      cloneToken(node.leftParenthesis), cloneNodeList(node.arguments),
+      cloneToken(node.leftParenthesis),
+      cloneNodeList(node.arguments),
       cloneToken(node.rightParenthesis));
 
   @override
   AsExpression visitAsExpression(AsExpression node) => new AsExpression(
-      cloneNode(node.expression), cloneToken(node.asOperator),
+      cloneNode(node.expression),
+      cloneToken(node.asOperator),
       cloneNode(node.type));
 
   @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(

[Brian Wilkerson, 2015/09/02 15:49:15]

This needs to be updated to clone the new children.

[Paul Berry, 2015/09/07 19:44:29]

Done.

-      cloneToken(node.assertKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.condition), cloneToken(node.rightParenthesis),
+      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), cloneNode(node.rightHandSide));
 
   @override
   AwaitExpression visitAwaitExpression(AwaitExpression node) =>
       new AwaitExpression(
           cloneToken(node.awaitKeyword), cloneNode(node.expression));
 
   @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) =>
       new BinaryExpression(cloneNode(node.leftOperand),
           cloneToken(node.operator), cloneNode(node.rightOperand));
 
   @override
   Block visitBlock(Block node) => new Block(cloneToken(node.leftBracket),
       cloneNodeList(node.statements), cloneToken(node.rightBracket));
 
   @override
-  BlockFunctionBody visitBlockFunctionBody(
-      BlockFunctionBody node) => new BlockFunctionBody(
-      cloneToken(node.keyword), cloneToken(node.star), cloneNode(node.block));
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) =>
+      new BlockFunctionBody(cloneToken(node.keyword), 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.breakKeyword), cloneNode(node.label),
+      cloneToken(node.breakKeyword),
+      cloneNode(node.label),
       cloneToken(node.semicolon));
 
   @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) =>
       new CascadeExpression(
           cloneNode(node.target), cloneNodeList(node.cascadeSections));
 
   @override
   CatchClause visitCatchClause(CatchClause node) => new CatchClause(
-      cloneToken(node.onKeyword), cloneNode(node.exceptionType),
-      cloneToken(node.catchKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.exceptionParameter), cloneToken(node.comma),
-      cloneNode(node.stackTraceParameter), cloneToken(node.rightParenthesis),
+      cloneToken(node.onKeyword),
+      cloneNode(node.exceptionType),
+      cloneToken(node.catchKeyword),
+      cloneToken(node.leftParenthesis),
+      cloneNode(node.exceptionParameter),
+      cloneToken(node.comma),
+      cloneNode(node.stackTraceParameter),
+      cloneToken(node.rightParenthesis),
       cloneNode(node.body));
 
   @override
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration copy = new ClassDeclaration(
-        cloneNode(node.documentationComment), cloneNodeList(node.metadata),
-        cloneToken(node.abstractKeyword), cloneToken(node.classKeyword),
-        cloneNode(node.name), cloneNode(node.typeParameters),
-        cloneNode(node.extendsClause), cloneNode(node.withClause),
-        cloneNode(node.implementsClause), cloneToken(node.leftBracket),
-        cloneNodeList(node.members), cloneToken(node.rightBracket));
+        cloneNode(node.documentationComment),
+        cloneNodeList(node.metadata),
+        cloneToken(node.abstractKeyword),
+        cloneToken(node.classKeyword),
+        cloneNode(node.name),
+        cloneNode(node.typeParameters),
+        cloneNode(node.extendsClause),
+        cloneNode(node.withClause),
+        cloneNode(node.implementsClause),
+        cloneToken(node.leftBracket),
+        cloneNodeList(node.members),
+        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.typedefKeyword), cloneNode(node.name),
-      cloneNode(node.typeParameters), cloneToken(node.equals),
-      cloneToken(node.abstractKeyword), cloneNode(node.superclass),
-      cloneNode(node.withClause), cloneNode(node.implementsClause),
+      cloneNode(node.documentationComment),
+      cloneNodeList(node.metadata),
+      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
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationCommentWithReferences(
           cloneTokenList(node.tokens), cloneNodeList(node.references));
     } else if (node.isBlock) {
       return Comment.createBlockComment(cloneTokenList(node.tokens));
     }
     return Comment.createEndOfLineComment(cloneTokenList(node.tokens));
   }
 
   @override
   CommentReference visitCommentReference(CommentReference node) =>
       new CommentReference(
           cloneToken(node.newKeyword), cloneNode(node.identifier));
 
   @override
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
-    CompilationUnit clone = new CompilationUnit(cloneToken(node.beginToken),
-        cloneNode(node.scriptTag), cloneNodeList(node.directives),
-        cloneNodeList(node.declarations), cloneToken(node.endToken));
+    CompilationUnit clone = new CompilationUnit(
+        cloneToken(node.beginToken),
+        cloneNode(node.scriptTag),
+        cloneNodeList(node.directives),
+        cloneNodeList(node.declarations),
+        cloneToken(node.endToken));
     clone.lineInfo = node.lineInfo;
     return clone;
   }
 
   @override
   ConditionalExpression visitConditionalExpression(
-      ConditionalExpression node) => new ConditionalExpression(
-      cloneNode(node.condition), cloneToken(node.question),
-      cloneNode(node.thenExpression), cloneToken(node.colon),
-      cloneNode(node.elseExpression));
+          ConditionalExpression node) =>
+      new ConditionalExpression(
+          cloneNode(node.condition),
+          cloneToken(node.question),
+          cloneNode(node.thenExpression),
+          cloneToken(node.colon),
+          cloneNode(node.elseExpression));
 
   @override
   ConstructorDeclaration visitConstructorDeclaration(
-      ConstructorDeclaration node) => new ConstructorDeclaration(
-      cloneNode(node.documentationComment), cloneNodeList(node.metadata),
-      cloneToken(node.externalKeyword), cloneToken(node.constKeyword),
-      cloneToken(node.factoryKeyword), cloneNode(node.returnType),
-      cloneToken(node.period), cloneNode(node.name), cloneNode(node.parameters),
-      cloneToken(node.separator), cloneNodeList(node.initializers),
-      cloneNode(node.redirectedConstructor), cloneNode(node.body));
+          ConstructorDeclaration node) =>
+      new ConstructorDeclaration(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.externalKeyword),
+          cloneToken(node.constKeyword),
+          cloneToken(node.factoryKeyword),
+          cloneNode(node.returnType),
+          cloneToken(node.period),
+          cloneNode(node.name),
+          cloneNode(node.parameters),
+          cloneToken(node.separator),
+          cloneNodeList(node.initializers),
+          cloneNode(node.redirectedConstructor),
+          cloneNode(node.body));
 
   @override
   ConstructorFieldInitializer visitConstructorFieldInitializer(
-      ConstructorFieldInitializer node) => new ConstructorFieldInitializer(
-      cloneToken(node.thisKeyword), cloneToken(node.period),
-      cloneNode(node.fieldName), cloneToken(node.equals),
-      cloneNode(node.expression));
+          ConstructorFieldInitializer node) =>
+      new ConstructorFieldInitializer(
+          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.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), cloneNode(node.identifier));
+      new DeclaredIdentifier(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.keyword),
+          cloneNode(node.type),
+          cloneNode(node.identifier));
 
   @override
   DefaultFormalParameter visitDefaultFormalParameter(
-      DefaultFormalParameter node) => new DefaultFormalParameter(
-      cloneNode(node.parameter), node.kind, cloneToken(node.separator),
-      cloneNode(node.defaultValue));
+          DefaultFormalParameter node) =>
+      new DefaultFormalParameter(cloneNode(node.parameter), node.kind,
+          cloneToken(node.separator), cloneNode(node.defaultValue));
 
   @override
   DoStatement visitDoStatement(DoStatement node) => new DoStatement(
-      cloneToken(node.doKeyword), cloneNode(node.body),
-      cloneToken(node.whileKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.condition), cloneToken(node.rightParenthesis),
+      cloneToken(node.doKeyword),
+      cloneNode(node.body),
+      cloneToken(node.whileKeyword),
+      cloneToken(node.leftParenthesis),
+      cloneNode(node.condition),
+      cloneToken(node.rightParenthesis),
       cloneToken(node.semicolon));
 
   @override
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) =>
       new DoubleLiteral(cloneToken(node.literal), node.value);
 
   @override
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) =>
       new EmptyFunctionBody(cloneToken(node.semicolon));
 
   @override
   EmptyStatement visitEmptyStatement(EmptyStatement node) =>
       new EmptyStatement(cloneToken(node.semicolon));
 
   @override
   AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
       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.enumKeyword),
-          cloneNode(node.name), cloneToken(node.leftBracket),
-          cloneNodeList(node.constants), cloneToken(node.rightBracket));
+      new EnumDeclaration(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          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),
-        cloneToken(node.keyword), cloneNode(node.uri),
-        cloneNodeList(node.combinators), cloneToken(node.semicolon));
+        cloneNode(node.documentationComment),
+        cloneNodeList(node.metadata),
+        cloneToken(node.keyword),
+        cloneNode(node.uri),
+        cloneNodeList(node.combinators),
+        cloneToken(node.semicolon));
     directive.source = node.source;
     directive.uriContent = node.uriContent;
     return directive;
   }
 
   @override
   ExpressionFunctionBody visitExpressionFunctionBody(
-      ExpressionFunctionBody node) => new ExpressionFunctionBody(
-      cloneToken(node.keyword), cloneToken(node.functionDefinition),
-      cloneNode(node.expression), cloneToken(node.semicolon));
+          ExpressionFunctionBody node) =>
+      new ExpressionFunctionBody(
+          cloneToken(node.keyword),
+          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.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));
+      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.thisKeyword),
-          cloneToken(node.period), cloneNode(node.identifier),
-          cloneNode(node.typeParameters), cloneNode(node.parameters));
+      new FieldFormalParameter(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.keyword),
+          cloneNode(node.type),
+          cloneToken(node.thisKeyword),
+          cloneToken(node.period),
+          cloneNode(node.identifier),
+          cloneNode(node.typeParameters),
+          cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.withReference(cloneToken(node.awaitKeyword),
-          cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
-          cloneNode(node.identifier), cloneToken(node.inKeyword),
-          cloneNode(node.iterable), cloneToken(node.rightParenthesis),
+      return new ForEachStatement.withReference(
+          cloneToken(node.awaitKeyword),
+          cloneToken(node.forKeyword),
+          cloneToken(node.leftParenthesis),
+          cloneNode(node.identifier),
+          cloneToken(node.inKeyword),
+          cloneNode(node.iterable),
+          cloneToken(node.rightParenthesis),
           cloneNode(node.body));
     }
-    return new ForEachStatement.withDeclaration(cloneToken(node.awaitKeyword),
-        cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
-        cloneNode(loopVariable), cloneToken(node.inKeyword),
-        cloneNode(node.iterable), cloneToken(node.rightParenthesis),
+    return new ForEachStatement.withDeclaration(
+        cloneToken(node.awaitKeyword),
+        cloneToken(node.forKeyword),
+        cloneToken(node.leftParenthesis),
+        cloneNode(loopVariable),
+        cloneToken(node.inKeyword),
+        cloneNode(node.iterable),
+        cloneToken(node.rightParenthesis),
         cloneNode(node.body));
   }
 
   @override
   FormalParameterList visitFormalParameterList(FormalParameterList node) =>
-      new FormalParameterList(cloneToken(node.leftParenthesis),
-          cloneNodeList(node.parameters), cloneToken(node.leftDelimiter),
-          cloneToken(node.rightDelimiter), cloneToken(node.rightParenthesis));
+      new FormalParameterList(
+          cloneToken(node.leftParenthesis),
+          cloneNodeList(node.parameters),
+          cloneToken(node.leftDelimiter),
+          cloneToken(node.rightDelimiter),
+          cloneToken(node.rightParenthesis));
 
   @override
   ForStatement visitForStatement(ForStatement node) => new ForStatement(
-      cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.variables), cloneNode(node.initialization),
-      cloneToken(node.leftSeparator), cloneNode(node.condition),
-      cloneToken(node.rightSeparator), cloneNodeList(node.updaters),
-      cloneToken(node.rightParenthesis), cloneNode(node.body));
+      cloneToken(node.forKeyword),
+      cloneToken(node.leftParenthesis),
+      cloneNode(node.variables),
+      cloneNode(node.initialization),
+      cloneToken(node.leftSeparator),
+      cloneNode(node.condition),
+      cloneToken(node.rightSeparator),
+      cloneNodeList(node.updaters),
+      cloneToken(node.rightParenthesis),
+      cloneNode(node.body));
 
   @override
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) =>
-      new FunctionDeclaration(cloneNode(node.documentationComment),
-          cloneNodeList(node.metadata), cloneToken(node.externalKeyword),
-          cloneNode(node.returnType), cloneToken(node.propertyKeyword),
-          cloneNode(node.name), cloneNode(node.functionExpression));
+      new FunctionDeclaration(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.externalKeyword),
+          cloneNode(node.returnType),
+          cloneToken(node.propertyKeyword),
+          cloneNode(node.name),
+          cloneNode(node.functionExpression));
 
   @override
   FunctionDeclarationStatement visitFunctionDeclarationStatement(
           FunctionDeclarationStatement node) =>
       new FunctionDeclarationStatement(cloneNode(node.functionDeclaration));
 
   @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) =>
       new FunctionExpression(cloneNode(node.typeParameters),
           cloneNode(node.parameters), cloneNode(node.body));
 
   @override
   FunctionExpressionInvocation visitFunctionExpressionInvocation(
-      FunctionExpressionInvocation node) => new FunctionExpressionInvocation(
-      cloneNode(node.function), cloneNode(node.typeArguments),
-      cloneNode(node.argumentList));
+          FunctionExpressionInvocation node) =>
+      new FunctionExpressionInvocation(cloneNode(node.function),
+          cloneNode(node.typeArguments), cloneNode(node.argumentList));
 
   @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
-      new FunctionTypeAlias(cloneNode(node.documentationComment),
-          cloneNodeList(node.metadata), cloneToken(node.typedefKeyword),
-          cloneNode(node.returnType), cloneNode(node.name),
-          cloneNode(node.typeParameters), cloneNode(node.parameters),
+      new FunctionTypeAlias(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          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(
-      cloneNode(node.documentationComment), cloneNodeList(node.metadata),
-      cloneNode(node.returnType), cloneNode(node.identifier),
-      cloneNode(node.typeParameters), cloneNode(node.parameters));
+          FunctionTypedFormalParameter node) =>
+      new FunctionTypedFormalParameter(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneNode(node.returnType),
+          cloneNode(node.identifier),
+          cloneNode(node.typeParameters),
+          cloneNode(node.parameters));
 
   @override
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(
       cloneToken(node.keyword), cloneNodeList(node.hiddenNames));
 
   @override
   IfStatement visitIfStatement(IfStatement node) => new IfStatement(
-      cloneToken(node.ifKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.condition), cloneToken(node.rightParenthesis),
-      cloneNode(node.thenStatement), cloneToken(node.elseKeyword),
+      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.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.deferredKeyword), cloneToken(node.asKeyword),
-        cloneNode(node.prefix), cloneNodeList(node.combinators),
+        cloneNode(node.documentationComment),
+        cloneNodeList(node.metadata),
+        cloneToken(node.keyword),
+        cloneNode(node.uri),
+        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) {
     Token period = node.period;
     if (period == null) {
-      return new IndexExpression.forTarget(cloneNode(node.target),
-          cloneToken(node.leftBracket), cloneNode(node.index),
+      return new IndexExpression.forTarget(
+          cloneNode(node.target),
+          cloneToken(node.leftBracket),
+          cloneNode(node.index),
           cloneToken(node.rightBracket));
     } else {
-      return new IndexExpression.forCascade(cloneToken(period),
-          cloneToken(node.leftBracket), cloneNode(node.index),
+      return new IndexExpression.forCascade(
+          cloneToken(period),
+          cloneToken(node.leftBracket),
+          cloneNode(node.index),
           cloneToken(node.rightBracket));
     }
   }
 
   @override
   InstanceCreationExpression visitInstanceCreationExpression(
-      InstanceCreationExpression node) => new InstanceCreationExpression(
-      cloneToken(node.keyword), cloneNode(node.constructorName),
-      cloneNode(node.argumentList));
+          InstanceCreationExpression node) =>
+      new InstanceCreationExpression(cloneToken(node.keyword),
+          cloneNode(node.constructorName), cloneNode(node.argumentList));
 
   @override
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) =>
       new IntegerLiteral(cloneToken(node.literal), node.value);
 
   @override
   InterpolationExpression visitInterpolationExpression(
-      InterpolationExpression node) => new InterpolationExpression(
-      cloneToken(node.leftBracket), cloneNode(node.expression),
-      cloneToken(node.rightBracket));
+          InterpolationExpression node) =>
+      new InterpolationExpression(cloneToken(node.leftBracket),
+          cloneNode(node.expression), cloneToken(node.rightBracket));
 
   @override
   InterpolationString visitInterpolationString(InterpolationString node) =>
       new InterpolationString(cloneToken(node.contents), node.value);
 
   @override
   IsExpression visitIsExpression(IsExpression node) => new IsExpression(
-      cloneNode(node.expression), cloneToken(node.isOperator),
-      cloneToken(node.notOperator), cloneNode(node.type));
+      cloneNode(node.expression),
+      cloneToken(node.isOperator),
+      cloneToken(node.notOperator),
+      cloneNode(node.type));
 
   @override
   Label visitLabel(Label node) =>
       new Label(cloneNode(node.label), cloneToken(node.colon));
 
   @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.libraryKeyword),
-          cloneNode(node.name), cloneToken(node.semicolon));
+      new LibraryDirective(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          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(
-      cloneToken(node.constKeyword), cloneNode(node.typeArguments),
-      cloneToken(node.leftBracket), cloneNodeList(node.elements),
+      cloneToken(node.constKeyword),
+      cloneNode(node.typeArguments),
+      cloneToken(node.leftBracket),
+      cloneNodeList(node.elements),
       cloneToken(node.rightBracket));
 
   @override
   MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral(
-      cloneToken(node.constKeyword), cloneNode(node.typeArguments),
-      cloneToken(node.leftBracket), cloneNodeList(node.entries),
+      cloneToken(node.constKeyword),
+      cloneNode(node.typeArguments),
+      cloneToken(node.leftBracket),
+      cloneNodeList(node.entries),
       cloneToken(node.rightBracket));
 
   @override
-  MapLiteralEntry visitMapLiteralEntry(
-      MapLiteralEntry node) => new MapLiteralEntry(
-      cloneNode(node.key), cloneToken(node.separator), cloneNode(node.value));
+  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) =>
+      new MapLiteralEntry(cloneNode(node.key), cloneToken(node.separator),
+          cloneNode(node.value));
 
   @override
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
-      new MethodDeclaration(cloneNode(node.documentationComment),
-          cloneNodeList(node.metadata), cloneToken(node.externalKeyword),
-          cloneToken(node.modifierKeyword), cloneNode(node.returnType),
-          cloneToken(node.propertyKeyword), cloneToken(node.operatorKeyword),
-          cloneNode(node.name), cloneNode(node.typeParameters),
-          cloneNode(node.parameters), cloneNode(node.body));
+      new MethodDeclaration(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.externalKeyword),
+          cloneToken(node.modifierKeyword),
+          cloneNode(node.returnType),
+          cloneToken(node.propertyKeyword),
+          cloneToken(node.operatorKeyword),
+          cloneNode(node.name),
+          cloneNode(node.typeParameters),
+          cloneNode(node.parameters),
+          cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) =>
-      new MethodInvocation(cloneNode(node.target), cloneToken(node.operator),
-          cloneNode(node.methodName), cloneNode(node.typeArguments),
+      new MethodInvocation(
+          cloneNode(node.target),
+          cloneToken(node.operator),
+          cloneNode(node.methodName),
+          cloneNode(node.typeArguments),
           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.nativeKeyword), cloneNode(node.name));
 
   @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
       new NativeFunctionBody(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));
+          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.partKeyword), cloneNode(node.uri),
+        cloneNode(node.documentationComment),
+        cloneNodeList(node.metadata),
+        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.partKeyword),
-          cloneToken(node.ofKeyword), cloneNode(node.libraryName),
+      new PartOfDirective(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          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.target),
+      cloneToken(node.operator),
       cloneNode(node.propertyName));
 
   @override
   RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
           RedirectingConstructorInvocation node) =>
-      new RedirectingConstructorInvocation(cloneToken(node.thisKeyword),
-          cloneToken(node.period), cloneNode(node.constructorName),
+      new RedirectingConstructorInvocation(
+          cloneToken(node.thisKeyword),
+          cloneToken(node.period),
+          cloneNode(node.constructorName),
           cloneNode(node.argumentList));
 
   @override
   RethrowExpression visitRethrowExpression(RethrowExpression node) =>
       new RethrowExpression(cloneToken(node.rethrowKeyword));
 
   @override
   ReturnStatement visitReturnStatement(ReturnStatement node) =>
       new ReturnStatement(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));
 
   @override
   SimpleFormalParameter visitSimpleFormalParameter(
-      SimpleFormalParameter node) => new SimpleFormalParameter(
-      cloneNode(node.documentationComment), cloneNodeList(node.metadata),
-      cloneToken(node.keyword), cloneNode(node.type),
-      cloneNode(node.identifier));
+          SimpleFormalParameter node) =>
+      new SimpleFormalParameter(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.keyword),
+          cloneNode(node.type),
+          cloneNode(node.identifier));
 
   @override
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) =>
       new SimpleIdentifier(cloneToken(node.token));
 
   @override
   SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) =>
       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.superKeyword), cloneToken(node.period),
-      cloneNode(node.constructorName), cloneNode(node.argumentList));
+          SuperConstructorInvocation node) =>
+      new SuperConstructorInvocation(
+          cloneToken(node.superKeyword),
+          cloneToken(node.period),
+          cloneNode(node.constructorName),
+          cloneNode(node.argumentList));
 
   @override
   SuperExpression visitSuperExpression(SuperExpression node) =>
       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.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));
+      cloneNodeList(node.labels),
+      cloneToken(node.keyword),
+      cloneToken(node.colon),
+      cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) =>
-      new SwitchStatement(cloneToken(node.switchKeyword),
-          cloneToken(node.leftParenthesis), cloneNode(node.expression),
-          cloneToken(node.rightParenthesis), cloneToken(node.leftBracket),
-          cloneNodeList(node.members), cloneToken(node.rightBracket));
+      new SwitchStatement(
+          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.thisKeyword));
 
   @override
   ThrowExpression visitThrowExpression(ThrowExpression node) =>
       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));
+          TopLevelVariableDeclaration node) =>
+      new TopLevelVariableDeclaration(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneNode(node.variables),
+          cloneToken(node.semicolon));
 
   @override
   TryStatement visitTryStatement(TryStatement node) => new TryStatement(
-      cloneToken(node.tryKeyword), cloneNode(node.body),
-      cloneNodeList(node.catchClauses), cloneToken(node.finallyKeyword),
+      cloneToken(node.tryKeyword),
+      cloneNode(node.body),
+      cloneNodeList(node.catchClauses),
+      cloneToken(node.finallyKeyword),
       cloneNode(node.finallyBlock));
 
   @override
   TypeArgumentList visitTypeArgumentList(TypeArgumentList node) =>
       new TypeArgumentList(cloneToken(node.leftBracket),
           cloneNodeList(node.arguments), cloneToken(node.rightBracket));
 
   @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.extendsKeyword),
+      cloneNode(node.documentationComment),
+      cloneNodeList(node.metadata),
+      cloneNode(node.name),
+      cloneToken(node.extendsKeyword),
       cloneNode(node.bound));
 
   @override
   TypeParameterList visitTypeParameterList(TypeParameterList node) =>
       new TypeParameterList(cloneToken(node.leftBracket),
           cloneNodeList(node.typeParameters), cloneToken(node.rightBracket));
 
   @override
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) =>
       new VariableDeclaration(cloneNode(node.name), cloneToken(node.equals),
           cloneNode(node.initializer));
 
   @override
   VariableDeclarationList visitVariableDeclarationList(
-      VariableDeclarationList node) => new VariableDeclarationList(
-      cloneNode(node.documentationComment), cloneNodeList(node.metadata),
-      cloneToken(node.keyword), cloneNode(node.type),
-      cloneNodeList(node.variables));
+          VariableDeclarationList node) =>
+      new VariableDeclarationList(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.keyword),
+          cloneNode(node.type),
+          cloneNodeList(node.variables));
 
   @override
   VariableDeclarationStatement visitVariableDeclarationStatement(
-      VariableDeclarationStatement node) => new VariableDeclarationStatement(
-      cloneNode(node.variables), cloneToken(node.semicolon));
+          VariableDeclarationStatement node) =>
+      new VariableDeclarationStatement(
+          cloneNode(node.variables), cloneToken(node.semicolon));
 
   @override
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(
-      cloneToken(node.whileKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.condition), cloneToken(node.rightParenthesis),
+      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
   YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(
-      cloneToken(node.yieldKeyword), cloneToken(node.star),
-      cloneNode(node.expression), cloneToken(node.semicolon));
+      cloneToken(node.yieldKeyword),
+      cloneToken(node.star),
+      cloneNode(node.expression),
+      cloneToken(node.semicolon));
 
   /**
    * Return a clone of the given [node].
    */
   static AstNode clone(AstNode node) {
     return node.accept(new AstCloner());
   }
 }
 
 /**
@@ skipping 73 matching lines @@
 
   @override
   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) {

[Brian Wilkerson, 2015/09/02 15:49:15]

This needs to be updated to compare the new children.

[Paul Berry, 2015/09/07 19:44:29]

Done.

     AssertStatement other = _other as AssertStatement;
     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) {
@@ skipping 974 matching lines @@
    */
   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 the offset of the first node is
    * greater than the offset of the second node.
    */
-  static Comparator<AstNode> LEXICAL_ORDER =
-      (AstNode first, AstNode second) => first.offset - second.offset;
+  static Comparator<AstNode> LEXICAL_ORDER = (AstNode first, AstNode second) =>
+      first.offset - second.offset;
 
   /**
    * The parent of the node, or `null` if the node is the root of an AST
    * structure.
    */
   AstNode _parent;
 
   /**
    * A table mapping the names of properties to their values, or `null` if this
    * node does not have any properties associated with it.
@@ skipping 1098 matching lines @@
    * 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) {
+  CatchClause(
+      this.onKeyword,
+      TypeName exceptionType,
+      this.catchKeyword,
+      this.leftParenthesis,
+      SimpleIdentifier exceptionParameter,
+      this.comma,
+      SimpleIdentifier stackTraceParameter,
+      this.rightParenthesis,
+      Block body) {
     _exceptionType = _becomeParentOf(exceptionType);
     _exceptionParameter = _becomeParentOf(exceptionParameter);
     _stackTraceParameter = _becomeParentOf(stackTraceParameter);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
@@ skipping 182 matching lines @@
   /**
    * Initialize a newly created class declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the class does not have the
    * corresponding attribute. The [abstractKeyword] can be `null` if the class
    * is not abstract. The [typeParameters] can be `null` if the class does not
    * have any type parameters. Any or all of the [extendsClause], [withClause],
    * 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)
+  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) {
     _typeParameters = _becomeParentOf(typeParameters);
     _extendsClause = _becomeParentOf(extendsClause);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
     _members = new NodeList<ClassMember>(this, members);
   }
 
   @override
   Iterable get childEntities => super._childEntities
@@ skipping 231 matching lines @@
   ImplementsClause _implementsClause;
 
   /**
    * Initialize a newly created class type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the class type alias does not
    * 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)
+  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, name, semicolon) {
     _typeParameters = _becomeParentOf(typeParameters);
     _superclass = _becomeParentOf(superclass);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(typedefKeyword)
@@ skipping 366 matching lines @@
    */
   LineInfo lineInfo;
 
   /**
    * 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,
+  CompilationUnit(
+      this.beginToken,
+      ScriptTag scriptTag,
+      List<Directive> directives,
+      List<CompilationUnitMember> declarations,
       this.endToken) {
     _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) {
@@ skipping 650 matching lines @@
    * constructor cannot be used to create a constant. The [factoryKeyword] can
    * be `null` if the constructor is not a factory. The [period] and [name] can
    * both be `null` if the constructor is not a named constructor. The
    * [separator] can be `null` if the constructor does not have any initializers
    * and does not redirect to a different constructor. The list of
    * [initializers] can be `null` if the constructor does not have any
    * initializers. The [redirectedConstructor] can be `null` if the constructor
    * 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,
+  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)
+      ConstructorName redirectedConstructor,
+      FunctionBody body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _parameters = _becomeParentOf(parameters);
     _initializers = new NodeList<ConstructorInitializer>(this, initializers);
     _redirectedConstructor = _becomeParentOf(redirectedConstructor);
     _body = _becomeParentOf(body);
   }
 
   /**
@@ skipping 760 matching lines @@
   Token rightParenthesis;
 
   /**
    * 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,
+  DoStatement(
+      this.doKeyword,
+      Statement body,
+      this.whileKeyword,
+      this.leftParenthesis,
+      Expression condition,
+      this.rightParenthesis,
       this.semicolon) {
     _body = _becomeParentOf(body);
     _condition = _becomeParentOf(condition);
   }
 
   @override
   Token get beginToken => doKeyword;
 
   /**
    * Return the body of the loop.
@@ skipping 385 matching lines @@
    * 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.enumKeyword,
-      SimpleIdentifier name, this.leftBracket,
-      List<EnumConstantDeclaration> constants, this.rightBracket)
+  EnumDeclaration(
+      Comment comment,
+      List<Annotation> metadata,
+      this.enumKeyword,
+      SimpleIdentifier name,
+      this.leftBracket,
+      List<EnumConstantDeclaration> constants,
+      this.rightBracket)
       : super(comment, metadata, name) {
     _constants = new NodeList<EnumConstantDeclaration>(this, constants);
   }
 
   @override
   // TODO(brianwilkerson) Add commas?
   Iterable get childEntities => super._childEntities
     ..add(enumKeyword)
     ..add(_name)
     ..add(leftBracket)
@@ skipping 594 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 there is a type.
    * 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.thisKeyword, this.period, SimpleIdentifier identifier,
-      TypeParameterList typeParameters, FormalParameterList parameters)
+  FieldFormalParameter(
+      Comment comment,
+      List<Annotation> metadata,
+      this.keyword,
+      TypeName type,
+      this.thisKeyword,
+      this.period,
+      SimpleIdentifier identifier,
+      TypeParameterList typeParameters,
+      FormalParameterList parameters)
       : super(comment, metadata, identifier) {
     _type = _becomeParentOf(type);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
@@ skipping 151 matching lines @@
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * Initialize a newly created for-each statement. The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   @deprecated // Use new ForEachStatement.withDeclaration(...)
-  ForEachStatement.con1(this.awaitKeyword, this.forKeyword,
-      this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword,
-      Expression iterator, this.rightParenthesis, Statement body) {
+  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);
   }
 
   /**
    * Initialize a newly created for-each statement. The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   @deprecated // Use new ForEachStatement.withReference(...)
-  ForEachStatement.con2(this.awaitKeyword, this.forKeyword,
-      this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword,
-      Expression iterator, this.rightParenthesis, Statement body) {
+  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);
   }
 
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared internally (in the for-loop part). The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
-  ForEachStatement.withDeclaration(this.awaitKeyword, this.forKeyword,
-      this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword,
-      Expression iterator, this.rightParenthesis, Statement body) {
+  ForEachStatement.withDeclaration(
+      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);
   }
 
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared outside the for loop. The [awaitKeyword] can be `null` if this
    * is not an asynchronous for loop.
    */
-  ForEachStatement.withReference(this.awaitKeyword, this.forKeyword,
-      this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword,
-      Expression iterator, this.rightParenthesis, Statement body) {
+  ForEachStatement.withReference(
+      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);
   }
 
   @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
@@ skipping 310 matching lines @@
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * 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) {
+  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);
     _updaters = new NodeList<Expression>(this, updaters);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => forKeyword;
 
@@ skipping 154 matching lines @@
   FunctionExpression _functionExpression;
 
   /**
    * Initialize a newly created function declaration. Either or both of the
    * [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)
+  FunctionDeclaration(
+      Comment comment,
+      List<Annotation> metadata,
+      this.externalKeyword,
+      TypeName returnType,
+      this.propertyKeyword,
+      SimpleIdentifier name,
+      FunctionExpression functionExpression)
       : super(comment, metadata, name) {
     _returnType = _becomeParentOf(returnType);
     _functionExpression = _becomeParentOf(functionExpression);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(externalKeyword)
     ..add(_returnType)
     ..add(propertyKeyword)
@@ skipping 395 matching lines @@
    */
   FormalParameterList _parameters;
 
   /**
    * 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,
+  FunctionTypeAlias(
+      Comment comment,
+      List<Annotation> metadata,
+      Token keyword,
+      TypeName returnType,
+      SimpleIdentifier name,
+      TypeParameterList typeParameters,
+      FormalParameterList parameters,
       Token semicolon)
       : super(comment, metadata, keyword, name, semicolon) {
     _returnType = _becomeParentOf(returnType);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(typedefKeyword)
@@ skipping 84 matching lines @@
    * The parameters of the function-typed 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 [returnType] can be `null` if no return type
    * was specified.
    */
-  FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata,
-      TypeName returnType, SimpleIdentifier identifier,
-      TypeParameterList typeParameters, FormalParameterList parameters)
+  FunctionTypedFormalParameter(
+      Comment comment,
+      List<Annotation> metadata,
+      TypeName returnType,
+      SimpleIdentifier identifier,
+      TypeParameterList typeParameters,
+      FormalParameterList parameters)
       : super(comment, metadata, identifier) {
     _returnType = _becomeParentOf(returnType);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
@@ skipping 636 matching lines @@
   /**
    * The statement that is executed if the condition evaluates to `false`, or
    * `null` if there is no else statement.
    */
   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,
+  IfStatement(
+      this.ifKeyword,
+      this.leftParenthesis,
+      Expression condition,
+      this.rightParenthesis,
+      Statement thenStatement,
+      this.elseKeyword,
       Statement elseStatement) {
     _condition = _becomeParentOf(condition);
     _thenStatement = _becomeParentOf(thenStatement);
     _elseStatement = _becomeParentOf(elseStatement);
   }
 
   @override
   Token get beginToken => ifKeyword;
 
   @override
@@ skipping 133 matching lines @@
 }
 
 /**
  * An import directive.
  *
  * > importDirective ::=
  * >     [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  * >   | [Annotation] 'import' [StringLiteral] 'deferred' 'as' identifier [Combinator]* ';'
  */
 class ImportDirective extends NamespaceDirective {
-  static Comparator<ImportDirective> COMPARATOR = (ImportDirective import1,
-      ImportDirective import2) {
+  static Comparator<ImportDirective> COMPARATOR =
+      (ImportDirective import1, ImportDirective import2) {
     //
     // uri
     //
     StringLiteral uri1 = import1.uri;
     StringLiteral uri2 = import2.uri;
     String uriStr1 = uri1.stringValue;
     String uriStr2 = uri2.stringValue;
     if (uriStr1 != null || uriStr2 != null) {
       if (uriStr1 == null) {
         return -1;
@@ skipping 98 matching lines @@
   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 [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.deferredKeyword, this.asKeyword,
-      SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon)
+  ImportDirective(
+      Comment comment,
+      List<Annotation> metadata,
+      Token keyword,
+      StringLiteral libraryUri,
+      this.deferredKeyword,
+      this.asKeyword,
+      SimpleIdentifier prefix,
+      List<Combinator> combinators,
+      Token semicolon)
       : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
     _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;
@@ skipping 94 matching lines @@
    * mapping of old tokens to new tokens.
    */
   IncrementalAstCloner(this._oldNode, this._newNode, this._tokenMap);
 
   @override
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) =>
       new AdjacentStrings(_cloneNodeList(node.strings));
 
   @override
   Annotation visitAnnotation(Annotation node) {
-    Annotation copy = new Annotation(_mapToken(node.atSign),
-        _cloneNode(node.name), _mapToken(node.period),
-        _cloneNode(node.constructorName), _cloneNode(node.arguments));
+    Annotation copy = new Annotation(
+        _mapToken(node.atSign),
+        _cloneNode(node.name),
+        _mapToken(node.period),
+        _cloneNode(node.constructorName),
+        _cloneNode(node.arguments));
     copy.element = node.element;
     return copy;
   }
 
   @override
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(
-      _mapToken(node.leftParenthesis), _cloneNodeList(node.arguments),
+      _mapToken(node.leftParenthesis),
+      _cloneNodeList(node.arguments),
       _mapToken(node.rightParenthesis));
 
   @override
   AsExpression visitAsExpression(AsExpression node) {
     AsExpression copy = new AsExpression(_cloneNode(node.expression),
         _mapToken(node.asOperator), _cloneNode(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(

[Brian Wilkerson, 2015/09/02 15:49:16]

This needs to be updated to map/clone the new children.

[Paul Berry, 2015/09/07 19:44:29]

Done.

-      _mapToken(node.assertKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.condition), _mapToken(node.rightParenthesis),
+      _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),
+        _cloneNode(node.leftHandSide),
+        _mapToken(node.operator),
         _cloneNode(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AwaitExpression visitAwaitExpression(AwaitExpression node) =>
       new AwaitExpression(
           _mapToken(node.awaitKeyword), _cloneNode(node.expression));
 
   @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) {
     BinaryExpression copy = new BinaryExpression(_cloneNode(node.leftOperand),
         _mapToken(node.operator), _cloneNode(node.rightOperand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   Block visitBlock(Block node) => new Block(_mapToken(node.leftBracket),
       _cloneNodeList(node.statements), _mapToken(node.rightBracket));
 
   @override
-  BlockFunctionBody visitBlockFunctionBody(
-      BlockFunctionBody node) => new BlockFunctionBody(
-      _mapToken(node.keyword), _mapToken(node.star), _cloneNode(node.block));
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) =>
+      new BlockFunctionBody(_mapToken(node.keyword), _mapToken(node.star),
+          _cloneNode(node.block));
 
   @override
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) {
     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.breakKeyword), _cloneNode(node.label),
+      _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;
     return copy;
   }
 
   @override
   CatchClause visitCatchClause(CatchClause node) => new CatchClause(
-      _mapToken(node.onKeyword), _cloneNode(node.exceptionType),
-      _mapToken(node.catchKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.exceptionParameter), _mapToken(node.comma),
-      _cloneNode(node.stackTraceParameter), _mapToken(node.rightParenthesis),
+      _mapToken(node.onKeyword),
+      _cloneNode(node.exceptionType),
+      _mapToken(node.catchKeyword),
+      _mapToken(node.leftParenthesis),
+      _cloneNode(node.exceptionParameter),
+      _mapToken(node.comma),
+      _cloneNode(node.stackTraceParameter),
+      _mapToken(node.rightParenthesis),
       _cloneNode(node.body));
 
   @override
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration copy = new ClassDeclaration(
-        _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
-        _mapToken(node.abstractKeyword), _mapToken(node.classKeyword),
-        _cloneNode(node.name), _cloneNode(node.typeParameters),
-        _cloneNode(node.extendsClause), _cloneNode(node.withClause),
-        _cloneNode(node.implementsClause), _mapToken(node.leftBracket),
-        _cloneNodeList(node.members), _mapToken(node.rightBracket));
+        _cloneNode(node.documentationComment),
+        _cloneNodeList(node.metadata),
+        _mapToken(node.abstractKeyword),
+        _mapToken(node.classKeyword),
+        _cloneNode(node.name),
+        _cloneNode(node.typeParameters),
+        _cloneNode(node.extendsClause),
+        _cloneNode(node.withClause),
+        _cloneNode(node.implementsClause),
+        _mapToken(node.leftBracket),
+        _cloneNodeList(node.members),
+        _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.typedefKeyword), _cloneNode(node.name),
-      _cloneNode(node.typeParameters), _mapToken(node.equals),
-      _mapToken(node.abstractKeyword), _cloneNode(node.superclass),
-      _cloneNode(node.withClause), _cloneNode(node.implementsClause),
+      _cloneNode(node.documentationComment),
+      _cloneNodeList(node.metadata),
+      _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
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationCommentWithReferences(
           _mapTokens(node.tokens), _cloneNodeList(node.references));
     } else if (node.isBlock) {
       return Comment.createBlockComment(_mapTokens(node.tokens));
     }
     return Comment.createEndOfLineComment(_mapTokens(node.tokens));
   }
 
   @override
   CommentReference visitCommentReference(CommentReference node) =>
       new CommentReference(
           _mapToken(node.newKeyword), _cloneNode(node.identifier));
 
   @override
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
-    CompilationUnit copy = new CompilationUnit(_mapToken(node.beginToken),
-        _cloneNode(node.scriptTag), _cloneNodeList(node.directives),
-        _cloneNodeList(node.declarations), _mapToken(node.endToken));
+    CompilationUnit copy = new CompilationUnit(
+        _mapToken(node.beginToken),
+        _cloneNode(node.scriptTag),
+        _cloneNodeList(node.directives),
+        _cloneNodeList(node.declarations),
+        _mapToken(node.endToken));
     copy.lineInfo = node.lineInfo;
     copy.element = node.element;
     return copy;
   }
 
   @override
   ConditionalExpression visitConditionalExpression(ConditionalExpression node) {
     ConditionalExpression copy = new ConditionalExpression(
-        _cloneNode(node.condition), _mapToken(node.question),
-        _cloneNode(node.thenExpression), _mapToken(node.colon),
+        _cloneNode(node.condition),
+        _mapToken(node.question),
+        _cloneNode(node.thenExpression),
+        _mapToken(node.colon),
         _cloneNode(node.elseExpression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ConstructorDeclaration visitConstructorDeclaration(
       ConstructorDeclaration node) {
     ConstructorDeclaration copy = new ConstructorDeclaration(
-        _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
-        _mapToken(node.externalKeyword), _mapToken(node.constKeyword),
-        _mapToken(node.factoryKeyword), _cloneNode(node.returnType),
-        _mapToken(node.period), _cloneNode(node.name),
-        _cloneNode(node.parameters), _mapToken(node.separator),
+        _cloneNode(node.documentationComment),
+        _cloneNodeList(node.metadata),
+        _mapToken(node.externalKeyword),
+        _mapToken(node.constKeyword),
+        _mapToken(node.factoryKeyword),
+        _cloneNode(node.returnType),
+        _mapToken(node.period),
+        _cloneNode(node.name),
+        _cloneNode(node.parameters),
+        _mapToken(node.separator),
         _cloneNodeList(node.initializers),
-        _cloneNode(node.redirectedConstructor), _cloneNode(node.body));
+        _cloneNode(node.redirectedConstructor),
+        _cloneNode(node.body));
     copy.element = node.element;
     return copy;
   }
 
   @override
   ConstructorFieldInitializer visitConstructorFieldInitializer(
-      ConstructorFieldInitializer node) => new ConstructorFieldInitializer(
-      _mapToken(node.thisKeyword), _mapToken(node.period),
-      _cloneNode(node.fieldName), _mapToken(node.equals),
-      _cloneNode(node.expression));
+          ConstructorFieldInitializer node) =>
+      new ConstructorFieldInitializer(
+          _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.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), _cloneNode(node.identifier));
+      new DeclaredIdentifier(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.keyword),
+          _cloneNode(node.type),
+          _cloneNode(node.identifier));
 
   @override
   DefaultFormalParameter visitDefaultFormalParameter(
-      DefaultFormalParameter node) => new DefaultFormalParameter(
-      _cloneNode(node.parameter), node.kind, _mapToken(node.separator),
-      _cloneNode(node.defaultValue));
+          DefaultFormalParameter node) =>
+      new DefaultFormalParameter(_cloneNode(node.parameter), node.kind,
+          _mapToken(node.separator), _cloneNode(node.defaultValue));
 
   @override
   DoStatement visitDoStatement(DoStatement node) => new DoStatement(
-      _mapToken(node.doKeyword), _cloneNode(node.body),
-      _mapToken(node.whileKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.condition), _mapToken(node.rightParenthesis),
+      _mapToken(node.doKeyword),
+      _cloneNode(node.body),
+      _mapToken(node.whileKeyword),
+      _mapToken(node.leftParenthesis),
+      _cloneNode(node.condition),
+      _mapToken(node.rightParenthesis),
       _mapToken(node.semicolon));
 
   @override
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral copy = new DoubleLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) =>
       new EmptyFunctionBody(_mapToken(node.semicolon));
 
   @override
   EmptyStatement visitEmptyStatement(EmptyStatement node) =>
       new EmptyStatement(_mapToken(node.semicolon));
 
   @override
   AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
       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.enumKeyword), _cloneNode(node.name),
-      _mapToken(node.leftBracket), _cloneNodeList(node.constants),
+      _cloneNode(node.documentationComment),
+      _cloneNodeList(node.metadata),
+      _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),
-        _mapToken(node.keyword), _cloneNode(node.uri),
-        _cloneNodeList(node.combinators), _mapToken(node.semicolon));
+        _cloneNode(node.documentationComment),
+        _cloneNodeList(node.metadata),
+        _mapToken(node.keyword),
+        _cloneNode(node.uri),
+        _cloneNodeList(node.combinators),
+        _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   @override
   ExpressionFunctionBody visitExpressionFunctionBody(
-      ExpressionFunctionBody node) => new ExpressionFunctionBody(
-      _mapToken(node.keyword), _mapToken(node.functionDefinition),
-      _cloneNode(node.expression), _mapToken(node.semicolon));
+          ExpressionFunctionBody node) =>
+      new ExpressionFunctionBody(
+          _mapToken(node.keyword),
+          _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.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));
+      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.thisKeyword),
-          _mapToken(node.period), _cloneNode(node.identifier),
-          _cloneNode(node.typeParameters), _cloneNode(node.parameters));
+      new FieldFormalParameter(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.keyword),
+          _cloneNode(node.type),
+          _mapToken(node.thisKeyword),
+          _mapToken(node.period),
+          _cloneNode(node.identifier),
+          _cloneNode(node.typeParameters),
+          _cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.withReference(_mapToken(node.awaitKeyword),
-          _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
-          _cloneNode(node.identifier), _mapToken(node.inKeyword),
-          _cloneNode(node.iterable), _mapToken(node.rightParenthesis),
+      return new ForEachStatement.withReference(
+          _mapToken(node.awaitKeyword),
+          _mapToken(node.forKeyword),
+          _mapToken(node.leftParenthesis),
+          _cloneNode(node.identifier),
+          _mapToken(node.inKeyword),
+          _cloneNode(node.iterable),
+          _mapToken(node.rightParenthesis),
           _cloneNode(node.body));
     }
-    return new ForEachStatement.withDeclaration(_mapToken(node.awaitKeyword),
-        _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
-        _cloneNode(loopVariable), _mapToken(node.inKeyword),
-        _cloneNode(node.iterable), _mapToken(node.rightParenthesis),
+    return new ForEachStatement.withDeclaration(
+        _mapToken(node.awaitKeyword),
+        _mapToken(node.forKeyword),
+        _mapToken(node.leftParenthesis),
+        _cloneNode(loopVariable),
+        _mapToken(node.inKeyword),
+        _cloneNode(node.iterable),
+        _mapToken(node.rightParenthesis),
         _cloneNode(node.body));
   }
 
   @override
   FormalParameterList visitFormalParameterList(FormalParameterList node) =>
-      new FormalParameterList(_mapToken(node.leftParenthesis),
-          _cloneNodeList(node.parameters), _mapToken(node.leftDelimiter),
-          _mapToken(node.rightDelimiter), _mapToken(node.rightParenthesis));
+      new FormalParameterList(
+          _mapToken(node.leftParenthesis),
+          _cloneNodeList(node.parameters),
+          _mapToken(node.leftDelimiter),
+          _mapToken(node.rightDelimiter),
+          _mapToken(node.rightParenthesis));
 
   @override
   ForStatement visitForStatement(ForStatement node) => new ForStatement(
-      _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.variables), _cloneNode(node.initialization),
-      _mapToken(node.leftSeparator), _cloneNode(node.condition),
-      _mapToken(node.rightSeparator), _cloneNodeList(node.updaters),
-      _mapToken(node.rightParenthesis), _cloneNode(node.body));
+      _mapToken(node.forKeyword),
+      _mapToken(node.leftParenthesis),
+      _cloneNode(node.variables),
+      _cloneNode(node.initialization),
+      _mapToken(node.leftSeparator),
+      _cloneNode(node.condition),
+      _mapToken(node.rightSeparator),
+      _cloneNodeList(node.updaters),
+      _mapToken(node.rightParenthesis),
+      _cloneNode(node.body));
 
   @override
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) =>
-      new FunctionDeclaration(_cloneNode(node.documentationComment),
-          _cloneNodeList(node.metadata), _mapToken(node.externalKeyword),
-          _cloneNode(node.returnType), _mapToken(node.propertyKeyword),
-          _cloneNode(node.name), _cloneNode(node.functionExpression));
+      new FunctionDeclaration(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.externalKeyword),
+          _cloneNode(node.returnType),
+          _mapToken(node.propertyKeyword),
+          _cloneNode(node.name),
+          _cloneNode(node.functionExpression));
 
   @override
   FunctionDeclarationStatement visitFunctionDeclarationStatement(
           FunctionDeclarationStatement node) =>
       new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration));
 
   @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) {
     FunctionExpression copy = new FunctionExpression(
-        _cloneNode(node.typeParameters), _cloneNode(node.parameters),
+        _cloneNode(node.typeParameters),
+        _cloneNode(node.parameters),
         _cloneNode(node.body));
     copy.element = node.element;
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   FunctionExpressionInvocation visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     FunctionExpressionInvocation copy = new FunctionExpressionInvocation(
-        _cloneNode(node.function), _cloneNode(node.typeArguments),
+        _cloneNode(node.function),
+        _cloneNode(node.typeArguments),
         _cloneNode(node.argumentList));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     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.typedefKeyword),
-          _cloneNode(node.returnType), _cloneNode(node.name),
-          _cloneNode(node.typeParameters), _cloneNode(node.parameters),
+      new FunctionTypeAlias(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _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(
-      _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
-      _cloneNode(node.returnType), _cloneNode(node.identifier),
-      _cloneNode(node.typeParameters), _cloneNode(node.parameters));
+          FunctionTypedFormalParameter node) =>
+      new FunctionTypedFormalParameter(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _cloneNode(node.returnType),
+          _cloneNode(node.identifier),
+          _cloneNode(node.typeParameters),
+          _cloneNode(node.parameters));
 
   @override
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(
       _mapToken(node.keyword), _cloneNodeList(node.hiddenNames));
 
   @override
   IfStatement visitIfStatement(IfStatement node) => new IfStatement(
-      _mapToken(node.ifKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.condition), _mapToken(node.rightParenthesis),
-      _cloneNode(node.thenStatement), _mapToken(node.elseKeyword),
+      _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.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.deferredKeyword),
-          _mapToken(node.asKeyword), _cloneNode(node.prefix),
-          _cloneNodeList(node.combinators), _mapToken(node.semicolon));
+      new ImportDirective(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.keyword),
+          _cloneNode(node.uri),
+          _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(_cloneNode(node.target),
-          _mapToken(node.leftBracket), _cloneNode(node.index),
+      copy = new IndexExpression.forTarget(
+          _cloneNode(node.target),
+          _mapToken(node.leftBracket),
+          _cloneNode(node.index),
           _mapToken(node.rightBracket));
     } else {
       copy = new IndexExpression.forCascade(period, _mapToken(node.leftBracket),
           _cloneNode(node.index), _mapToken(node.rightBracket));
     }
     copy.auxiliaryElements = node.auxiliaryElements;
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   InstanceCreationExpression visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     InstanceCreationExpression copy = new InstanceCreationExpression(
-        _mapToken(node.keyword), _cloneNode(node.constructorName),
+        _mapToken(node.keyword),
+        _cloneNode(node.constructorName),
         _cloneNode(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) {
     IntegerLiteral copy =
         new IntegerLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   InterpolationExpression visitInterpolationExpression(
-      InterpolationExpression node) => new InterpolationExpression(
-      _mapToken(node.leftBracket), _cloneNode(node.expression),
-      _mapToken(node.rightBracket));
+          InterpolationExpression node) =>
+      new InterpolationExpression(_mapToken(node.leftBracket),
+          _cloneNode(node.expression), _mapToken(node.rightBracket));
 
   @override
   InterpolationString visitInterpolationString(InterpolationString node) =>
       new InterpolationString(_mapToken(node.contents), node.value);
 
   @override
   IsExpression visitIsExpression(IsExpression node) {
-    IsExpression copy = new IsExpression(_cloneNode(node.expression),
-        _mapToken(node.isOperator), _mapToken(node.notOperator),
+    IsExpression copy = new IsExpression(
+        _cloneNode(node.expression),
+        _mapToken(node.isOperator),
+        _mapToken(node.notOperator),
         _cloneNode(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   Label visitLabel(Label node) =>
       new Label(_cloneNode(node.label), _mapToken(node.colon));
 
   @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.libraryKeyword),
-          _cloneNode(node.name), _mapToken(node.semicolon));
+      new LibraryDirective(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _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;
   }
 
   @override
   ListLiteral visitListLiteral(ListLiteral node) {
-    ListLiteral copy = new ListLiteral(_mapToken(node.constKeyword),
-        _cloneNode(node.typeArguments), _mapToken(node.leftBracket),
-        _cloneNodeList(node.elements), _mapToken(node.rightBracket));
+    ListLiteral copy = new ListLiteral(
+        _mapToken(node.constKeyword),
+        _cloneNode(node.typeArguments),
+        _mapToken(node.leftBracket),
+        _cloneNodeList(node.elements),
+        _mapToken(node.rightBracket));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   MapLiteral visitMapLiteral(MapLiteral node) {
-    MapLiteral copy = new MapLiteral(_mapToken(node.constKeyword),
-        _cloneNode(node.typeArguments), _mapToken(node.leftBracket),
-        _cloneNodeList(node.entries), _mapToken(node.rightBracket));
+    MapLiteral copy = new MapLiteral(
+        _mapToken(node.constKeyword),
+        _cloneNode(node.typeArguments),
+        _mapToken(node.leftBracket),
+        _cloneNodeList(node.entries),
+        _mapToken(node.rightBracket));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
-  MapLiteralEntry visitMapLiteralEntry(
-      MapLiteralEntry node) => new MapLiteralEntry(
-      _cloneNode(node.key), _mapToken(node.separator), _cloneNode(node.value));
+  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) =>
+      new MapLiteralEntry(_cloneNode(node.key), _mapToken(node.separator),
+          _cloneNode(node.value));
 
   @override
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
-      new MethodDeclaration(_cloneNode(node.documentationComment),
-          _cloneNodeList(node.metadata), _mapToken(node.externalKeyword),
-          _mapToken(node.modifierKeyword), _cloneNode(node.returnType),
-          _mapToken(node.propertyKeyword), _mapToken(node.operatorKeyword),
-          _cloneNode(node.name), _cloneNode(node._typeParameters),
-          _cloneNode(node.parameters), _cloneNode(node.body));
+      new MethodDeclaration(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.externalKeyword),
+          _mapToken(node.modifierKeyword),
+          _cloneNode(node.returnType),
+          _mapToken(node.propertyKeyword),
+          _mapToken(node.operatorKeyword),
+          _cloneNode(node.name),
+          _cloneNode(node._typeParameters),
+          _cloneNode(node.parameters),
+          _cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) {
-    MethodInvocation copy = new MethodInvocation(_cloneNode(node.target),
-        _mapToken(node.operator), _cloneNode(node.methodName),
-        _cloneNode(node.typeArguments), _cloneNode(node.argumentList));
+    MethodInvocation copy = new MethodInvocation(
+        _cloneNode(node.target),
+        _mapToken(node.operator),
+        _cloneNode(node.methodName),
+        _cloneNode(node.typeArguments),
+        _cloneNode(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) {
     NamedExpression copy =
         new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
     copy.propagatedType = node.propagatedType;
@@ skipping 15 matching lines @@
     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.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.partKeyword), _cloneNode(node.uri),
+        _cloneNode(node.documentationComment),
+        _cloneNodeList(node.metadata),
+        _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.partKeyword), _mapToken(node.ofKeyword),
-        _cloneNode(node.libraryName), _mapToken(node.semicolon));
+        _cloneNode(node.documentationComment),
+        _cloneNodeList(node.metadata),
+        _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));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
@@ skipping 28 matching lines @@
         _mapToken(node.operator), _cloneNode(node.propertyName));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation copy =
-        new RedirectingConstructorInvocation(_mapToken(node.thisKeyword),
-            _mapToken(node.period), _cloneNode(node.constructorName),
+        new RedirectingConstructorInvocation(
+            _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.rethrowKeyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ReturnStatement visitReturnStatement(ReturnStatement node) =>
       new ReturnStatement(_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));
 
   @override
   SimpleFormalParameter visitSimpleFormalParameter(
-      SimpleFormalParameter node) => new SimpleFormalParameter(
-      _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
-      _mapToken(node.keyword), _cloneNode(node.type),
-      _cloneNode(node.identifier));
+          SimpleFormalParameter node) =>
+      new SimpleFormalParameter(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.keyword),
+          _cloneNode(node.type),
+          _cloneNode(node.identifier));
 
   @override
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) {
     Token mappedToken = _mapToken(node.token);
     if (mappedToken == null) {
       // This only happens for SimpleIdentifiers created by the parser as part
       // of scanning documentation comments (the tokens for those identifiers
       // are not in the original token stream and hence do not get copied).
       // This extra check can be removed if the scanner is changed to scan
       // documentation comments for the parser.
@@ skipping 23 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.superKeyword), _mapToken(node.period),
-        _cloneNode(node.constructorName), _cloneNode(node.argumentList));
+        _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.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.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));
+      _cloneNodeList(node.labels),
+      _mapToken(node.keyword),
+      _mapToken(node.colon),
+      _cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) =>
-      new SwitchStatement(_mapToken(node.switchKeyword),
-          _mapToken(node.leftParenthesis), _cloneNode(node.expression),
-          _mapToken(node.rightParenthesis), _mapToken(node.leftBracket),
-          _cloneNodeList(node.members), _mapToken(node.rightBracket));
+      new SwitchStatement(
+          _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.thisKeyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   ThrowExpression visitThrowExpression(ThrowExpression node) {
     ThrowExpression copy = 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), _cloneNodeList(node.metadata),
-      _cloneNode(node.variables), _mapToken(node.semicolon));
+          TopLevelVariableDeclaration node) =>
+      new TopLevelVariableDeclaration(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _cloneNode(node.variables),
+          _mapToken(node.semicolon));
 
   @override
   TryStatement visitTryStatement(TryStatement node) => new TryStatement(
-      _mapToken(node.tryKeyword), _cloneNode(node.body),
-      _cloneNodeList(node.catchClauses), _mapToken(node.finallyKeyword),
+      _mapToken(node.tryKeyword),
+      _cloneNode(node.body),
+      _cloneNodeList(node.catchClauses),
+      _mapToken(node.finallyKeyword),
       _cloneNode(node.finallyBlock));
 
   @override
   TypeArgumentList visitTypeArgumentList(TypeArgumentList node) =>
       new TypeArgumentList(_mapToken(node.leftBracket),
           _cloneNodeList(node.arguments), _mapToken(node.rightBracket));
 
   @override
   TypeName visitTypeName(TypeName node) {
     TypeName copy =
         new TypeName(_cloneNode(node.name), _cloneNode(node.typeArguments));
     copy.type = node.type;
     return copy;
   }
 
   @override
   TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(
-      _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
-      _cloneNode(node.name), _mapToken(node.extendsKeyword),
+      _cloneNode(node.documentationComment),
+      _cloneNodeList(node.metadata),
+      _cloneNode(node.name),
+      _mapToken(node.extendsKeyword),
       _cloneNode(node.bound));
 
   @override
   TypeParameterList visitTypeParameterList(TypeParameterList node) =>
       new TypeParameterList(_mapToken(node.leftBracket),
           _cloneNodeList(node.typeParameters), _mapToken(node.rightBracket));
 
   @override
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) =>
       new VariableDeclaration(_cloneNode(node.name), _mapToken(node.equals),
           _cloneNode(node.initializer));
 
   @override
   VariableDeclarationList visitVariableDeclarationList(
-      VariableDeclarationList node) => new VariableDeclarationList(null,
-      _cloneNodeList(node.metadata), _mapToken(node.keyword),
-      _cloneNode(node.type), _cloneNodeList(node.variables));
+          VariableDeclarationList node) =>
+      new VariableDeclarationList(
+          null,
+          _cloneNodeList(node.metadata),
+          _mapToken(node.keyword),
+          _cloneNode(node.type),
+          _cloneNodeList(node.variables));
 
   @override
   VariableDeclarationStatement visitVariableDeclarationStatement(
-      VariableDeclarationStatement node) => new VariableDeclarationStatement(
-      _cloneNode(node.variables), _mapToken(node.semicolon));
+          VariableDeclarationStatement node) =>
+      new VariableDeclarationStatement(
+          _cloneNode(node.variables), _mapToken(node.semicolon));
 
   @override
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(
-      _mapToken(node.whileKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.condition), _mapToken(node.rightParenthesis),
+      _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
   YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(
-      _mapToken(node.yieldKeyword), _mapToken(node.star),
-      _cloneNode(node.expression), _mapToken(node.semicolon));
+      _mapToken(node.yieldKeyword),
+      _mapToken(node.star),
+      _cloneNode(node.expression),
+      _mapToken(node.semicolon));
 
   AstNode _cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     if (identical(node, _oldNode)) {
       return _newNode;
     }
     return node.accept(this) as AstNode;
   }
@@ skipping 1262 matching lines @@
    * Initialize a newly created method declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the method
    * is not external. The [modifierKeyword] can be `null` if the method is
    * neither abstract nor static. The [returnType] can be `null` if no return
    * 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,
-      TypeParameterList typeParameters, FormalParameterList parameters,
+  MethodDeclaration(
+      Comment comment,
+      List<Annotation> metadata,
+      this.externalKeyword,
+      this.modifierKeyword,
+      TypeName returnType,
+      this.propertyKeyword,
+      this.operatorKeyword,
+      SimpleIdentifier name,
+      TypeParameterList typeParameters,
+      FormalParameterList parameters,
       FunctionBody body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
     _body = _becomeParentOf(body);
   }
 
   /**
@@ skipping 183 matching lines @@
 
   /**
    * The list of arguments to the method.
    */
   ArgumentList _argumentList;
 
   /**
    * Initialize a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.
    */
-  MethodInvocation(Expression target, this.operator,
-      SimpleIdentifier methodName, TypeArgumentList typeArguments,
+  MethodInvocation(
+      Expression target,
+      this.operator,
+      SimpleIdentifier methodName,
+      TypeArgumentList typeArguments,
       ArgumentList argumentList) {
     _target = _becomeParentOf(target);
     _methodName = _becomeParentOf(methodName);
     _typeArguments = _becomeParentOf(typeArguments);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the method.
    */
@@ skipping 774 matching lines @@
       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) {

[Brian Wilkerson, 2015/09/02 15:49:15]

This needs to be updated to replace the message.

[Paul Berry, 2015/09/07 19:44:29]

Done.

     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)) {
@@ skipping 3411 matching lines @@
   R visitPrefixedIdentifier(PrefixedIdentifier node) => null;
 
   @override
   R visitPrefixExpression(PrefixExpression node) => null;
 
   @override
   R visitPropertyAccess(PropertyAccess node) => null;
 
   @override
   R visitRedirectingConstructorInvocation(
-      RedirectingConstructorInvocation node) => null;
+          RedirectingConstructorInvocation node) =>
+      null;
 
   @override
   R visitRethrowExpression(RethrowExpression node) => null;
 
   @override
   R visitReturnStatement(ReturnStatement node) => null;
 
   @override
   R visitScriptTag(ScriptTag node) => null;
 
@@ skipping 1200 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.switchKeyword, this.leftParenthesis,
-      Expression expression, this.rightParenthesis, this.leftBracket,
-      List<SwitchMember> members, this.rightBracket) {
+  SwitchStatement(
+      this.switchKeyword,
+      this.leftParenthesis,
+      Expression expression,
+      this.rightParenthesis,
+      this.leftBracket,
+      List<SwitchMember> members,
+      this.rightBracket) {
     _expression = _becomeParentOf(expression);
     _members = new NodeList<SwitchMember>(this, members);
   }
 
   @override
   Token get beginToken => switchKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(switchKeyword)
@@ skipping 331 matching lines @@
 
   @override
   Object visitAsExpression(AsExpression node) {
     _visitNode(node.expression);
     _writer.print(" as ");
     _visitNode(node.type);
     return null;
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {

[Brian Wilkerson, 2015/09/02 15:49:15]

This needs to be updated to print the new children.

[Paul Berry, 2015/09/07 19:44:29]

Done.

     _writer.print("assert (");
     _visitNode(node.condition);
     _writer.print(");");
     return null;
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     _visitNode(node.leftHandSide);
     _writer.print(' ');
@@ skipping 1848 matching lines @@
   R visitPrefixedIdentifier(PrefixedIdentifier node) => visitNode(node);
 
   @override
   R visitPrefixExpression(PrefixExpression node) => visitNode(node);
 
   @override
   R visitPropertyAccess(PropertyAccess node) => visitNode(node);
 
   @override
   R visitRedirectingConstructorInvocation(
-      RedirectingConstructorInvocation node) => visitNode(node);
+          RedirectingConstructorInvocation node) =>
+      visitNode(node);
 
   @override
   R visitRethrowExpression(RethrowExpression node) => visitNode(node);
 
   @override
   R visitReturnStatement(ReturnStatement node) => visitNode(node);
 
   @override
   R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
 
@@ skipping 733 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }