Reformat

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 140 matching lines @@
     _metadata.clear();
     _metadata.addAll(metadata);
   }
 
   /**
    * Return a list containing the comment and annotations associated with this
    * node, sorted in lexical order.
    */
   List<AstNode> get sortedCommentAndAnnotations {
     return <AstNode>[]
-        ..add(_comment)
-        ..addAll(_metadata)
-        ..sort(AstNode.LEXICAL_ORDER);
+      ..add(_comment)
+      ..addAll(_metadata)
+      ..sort(AstNode.LEXICAL_ORDER);
   }
 
   /**
    * Return a holder of child entities that subclasses can add to.
    */
   ChildEntities get _childEntities {
     ChildEntities result = new ChildEntities();
     if (_commentIsBeforeAnnotations()) {
       result
-          ..add(_comment)
-          ..addAll(_metadata);
+        ..add(_comment)
+        ..addAll(_metadata);
     } else {
       result.addAll(sortedCommentAndAnnotations);
     }
     return result;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     if (_commentIsBeforeAnnotations()) {
       _safelyVisitChild(_comment, visitor);
@@ skipping 94 matching lines @@
    */
   void set arguments(ArgumentList arguments) {
     _arguments = _becomeParentOf(arguments);
   }
 
   @override
   Token get beginToken => atSign;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(atSign)
-      ..add(_name)
-      ..add(period)
-      ..add(_constructorName)
-      ..add(_arguments);
+    ..add(atSign)
+    ..add(_name)
+    ..add(period)
+    ..add(_constructorName)
+    ..add(_arguments);
 
   /**
    * Return the name of the constructor being invoked, or `null` if this
    * annotation is not the invocation of a named constructor.
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor being invoked to the given [name].
    */
@@ skipping 101 matching lines @@
    * based on propagated type information. The list must be the same length as
    * the number of arguments, but can contain `null` entries if a given argument
    * does not correspond to a formal parameter.
    */
   List<ParameterElement> _correspondingPropagatedParameters;
 
   /**
    * Initialize a newly created list of arguments. The list of [arguments] can
    * be `null` if there are no arguments.
    */
-  ArgumentList(this.leftParenthesis, List<Expression> arguments,
-      this.rightParenthesis) {
+  ArgumentList(
+      this.leftParenthesis, List<Expression> arguments, this.rightParenthesis) {
     _arguments = new NodeList<Expression>(this, arguments);
   }
 
   /**
    * Return the expressions producing the values of the arguments. Although the
    * language requires that positional arguments appear before named arguments,
    * this class allows them to be intermixed.
    */
   NodeList<Expression> get arguments => _arguments;
 
   @override
   Token get beginToken => leftParenthesis;
 
   /**
    * TODO(paulberry): Add commas.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(leftParenthesis)
-      ..addAll(_arguments)
-      ..add(rightParenthesis);
+    ..add(leftParenthesis)
+    ..addAll(_arguments)
+    ..add(rightParenthesis);
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this
    * list to the given list of [parameters]. The list of parameters must be the
    * same length as the number of arguments, but can contain `null` entries if a
    * given argument does not correspond to a formal parameter.
    */
-  void set
-      correspondingPropagatedParameters(List<ParameterElement> parameters) {
+  void set correspondingPropagatedParameters(
+      List<ParameterElement> parameters) {
     if (parameters.length != _arguments.length) {
       throw new IllegalArgumentException(
           "Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
     _correspondingPropagatedParameters = parameters;
   }
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this
    * list to the given list of parameters. The list of parameters must be the
@@ skipping 132 matching lines @@
   AsExpression(Expression expression, this.asOperator, TypeName type) {
     _expression = _becomeParentOf(expression);
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_expression)
-      ..add(asOperator)
-      ..add(_type);
+    ..add(_expression)
+    ..add(asOperator)
+    ..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value being cast.
    */
   Expression get expression => _expression;
 
   /**
@@ skipping 57 matching lines @@
   Token rightParenthesis;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created assert statement.
    */
-  AssertStatement(this.assertKeyword, this.leftParenthesis, Expression condition,
-      this.rightParenthesis, this.semicolon) {
+  AssertStatement(this.assertKeyword, this.leftParenthesis,
+      Expression condition, this.rightParenthesis, this.semicolon) {
     _condition = _becomeParentOf(condition);
   }
 
   @override
   Token get beginToken => assertKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(assertKeyword)
-      ..add(leftParenthesis)
-      ..add(_condition)
-      ..add(rightParenthesis)
-      ..add(semicolon);
+    ..add(assertKeyword)
+    ..add(leftParenthesis)
+    ..add(_condition)
+    ..add(rightParenthesis)
+    ..add(semicolon);
 
   /**
    * Return the condition that is being asserted to be `true`.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition that is being asserted to be `true` to the given
    * [expression].
    */
@@ skipping 61 matching lines @@
    * The element associated with the operator based on the propagated type of
    * the left-hand-side, or `null` if the AST structure has not been resolved,
    * if the operator is not a compound operator, or if the operator could not be
    * resolved.
    */
   MethodElement propagatedElement;
 
   /**
    * Initialize a newly created assignment expression.
    */
-  AssignmentExpression(Expression leftHandSide, this.operator,
-      Expression rightHandSide) {
+  AssignmentExpression(
+      Expression leftHandSide, this.operator, Expression rightHandSide) {
     if (leftHandSide == null || rightHandSide == null) {
       String message;
       if (leftHandSide == null) {
         if (rightHandSide == null) {
           message = "Both the left-hand and right-hand sides are null";
         } else {
           message = "The left-hand size is null";
         }
       } else {
         message = "The right-hand size is null";
       }
       AnalysisEngine.instance.logger.logError(
-          message,
-          new CaughtException(new AnalysisException(message), null));
+          message, new CaughtException(new AnalysisException(message), null));
     }
     _leftHandSide = _becomeParentOf(leftHandSide);
     _rightHandSide = _becomeParentOf(rightHandSide);
   }
 
   @override
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_leftHandSide)
-      ..add(operator)
-      ..add(_rightHandSide);
+    ..add(_leftHandSide)
+    ..add(operator)
+    ..add(_rightHandSide);
 
   @override
   Token get endToken => _rightHandSide.endToken;
 
   /**
    * Set the expression used to compute the left hand side to the given
    * [expression].
    */
   Expression get leftHandSide => _leftHandSide;
 
@@ skipping 133 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.
+  AstCloner(
+      [this.cloneTokens = false]); // TODO(brianwilkerson) Change this to be a named parameter.
 
   /**
    * Return a clone of the given [node].
    */
   AstNode cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as AstNode;
   }
@@ skipping 30 matching lines @@
       return tokens.map((Token token) => token.copy()).toList();
     }
     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));
+  Annotation visitAnnotation(Annotation node) => new Annotation(
+      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.rightParenthesis));
+  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(
+      cloneToken(node.leftParenthesis), cloneNodeList(node.arguments),
+      cloneToken(node.rightParenthesis));
 
   @override
-  AsExpression visitAsExpression(AsExpression node) =>
-      new AsExpression(
-          cloneNode(node.expression),
-          cloneToken(node.asOperator),
-          cloneNode(node.type));
+  AsExpression visitAsExpression(AsExpression node) => new AsExpression(
+      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(
+      cloneToken(node.assertKeyword), cloneToken(node.leftParenthesis),
+      cloneNode(node.condition), cloneToken(node.rightParenthesis),
+      cloneToken(node.semicolon));
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) =>
-      new AssignmentExpression(
-          cloneNode(node.leftHandSide),
-          cloneToken(node.operator),
-          cloneNode(node.rightHandSide));
+      new AssignmentExpression(cloneNode(node.leftHandSide),
+          cloneToken(node.operator), cloneNode(node.rightHandSide));
 
   @override
   AwaitExpression visitAwaitExpression(AwaitExpression node) =>
-      new AwaitExpression(cloneToken(node.awaitKeyword), cloneNode(node.expression));
+      new AwaitExpression(
+          cloneToken(node.awaitKeyword), cloneNode(node.expression));
 
   @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) =>
-      new BinaryExpression(
-          cloneNode(node.leftOperand),
-          cloneToken(node.operator),
-          cloneNode(node.rightOperand));
+      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));
+  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.semicolon));
+  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(
+      cloneToken(node.breakKeyword), cloneNode(node.label),
+      cloneToken(node.semicolon));
 
   @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) =>
       new CascadeExpression(
-          cloneNode(node.target),
-          cloneNodeList(node.cascadeSections));
+          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),
-          cloneNode(node.body));
+  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),
+      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),
-          cloneToken(node.semicolon));
+  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),
+      cloneToken(node.semicolon));
 
   @override
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationCommentWithReferences(
-          cloneTokenList(node.tokens),
-          cloneNodeList(node.references));
+          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));
+      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 visitConditionalExpression(
+      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 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));
 
   @override
-  ConstructorFieldInitializer
-      visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
-      new ConstructorFieldInitializer(
-          cloneToken(node.thisKeyword),
-          cloneToken(node.period),
-          cloneNode(node.fieldName),
-          cloneToken(node.equals),
-          cloneNode(node.expression));
+  ConstructorFieldInitializer visitConstructorFieldInitializer(
+      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));
+          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));
+      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 visitDefaultFormalParameter(
+      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.semicolon));
+  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.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));
+      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 visitExpressionFunctionBody(
+      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));
+      new ExpressionStatement(
+          cloneNode(node.expression), cloneToken(node.semicolon));
 
   @override
-  ExtendsClause visitExtendsClause(ExtendsClause node) =>
-      new ExtendsClause(cloneToken(node.extendsKeyword), cloneNode(node.superclass));
+  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),
+      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.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.con2(
-          cloneToken(node.awaitKeyword),
-          cloneToken(node.forKeyword),
-          cloneToken(node.leftParenthesis),
-          cloneNode(node.identifier),
-          cloneToken(node.inKeyword),
-          cloneNode(node.iterable),
-          cloneToken(node.rightParenthesis),
+      return new ForEachStatement.con2(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.con1(
-        cloneToken(node.awaitKeyword),
-        cloneToken(node.forKeyword),
-        cloneToken(node.leftParenthesis),
-        cloneNode(loopVariable),
-        cloneToken(node.inKeyword),
-        cloneNode(node.iterable),
-        cloneToken(node.rightParenthesis),
+    return new ForEachStatement.con1(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));
+  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));
 
   @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) =>
+  FunctionDeclarationStatement visitFunctionDeclarationStatement(
+          FunctionDeclarationStatement node) =>
       new FunctionDeclarationStatement(cloneNode(node.functionDeclaration));
 
   @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) =>
       new FunctionExpression(cloneNode(node.parameters), cloneNode(node.body));
 
   @override
-  FunctionExpressionInvocation
-      visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
-      new FunctionExpressionInvocation(
-          cloneNode(node.function),
-          cloneNode(node.argumentList));
+  FunctionExpressionInvocation visitFunctionExpressionInvocation(
+      FunctionExpressionInvocation node) => new FunctionExpressionInvocation(
+      cloneNode(node.function), cloneNode(node.argumentList));
 
   @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
-      new FunctionTypeAlias(
-          cloneNode(node.documentationComment),
-          cloneNodeList(node.metadata),
-          cloneToken(node.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.parameters));
+  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(
+      FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(
+      cloneNode(node.documentationComment), cloneNodeList(node.metadata),
+      cloneNode(node.returnType), cloneNode(node.identifier),
+      cloneNode(node.parameters));
 
   @override
-  HideCombinator visitHideCombinator(HideCombinator node) =>
-      new HideCombinator(cloneToken(node.keyword), cloneNodeList(node.hiddenNames));
+  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),
-          cloneNode(node.elseStatement));
+  IfStatement visitIfStatement(IfStatement node) => new IfStatement(
+      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));
+      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 visitInstanceCreationExpression(
+      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 visitInterpolationExpression(
+      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));
+  IsExpression visitIsExpression(IsExpression node) => new IsExpression(
+      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));
+      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.rightBracket));
+  ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral(
+      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.rightBracket));
+  MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral(
+      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.parameters),
+      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.parameters),
           cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) =>
-      new MethodInvocation(
-          cloneNode(node.target),
-          cloneToken(node.period),
-          cloneNode(node.methodName),
-          cloneNode(node.argumentList));
+      new MethodInvocation(cloneNode(node.target), cloneToken(node.period),
+          cloneNode(node.methodName), cloneNode(node.argumentList));
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) =>
       new NamedExpression(cloneNode(node.name), cloneNode(node.expression));
 
   @override
   AstNode visitNativeClause(NativeClause node) =>
       new NativeClause(cloneToken(node.nativeKeyword), cloneNode(node.name));
 
   @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
-      new NativeFunctionBody(
-          cloneToken(node.nativeKeyword),
-          cloneNode(node.stringLiteral),
-          cloneToken(node.semicolon));
+      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 visitParenthesizedExpression(
+      ParenthesizedExpression node) => new ParenthesizedExpression(
+      cloneToken(node.leftParenthesis), cloneNode(node.expression),
+      cloneToken(node.rightParenthesis));
 
   @override
   PartDirective visitPartDirective(PartDirective node) {
     PartDirective directive = new PartDirective(
-        cloneNode(node.documentationComment),
-        cloneNodeList(node.metadata),
-        cloneToken(node.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),
+      new PrefixedIdentifier(cloneNode(node.prefix), cloneToken(node.period),
           cloneNode(node.identifier));
 
   @override
   PrefixExpression visitPrefixExpression(PrefixExpression node) =>
       new PrefixExpression(cloneToken(node.operator), cloneNode(node.operand));
 
   @override
-  PropertyAccess visitPropertyAccess(PropertyAccess node) =>
-      new PropertyAccess(
-          cloneNode(node.target),
-          cloneToken(node.operator),
-          cloneNode(node.propertyName));
+  PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess(
+      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),
+  RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
+          RedirectingConstructorInvocation node) =>
+      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));
+      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));
+  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 visitSimpleFormalParameter(
+      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 visitSuperConstructorInvocation(
+      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.statements));
+  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(
+      cloneNodeList(node.labels), cloneToken(node.keyword),
+      cloneNode(node.expression), cloneToken(node.colon),
+      cloneNodeList(node.statements));
 
   @override
-  SwitchDefault visitSwitchDefault(SwitchDefault node) =>
-      new SwitchDefault(
-          cloneNodeList(node.labels),
-          cloneToken(node.keyword),
-          cloneToken(node.colon),
-          cloneNodeList(node.statements));
+  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(
+      cloneNodeList(node.labels), cloneToken(node.keyword),
+      cloneToken(node.colon), cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) =>
-      new SwitchStatement(
-          cloneToken(node.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));
+  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));
+      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 visitTopLevelVariableDeclaration(
+      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),
-          cloneNode(node.finallyBlock));
+  TryStatement visitTryStatement(TryStatement node) => new TryStatement(
+      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));
+      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.bound));
+  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(
+      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));
+      new TypeParameterList(cloneToken(node.leftBracket),
+          cloneNodeList(node.typeParameters), cloneToken(node.rightBracket));
 
   @override
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) =>
-      new VariableDeclaration(
-          null,
-          cloneNodeList(node.metadata),
-          cloneNode(node.name),
-          cloneToken(node.equals),
+      new VariableDeclaration(null, cloneNodeList(node.metadata),
+          cloneNode(node.name), cloneToken(node.equals),
           cloneNode(node.initializer));
 
   @override
-  VariableDeclarationList
-      visitVariableDeclarationList(VariableDeclarationList node) =>
-      new VariableDeclarationList(
-          null,
-          cloneNodeList(node.metadata),
-          cloneToken(node.keyword),
-          cloneNode(node.type),
-          cloneNodeList(node.variables));
+  VariableDeclarationList visitVariableDeclarationList(
+      VariableDeclarationList node) => new VariableDeclarationList(null,
+      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 visitVariableDeclarationStatement(
+      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),
-          cloneNode(node.body));
+  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(
+      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));
+  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));
+  YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(
+      cloneToken(node.yieldKeyword), cloneToken(node.star),
+      cloneNode(node.expression), cloneToken(node.semicolon));
 }
 
 /**
  * An AstVisitor that compares the structure of two AstNodes to see whether they
  * are equal.
  */
 class AstComparator implements AstVisitor<bool> {
   /**
    * The AST node with which the node being visited is to be compared. This is
    * only valid at the beginning of each visit method (until [isEqualNodes] is
@@ skipping 152 matching lines @@
         isEqualTokens(node.comma, other.comma) &&
         isEqualNodes(node.stackTraceParameter, other.stackTraceParameter) &&
         isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
         isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration other = _other as ClassDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.abstractKeyword, other.abstractKeyword) &&
         isEqualTokens(node.classKeyword, other.classKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.typeParameters, other.typeParameters) &&
         isEqualNodes(node.extendsClause, other.extendsClause) &&
         isEqualNodes(node.withClause, other.withClause) &&
         isEqualNodes(node.implementsClause, other.implementsClause) &&
         isEqualTokens(node.leftBracket, other.leftBracket) &&
         _isEqualNodeLists(node.members, other.members) &&
         isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitClassTypeAlias(ClassTypeAlias node) {
     ClassTypeAlias other = _other as ClassTypeAlias;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.typeParameters, other.typeParameters) &&
         isEqualTokens(node.equals, other.equals) &&
         isEqualTokens(node.abstractKeyword, other.abstractKeyword) &&
         isEqualNodes(node.superclass, other.superclass) &&
         isEqualNodes(node.withClause, other.withClause) &&
         isEqualNodes(node.implementsClause, other.implementsClause) &&
         isEqualTokens(node.semicolon, other.semicolon);
@@ skipping 29 matching lines @@
         isEqualTokens(node.question, other.question) &&
         isEqualNodes(node.thenExpression, other.thenExpression) &&
         isEqualTokens(node.colon, other.colon) &&
         isEqualNodes(node.elseExpression, other.elseExpression);
   }
 
   @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration other = _other as ConstructorDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.externalKeyword, other.externalKeyword) &&
         isEqualTokens(node.constKeyword, other.constKeyword) &&
         isEqualTokens(node.factoryKeyword, other.factoryKeyword) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualTokens(node.period, other.period) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.parameters, other.parameters) &&
         isEqualTokens(node.separator, other.separator) &&
         _isEqualNodeLists(node.initializers, other.initializers) &&
@@ skipping 24 matching lines @@
     ContinueStatement other = _other as ContinueStatement;
     return isEqualTokens(node.continueKeyword, other.continueKeyword) &&
         isEqualNodes(node.label, other.label) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitDeclaredIdentifier(DeclaredIdentifier node) {
     DeclaredIdentifier other = _other as DeclaredIdentifier;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.keyword, other.keyword) &&
         isEqualNodes(node.type, other.type) &&
         isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitDefaultFormalParameter(DefaultFormalParameter node) {
     DefaultFormalParameter other = _other as DefaultFormalParameter;
     return isEqualNodes(node.parameter, other.parameter) &&
@@ skipping 30 matching lines @@
   @override
   bool visitEmptyStatement(EmptyStatement node) {
     EmptyStatement other = _other as EmptyStatement;
     return isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitEnumConstantDeclaration(EnumConstantDeclaration node) {
     EnumConstantDeclaration other = _other as EnumConstantDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualNodes(node.name, other.name);
   }
 
   @override
   bool visitEnumDeclaration(EnumDeclaration node) {
     EnumDeclaration other = _other as EnumDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.enumKeyword, other.enumKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualTokens(node.leftBracket, other.leftBracket) &&
         _isEqualNodeLists(node.constants, other.constants) &&
         isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitExportDirective(ExportDirective node) {
     ExportDirective other = _other as ExportDirective;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.keyword, other.keyword) &&
         isEqualNodes(node.uri, other.uri) &&
         _isEqualNodeLists(node.combinators, other.combinators) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
     ExpressionFunctionBody other = _other as ExpressionFunctionBody;
@@ skipping 13 matching lines @@
   bool visitExtendsClause(ExtendsClause node) {
     ExtendsClause other = _other as ExtendsClause;
     return isEqualTokens(node.extendsKeyword, other.extendsKeyword) &&
         isEqualNodes(node.superclass, other.superclass);
   }
 
   @override
   bool visitFieldDeclaration(FieldDeclaration node) {
     FieldDeclaration other = _other as FieldDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.staticKeyword, other.staticKeyword) &&
         isEqualNodes(node.fields, other.fields) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitFieldFormalParameter(FieldFormalParameter node) {
     FieldFormalParameter other = _other as FieldFormalParameter;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.keyword, other.keyword) &&
         isEqualNodes(node.type, other.type) &&
         isEqualTokens(node.thisKeyword, other.thisKeyword) &&
         isEqualTokens(node.period, other.period) &&
         isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitForEachStatement(ForEachStatement node) {
@@ skipping 29 matching lines @@
         isEqualTokens(node.rightSeparator, other.rightSeparator) &&
         _isEqualNodeLists(node.updaters, other.updaters) &&
         isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
         isEqualNodes(node.body, other.body);
   }
 
   @override
   bool visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionDeclaration other = _other as FunctionDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.externalKeyword, other.externalKeyword) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.functionExpression, other.functionExpression);
   }
 
   @override
   bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
@@ skipping 12 matching lines @@
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     FunctionExpressionInvocation other = _other as FunctionExpressionInvocation;
     return isEqualNodes(node.function, other.function) &&
         isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAlias other = _other as FunctionTypeAlias;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.typeParameters, other.typeParameters) &&
         isEqualNodes(node.parameters, other.parameters) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     FunctionTypedFormalParameter other = _other as FunctionTypedFormalParameter;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualNodes(node.identifier, other.identifier) &&
         isEqualNodes(node.parameters, other.parameters);
   }
 
   @override
   bool visitHideCombinator(HideCombinator node) {
     HideCombinator other = _other as HideCombinator;
     return isEqualTokens(node.keyword, other.keyword) &&
@@ skipping 16 matching lines @@
   bool visitImplementsClause(ImplementsClause node) {
     ImplementsClause other = _other as ImplementsClause;
     return isEqualTokens(node.implementsKeyword, other.implementsKeyword) &&
         _isEqualNodeLists(node.interfaces, other.interfaces);
   }
 
   @override
   bool visitImportDirective(ImportDirective node) {
     ImportDirective other = _other as ImportDirective;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.keyword, other.keyword) &&
         isEqualNodes(node.uri, other.uri) &&
         isEqualTokens(node.deferredKeyword, other.deferredKeyword) &&
         isEqualTokens(node.asKeyword, other.asKeyword) &&
         isEqualNodes(node.prefix, other.prefix) &&
         _isEqualNodeLists(node.combinators, other.combinators) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
@@ skipping 56 matching lines @@
   bool visitLabeledStatement(LabeledStatement node) {
     LabeledStatement other = _other as LabeledStatement;
     return _isEqualNodeLists(node.labels, other.labels) &&
         isEqualNodes(node.statement, other.statement);
   }
 
   @override
   bool visitLibraryDirective(LibraryDirective node) {
     LibraryDirective other = _other as LibraryDirective;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.libraryKeyword, other.libraryKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitLibraryIdentifier(LibraryIdentifier node) {
     LibraryIdentifier other = _other as LibraryIdentifier;
     return _isEqualNodeLists(node.components, other.components);
@@ skipping 24 matching lines @@
     MapLiteralEntry other = _other as MapLiteralEntry;
     return isEqualNodes(node.key, other.key) &&
         isEqualTokens(node.separator, other.separator) &&
         isEqualNodes(node.value, other.value);
   }
 
   @override
   bool visitMethodDeclaration(MethodDeclaration node) {
     MethodDeclaration other = _other as MethodDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.externalKeyword, other.externalKeyword) &&
         isEqualTokens(node.modifierKeyword, other.modifierKeyword) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
         isEqualTokens(node.propertyKeyword, other.propertyKeyword) &&
         isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.parameters, other.parameters) &&
         isEqualNodes(node.body, other.body);
   }
@@ skipping 40 matching lines @@
     ParenthesizedExpression other = _other as ParenthesizedExpression;
     return isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
         isEqualNodes(node.expression, other.expression) &&
         isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
   @override
   bool visitPartDirective(PartDirective node) {
     PartDirective other = _other as PartDirective;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.partKeyword, other.partKeyword) &&
         isEqualNodes(node.uri, other.uri) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitPartOfDirective(PartOfDirective node) {
     PartOfDirective other = _other as PartOfDirective;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.partKeyword, other.partKeyword) &&
         isEqualTokens(node.ofKeyword, other.ofKeyword) &&
         isEqualNodes(node.libraryName, other.libraryName) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitPostfixExpression(PostfixExpression node) {
     PostfixExpression other = _other as PostfixExpression;
@@ skipping 18 matching lines @@
 
   @override
   bool visitPropertyAccess(PropertyAccess node) {
     PropertyAccess other = _other as PropertyAccess;
     return isEqualNodes(node.target, other.target) &&
         isEqualTokens(node.operator, other.operator) &&
         isEqualNodes(node.propertyName, other.propertyName);
   }
 
   @override
-  bool
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  bool visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation other =
         _other as RedirectingConstructorInvocation;
     return isEqualTokens(node.thisKeyword, other.thisKeyword) &&
         isEqualTokens(node.period, other.period) &&
         isEqualNodes(node.constructorName, other.constructorName) &&
         isEqualNodes(node.argumentList, other.argumentList);
   }
 
   @override
   bool visitRethrowExpression(RethrowExpression node) {
@@ skipping 19 matching lines @@
   bool visitShowCombinator(ShowCombinator node) {
     ShowCombinator other = _other as ShowCombinator;
     return isEqualTokens(node.keyword, other.keyword) &&
         _isEqualNodeLists(node.shownNames, other.shownNames);
   }
 
   @override
   bool visitSimpleFormalParameter(SimpleFormalParameter node) {
     SimpleFormalParameter other = _other as SimpleFormalParameter;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.keyword, other.keyword) &&
         isEqualNodes(node.type, other.type) &&
         isEqualNodes(node.identifier, other.identifier);
   }
 
   @override
   bool visitSimpleIdentifier(SimpleIdentifier node) {
     SimpleIdentifier other = _other as SimpleIdentifier;
     return isEqualTokens(node.token, other.token);
@@ skipping 75 matching lines @@
   bool visitThrowExpression(ThrowExpression node) {
     ThrowExpression other = _other as ThrowExpression;
     return isEqualTokens(node.throwKeyword, other.throwKeyword) &&
         isEqualNodes(node.expression, other.expression);
   }
 
   @override
   bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     TopLevelVariableDeclaration other = _other as TopLevelVariableDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualNodes(node.variables, other.variables) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
   bool visitTryStatement(TryStatement node) {
     TryStatement other = _other as TryStatement;
     return isEqualTokens(node.tryKeyword, other.tryKeyword) &&
         isEqualNodes(node.body, other.body) &&
@@ skipping 14 matching lines @@
   bool visitTypeName(TypeName node) {
     TypeName other = _other as TypeName;
     return isEqualNodes(node.name, other.name) &&
         isEqualNodes(node.typeArguments, other.typeArguments);
   }
 
   @override
   bool visitTypeParameter(TypeParameter node) {
     TypeParameter other = _other as TypeParameter;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualNodes(node.name, other.name) &&
         isEqualTokens(node.extendsKeyword, other.extendsKeyword) &&
         isEqualNodes(node.bound, other.bound);
   }
 
   @override
   bool visitTypeParameterList(TypeParameterList node) {
     TypeParameterList other = _other as TypeParameterList;
     return isEqualTokens(node.leftBracket, other.leftBracket) &&
         _isEqualNodeLists(node.typeParameters, other.typeParameters) &&
         isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
   @override
   bool visitVariableDeclaration(VariableDeclaration node) {
     VariableDeclaration other = _other as VariableDeclaration;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualNodes(node.name, other.name) &&
         isEqualTokens(node.equals, other.equals) &&
         isEqualNodes(node.initializer, other.initializer);
   }
 
   @override
   bool visitVariableDeclarationList(VariableDeclarationList node) {
     VariableDeclarationList other = _other as VariableDeclarationList;
     return isEqualNodes(
-        node.documentationComment,
-        other.documentationComment) &&
+            node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.keyword, other.keyword) &&
         isEqualNodes(node.type, other.type) &&
         _isEqualNodeLists(node.variables, other.variables);
   }
 
   @override
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     VariableDeclarationStatement other = _other as VariableDeclarationStatement;
     return isEqualNodes(node.variables, other.variables) &&
@@ skipping 460 matching lines @@
   R visitPartOfDirective(PartOfDirective node);
 
   R visitPostfixExpression(PostfixExpression node);
 
   R visitPrefixedIdentifier(PrefixedIdentifier node);
 
   R visitPrefixExpression(PrefixExpression node);
 
   R visitPropertyAccess(PropertyAccess node);
 
-  R
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node);
+  R visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node);
 
   R visitRethrowExpression(RethrowExpression node);
 
   R visitReturnStatement(ReturnStatement node);
 
   R visitScriptTag(ScriptTag node);
 
   R visitShowCombinator(ShowCombinator node);
 
   R visitSimpleFormalParameter(SimpleFormalParameter node);
@@ skipping 72 matching lines @@
   @override
   Token get beginToken {
     if (awaitKeyword != null) {
       return awaitKeyword;
     }
     return _expression.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(awaitKeyword)
-      ..add(_expression);
+    ..add(awaitKeyword)
+    ..add(_expression);
 
   @override
   Token get endToken => _expression.endToken;
 
   /**
    * Return the expression whose value is being waited on.
    */
   Expression get expression => _expression;
 
   /**
@@ skipping 48 matching lines @@
    * The element associated with the operator based on the propagated type of
    * the left operand, or `null` if the AST structure has not been resolved, if
    * the operator is not user definable, or if the operator could not be
    * resolved.
    */
   MethodElement propagatedElement;
 
   /**
    * Initialize a newly created binary expression.
    */
-  BinaryExpression(Expression leftOperand, this.operator,
-      Expression rightOperand) {
+  BinaryExpression(
+      Expression leftOperand, this.operator, Expression rightOperand) {
     _leftOperand = _becomeParentOf(leftOperand);
     _rightOperand = _becomeParentOf(rightOperand);
   }
 
   @override
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_leftOperand)
-      ..add(operator)
-      ..add(_rightOperand);
+    ..add(_leftOperand)
+    ..add(operator)
+    ..add(_rightOperand);
 
   @override
   Token get endToken => _rightOperand.endToken;
 
   /**
    * Return the expression used to compute the left operand.
    */
   Expression get leftOperand => _leftOperand;
 
   /**
@@ skipping 113 matching lines @@
    */
   Block(this.leftBracket, List<Statement> statements, this.rightBracket) {
     _statements = new NodeList<Statement>(this, statements);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(leftBracket)
-      ..addAll(_statements)
-      ..add(rightBracket);
+    ..add(leftBracket)
+    ..addAll(_statements)
+    ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the statements contained in the block.
    */
   NodeList<Statement> get statements => _statements;
 
   @override
@@ skipping 49 matching lines @@
 
   /**
    * Set the block representing the body of the function to the given [block].
    */
   void set block(Block block) {
     _block = _becomeParentOf(block);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
-      ..add(star)
-      ..add(_block);
+    ..add(keyword)
+    ..add(star)
+    ..add(_block);
 
   @override
   Token get endToken => _block.endToken;
 
   @override
   bool get isAsynchronous => keyword != null && keyword.lexeme == Parser.ASYNC;
 
   @override
   bool get isGenerator => star != null;
 
@@ skipping 146 matching lines @@
    */
   BreakStatement(this.breakKeyword, SimpleIdentifier label, this.semicolon) {
     _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => breakKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(breakKeyword)
-      ..add(_label)
-      ..add(semicolon);
+    ..add(breakKeyword)
+    ..add(_label)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the token representing the 'break' keyword.
    */
   @deprecated // Use "this.breakKeyword"
   Token get keyword => breakKeyword;
 
@@ skipping 66 matching lines @@
   @override
   Token get beginToken => _target.beginToken;
 
   /**
    * Return the cascade sections sharing the common target.
    */
   NodeList<Expression> get cascadeSections => _cascadeSections;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_target)
-      ..addAll(_cascadeSections);
+    ..add(_target)
+    ..addAll(_cascadeSections);
 
   @override
   Token get endToken => _cascadeSections.endToken;
 
   @override
   int get precedence => 2;
 
   /**
    * Return the target of the cascade sections.
    */
@@ skipping 108 matching lines @@
 
   /**
    * Set the body of the catch block to the given [block].
    */
   void set body(Block block) {
     _body = _becomeParentOf(block);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(onKeyword)
-      ..add(_exceptionType)
-      ..add(catchKeyword)
-      ..add(leftParenthesis)
-      ..add(_exceptionParameter)
-      ..add(comma)
-      ..add(_stackTraceParameter)
-      ..add(rightParenthesis)
-      ..add(_body);
+    ..add(onKeyword)
+    ..add(_exceptionType)
+    ..add(catchKeyword)
+    ..add(leftParenthesis)
+    ..add(_exceptionParameter)
+    ..add(comma)
+    ..add(_stackTraceParameter)
+    ..add(rightParenthesis)
+    ..add(_body);
 
   @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the parameter whose value will be the exception that was thrown, or
    * `null` if there is no 'catch' keyword.
    */
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
@@ skipping 153 matching lines @@
    * 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)
+      WithClause withClause, ImplementsClause implementsClause,
+      this.leftBracket, List<ClassMember> members, this.rightBracket)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
     _extendsClause = _becomeParentOf(extendsClause);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
     _members = new NodeList<ClassMember>(this, members);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(abstractKeyword)
-      ..add(classKeyword)
-      ..add(_name)
-      ..add(_typeParameters)
-      ..add(_extendsClause)
-      ..add(_withClause)
-      ..add(_implementsClause)
-      ..add(_nativeClause)
-      ..add(leftBracket)
-      ..addAll(members)
-      ..add(rightBracket);
+    ..add(abstractKeyword)
+    ..add(classKeyword)
+    ..add(_name)
+    ..add(_typeParameters)
+    ..add(_extendsClause)
+    ..add(_withClause)
+    ..add(_implementsClause)
+    ..add(_nativeClause)
+    ..add(leftBracket)
+    ..addAll(members)
+    ..add(rightBracket);
 
   @override
   ClassElement get element =>
       _name != null ? (_name.staticElement as ClassElement) : null;
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the extends clause for this class, or `null` if the class does not
@@ skipping 241 matching lines @@
       : super(comment, metadata, keyword, semicolon) {
     _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
     _superclass = _becomeParentOf(superclass);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(typedefKeyword)
-      ..add(_name)
-      ..add(_typeParameters)
-      ..add(equals)
-      ..add(abstractKeyword)
-      ..add(_superclass)
-      ..add(_withClause)
-      ..add(_implementsClause)
-      ..add(semicolon);
+    ..add(typedefKeyword)
+    ..add(_name)
+    ..add(_typeParameters)
+    ..add(equals)
+    ..add(abstractKeyword)
+    ..add(_superclass)
+    ..add(_withClause)
+    ..add(_implementsClause)
+    ..add(semicolon);
 
   @override
   ClassElement get element =>
       _name != null ? (_name.staticElement as ClassElement) : null;
 
   /**
    * Return the implements clause for this class, or `null` if there is no
    * implements clause.
    */
   ImplementsClause get implementsClause => _implementsClause;
@@ skipping 182 matching lines @@
 
   /**
    * Create a block comment consisting of the given [tokens].
    */
   static Comment createBlockComment(List<Token> tokens) =>
       new Comment(tokens, CommentType.BLOCK, null);
 
   /**
    * Create a documentation comment consisting of the given [tokens].
    */
-  static Comment createDocumentationComment(List<Token> tokens) =>
-      new Comment(tokens, CommentType.DOCUMENTATION, new List<CommentReference>());
+  static Comment createDocumentationComment(List<Token> tokens) => new Comment(
+      tokens, CommentType.DOCUMENTATION, new List<CommentReference>());
 
   /**
    * Create a documentation comment consisting of the given [tokens] and having
    * the given [references] embedded within it.
    */
-  static Comment createDocumentationCommentWithReferences(List<Token> tokens,
-      List<CommentReference> references) =>
+  static Comment createDocumentationCommentWithReferences(
+          List<Token> tokens, List<CommentReference> references) =>
       new Comment(tokens, CommentType.DOCUMENTATION, references);
 
   /**
    * Create an end-of-line comment consisting of the given [tokens].
    */
   static Comment createEndOfLineComment(List<Token> tokens) =>
       new Comment(tokens, CommentType.END_OF_LINE, null);
 }
 
 /**
@@ skipping 20 matching lines @@
    */
   CommentReference(this.newKeyword, Identifier identifier) {
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Token get beginToken => _identifier.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(newKeyword)
-      ..add(_identifier);
+    ..add(newKeyword)
+    ..add(_identifier);
 
   @override
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being referenced.
    */
   Identifier get identifier => _identifier;
 
   /**
@@ skipping 121 matching lines @@
     _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) {
       result
-          ..addAll(_directives)
-          ..addAll(_declarations);
+        ..addAll(_directives)
+        ..addAll(_declarations);
     } else {
       result.addAll(sortedDirectivesAndDeclarations);
     }
     return result;
   }
 
   /**
    * Return the declarations contained in this compilation unit.
    */
   NodeList<CompilationUnitMember> get declarations => _declarations;
@@ skipping 28 matching lines @@
   void set scriptTag(ScriptTag scriptTag) {
     _scriptTag = _becomeParentOf(scriptTag);
   }
 
   /**
    * Return a list containing all of the directives and declarations in this
    * compilation unit, sorted in lexical order.
    */
   List<AstNode> get sortedDirectivesAndDeclarations {
     return <AstNode>[]
-        ..addAll(_directives)
-        ..addAll(_declarations)
-        ..sort(AstNode.LEXICAL_ORDER);
+      ..addAll(_directives)
+      ..addAll(_declarations)
+      ..sort(AstNode.LEXICAL_ORDER);
   }
 
   /**
    * Return `true` if all of the directives are lexically before any
    * declarations.
    */
   bool get _directivesAreBeforeDeclarations {
     if (_directives.isEmpty || _declarations.isEmpty) {
       return true;
     }
@@ skipping 80 matching lines @@
     _condition = _becomeParentOf(condition);
     _thenExpression = _becomeParentOf(thenExpression);
     _elseExpression = _becomeParentOf(elseExpression);
   }
 
   @override
   Token get beginToken => _condition.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_condition)
-      ..add(question)
-      ..add(_thenExpression)
-      ..add(colon)
-      ..add(_elseExpression);
+    ..add(_condition)
+    ..add(question)
+    ..add(_thenExpression)
+    ..add(colon)
+    ..add(_elseExpression);
 
   /**
    * Return the condition used to determine which of the expressions is executed
    * next.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition used to determine which of the expressions is executed
    * next to the given [expression].
@@ skipping 247 matching lines @@
         // numeric or {@code null}
         if (leftOperand is int && rightOperand is int) {
           if (rightOperand != 0) {
             return leftOperand ~/ rightOperand;
           } else {
             return 0;
           }
         } else if (leftOperand is double && rightOperand is double) {
           return leftOperand ~/ rightOperand;
         }
-      } else {
-      }
+      } else {}
       break;
     }
     // TODO(brianwilkerson) This doesn't handle numeric conversions.
     return visitExpression(node);
   }
 
   @override
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
 
   @override
@@ skipping 80 matching lines @@
           return ~operand;
         }
       } else if (node.operator.type == TokenType.MINUS) {
         if (operand == null) {
           return null;
         } else if (operand is int) {
           return -operand;
         } else if (operand is double) {
           return -operand;
         }
-      } else {
-      }
+      } else {}
       break;
     }
     return NOT_A_CONSTANT;
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) => _getConstantValue(null);
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) =>
@@ skipping 181 matching lines @@
 
   /**
    * Set the body of the constructor to the given [functionBody].
    */
   void set body(FunctionBody functionBody) {
     _body = _becomeParentOf(functionBody);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(externalKeyword)
-      ..add(constKeyword)
-      ..add(factoryKeyword)
-      ..add(_returnType)
-      ..add(period)
-      ..add(_name)
-      ..add(_parameters)
-      ..add(separator)
-      ..addAll(initializers)
-      ..add(_redirectedConstructor)
-      ..add(_body);
+    ..add(externalKeyword)
+    ..add(constKeyword)
+    ..add(factoryKeyword)
+    ..add(_returnType)
+    ..add(period)
+    ..add(_name)
+    ..add(_parameters)
+    ..add(separator)
+    ..addAll(initializers)
+    ..add(_redirectedConstructor)
+    ..add(_body);
 
   @override
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (!_initializers.isEmpty) {
       return _initializers.endToken;
     }
     return _parameters.endToken;
   }
@@ skipping 129 matching lines @@
   @override
   Token get beginToken {
     if (thisKeyword != null) {
       return thisKeyword;
     }
     return _fieldName.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(thisKeyword)
-      ..add(period)
-      ..add(_fieldName)
-      ..add(equals)
-      ..add(_expression);
+    ..add(thisKeyword)
+    ..add(period)
+    ..add(_fieldName)
+    ..add(equals)
+    ..add(_expression);
 
   @override
   Token get endToken => _expression.endToken;
 
   /**
    * Return the expression computing the value to which the field will be
    * initialized.
    */
   Expression get expression => _expression;
 
@@ skipping 42 matching lines @@
   }
 }
 
 /**
  * A node that can occur in the initializer list of a constructor declaration.
  *
  * > constructorInitializer ::=
  * >     [SuperConstructorInvocation]
  * >   | [ConstructorFieldInitializer]
  */
-abstract class ConstructorInitializer extends AstNode {
-}
+abstract class ConstructorInitializer extends AstNode {}
 
 /**
  * The name of the constructor.
  *
  * > constructorName ::=
  * >     type ('.' identifier)?
  */
 class ConstructorName extends AstNode {
   /**
    * The name of the type defining the constructor.
@@ skipping 26 matching lines @@
   ConstructorName(TypeName type, this.period, SimpleIdentifier name) {
     _type = _becomeParentOf(type);
     _name = _becomeParentOf(name);
   }
 
   @override
   Token get beginToken => _type.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_type)
-      ..add(period)
-      ..add(_name);
+    ..add(_type)
+    ..add(period)
+    ..add(_name);
 
   @override
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
   /**
@@ skipping 60 matching lines @@
    * AST has not yet been resolved or if the target could not be resolved.
    * Note that if the source code has errors, the target may be invalid (e.g.
    * the target may be in an enclosing function).
    */
   AstNode target;
 
   /**
    * Initialize a newly created continue statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
-  ContinueStatement(this.continueKeyword, SimpleIdentifier label, this.semicolon) {
+  ContinueStatement(
+      this.continueKeyword, SimpleIdentifier label, this.semicolon) {
     _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => continueKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(continueKeyword)
-      ..add(_label)
-      ..add(semicolon);
+    ..add(continueKeyword)
+    ..add(_label)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the token for the 'continue' keyword, or `null` if there is no
    * 'continue' keyword.
    */
   @deprecated // Use "this.continueKeyword"
   Token get keyword => continueKeyword;
@@ skipping 81 matching lines @@
    */
   DeclaredIdentifier(Comment comment, List<Annotation> metadata, this.keyword,
       TypeName type, SimpleIdentifier identifier)
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
-      ..add(_type)
-      ..add(_identifier);
+    ..add(keyword)
+    ..add(_type)
+    ..add(_identifier);
 
   @override
   LocalVariableElement get element {
     if (_identifier == null) {
       return null;
     }
     return _identifier.staticElement as LocalVariableElement;
   }
 
   @override
@@ skipping 17 matching lines @@
   /**
    * Set the name of the variable being declared to the given [identifier].
    */
   void set identifier(SimpleIdentifier identifier) {
     _identifier = _becomeParentOf(identifier);
   }
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    */
-  bool get isConst =>
-      (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.CONST;
+  bool get isConst => (keyword is KeywordToken) &&
+      (keyword as KeywordToken).keyword == Keyword.CONST;
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return `false`
    * even though they are implicitly final.
    */
-  bool get isFinal =>
-      (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
+  bool get isFinal => (keyword is KeywordToken) &&
+      (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the
    * parameter does not have a declared type.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
@@ skipping 54 matching lines @@
       this.separator, Expression defaultValue) {
     _parameter = _becomeParentOf(parameter);
     _defaultValue = _becomeParentOf(defaultValue);
   }
 
   @override
   Token get beginToken => _parameter.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_parameter)
-      ..add(separator)
-      ..add(_defaultValue);
+    ..add(_parameter)
+    ..add(separator)
+    ..add(_defaultValue);
 
   /**
    * Return the expression computing the default value for the parameter, or
    * `null` if there is no default value.
    */
   Expression get defaultValue => _defaultValue;
 
   /**
    * Set the expression computing the default value for the parameter to the
    * given [expression].
@@ skipping 167 matching lines @@
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
     _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(doKeyword)
-      ..add(_body)
-      ..add(whileKeyword)
-      ..add(leftParenthesis)
-      ..add(_condition)
-      ..add(rightParenthesis)
-      ..add(semicolon);
+    ..add(doKeyword)
+    ..add(_body)
+    ..add(whileKeyword)
+    ..add(leftParenthesis)
+    ..add(_condition)
+    ..add(rightParenthesis)
+    ..add(semicolon);
 
   /**
    * Return the condition that determines when the loop will terminate.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition that determines when the loop will terminate to the given
    * [expression].
    */
@@ skipping 282 matching lines @@
    * The name of the constant.
    */
   SimpleIdentifier _name;
 
   /**
    * Initialize a newly created enum constant declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the constant does not have the
    * corresponding attribute. (Technically, enum constants cannot have metadata,
    * but we allow it for consistency.)
    */
-  EnumConstantDeclaration(Comment comment, List<Annotation> metadata,
-      SimpleIdentifier name)
+  EnumConstantDeclaration(
+      Comment comment, List<Annotation> metadata, SimpleIdentifier name)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
   }
 
   @override
   Iterable get childEntities => super._childEntities..add(_name);
 
   @override
   FieldElement get element =>
       _name == null ? null : (_name.staticElement as FieldElement);
@@ skipping 68 matching lines @@
       SimpleIdentifier name, this.leftBracket,
       List<EnumConstantDeclaration> constants, this.rightBracket)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
     _constants = new NodeList<EnumConstantDeclaration>(this, constants);
   }
 
   @override
   // TODO(brianwilkerson) Add commas?
   Iterable get childEntities => super._childEntities
-      ..add(enumKeyword)
-      ..add(_name)
-      ..add(leftBracket)
-      ..addAll(_constants)
-      ..add(rightBracket);
+    ..add(enumKeyword)
+    ..add(_name)
+    ..add(leftBracket)
+    ..addAll(_constants)
+    ..add(rightBracket);
 
   /**
    * Return the enumeration constants being declared.
    */
   NodeList<EnumConstantDeclaration> get constants => _constants;
 
   @override
   ClassElement get element =>
       _name != null ? (_name.staticElement as ClassElement) : null;
 
@@ skipping 64 matching lines @@
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute. The list of [combinators] can be `null` if there
    * are no combinators.
    */
   ExportDirective(Comment comment, List<Annotation> metadata, Token keyword,
       StringLiteral libraryUri, List<Combinator> combinators, Token semicolon)
       : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(_uri)
-      ..addAll(combinators)
-      ..add(semicolon);
+    ..add(_uri)
+    ..addAll(combinators)
+    ..add(semicolon);
 
   @override
   ExportElement get element => super.element as ExportElement;
 
   @override
   LibraryElement get uriElement {
     if (element != null) {
       return element.exportedLibrary;
     }
     return null;
@@ skipping 202 matching lines @@
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
     return functionDefinition;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
-      ..add(functionDefinition)
-      ..add(_expression)
-      ..add(semicolon);
+    ..add(keyword)
+    ..add(functionDefinition)
+    ..add(_expression)
+    ..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
@@ skipping 47 matching lines @@
    */
   ExpressionStatement(Expression expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_expression)
-      ..add(semicolon);
+    ..add(_expression)
+    ..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
@@ skipping 42 matching lines @@
    */
   ExtendsClause(this.extendsKeyword, TypeName superclass) {
     _superclass = _becomeParentOf(superclass);
   }
 
   @override
   Token get beginToken => extendsKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(extendsKeyword)
-      ..add(_superclass);
+    ..add(extendsKeyword)
+    ..add(_superclass);
 
   @override
   Token get endToken => _superclass.endToken;
 
   /**
    * Return the token for the 'extends' keyword.
    */
   @deprecated // Use "this.extendsKeyword"
   Token get keyword => extendsKeyword;
 
@@ skipping 56 matching lines @@
    * not a static field.
    */
   FieldDeclaration(Comment comment, List<Annotation> metadata,
       this.staticKeyword, VariableDeclarationList fieldList, this.semicolon)
       : super(comment, metadata) {
     _fieldList = _becomeParentOf(fieldList);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(staticKeyword)
-      ..add(_fieldList)
-      ..add(semicolon);
+    ..add(staticKeyword)
+    ..add(_fieldList)
+    ..add(semicolon);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the fields being declared.
    */
@@ skipping 87 matching lines @@
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return thisKeyword;
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
-      ..add(_type)
-      ..add(thisKeyword)
-      ..add(period)
-      ..add(identifier)
-      ..add(_parameters);
+    ..add(keyword)
+    ..add(_type)
+    ..add(thisKeyword)
+    ..add(period)
+    ..add(identifier)
+    ..add(_parameters);
 
   @override
   Token get endToken {
     if (_parameters != null) {
       return _parameters.endToken;
     }
     return identifier.endToken;
   }
 
   @override
-  bool get isConst =>
-      (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.CONST;
+  bool get isConst => (keyword is KeywordToken) &&
+      (keyword as KeywordToken).keyword == Keyword.CONST;
 
   @override
-  bool get isFinal =>
-      (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
+  bool get isFinal => (keyword is KeywordToken) &&
+      (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Return the parameters of the function-typed parameter, or `null` if this is
    * not a function-typed field formal parameter.
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Set the parameters of the function-typed parameter to the given
    * [parameters].
@@ skipping 132 matching lines @@
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
     _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(awaitKeyword)
-      ..add(forKeyword)
-      ..add(leftParenthesis)
-      ..add(_loopVariable)
-      ..add(_identifier)
-      ..add(inKeyword)
-      ..add(_iterable)
-      ..add(rightParenthesis)
-      ..add(_body);
+    ..add(awaitKeyword)
+    ..add(forKeyword)
+    ..add(leftParenthesis)
+    ..add(_loopVariable)
+    ..add(_identifier)
+    ..add(inKeyword)
+    ..add(_iterable)
+    ..add(rightParenthesis)
+    ..add(_body);
 
   @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the loop variable, or `null` if the loop variable is declared in the
    * 'for'.
    */
   SimpleIdentifier get identifier => _identifier;
 
@@ skipping 166 matching lines @@
     ChildEntities result = new ChildEntities()..add(leftParenthesis);
     bool leftDelimiterNeeded = leftDelimiter != null;
     for (FormalParameter parameter in _parameters) {
       if (leftDelimiterNeeded && leftDelimiter.offset < parameter.offset) {
         result.add(leftDelimiter);
         leftDelimiterNeeded = false;
       }
       result.add(parameter);
     }
     return result
-        ..add(rightDelimiter)
-        ..add(rightParenthesis);
+      ..add(rightDelimiter)
+      ..add(rightParenthesis);
   }
 
   @override
   Token get endToken => rightParenthesis;
 
   /**
    * Return a list containing the elements representing the parameters in this
    * list. The list will contain `null`s if the parameters in this list have not
    * been resolved.
    */
@@ skipping 116 matching lines @@
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
     _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(forKeyword)
-      ..add(leftParenthesis)
-      ..add(_variableList)
-      ..add(_initialization)
-      ..add(leftSeparator)
-      ..add(_condition)
-      ..add(rightSeparator)
-      ..addAll(_updaters)
-      ..add(rightParenthesis)
-      ..add(_body);
+    ..add(forKeyword)
+    ..add(leftParenthesis)
+    ..add(_variableList)
+    ..add(_initialization)
+    ..add(leftSeparator)
+    ..add(_condition)
+    ..add(rightSeparator)
+    ..addAll(_updaters)
+    ..add(rightParenthesis)
+    ..add(_body);
 
   /**
    * Return the condition used to determine when to terminate the loop, or
    * `null` if there is no condition.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition used to determine when to terminate the loop to the given
    * [expression].
@@ skipping 136 matching lines @@
       this.externalKeyword, TypeName returnType, this.propertyKeyword,
       SimpleIdentifier name, FunctionExpression functionExpression)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _functionExpression = _becomeParentOf(functionExpression);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(externalKeyword)
-      ..add(_returnType)
-      ..add(propertyKeyword)
-      ..add(_name)
-      ..add(_functionExpression);
+    ..add(externalKeyword)
+    ..add(_returnType)
+    ..add(propertyKeyword)
+    ..add(_name)
+    ..add(_functionExpression);
 
   @override
   ExecutableElement get element =>
       _name != null ? (_name.staticElement as ExecutableElement) : null;
 
   @override
   Token get endToken => _functionExpression.endToken;
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 18 matching lines @@
    * Set the function expression being wrapped to the given
    * [functionExpression].
    */
   void set functionExpression(FunctionExpression functionExpression) {
     _functionExpression = _becomeParentOf(functionExpression);
   }
 
   /**
    * Return `true` if this function declares a getter.
    */
-  bool get isGetter =>
-      propertyKeyword != null &&
-          (propertyKeyword as KeywordToken).keyword == Keyword.GET;
+  bool get isGetter => propertyKeyword != null &&
+      (propertyKeyword as KeywordToken).keyword == Keyword.GET;
 
   /**
    * Return `true` if this function declares a setter.
    */
-  bool get isSetter =>
-      propertyKeyword != null &&
-          (propertyKeyword as KeywordToken).keyword == Keyword.SET;
+  bool get isSetter => propertyKeyword != null &&
+      (propertyKeyword as KeywordToken).keyword == Keyword.SET;
 
   /**
    * Return the name of the function, or `null` if the function is not named.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the function to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
@@ skipping 122 matching lines @@
 
   /**
    * Set the body of the function to the given [functionBody].
    */
   void set body(FunctionBody functionBody) {
     _body = _becomeParentOf(functionBody);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_parameters)
-      ..add(_body);
+    ..add(_parameters)
+    ..add(_body);
 
   @override
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (_parameters != null) {
       return _parameters.endToken;
     }
     // This should never be reached because external functions must be named,
     // hence either the body or the name should be non-null.
@@ skipping 93 matching lines @@
   ExecutableElement get bestElement {
     ExecutableElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_function)
-      ..add(_argumentList);
+    ..add(_function)
+    ..add(_argumentList);
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the expression producing the function being invoked.
    */
   Expression get function => _function;
 
   /**
@@ skipping 50 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, Token semicolon)
+      TypeName returnType, SimpleIdentifier name,
+      TypeParameterList typeParameters, FormalParameterList parameters,
+      Token semicolon)
       : super(comment, metadata, keyword, semicolon) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(typedefKeyword)
-      ..add(_returnType)
-      ..add(_name)
-      ..add(_typeParameters)
-      ..add(_parameters)
-      ..add(semicolon);
+    ..add(typedefKeyword)
+    ..add(_returnType)
+    ..add(_name)
+    ..add(_typeParameters)
+    ..add(_parameters)
+    ..add(semicolon);
 
   @override
   FunctionTypeAliasElement get element =>
       _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
    * Return the name of the function type being declared.
    */
   SimpleIdentifier get name => _name;
 
@@ skipping 93 matching lines @@
   @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(_returnType)
-      ..add(identifier)
-      ..add(parameters);
+    ..add(_returnType)
+    ..add(identifier)
+    ..add(parameters);
 
   @override
   Token get endToken => _parameters.endToken;
 
   @override
   bool get isConst => false;
 
   @override
   bool get isFinal => false;
 
@@ skipping 334 matching lines @@
   @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) => visitIdentifier(node);
 
   @override
   R visitPrefixExpression(PrefixExpression node) => visitExpression(node);
 
   @override
   R visitPropertyAccess(PropertyAccess node) => visitExpression(node);
 
   @override
-  R
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) =>
+  R visitRedirectingConstructorInvocation(
+          RedirectingConstructorInvocation node) =>
       visitConstructorInitializer(node);
 
   @override
   R visitRethrowExpression(RethrowExpression node) => visitExpression(node);
 
   @override
   R visitReturnStatement(ReturnStatement node) => visitStatement(node);
 
   @override
   R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
@@ skipping 90 matching lines @@
   @override
   R visitWhileStatement(WhileStatement node) => visitStatement(node);
 
   @override
   R visitWithClause(WithClause node) => visitNode(node);
 
   @override
   R visitYieldStatement(YieldStatement node) => visitStatement(node);
 }
 
-class GeneralizingAstVisitor_BreadthFirstVisitor extends
-    GeneralizingAstVisitor<Object> {
+class GeneralizingAstVisitor_BreadthFirstVisitor
+    extends GeneralizingAstVisitor<Object> {
   final BreadthFirstVisitor BreadthFirstVisitor_this;
 
   GeneralizingAstVisitor_BreadthFirstVisitor(this.BreadthFirstVisitor_this)
       : super();
 
   @override
   Object visitNode(AstNode node) {
     BreadthFirstVisitor_this._queue.add(node);
     return null;
   }
@@ skipping 15 matching lines @@
   /**
    * Initialize a newly created import show combinator.
    */
   HideCombinator(Token keyword, List<SimpleIdentifier> hiddenNames)
       : super(keyword) {
     _hiddenNames = new NodeList<SimpleIdentifier>(this, hiddenNames);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
-      ..addAll(_hiddenNames);
+    ..add(keyword)
+    ..addAll(_hiddenNames);
 
   @override
   Token get endToken => _hiddenNames.endToken;
 
   /**
    * Return the list of names from the library that are hidden by this
    * combinator.
    */
   NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
 
@@ skipping 109 matching lines @@
     _condition = _becomeParentOf(condition);
     _thenStatement = _becomeParentOf(thenStatement);
     _elseStatement = _becomeParentOf(elseStatement);
   }
 
   @override
   Token get beginToken => ifKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(ifKeyword)
-      ..add(leftParenthesis)
-      ..add(_condition)
-      ..add(rightParenthesis)
-      ..add(_thenStatement)
-      ..add(elseKeyword)
-      ..add(_elseStatement);
+    ..add(ifKeyword)
+    ..add(leftParenthesis)
+    ..add(_condition)
+    ..add(rightParenthesis)
+    ..add(_thenStatement)
+    ..add(elseKeyword)
+    ..add(_elseStatement);
 
   /**
    * Return the condition used to determine which of the statements is executed
    * next.
    */
   Expression get condition => _condition;
 
   /**
    * Set the condition used to determine which of the statements is executed
    * next to the given [expression].
@@ skipping 73 matching lines @@
   }
 
   @override
   Token get beginToken => implementsKeyword;
 
   /**
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(implementsKeyword)
-      ..addAll(interfaces);
+    ..add(implementsKeyword)
+    ..addAll(interfaces);
 
   @override
   Token get endToken => _interfaces.endToken;
 
   /**
    * Return the list of the interfaces that are being implemented.
    */
   NodeList<TypeName> get interfaces => _interfaces;
 
   /**
@@ skipping 20 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 116 matching lines @@
    * The token representing the 'as' token, or `null` if the imported names are
    * not prefixed.
    */
   @deprecated // Use "this.asKeyword"
   Token get asToken => asKeyword;
 
   /**
    * The token representing the 'as' token to the given token.
    */
   @deprecated // Use "this.asKeyword"
-  set asToken (Token token) {
+  set asToken(Token token) {
     asKeyword = token;
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(_uri)
-      ..add(deferredKeyword)
-      ..add(asKeyword)
-      ..add(_prefix)
-      ..addAll(combinators)
-      ..add(semicolon);
+    ..add(_uri)
+    ..add(deferredKeyword)
+    ..add(asKeyword)
+    ..add(_prefix)
+    ..addAll(combinators)
+    ..add(semicolon);
 
   /**
    * Return the token representing the 'deferred' token, or `null` if the
    * imported is not deferred.
    */
   @deprecated // Use "this.deferredKeyword"
   Token get deferredToken => deferredKeyword;
 
   /**
    * Set the token representing the 'deferred' token to the given token.
    */
   @deprecated // Use "this.deferredKeyword"
-  set deferredToken (Token token) {
+  set deferredToken(Token token) {
     deferredKeyword = token;
   }
 
   @override
   ImportElement get element => super.element as ImportElement;
 
   /**
    * Return the prefix to be used with the imported names, or `null` if the
    * imported names are not prefixed.
    */
@@ skipping 54 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.rightParenthesis));
+  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(
+      _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));
+    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(
+      _mapToken(node.assertKeyword), _mapToken(node.leftParenthesis),
+      _cloneNode(node.condition), _mapToken(node.rightParenthesis),
+      _mapToken(node.semicolon));
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression copy = new AssignmentExpression(
-        _cloneNode(node.leftHandSide),
-        _mapToken(node.operator),
+        _cloneNode(node.leftHandSide), _mapToken(node.operator),
         _cloneNode(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AwaitExpression visitAwaitExpression(AwaitExpression node) =>
-      new AwaitExpression(_mapToken(node.awaitKeyword), _cloneNode(node.expression));
+      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));
+    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));
+  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.semicolon));
+  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(
+      _mapToken(node.breakKeyword), _cloneNode(node.label),
+      _mapToken(node.semicolon));
 
   @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) {
     CascadeExpression copy = new CascadeExpression(
-        _cloneNode(node.target),
-        _cloneNodeList(node.cascadeSections));
+        _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),
-          _cloneNode(node.body));
+  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),
+      _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),
-          _mapToken(node.semicolon));
+  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),
+      _mapToken(node.semicolon));
 
   @override
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationCommentWithReferences(
-          _mapTokens(node.tokens),
-          _cloneNodeList(node.references));
+          _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));
+      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 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 visitConstructorFieldInitializer(
+      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));
+        _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));
+      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 visitDefaultFormalParameter(
+      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.semicolon));
+  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.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));
+      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),
-          _mapToken(node.rightBracket));
+  AstNode visitEnumDeclaration(EnumDeclaration node) => new EnumDeclaration(
+      _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 visitExpressionFunctionBody(
+      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));
+      new ExpressionStatement(
+          _cloneNode(node.expression), _mapToken(node.semicolon));
 
   @override
-  ExtendsClause visitExtendsClause(ExtendsClause node) =>
-      new ExtendsClause(_mapToken(node.extendsKeyword), _cloneNode(node.superclass));
+  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),
+      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.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.con2(
-          _mapToken(node.awaitKeyword),
-          _mapToken(node.forKeyword),
-          _mapToken(node.leftParenthesis),
-          _cloneNode(node.identifier),
-          _mapToken(node.inKeyword),
-          _cloneNode(node.iterable),
-          _mapToken(node.rightParenthesis),
+      return new ForEachStatement.con2(_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.con1(
-        _mapToken(node.awaitKeyword),
-        _mapToken(node.forKeyword),
-        _mapToken(node.leftParenthesis),
-        _cloneNode(loopVariable),
-        _mapToken(node.inKeyword),
-        _cloneNode(node.iterable),
-        _mapToken(node.rightParenthesis),
+    return new ForEachStatement.con1(_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));
+  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));
 
   @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) =>
+  FunctionDeclarationStatement visitFunctionDeclarationStatement(
+          FunctionDeclarationStatement node) =>
       new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration));
 
   @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) {
-    FunctionExpression copy =
-        new FunctionExpression(_cloneNode(node.parameters), _cloneNode(node.body));
+    FunctionExpression copy = new FunctionExpression(
+        _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 visitFunctionExpressionInvocation(
+      FunctionExpressionInvocation node) {
     FunctionExpressionInvocation copy = new FunctionExpressionInvocation(
-        _cloneNode(node.function),
-        _cloneNode(node.argumentList));
+        _cloneNode(node.function), _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.parameters));
+  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(
+      FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(
+      _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
+      _cloneNode(node.returnType), _cloneNode(node.identifier),
+      _cloneNode(node.parameters));
 
   @override
-  HideCombinator visitHideCombinator(HideCombinator node) =>
-      new HideCombinator(_mapToken(node.keyword), _cloneNodeList(node.hiddenNames));
+  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),
-          _cloneNode(node.elseStatement));
+  IfStatement visitIfStatement(IfStatement node) => new IfStatement(
+      _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));
+      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 = 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 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 visitInterpolationExpression(
+      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));
+      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.parameters),
+      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.parameters),
           _cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) {
-    MethodInvocation copy = new MethodInvocation(
-        _cloneNode(node.target),
-        _mapToken(node.period),
-        _cloneNode(node.methodName),
+    MethodInvocation copy = new MethodInvocation(_cloneNode(node.target),
+        _mapToken(node.period), _cloneNode(node.methodName),
         _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;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   AstNode visitNativeClause(NativeClause node) =>
       new NativeClause(_mapToken(node.nativeKeyword), _cloneNode(node.name));
 
   @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) =>
-      new NativeFunctionBody(
-          _mapToken(node.nativeKeyword),
-          _cloneNode(node.stringLiteral),
-          _mapToken(node.semicolon));
+      new NativeFunctionBody(_mapToken(node.nativeKeyword),
+          _cloneNode(node.stringLiteral), _mapToken(node.semicolon));
 
   @override
   NullLiteral visitNullLiteral(NullLiteral node) {
     NullLiteral copy = new NullLiteral(_mapToken(node.literal));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
-  ParenthesizedExpression
-      visitParenthesizedExpression(ParenthesizedExpression node) {
+  ParenthesizedExpression 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));
+    PostfixExpression copy = new PostfixExpression(
+        _cloneNode(node.operand), _mapToken(node.operator));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) {
-    PrefixedIdentifier copy = new PrefixedIdentifier(
-        _cloneNode(node.prefix),
-        _mapToken(node.period),
-        _cloneNode(node.identifier));
+    PrefixedIdentifier copy = new PrefixedIdentifier(_cloneNode(node.prefix),
+        _mapToken(node.period), _cloneNode(node.identifier));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   PrefixExpression visitPrefixExpression(PrefixExpression node) {
-    PrefixExpression copy =
-        new PrefixExpression(_mapToken(node.operator), _cloneNode(node.operand));
+    PrefixExpression copy = new PrefixExpression(
+        _mapToken(node.operator), _cloneNode(node.operand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   PropertyAccess visitPropertyAccess(PropertyAccess node) {
-    PropertyAccess copy = new PropertyAccess(
-        _cloneNode(node.target),
-        _mapToken(node.operator),
-        _cloneNode(node.propertyName));
+    PropertyAccess copy = new PropertyAccess(_cloneNode(node.target),
+        _mapToken(node.operator), _cloneNode(node.propertyName));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
-  RedirectingConstructorInvocation
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  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));
+    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));
+      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));
+  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 visitSimpleFormalParameter(
+      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 20 matching lines @@
   @override
   StringInterpolation visitStringInterpolation(StringInterpolation node) {
     StringInterpolation copy =
         new StringInterpolation(_cloneNodeList(node.elements));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
-  SuperConstructorInvocation
-      visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+  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.statements));
+  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(
+      _cloneNodeList(node.labels), _mapToken(node.keyword),
+      _cloneNode(node.expression), _mapToken(node.colon),
+      _cloneNodeList(node.statements));
 
   @override
-  SwitchDefault visitSwitchDefault(SwitchDefault node) =>
-      new SwitchDefault(
-          _cloneNodeList(node.labels),
-          _mapToken(node.keyword),
-          _mapToken(node.colon),
-          _cloneNodeList(node.statements));
+  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(
+      _cloneNodeList(node.labels), _mapToken(node.keyword),
+      _mapToken(node.colon), _cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) =>
-      new SwitchStatement(
-          _mapToken(node.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));
+    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));
+    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 visitTopLevelVariableDeclaration(
+      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),
-          _cloneNode(node.finallyBlock));
+  TryStatement visitTryStatement(TryStatement node) => new TryStatement(
+      _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));
+      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.bound));
+  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(
+      _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));
+      new TypeParameterList(_mapToken(node.leftBracket),
+          _cloneNodeList(node.typeParameters), _mapToken(node.rightBracket));
 
   @override
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) =>
-      new VariableDeclaration(
-          null,
-          _cloneNodeList(node.metadata),
-          _cloneNode(node.name),
-          _mapToken(node.equals),
+      new VariableDeclaration(null, _cloneNodeList(node.metadata),
+          _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 visitVariableDeclarationList(
+      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 visitVariableDeclarationStatement(
+      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),
-          _cloneNode(node.body));
+  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(
+      _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));
+  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));
+  YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement(
+      _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 74 matching lines @@
    * If this expression is both in a getter and setter context, the
    * [AuxiliaryElements] will be set to hold onto the static and propagated
    * information. The auxiliary element will hold onto the elements from the
    * getter context.
    */
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created index expression.
    */
-  IndexExpression.forCascade(this.period, this.leftBracket, Expression index,
-      this.rightBracket) {
+  IndexExpression.forCascade(
+      this.period, this.leftBracket, Expression index, this.rightBracket) {
     _index = _becomeParentOf(index);
   }
 
   /**
    * Initialize a newly created index expression.
    */
   IndexExpression.forTarget(Expression target, this.leftBracket,
       Expression index, this.rightBracket) {
     _target = _becomeParentOf(target);
     _index = _becomeParentOf(index);
@@ skipping 17 matching lines @@
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_target)
-      ..add(period)
-      ..add(leftBracket)
-      ..add(_index)
-      ..add(rightBracket);
+    ..add(_target)
+    ..add(period)
+    ..add(leftBracket)
+    ..add(_index)
+    ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to compute the index.
    */
   Expression get index => _index;
 
   /**
@@ skipping 217 matching lines @@
    */
   void set argumentList(ArgumentList argumentList) {
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken => keyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
-      ..add(_constructorName)
-      ..add(_argumentList);
+    ..add(keyword)
+    ..add(_constructorName)
+    ..add(_argumentList);
 
   /**
    * Return the name of the constructor to be invoked.
    */
   ConstructorName get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor to be invoked to the given [name].
    */
   void set constructorName(ConstructorName name) {
     _constructorName = _becomeParentOf(name);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return `true` if this creation expression is used to invoke a constant
    * constructor.
    */
-  bool get isConst =>
-      keyword is KeywordToken && (keyword as KeywordToken).keyword == Keyword.CONST;
+  bool get isConst => keyword is KeywordToken &&
+      (keyword as KeywordToken).keyword == Keyword.CONST;
 
   @override
   int get precedence => 16;
 
   @override
   accept(AstVisitor visitor) => visitor.visitInstanceCreationExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_constructorName, visitor);
@@ skipping 49 matching lines @@
   }
 }
 
 /**
  * A node within a [StringInterpolation].
  *
  * > interpolationElement ::=
  * >     [InterpolationExpression]
  * >   | [InterpolationString]
  */
-abstract class InterpolationElement extends AstNode {
-}
+abstract class InterpolationElement extends AstNode {}
 
 /**
  * An expression embedded in a string interpolation.
  *
  * > interpolationExpression ::=
  * >     '$' [SimpleIdentifier]
  * >   | '$' '{' [Expression] '}'
  */
 class InterpolationExpression extends InterpolationElement {
   /**
@@ skipping 10 matching lines @@
 
   /**
    * The right curly bracket, or `null` if the expression is an identifier
    * without brackets.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    */
-  InterpolationExpression(this.leftBracket, Expression expression,
-      this.rightBracket) {
+  InterpolationExpression(
+      this.leftBracket, Expression expression, this.rightBracket) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(leftBracket)
-      ..add(_expression)
-      ..add(rightBracket);
+    ..add(leftBracket)
+    ..add(_expression)
+    ..add(rightBracket);
 
   @override
   Token get endToken {
     if (rightBracket != null) {
       return rightBracket;
     }
     return _expression.endToken;
   }
 
   /**
@@ skipping 95 matching lines @@
    * Set the value of the literal to the given [string].
    */
   void set value(String string) {
     _value = string;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInterpolationString(this);
 
   @override
-  void visitChildren(AstVisitor visitor) {
-  }
+  void visitChildren(AstVisitor visitor) {}
 }
 
 /**
  * An is expression.
  *
  * > isExpression ::=
  * >     [Expression] 'is' '!'? [TypeName]
  */
 class IsExpression extends Expression {
   /**
@@ skipping 13 matching lines @@
 
   /**
    * The name of the type being tested for.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
-  IsExpression(Expression expression, this.isOperator, this.notOperator,
-      TypeName type) {
+  IsExpression(
+      Expression expression, this.isOperator, this.notOperator, TypeName type) {
     _expression = _becomeParentOf(expression);
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_expression)
-      ..add(isOperator)
-      ..add(notOperator)
-      ..add(_type);
+    ..add(_expression)
+    ..add(isOperator)
+    ..add(notOperator)
+    ..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    */
   Expression get expression => _expression;
 
   /**
@@ skipping 51 matching lines @@
    */
   Label(SimpleIdentifier label, this.colon) {
     _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => _label.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_label)
-      ..add(colon);
+    ..add(_label)
+    ..add(colon);
 
   @override
   Token get endToken => colon;
 
   /**
    * Return the label being associated with the statement.
    */
   SimpleIdentifier get label => _label;
 
   /**
@@ skipping 40 matching lines @@
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return _statement.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..addAll(_labels)
-      ..add(_statement);
+    ..addAll(_labels)
+    ..add(_statement);
 
   @override
   Token get endToken => _statement.endToken;
 
   /**
    * Return the labels being associated with the statement.
    */
   NodeList<Label> get labels => _labels;
 
   /**
@@ skipping 50 matching lines @@
    * corresponding attribute.
    */
   LibraryDirective(Comment comment, List<Annotation> metadata,
       this.libraryKeyword, LibraryIdentifier name, this.semicolon)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(libraryKeyword)
-      ..add(_name)
-      ..add(semicolon);
+    ..add(libraryKeyword)
+    ..add(_name)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => libraryKeyword;
 
   @override
   Token get keyword => libraryKeyword;
 
@@ skipping 149 matching lines @@
       return typeArguments.beginToken;
     }
     return leftBracket;
   }
 
   /**
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => super._childEntities
-      ..add(leftBracket)
-      ..addAll(_elements)
-      ..add(rightBracket);
+    ..add(leftBracket)
+    ..addAll(_elements)
+    ..add(rightBracket);
 
   /**
    * Return the expressions used to compute the elements of the list.
    */
   NodeList<Expression> get elements => _elements;
 
   @override
   Token get endToken => rightBracket;
 
   @override
@@ skipping 67 matching lines @@
       return typeArguments.beginToken;
     }
     return leftBracket;
   }
 
   /**
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => super._childEntities
-      ..add(leftBracket)
-      ..addAll(entries)
-      ..add(rightBracket);
+    ..add(leftBracket)
+    ..addAll(entries)
+    ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the entries in the map.
    */
   NodeList<MapLiteralEntry> get entries => _entries;
 
   @override
@@ skipping 34 matching lines @@
   MapLiteralEntry(Expression key, this.separator, Expression value) {
     _key = _becomeParentOf(key);
     _value = _becomeParentOf(value);
   }
 
   @override
   Token get beginToken => _key.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_key)
-      ..add(separator)
-      ..add(_value);
+    ..add(_key)
+    ..add(separator)
+    ..add(_value);
 
   @override
   Token get endToken => _value.endToken;
 
   /**
    * Return the expression computing the key with which the value will be
    * associated.
    */
   Expression get key => _key;
 
@@ skipping 118 matching lines @@
 
   /**
    * Set the body of the method to the given [functionBody].
    */
   void set body(FunctionBody functionBody) {
     _body = _becomeParentOf(functionBody);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(externalKeyword)
-      ..add(modifierKeyword)
-      ..add(_returnType)
-      ..add(propertyKeyword)
-      ..add(operatorKeyword)
-      ..add(_name)
-      ..add(_parameters)
-      ..add(_body);
+    ..add(externalKeyword)
+    ..add(modifierKeyword)
+    ..add(_returnType)
+    ..add(propertyKeyword)
+    ..add(operatorKeyword)
+    ..add(_name)
+    ..add(_parameters)
+    ..add(_body);
 
   /**
    * Return the element associated with this method, or `null` if the AST
    * structure has not been resolved. The element can either be a
    * [MethodElement], if this represents the declaration of a normal method, or
    * a [PropertyAccessorElement] if this represents the declaration of either a
    * getter or a setter.
    */
   @override
   ExecutableElement get element =>
@@ skipping 21 matching lines @@
    */
   bool get isAbstract {
     FunctionBody body = _body;
     return externalKeyword == null &&
         (body is EmptyFunctionBody && !body.semicolon.isSynthetic);
   }
 
   /**
    * Return `true` if this method declares a getter.
    */
-  bool get isGetter =>
-      propertyKeyword != null &&
-          (propertyKeyword as KeywordToken).keyword == Keyword.GET;
+  bool get isGetter => propertyKeyword != null &&
+      (propertyKeyword as KeywordToken).keyword == Keyword.GET;
 
   /**
    * Return `true` if this method declares an operator.
    */
   bool get isOperator => operatorKeyword != null;
 
   /**
    * Return `true` if this method declares a setter.
    */
-  bool get isSetter =>
-      propertyKeyword != null &&
-          (propertyKeyword as KeywordToken).keyword == Keyword.SET;
+  bool get isSetter => propertyKeyword != null &&
+      (propertyKeyword as KeywordToken).keyword == Keyword.SET;
 
   /**
    * Return `true` if this method is declared to be a static method.
    */
-  bool get isStatic =>
-      modifierKeyword != null &&
-          (modifierKeyword as KeywordToken).keyword == Keyword.STATIC;
+  bool get isStatic => modifierKeyword != null &&
+      (modifierKeyword as KeywordToken).keyword == Keyword.STATIC;
 
   /**
    * Return the name of the method.
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Set the name of the method to the given [identifier].
    */
   void set name(SimpleIdentifier identifier) {
@@ skipping 100 matching lines @@
     if (_target != null) {
       return _target.beginToken;
     } else if (period != null) {
       return period;
     }
     return _methodName.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_target)
-      ..add(period)
-      ..add(_methodName)
-      ..add(_argumentList);
+    ..add(_target)
+    ..add(period)
+    ..add(_methodName)
+    ..add(_argumentList);
 
   @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of
    * this expression is not stored locally but is stored in the nearest ancestor
    * that is a [CascadeExpression].
    */
   bool get isCascaded =>
@@ skipping 87 matching lines @@
   NamedExpression(Label name, Expression expression) {
     _name = _becomeParentOf(name);
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_name)
-      ..add(_expression);
+    ..add(_name)
+    ..add(_expression);
 
   /**
    * Return the element representing the parameter being named by this
    * expression, or `null` if the AST structure has not been resolved or if
    * there is no parameter with the same name as this expression.
    */
   ParameterElement get element {
     Element element = _name.label.staticElement;
     if (element is ParameterElement) {
       return element;
@@ skipping 114 matching lines @@
    */
   NativeClause(this.nativeKeyword, StringLiteral name) {
     _name = _becomeParentOf(name);
   }
 
   @override
   Token get beginToken => nativeKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(nativeKeyword)
-      ..add(_name);
+    ..add(nativeKeyword)
+    ..add(_name);
 
   @override
   Token get endToken => _name.endToken;
 
   /**
    * Get the token representing the 'native' keyword.
    */
   @deprecated // Use "this.nativeKeyword"
   Token get keyword => nativeKeyword;
 
@@ skipping 48 matching lines @@
   /**
    * The token representing the semicolon that marks the end of the function
    * body.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of the 'native' token,
    * a string literal, and a semicolon.
    */
-  NativeFunctionBody(this.nativeKeyword, StringLiteral stringLiteral,
-      this.semicolon) {
+  NativeFunctionBody(
+      this.nativeKeyword, StringLiteral stringLiteral, this.semicolon) {
     _stringLiteral = _becomeParentOf(stringLiteral);
   }
 
   @override
   Token get beginToken => nativeKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(nativeKeyword)
-      ..add(_stringLiteral)
-      ..add(semicolon);
+    ..add(nativeKeyword)
+    ..add(_stringLiteral)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the token representing 'native' that marks the start of the function
    * body.
    */
   @deprecated // Use "this.nativeKeyword"
   Token get nativeToken => nativeKeyword;
@@ skipping 251 matching lines @@
       throw new NodeLocator_NodeFoundException();
     }
     return null;
   }
 }
 
 /**
  * An exception used by [NodeLocator] to cancel visiting after a node has been
  * found.
  */
-class NodeLocator_NodeFoundException extends RuntimeException {
-}
+class NodeLocator_NodeFoundException extends RuntimeException {}
 
 /**
  * An object that will replace one child node in an AST node with another node.
  */
 class NodeReplacer implements AstVisitor<bool> {
   /**
    * The node being replaced.
    */
   final AstNode _oldNode;
 
@@ skipping 850 matching lines @@
       node.target = _newNode as Expression;
       return true;
     } else if (identical(node.propertyName, _oldNode)) {
       node.propertyName = _newNode as SimpleIdentifier;
       return true;
     }
     return visitNode(node);
   }
 
   @override
-  bool
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  bool visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     if (identical(node.constructorName, _oldNode)) {
       node.constructorName = _newNode as SimpleIdentifier;
       return true;
     } else if (identical(node.argumentList, _oldNode)) {
       node.argumentList = _newNode as ArgumentList;
       return true;
     }
     return visitNode(node);
   }
 
@@ skipping 303 matching lines @@
   /**
    * The name of the parameter being declared.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute.
    */
-  NormalFormalParameter(Comment comment, List<Annotation> metadata,
-      SimpleIdentifier identifier) {
+  NormalFormalParameter(
+      Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
     _comment = _becomeParentOf(comment);
     _metadata = new NodeList<Annotation>(this, metadata);
     _identifier = _becomeParentOf(identifier);
   }
 
   /**
    * Return the documentation comment associated with this parameter, or `null`
    * if this parameter does not have a documentation comment associated with it.
    */
   Comment get documentationComment => _comment;
@@ skipping 37 matching lines @@
     _metadata.clear();
     _metadata.addAll(metadata);
   }
 
   /**
    * Return a list containing the comment and annotations associated with this
    * parameter, sorted in lexical order.
    */
   List<AstNode> get sortedCommentAndAnnotations {
     return <AstNode>[]
-        ..add(_comment)
-        ..addAll(_metadata)
-        ..sort(AstNode.LEXICAL_ORDER);
+      ..add(_comment)
+      ..addAll(_metadata)
+      ..sort(AstNode.LEXICAL_ORDER);
   }
 
   ChildEntities get _childEntities {
     ChildEntities result = new ChildEntities();
     if (_commentIsBeforeAnnotations()) {
       result
-          ..add(_comment)
-          ..addAll(_metadata);
+        ..add(_comment)
+        ..addAll(_metadata);
     } else {
       result.addAll(sortedCommentAndAnnotations);
     }
     return result;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     //
     // Note that subclasses are responsible for visiting the identifier because
@@ skipping 74 matching lines @@
   Expression _expression;
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * Initialize a newly created parenthesized expression.
    */
-  ParenthesizedExpression(this.leftParenthesis, Expression expression,
-      this.rightParenthesis) {
+  ParenthesizedExpression(
+      this.leftParenthesis, Expression expression, this.rightParenthesis) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => leftParenthesis;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(leftParenthesis)
-      ..add(_expression)
-      ..add(rightParenthesis);
+    ..add(leftParenthesis)
+    ..add(_expression)
+    ..add(rightParenthesis);
 
   @override
   Token get endToken => rightParenthesis;
 
   /**
    * Return the expression within the parentheses.
    */
   Expression get expression => _expression;
 
   /**
@@ skipping 36 matching lines @@
    * Initialize a newly created part directive. Either or both of the [comment]
    * and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   PartDirective(Comment comment, List<Annotation> metadata, this.partKeyword,
       StringLiteral partUri, this.semicolon)
       : super(comment, metadata, partUri);
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(partKeyword)
-      ..add(_uri)
-      ..add(semicolon);
+    ..add(partKeyword)
+    ..add(_uri)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => partKeyword;
 
   @override
   Token get keyword => partKeyword;
 
@@ skipping 51 matching lines @@
    * corresponding attribute.
    */
   PartOfDirective(Comment comment, List<Annotation> metadata, this.partKeyword,
       this.ofKeyword, LibraryIdentifier libraryName, this.semicolon)
       : super(comment, metadata) {
     _libraryName = _becomeParentOf(libraryName);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(partKeyword)
-      ..add(ofKeyword)
-      ..add(_libraryName)
-      ..add(semicolon);
+    ..add(partKeyword)
+    ..add(ofKeyword)
+    ..add(_libraryName)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => partKeyword;
 
   @override
   Token get keyword => partKeyword;
 
@@ skipping 101 matching lines @@
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_operand)
-      ..add(operator);
+    ..add(_operand)
+    ..add(operator);
 
   @override
   Token get endToken => operator;
 
   /**
    * Return the expression computing the operand for the operator.
    */
   Expression get operand => _operand;
 
   /**
@@ skipping 91 matching lines @@
   Token period;
 
   /**
    * The identifier being prefixed.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created prefixed identifier.
    */
-  PrefixedIdentifier(SimpleIdentifier prefix, this.period,
-      SimpleIdentifier identifier) {
+  PrefixedIdentifier(
+      SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
     _prefix = _becomeParentOf(prefix);
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Token get beginToken => _prefix.beginToken;
 
   @override
   Element get bestElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.bestElement;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_prefix)
-      ..add(period)
-      ..add(_identifier);
+    ..add(_prefix)
+    ..add(period)
+    ..add(_identifier);
 
   @override
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being prefixed.
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
@@ skipping 121 matching lines @@
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(operator)
-      ..add(_operand);
+    ..add(operator)
+    ..add(_operand);
 
   @override
   Token get endToken => _operand.endToken;
 
   /**
    * Return the expression computing the operand for the operator.
    */
   Expression get operand => _operand;
 
   /**
@@ skipping 94 matching lines @@
   Token operator;
 
   /**
    * The name of the property being accessed.
    */
   SimpleIdentifier _propertyName;
 
   /**
    * Initialize a newly created property access expression.
    */
-  PropertyAccess(Expression target, this.operator,
-      SimpleIdentifier propertyName) {
+  PropertyAccess(
+      Expression target, this.operator, SimpleIdentifier propertyName) {
     _target = _becomeParentOf(target);
     _propertyName = _becomeParentOf(propertyName);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_target)
-      ..add(operator)
-      ..add(_propertyName);
+    ..add(_target)
+    ..add(operator)
+    ..add(_propertyName);
 
   @override
   Token get endToken => _propertyName.endToken;
 
   @override
   bool get isAssignable => true;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of
    * this expression is not stored locally but is stored in the nearest ancestor
@@ skipping 531 matching lines @@
     return null;
   }
 
   @override
   R visitPropertyAccess(PropertyAccess node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
-  R
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  R visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitRethrowExpression(RethrowExpression node) {
     node.visitChildren(this);
     return null;
   }
 
@@ skipping 218 matching lines @@
    */
   void set argumentList(ArgumentList argumentList) {
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken => thisKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(thisKeyword)
-      ..add(period)
-      ..add(_constructorName)
-      ..add(_argumentList);
+    ..add(thisKeyword)
+    ..add(period)
+    ..add(_constructorName)
+    ..add(_argumentList);
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the
    * unnamed constructor is being invoked.
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor that is being invoked to the given
    * [identifier].
@@ skipping 111 matching lines @@
    */
   ReturnStatement(this.returnKeyword, Expression expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => returnKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(returnKeyword)
-      ..add(_expression)
-      ..add(semicolon);
+    ..add(returnKeyword)
+    ..add(_expression)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the expression computing the value to be returned, or `null` if no
    * explicit value was provided.
    */
   Expression get expression => _expression;
 
@@ skipping 266 matching lines @@
   ShowCombinator(Token keyword, List<SimpleIdentifier> shownNames)
       : super(keyword) {
     _shownNames = new NodeList<SimpleIdentifier>(this, shownNames);
   }
 
   /**
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(keyword)
-      ..addAll(_shownNames);
+    ..add(keyword)
+    ..addAll(_shownNames);
 
   @override
   Token get endToken => _shownNames.endToken;
 
   /**
    * Return the list of names from the library that are made visible by this
    * combinator.
    */
   NodeList<SimpleIdentifier> get shownNames => _shownNames;
 
@@ skipping 241 matching lines @@
   @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) => null;
 
   @override
   R visitPrefixExpression(PrefixExpression node) => null;
 
   @override
   R visitPropertyAccess(PropertyAccess node) => null;
 
   @override
-  R
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) =>
-      null;
+  R visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) => null;
 
   @override
   R visitRethrowExpression(RethrowExpression node) => null;
 
   @override
   R visitReturnStatement(ReturnStatement node) => null;
 
   @override
   R visitScriptTag(ScriptTag node) => null;
 
@@ skipping 113 matching lines @@
     } else if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return identifier.beginToken;
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
-      ..add(_type)
-      ..add(identifier);
+    ..add(keyword)
+    ..add(_type)
+    ..add(identifier);
 
   @override
   Token get endToken => identifier.endToken;
 
   @override
-  bool get isConst =>
-      (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.CONST;
+  bool get isConst => (keyword is KeywordToken) &&
+      (keyword as KeywordToken).keyword == Keyword.CONST;
 
   @override
-  bool get isFinal =>
-      (keyword is KeywordToken) && (keyword as KeywordToken).keyword == Keyword.FINAL;
+  bool get isFinal => (keyword is KeywordToken) &&
+      (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the
    * parameter does not have a declared type.
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
@@ skipping 267 matching lines @@
 
   /**
    * Return the given element if it is valid, or report the problem and return
    * `null` if it is not appropriate.
    *
    * The [parent] is the parent of the element, used for reporting when there is
    * a problem.
    * The [isValid] is `true` if the element is appropriate.
    * The [element] is the element to be associated with this identifier.
    */
-  Element _returnOrReportElement(AstNode parent, bool isValid,
-      Element element) {
+  Element _returnOrReportElement(
+      AstNode parent, bool isValid, Element element) {
     if (!isValid) {
       AnalysisEngine.instance.logger.logInformation(
           "Internal error: attempting to set the name of a ${parent.runtimeType} to a ${element.runtimeType}",
           new CaughtException(new AnalysisException(), null));
       return null;
     }
     return element;
   }
 
   /**
    * Return the given [element] if it is an appropriate element based on the
    * parent of this identifier, or `null` if it is not appropriate.
    */
   Element _validateElement(Element element) {
     if (element == null) {
       return null;
     }
     AstNode parent = this.parent;
     if (parent is ClassDeclaration && identical(parent.name, this)) {
       return _returnOrReportElement(parent, element is ClassElement, element);
     } else if (parent is ClassTypeAlias && identical(parent.name, this)) {
       return _returnOrReportElement(parent, element is ClassElement, element);
     } else if (parent is DeclaredIdentifier &&
         identical(parent.identifier, this)) {
       return _returnOrReportElement(
-          parent,
-          element is LocalVariableElement,
-          element);
+          parent, element is LocalVariableElement, element);
     } else if (parent is FormalParameter &&
         identical(parent.identifier, this)) {
       return _returnOrReportElement(
-          parent,
-          element is ParameterElement,
-          element);
+          parent, element is ParameterElement, element);
     } else if (parent is FunctionDeclaration && identical(parent.name, this)) {
       return _returnOrReportElement(
-          parent,
-          element is ExecutableElement,
-          element);
+          parent, element is ExecutableElement, element);
     } else if (parent is FunctionTypeAlias && identical(parent.name, this)) {
       return _returnOrReportElement(
-          parent,
-          element is FunctionTypeAliasElement,
-          element);
+          parent, element is FunctionTypeAliasElement, element);
     } else if (parent is MethodDeclaration && identical(parent.name, this)) {
       return _returnOrReportElement(
-          parent,
-          element is ExecutableElement,
-          element);
+          parent, element is ExecutableElement, element);
     } else if (parent is TypeParameter && identical(parent.name, this)) {
       return _returnOrReportElement(
-          parent,
-          element is TypeParameterElement,
-          element);
+          parent, element is TypeParameterElement, element);
     } else if (parent is VariableDeclaration && identical(parent.name, this)) {
       return _returnOrReportElement(
-          parent,
-          element is VariableElement,
-          element);
+          parent, element is VariableElement, element);
     }
     return element;
   }
 }
 
 /**
  * A string literal expression that does not contain any interpolations.
  *
  * > simpleStringLiteral ::=
  * >     rawStringLiteral
@@ skipping 368 matching lines @@
    */
   void set argumentList(ArgumentList argumentList) {
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   Token get beginToken => superKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(superKeyword)
-      ..add(period)
-      ..add(_constructorName)
-      ..add(_argumentList);
+    ..add(superKeyword)
+    ..add(period)
+    ..add(_constructorName)
+    ..add(_argumentList);
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the
    * unnamed constructor is being invoked.
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Set the name of the constructor that is being invoked to the given
    * [identifier].
@@ skipping 98 matching lines @@
    * if there are no labels.
    */
   SwitchCase(List<Label> labels, Token keyword, Expression expression,
       Token colon, List<Statement> statements)
       : super(labels, keyword, colon, statements) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..addAll(labels)
-      ..add(keyword)
-      ..add(_expression)
-      ..add(colon)
-      ..addAll(statements);
+    ..addAll(labels)
+    ..add(keyword)
+    ..add(_expression)
+    ..add(colon)
+    ..addAll(statements);
 
   /**
    * Return the expression controlling whether the statements will be executed.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression controlling whether the statements will be executed to
    * the given [expression].
    */
@@ skipping 22 matching lines @@
   /**
    * Initialize a newly created switch default. The list of [labels] can be
    * `null` if there are no labels.
    */
   SwitchDefault(List<Label> labels, Token keyword, Token colon,
       List<Statement> statements)
       : super(labels, keyword, colon, statements);
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..addAll(labels)
-      ..add(keyword)
-      ..add(colon)
-      ..addAll(statements);
+    ..addAll(labels)
+    ..add(keyword)
+    ..add(colon)
+    ..addAll(statements);
 
   @override
   accept(AstVisitor visitor) => visitor.visitSwitchDefault(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
@@ skipping 104 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)
-      ..add(leftParenthesis)
-      ..add(_expression)
-      ..add(rightParenthesis)
-      ..add(leftBracket)
-      ..addAll(_members)
-      ..add(rightBracket);
+    ..add(switchKeyword)
+    ..add(leftParenthesis)
+    ..add(_expression)
+    ..add(rightParenthesis)
+    ..add(leftBracket)
+    ..addAll(_members)
+    ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to determine which of the switch members will be
    * selected.
    */
   Expression get expression => _expression;
 
@@ skipping 57 matching lines @@
   SymbolLiteral(this.poundSign, this.components);
 
   @override
   Token get beginToken => poundSign;
 
   /**
    * TODO(paulberry): add "." tokens.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(poundSign)
-      ..addAll(components);
+    ..add(poundSign)
+    ..addAll(components);
 
   @override
   Token get endToken => components[components.length - 1];
 
   @override
   accept(AstVisitor visitor) => visitor.visitSymbolLiteral(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
@@ skipping 74 matching lines @@
    */
   ThrowExpression(this.throwKeyword, Expression expression) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => throwKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(throwKeyword)
-      ..add(_expression);
+    ..add(throwKeyword)
+    ..add(_expression);
 
   @override
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
     return throwKeyword;
   }
 
   /**
@@ skipping 59 matching lines @@
    * the corresponding attribute.
    */
   TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata,
       VariableDeclarationList variableList, this.semicolon)
       : super(comment, metadata) {
     _variableList = _becomeParentOf(variableList);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(_variableList)
-      ..add(semicolon);
+    ..add(_variableList)
+    ..add(semicolon);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 
@@ skipping 774 matching lines @@
       _writer.print("..");
     } else {
       _visitNode(node.target);
       _writer.print('.');
     }
     _visitNode(node.propertyName);
     return null;
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     _writer.print("this");
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitRethrowExpression(RethrowExpression node) {
     _writer.print("rethrow");
     return null;
@@ skipping 256 matching lines @@
         }
         nodes[i].accept(this);
       }
     }
   }
 
   /**
    * Print a list of [nodes], prefixed by the given [prefix] if the list is not
    * empty, and separated by the given [separator].
    */
-  void _visitNodeListWithSeparatorAndPrefix(String prefix,
-      NodeList<AstNode> nodes, String separator) {
+  void _visitNodeListWithSeparatorAndPrefix(
+      String prefix, NodeList<AstNode> nodes, String separator) {
     if (nodes != null) {
       int size = nodes.length;
       if (size > 0) {
         _writer.print(prefix);
         for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 
   /**
    * Print a list of [nodes], separated by the given [separator], followed by
    * the given [suffix] if the list is not empty.
    */
-  void _visitNodeListWithSeparatorAndSuffix(NodeList<AstNode> nodes,
-      String separator, String suffix) {
+  void _visitNodeListWithSeparatorAndSuffix(
+      NodeList<AstNode> nodes, String separator, String suffix) {
     if (nodes != null) {
       int size = nodes.length;
       if (size > 0) {
         for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
         _writer.print(suffix);
@@ skipping 99 matching lines @@
     _body = _becomeParentOf(block);
   }
 
   /**
    * Return the catch clauses contained in the try statement.
    */
   NodeList<CatchClause> get catchClauses => _catchClauses;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(tryKeyword)
-      ..add(_body)
-      ..addAll(_catchClauses)
-      ..add(finallyKeyword)
-      ..add(_finallyBlock);
+    ..add(tryKeyword)
+    ..add(_body)
+    ..addAll(_catchClauses)
+    ..add(finallyKeyword)
+    ..add(_finallyBlock);
 
   @override
   Token get endToken {
     if (_finallyBlock != null) {
       return _finallyBlock.endToken;
     } else if (finallyKeyword != null) {
       return finallyKeyword;
     } else if (!_catchClauses.isEmpty) {
       return _catchClauses.endToken;
     }
@@ skipping 93 matching lines @@
   NodeList<TypeName> _arguments;
 
   /**
    * The right bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created list of type arguments.
    */
-  TypeArgumentList(this.leftBracket, List<TypeName> arguments,
-      this.rightBracket) {
+  TypeArgumentList(
+      this.leftBracket, List<TypeName> arguments, this.rightBracket) {
     _arguments = new NodeList<TypeName>(this, arguments);
   }
 
   /**
    * Return the type arguments associated with the type.
    */
   NodeList<TypeName> get arguments => _arguments;
 
   @override
   Token get beginToken => leftBracket;
 
   /**
    * TODO(paulberry): Add commas.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(leftBracket)
-      ..addAll(_arguments)
-      ..add(rightBracket);
+    ..add(leftBracket)
+    ..addAll(_arguments)
+    ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeArgumentList(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _arguments.accept(visitor);
@@ skipping 37 matching lines @@
 
   /**
    * Set the type argument associated with this literal to the given
    * [typeArguments].
    */
   void set typeArguments(TypeArgumentList typeArguments) {
     _typeArguments = _becomeParentOf(typeArguments);
   }
 
   ChildEntities get _childEntities => new ChildEntities()
-      ..add(constKeyword)
-      ..add(_typeArguments);
+    ..add(constKeyword)
+    ..add(_typeArguments);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * The name of a type, which can optionally include type arguments.
  *
@@ skipping 24 matching lines @@
   TypeName(Identifier name, TypeArgumentList typeArguments) {
     _name = _becomeParentOf(name);
     _typeArguments = _becomeParentOf(typeArguments);
   }
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_name)
-      ..add(_typeArguments);
+    ..add(_name)
+    ..add(_typeArguments);
 
   @override
   Token get endToken {
     if (_typeArguments != null) {
       return _typeArguments.endToken;
     }
     return _name.endToken;
   }
 
   /**
@@ skipping 95 matching lines @@
   /**
    * Set the name of the upper bound for legal arguments to the given
    * [typeName].
    */
   void set bound(TypeName typeName) {
     _bound = _becomeParentOf(typeName);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(_name)
-      ..add(extendsKeyword)
-      ..add(_bound);
+    ..add(_name)
+    ..add(extendsKeyword)
+    ..add(_bound);
 
   @override
   TypeParameterElement get element =>
       _name != null ? (_name.staticElement as TypeParameterElement) : null;
 
   @override
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
@@ skipping 59 matching lines @@
   NodeList<TypeParameter> _typeParameters;
 
   /**
    * The right angle bracket.
    */
   final Token rightBracket;
 
   /**
    * Initialize a newly created list of type parameters.
    */
-  TypeParameterList(this.leftBracket, List<TypeParameter> typeParameters,
-      this.rightBracket) {
+  TypeParameterList(
+      this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
     _typeParameters = new NodeList<TypeParameter>(this, typeParameters);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(leftBracket)
-      ..addAll(_typeParameters)
-      ..add(rightBracket);
+    ..add(leftBracket)
+    ..addAll(_typeParameters)
+    ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   /**
    * Return the type parameters for the type.
    */
   NodeList<TypeParameter> get typeParameters => _typeParameters;
 
   @override
@@ skipping 254 matching lines @@
   @override
   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);
+  R visitRedirectingConstructorInvocation(
+      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 105 matching lines @@
   /**
    * The source to which the URI was resolved.
    */
   Source source;
 
   /**
    * Initialize a newly create URI-based directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
-  UriBasedDirective(Comment comment, List<Annotation> metadata,
-      StringLiteral uri)
+  UriBasedDirective(
+      Comment comment, List<Annotation> metadata, StringLiteral uri)
       : super(comment, metadata) {
     _uri = _becomeParentOf(uri);
   }
 
   /**
    * Return the URI referenced by this directive.
    */
   StringLiteral get uri => _uri;
 
   /**
@@ skipping 102 matching lines @@
    */
   VariableDeclaration(Comment comment, List<Annotation> metadata,
       SimpleIdentifier name, this.equals, Expression initializer)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
     _initializer = _becomeParentOf(initializer);
   }
 
   @override
   Iterable get childEntities => super._childEntities
-      ..add(_name)
-      ..add(equals)
-      ..add(_initializer);
+    ..add(_name)
+    ..add(equals)
+    ..add(_initializer);
 
   /**
    * This overridden implementation of getDocumentationComment() looks in the
    * grandparent node for dartdoc comments if no documentation is specifically
    * available on the node.
    */
   @override
   Comment get documentationComment {
     Comment comment = super.documentationComment;
     if (comment == null) {
@@ skipping 117 matching lines @@
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
     _variables = new NodeList<VariableDeclaration>(this, variables);
   }
 
   /**
    * TODO(paulberry): include commas.
    */
   @override
   Iterable get childEntities => super._childEntities
-      ..add(keyword)
-      ..add(_type)
-      ..addAll(_variables);
+    ..add(keyword)
+    ..add(_type)
+    ..addAll(_variables);
 
   @override
   Token get endToken => _variables.endToken;
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _variables.beginToken;
   }
 
   /**
    * Return `true` if the variables in this list were declared with the 'const'
    * modifier.
    */
-  bool get isConst =>
-      keyword is KeywordToken && (keyword as KeywordToken).keyword == Keyword.CONST;
+  bool get isConst => keyword is KeywordToken &&
+      (keyword as KeywordToken).keyword == Keyword.CONST;
 
   /**
    * Return `true` if the variables in this list were declared with the 'final'
    * modifier. Variables that are declared with the 'const' modifier will return
    * `false` even though they are implicitly final. (In other words, this is a
    * syntactic check rather than a semantic check.)
    */
-  bool get isFinal =>
-      keyword is KeywordToken && (keyword as KeywordToken).keyword == Keyword.FINAL;
+  bool get isFinal => keyword is KeywordToken &&
+      (keyword as KeywordToken).keyword == Keyword.FINAL;
 
   /**
    * Return the type of the variables being declared, or `null` if no type was
    * provided.
    */
   TypeName get type => _type;
 
   /**
    * Set the type of the variables being declared to the given [typeName].
    */
@@ skipping 31 matching lines @@
   VariableDeclarationList _variableList;
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created variable declaration statement.
    */
-  VariableDeclarationStatement(VariableDeclarationList variableList,
-      this.semicolon) {
+  VariableDeclarationStatement(
+      VariableDeclarationList variableList, this.semicolon) {
     _variableList = _becomeParentOf(variableList);
   }
 
   @override
   Token get beginToken => _variableList.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(_variableList)
-      ..add(semicolon);
+    ..add(_variableList)
+    ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   /**
    * Return the variables being declared.
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
@@ skipping 63 matching lines @@
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement) {
     _body = _becomeParentOf(statement);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(whileKeyword)
-      ..add(leftParenthesis)
-      ..add(_condition)
-      ..add(rightParenthesis)
-      ..add(_body);
+    ..add(whileKeyword)
+    ..add(leftParenthesis)
+    ..add(_condition)
+    ..add(rightParenthesis)
+    ..add(_body);
 
   /**
    * Return the expression used to determine whether to execute the body of the
    * loop.
    */
   Expression get condition => _condition;
 
   /**
    * Set the expression used to determine whether to execute the body of the
    * loop to the given [expression].
@@ skipping 54 matching lines @@
   }
 
   @override
   Token get beginToken => withKeyword;
 
   /**
    * TODO(paulberry): add commas.
    */
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(withKeyword)
-      ..addAll(_mixinTypes);
+    ..add(withKeyword)
+    ..addAll(_mixinTypes);
 
   @override
   Token get endToken => _mixinTypes.endToken;
 
   /**
    * Set the token representing the 'with' keyword to the given [token].
    */
   @deprecated // Use "this.withKeyword"
   void set mixinKeyword(Token token) {
     this.withKeyword = token;
@@ skipping 37 matching lines @@
 
   /**
    * The semicolon following the expression.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
-  YieldStatement(this.yieldKeyword, this.star, Expression expression,
-      this.semicolon) {
+  YieldStatement(
+      this.yieldKeyword, this.star, Expression expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (yieldKeyword != null) {
       return yieldKeyword;
     }
     return _expression.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
-      ..add(yieldKeyword)
-      ..add(star)
-      ..add(_expression)
-      ..add(semicolon);
+    ..add(yieldKeyword)
+    ..add(star)
+    ..add(_expression)
+    ..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   /**
    * Return the expression whose value will be yielded.
    */
   Expression get expression => _expression;
 
   /**
    * Set the expression whose value will be yielded to the given [expression].
    */
   void set expression(Expression expression) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }