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.
+   *
+   * Deprecated: please use [AssertStatement.withOptionalMessage] instead.
+   */
+  @deprecated
+  AssertStatement(Token assertKeyword, Token leftParenthesis,
+      Expression condition, Token rightParenthesis, Token semicolon)
+      : this.withOptionalMessage(assertKeyword, leftParenthesis, condition,
+            null, null, rightParenthesis, semicolon);
+
+  /**
+   * Initialize a newly created assert statement.
    */
-  AssertStatement(this.assertKeyword, this.leftParenthesis,
-      Expression condition, this.rightParenthesis, this.semicolon) {
+  AssertStatement.withOptionalMessage(
+      this.assertKeyword,
+      this.leftParenthesis,
+      Expression condition,
+      this.comma,
+      Expression message,
+      this.rightParenthesis,
+      this.semicolon) {
     _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;
+
+  /**
+   * Set the message to report if the assertion fails to the given
+   * [expression].
+   */
+  void set message(Expression expression) {
+    _message = _becomeParentOf(expression);
+  }
+
   @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(
-      cloneToken(node.assertKeyword), cloneToken(node.leftParenthesis),
-      cloneNode(node.condition), cloneToken(node.rightParenthesis),
-      cloneToken(node.semicolon));
+  AstNode visitAssertStatement(AssertStatement node) =>
+      new AssertStatement.withOptionalMessage(
+          cloneToken(node.assertKeyword),
+          cloneToken(node.leftParenthesis),
+          cloneNode(node.condition),
+          cloneToken(node.comma),
+          cloneNode(node.message),
+          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 78 matching lines @@
         isEqualTokens(node.asOperator, other.asOperator) &&
         isEqualNodes(node.type, other.type);
   }
 
   @override
   bool visitAssertStatement(AssertStatement node) {
     AssertStatement other = _other as AssertStatement;
     return isEqualTokens(node.assertKeyword, other.assertKeyword) &&
         isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
         isEqualNodes(node.condition, other.condition) &&
+        isEqualTokens(node.comma, other.comma) &&
+        isEqualNodes(node.message, other.message) &&
         isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression other = _other as AssignmentExpression;
     return isEqualNodes(node.leftHandSide, other.leftHandSide) &&
         isEqualTokens(node.operator, other.operator) &&
         isEqualNodes(node.rightHandSide, other.rightHandSide);
@@ skipping 970 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 1103 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(
-      _mapToken(node.assertKeyword), _mapToken(node.leftParenthesis),
-      _cloneNode(node.condition), _mapToken(node.rightParenthesis),
-      _mapToken(node.semicolon));
+  AstNode visitAssertStatement(AssertStatement node) =>
+      new AssertStatement.withOptionalMessage(
+          _mapToken(node.assertKeyword),
+          _mapToken(node.leftParenthesis),
+          _cloneNode(node.condition),
+          _mapToken(node.comma),
+          _cloneNode(node.message),
+          _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 779 matching lines @@
     }
     return visitNode(node);
   }
 
   @override
   bool visitAssertStatement(AssertStatement node) {
     if (identical(node.condition, _oldNode)) {
       node.condition = _newNode as Expression;
       return true;
     }
+    if (identical(node._message, _oldNode)) {
+      node.message = _newNode as Expression;
+      return true;
+    }
     return visitNode(node);
   }
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     if (identical(node.leftHandSide, _oldNode)) {
       node.leftHandSide = _newNode as Expression;
       return true;
     } else if (identical(node.rightHandSide, _oldNode)) {
       node.rightHandSide = _newNode as Expression;
@@ skipping 3407 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 334 matching lines @@
     _visitNode(node.expression);
     _writer.print(" as ");
     _visitNode(node.type);
     return null;
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {
     _writer.print("assert (");
     _visitNode(node.condition);
+    if (node.message != null) {
+      _writer.print(', ');
+      _visitNode(node.message);
+    }
     _writer.print(");");
     return null;
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     _visitNode(node.leftHandSide);
     _writer.print(' ');
     _writer.print(node.operator.lexeme);
     _writer.print(' ');
@@ skipping 1846 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);
   }
 }