dartfmt pkg/compiler

pkg/compiler/lib/src/tree/nodes.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
 import '../tokens/precedence_constants.dart' as Precedence show FUNCTION_INFO;
 import '../tokens/token.dart' show BeginGroupToken, Token;
-import '../tokens/token_constants.dart' as Tokens show IDENTIFIER_TOKEN, KEYWORD_TOKEN, PLUS_TOKEN;
+import '../tokens/token_constants.dart' as Tokens
+    show IDENTIFIER_TOKEN, KEYWORD_TOKEN, PLUS_TOKEN;
 import '../util/util.dart';
 import '../util/characters.dart';
-import '../resolution/secret_tree_element.dart' show NullTreeElementMixin, StoredTreeElementMixin;
+import '../resolution/secret_tree_element.dart'
+    show NullTreeElementMixin, StoredTreeElementMixin;
 import '../elements/elements.dart' show MetadataAnnotation;
 import 'dartstring.dart';
 import 'prettyprint.dart';
 import 'unparser.dart';
 
 abstract class Visitor<R> {
   const Visitor();
 
   R visitNode(Node node);
 
@@ skipping 43 matching lines @@
   R visitStringJuxtaposition(StringJuxtaposition node) => visitStringNode(node);
   R visitSyncForIn(SyncForIn node) => visitLoop(node);
   R visitLoop(Loop node) => visitStatement(node);
   R visitMetadata(Metadata node) => visitNode(node);
   R visitMixinApplication(MixinApplication node) => visitNode(node);
   R visitModifiers(Modifiers node) => visitNode(node);
   R visitNamedArgument(NamedArgument node) => visitExpression(node);
   R visitNamedMixinApplication(NamedMixinApplication node) {
     return visitMixinApplication(node);
   }
+
   R visitNewExpression(NewExpression node) => visitExpression(node);
   R visitNodeList(NodeList node) => visitNode(node);
   R visitOperator(Operator node) => visitIdentifier(node);
   R visitParenthesizedExpression(ParenthesizedExpression node) {
     return visitExpression(node);
   }
+
   R visitPart(Part node) => visitLibraryTag(node);
   R visitPartOf(PartOf node) => visitNode(node);
   R visitPostfix(Postfix node) => visitNodeList(node);
   R visitPrefix(Prefix node) => visitNodeList(node);
   R visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     return visitStatement(node);
   }
+
   R visitRethrow(Rethrow node) => visitStatement(node);
   R visitReturn(Return node) => visitStatement(node);
   R visitSend(Send node) => visitExpression(node);
   R visitSendSet(SendSet node) => visitSend(node);
   R visitStatement(Statement node) => visitNode(node);
   R visitStringNode(StringNode node) => visitExpression(node);
   R visitStringInterpolation(StringInterpolation node) => visitStringNode(node);
   R visitStringInterpolationPart(StringInterpolationPart node) {
     return visitNode(node);
   }
+
   R visitSwitchCase(SwitchCase node) => visitNode(node);
   R visitSwitchStatement(SwitchStatement node) => visitStatement(node);
   R visitLiteralSymbol(LiteralSymbol node) => visitExpression(node);
   R visitThrow(Throw node) => visitExpression(node);
   R visitTryStatement(TryStatement node) => visitStatement(node);
   R visitTypeAnnotation(TypeAnnotation node) => visitNode(node);
   R visitTypedef(Typedef node) => visitNode(node);
   R visitTypeVariable(TypeVariable node) => visitNode(node);
   R visitVariableDefinitions(VariableDefinitions node) => visitStatement(node);
   R visitWhile(While node) => visitLoop(node);
   R visitYield(Yield node) => visitStatement(node);
 }
 
 /// Visitor for [Node]s that take an additional argument of type [A] and returns
 /// a value of type [R].
 abstract class Visitor1<R, A> {
   const Visitor1();
 
   R visitNode(Node node, A arg);
 
   R visitAssert(Assert node, A arg) => visitStatement(node, arg);
   R visitAsyncForIn(AsyncForIn node, A arg) => visitLoop(node, arg);
   R visitAsyncModifier(AsyncModifier node, A arg) => visitNode(node, arg);
   R visitAwait(Await node, A arg) => visitExpression(node, arg);
   R visitBlock(Block node, A arg) => visitStatement(node, arg);
   R visitBreakStatement(BreakStatement node, A arg) {
     return visitGotoStatement(node, arg);
   }
+
   R visitCascade(Cascade node, A arg) => visitExpression(node, arg);
   R visitCascadeReceiver(CascadeReceiver node, A arg) {
     return visitExpression(node, arg);
   }
+
   R visitCaseMatch(CaseMatch node, A arg) => visitNode(node, arg);
   R visitCatchBlock(CatchBlock node, A arg) => visitNode(node, arg);
   R visitClassNode(ClassNode node, A arg) => visitNode(node, arg);
   R visitCombinator(Combinator node, A arg) => visitNode(node, arg);
   R visitConditional(Conditional node, A arg) => visitExpression(node, arg);
   R visitConditionalUri(ConditionalUri node, A arg) {
     return visitNode(node, arg);
   }
+
   R visitContinueStatement(ContinueStatement node, A arg) {
     return visitGotoStatement(node, arg);
   }
+
   R visitDottedName(DottedName node, A arg) {
     return visitExpression(node, arg);
   }
+
   R visitDoWhile(DoWhile node, A arg) => visitLoop(node, arg);
   R visitEmptyStatement(EmptyStatement node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitEnum(Enum node, A arg) => visitNode(node, arg);
   R visitExport(Export node, A arg) => visitLibraryDependency(node, arg);
   R visitExpression(Expression node, A arg) => visitNode(node, arg);
   R visitExpressionStatement(ExpressionStatement node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitFor(For node, A arg) => visitLoop(node, arg);
   R visitFunctionDeclaration(FunctionDeclaration node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitFunctionExpression(FunctionExpression node, A arg) {
     return visitExpression(node, arg);
   }
+
   R visitGotoStatement(GotoStatement node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitIdentifier(Identifier node, A arg) {
     return visitExpression(node, arg);
   }
+
   R visitImport(Import node, A arg) {
     return visitLibraryDependency(node, arg);
   }
+
   R visitIf(If node, A arg) => visitStatement(node, arg);
   R visitLabel(Label node, A arg) => visitNode(node, arg);
   R visitLabeledStatement(LabeledStatement node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitLibraryDependency(LibraryDependency node, A arg) {
     return visitLibraryTag(node, arg);
   }
+
   R visitLibraryName(LibraryName node, A arg) => visitLibraryTag(node, arg);
   R visitLibraryTag(LibraryTag node, A arg) => visitNode(node, arg);
   R visitLiteral(Literal node, A arg) => visitExpression(node, arg);
   R visitLiteralBool(LiteralBool node, A arg) => visitLiteral(node, arg);
   R visitLiteralDouble(LiteralDouble node, A arg) => visitLiteral(node, arg);
   R visitLiteralInt(LiteralInt node, A arg) => visitLiteral(node, arg);
   R visitLiteralList(LiteralList node, A arg) => visitExpression(node, arg);
   R visitLiteralMap(LiteralMap node, A arg) => visitExpression(node, arg);
   R visitLiteralMapEntry(LiteralMapEntry node, A arg) => visitNode(node, arg);
   R visitLiteralNull(LiteralNull node, A arg) => visitLiteral(node, arg);
   R visitLiteralString(LiteralString node, A arg) => visitStringNode(node, arg);
   R visitStringJuxtaposition(StringJuxtaposition node, A arg) {
     return visitStringNode(node, arg);
   }
+
   R visitSyncForIn(SyncForIn node, A arg) => visitLoop(node, arg);
   R visitLoop(Loop node, A arg) => visitStatement(node, arg);
   R visitMetadata(Metadata node, A arg) => visitNode(node, arg);
   R visitMixinApplication(MixinApplication node, A arg) => visitNode(node, arg);
   R visitModifiers(Modifiers node, A arg) => visitNode(node, arg);
   R visitNamedArgument(NamedArgument node, A arg) => visitExpression(node, arg);
   R visitNamedMixinApplication(NamedMixinApplication node, A arg) {
     return visitMixinApplication(node, arg);
   }
+
   R visitNewExpression(NewExpression node, A arg) => visitExpression(node, arg);
   R visitNodeList(NodeList node, A arg) => visitNode(node, arg);
   R visitOperator(Operator node, A arg) => visitIdentifier(node, arg);
   R visitParenthesizedExpression(ParenthesizedExpression node, A arg) {
     return visitExpression(node, arg);
   }
+
   R visitPart(Part node, A arg) => visitLibraryTag(node, arg);
   R visitPartOf(PartOf node, A arg) => visitNode(node, arg);
   R visitPostfix(Postfix node, A arg) => visitNodeList(node, arg);
   R visitPrefix(Prefix node, A arg) => visitNodeList(node, arg);
   R visitRedirectingFactoryBody(RedirectingFactoryBody node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitRethrow(Rethrow node, A arg) => visitStatement(node, arg);
   R visitReturn(Return node, A arg) => visitStatement(node, arg);
   R visitSend(Send node, A arg) => visitExpression(node, arg);
   R visitSendSet(SendSet node, A arg) => visitSend(node, arg);
   R visitStatement(Statement node, A arg) => visitNode(node, arg);
   R visitStringNode(StringNode node, A arg) => visitExpression(node, arg);
   R visitStringInterpolation(StringInterpolation node, A arg) {
     return visitStringNode(node, arg);
   }
+
   R visitStringInterpolationPart(StringInterpolationPart node, A arg) {
     return visitNode(node, arg);
   }
+
   R visitSwitchCase(SwitchCase node, A arg) => visitNode(node, arg);
   R visitSwitchStatement(SwitchStatement node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitLiteralSymbol(LiteralSymbol node, A arg) => visitExpression(node, arg);
   R visitThrow(Throw node, A arg) => visitExpression(node, arg);
   R visitTryStatement(TryStatement node, A arg) => visitStatement(node, arg);
   R visitTypeAnnotation(TypeAnnotation node, A arg) => visitNode(node, arg);
   R visitTypedef(Typedef node, A arg) => visitNode(node, arg);
   R visitTypeVariable(TypeVariable node, A arg) => visitNode(node, arg);
   R visitVariableDefinitions(VariableDefinitions node, A arg) {
     return visitStatement(node, arg);
   }
+
   R visitWhile(While node, A arg) => visitLoop(node, arg);
   R visitYield(Yield node, A arg) => visitStatement(node, arg);
 }
 
-
 Token firstBeginToken(Node first, Node second) {
   Token token = null;
   if (first != null) {
     token = first.getBeginToken();
   }
   if (token == null && second != null) {
     // [token] might be null even when [first] is not, e.g. for empty Modifiers.
     token = second.getBeginToken();
   }
   return token;
@@ skipping 137 matching lines @@
   final Identifier name;
   final Node superclass;
   final NodeList interfaces;
   final NodeList typeParameters;
   final NodeList body;
 
   final Token beginToken;
   final Token extendsKeyword;
   final Token endToken;
 
-  ClassNode(this.modifiers, this.name, this.typeParameters, this.superclass,
-            this.interfaces, this.beginToken,
-            this.extendsKeyword, this.body, this.endToken);
+  ClassNode(
+      this.modifiers,
+      this.name,
+      this.typeParameters,
+      this.superclass,
+      this.interfaces,
+      this.beginToken,
+      this.extendsKeyword,
+      this.body,
+      this.endToken);
 
   ClassNode asClassNode() => this;
 
   accept(Visitor visitor) => visitor.visitClassNode(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitClassNode(this, arg);
 
   visitChildren(Visitor visitor) {
     if (name != null) name.accept(visitor);
     if (typeParameters != null) typeParameters.accept(visitor);
@@ skipping 66 matching lines @@
   final Identifier name;
   final NodeList typeParameters;
 
   final Modifiers modifiers;
   final MixinApplication mixinApplication;
   final NodeList interfaces;
 
   final Token classKeyword;
   final Token endToken;
 
-  NamedMixinApplication(this.name, this.typeParameters,
-                        this.modifiers, this.mixinApplication, this.interfaces,
-                        this.classKeyword, this.endToken);
+  NamedMixinApplication(this.name, this.typeParameters, this.modifiers,
+      this.mixinApplication, this.interfaces, this.classKeyword, this.endToken);
 
   TypeAnnotation get superclass => mixinApplication.superclass;
   NodeList get mixins => mixinApplication.mixins;
 
   MixinApplication asMixinApplication() => this;
   NamedMixinApplication asNamedMixinApplication() => this;
 
   accept(Visitor visitor) => visitor.visitNamedMixinApplication(this);
 
   accept1(Visitor1 visitor, arg) {
@@ skipping 29 matching lines @@
 abstract class Statement extends Node {
   Statement();
 
   Statement asStatement() => this;
 
   bool isValidBreakTarget() => true;
 }
 
 /// Erroneous expression that behaves as a literal null.
 class ErrorExpression extends LiteralNull {
-  ErrorExpression(token)
-      : super(token);
+  ErrorExpression(token) : super(token);
 
   ErrorExpression asErrorExpression() => this;
 
   bool get isErroneous => true;
 }
 
 /**
  * A message send aka method invocation. In Dart, most operations can
  * (and should) be considered as message sends. Getters and setters
  * are just methods with a special syntax. Consequently, we model
  * property access, assignment, operators, and method calls with this
  * one node.
  */
 class Send extends Expression with StoredTreeElementMixin {
   final Node receiver;
   final Node selector;
   final NodeList argumentsNode;
 
   /// Whether this is a conditinal send of the form `a?.b`.
   final bool isConditional;
 
   Link<Node> get arguments => argumentsNode.nodes;
 
-  Send([this.receiver, this.selector, this.argumentsNode,
+  Send(
+      [this.receiver,
+      this.selector,
+      this.argumentsNode,
       this.isConditional = false]);
   Send.postfix(this.receiver, this.selector,
       [Node argument = null, this.isConditional = false])
       : argumentsNode = (argument == null)
-        ? new Postfix()
-        : new Postfix.singleton(argument);
+            ? new Postfix()
+            : new Postfix.singleton(argument);
   Send.prefix(this.receiver, this.selector,
       [Node argument = null, this.isConditional = false])
-      : argumentsNode = (argument == null)
-        ? new Prefix()
-        : new Prefix.singleton(argument);
+      : argumentsNode =
+            (argument == null) ? new Prefix() : new Prefix.singleton(argument);
 
   Send asSend() => this;
 
   accept(Visitor visitor) => visitor.visitSend(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitSend(this, arg);
 
   visitChildren(Visitor visitor) {
     if (receiver != null) receiver.accept(visitor);
     if (selector != null) selector.accept(visitor);
     if (argumentsNode != null) argumentsNode.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
     if (receiver != null) receiver.accept1(visitor, arg);
     if (selector != null) selector.accept1(visitor, arg);
     if (argumentsNode != null) argumentsNode.accept1(visitor, arg);
   }
 
   int argumentCount() {
     return (argumentsNode == null) ? -1 : argumentsNode.slowLength();
   }
 
   bool get isSuperCall {
     return receiver != null && receiver.isSuper();
   }
+
   bool get isOperator => selector is Operator;
   bool get isPropertyAccess => argumentsNode == null;
   bool get isFunctionObjectInvocation => selector == null;
   bool get isPrefix => argumentsNode is Prefix;
   bool get isPostfix => argumentsNode is Postfix;
   bool get isCall => !isOperator && !isPropertyAccess;
   bool get isIndex =>
       isOperator && identical(selector.asOperator().source, '[]');
   bool get isLogicalAnd =>
       isOperator && identical(selector.asOperator().source, '&&');
   bool get isLogicalOr =>
       isOperator && identical(selector.asOperator().source, '||');
   bool get isIfNull =>
       isOperator && identical(selector.asOperator().source, '??');
 
   bool get isTypeCast {
-    return isOperator
-        && identical(selector.asOperator().source, 'as');
+    return isOperator && identical(selector.asOperator().source, 'as');
   }
 
   bool get isTypeTest {
-    return isOperator
-        && identical(selector.asOperator().source, 'is');
+    return isOperator && identical(selector.asOperator().source, 'is');
   }
 
   bool get isIsNotCheck {
     return isTypeTest && arguments.head.asSend() != null;
   }
 
   TypeAnnotation get typeAnnotationFromIsCheckOrCast {
     assert(isOperator);
     assert(identical(selector.asOperator().source, 'is') ||
         identical(selector.asOperator().source, 'as'));
-    return isIsNotCheck
-        ? arguments.head.asSend().receiver
-        : arguments.head;
+    return isIsNotCheck ? arguments.head.asSend().receiver : arguments.head;
   }
 
   Token getBeginToken() {
     if (isPrefix && !isIndex) return selector.getBeginToken();
     return firstBeginToken(receiver, selector);
   }
 
   Token getEndToken() {
     if (isPrefix) {
       if (receiver != null) return receiver.getEndToken();
@@ skipping 21 matching lines @@
 
 class Prefix extends NodeList {
   Prefix() : super(null, const Link<Node>());
   Prefix.singleton(Node argument) : super.singleton(argument);
 }
 
 class SendSet extends Send {
   final Operator assignmentOperator;
   SendSet(receiver, selector, this.assignmentOperator, argumentsNode,
       [bool isConditional = false])
-    : super(receiver, selector, argumentsNode, isConditional);
-  SendSet.postfix(receiver,
-                  selector,
-                  this.assignmentOperator,
-                  [Node argument = null, bool isConditional = false])
+      : super(receiver, selector, argumentsNode, isConditional);
+  SendSet.postfix(receiver, selector, this.assignmentOperator,
+      [Node argument = null, bool isConditional = false])
       : super.postfix(receiver, selector, argument, isConditional);
-  SendSet.prefix(receiver,
-                 selector,
-                 this.assignmentOperator,
-                 [Node argument = null, bool isConditional = false])
+  SendSet.prefix(receiver, selector, this.assignmentOperator,
+      [Node argument = null, bool isConditional = false])
       : super.prefix(receiver, selector, argument, isConditional);
 
   SendSet asSendSet() => this;
 
   accept(Visitor visitor) => visitor.visitSendSet(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitSendSet(this, arg);
 
   visitChildren(Visitor visitor) {
     super.visitChildren(visitor);
     if (assignmentOperator != null) assignmentOperator.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
     super.visitChildren1(visitor, arg);
     if (assignmentOperator != null) assignmentOperator.accept1(visitor, arg);
   }
 
   /// `true` if this send is not a simple assignment.
   bool get isComplex => !identical(assignmentOperator.source, '=');
 
   /// Whether this is an if-null assignment of the form `a ??= b`.
-  bool get isIfNullAssignment =>
-      identical(assignmentOperator.source, '??=');
+  bool get isIfNullAssignment => identical(assignmentOperator.source, '??=');
 
   Send copyWithReceiver(Node newReceiver, bool isConditional) {
     assert(receiver == null);
-    return new SendSet(newReceiver, selector, assignmentOperator,
-                       argumentsNode, isConditional);
+    return new SendSet(newReceiver, selector, assignmentOperator, argumentsNode,
+        isConditional);
   }
 
   Token getBeginToken() {
     if (isPrefix) return assignmentOperator.getBeginToken();
     return super.getBeginToken();
   }
 
   Token getEndToken() {
     if (isPostfix) return assignmentOperator.getEndToken();
     return super.getEndToken();
@@ skipping 76 matching lines @@
 
   visitChildren1(Visitor1 visitor, arg) {
     if (nodes == null) return;
     for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
       if (link.head != null) link.head.accept1(visitor, arg);
     }
   }
 
   Token getBeginToken() {
     if (beginToken != null) return beginToken;
-     if (nodes != null) {
-       for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
-         if (link.head.getBeginToken() != null) {
-           return link.head.getBeginToken();
-         }
-         if (link.head.getEndToken() != null) {
-           return link.head.getEndToken();
-         }
-       }
-     }
+    if (nodes != null) {
+      for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
+        if (link.head.getBeginToken() != null) {
+          return link.head.getBeginToken();
+        }
+        if (link.head.getEndToken() != null) {
+          return link.head.getEndToken();
+        }
+      }
+    }
     return endToken;
   }
 
   Token getEndToken() {
     if (endToken != null) return endToken;
     if (nodes != null) {
       Link<Node> link = nodes;
       if (link.isEmpty) return beginToken;
       while (!link.tail.isEmpty) link = link.tail;
       Node lastNode = link.head;
@@ skipping 31 matching lines @@
 }
 
 class If extends Statement {
   final ParenthesizedExpression condition;
   final Statement thenPart;
   final Statement elsePart;
 
   final Token ifToken;
   final Token elseToken;
 
-  If(this.condition, this.thenPart, this.elsePart,
-     this.ifToken, this.elseToken);
+  If(this.condition, this.thenPart, this.elsePart, this.ifToken,
+      this.elseToken);
 
   If asIf() => this;
 
   bool get hasElsePart => elsePart != null;
 
   accept(Visitor visitor) => visitor.visitIf(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitIf(this, arg);
 
   visitChildren(Visitor visitor) {
@@ skipping 17 matching lines @@
 }
 
 class Conditional extends Expression {
   final Expression condition;
   final Expression thenExpression;
   final Expression elseExpression;
 
   final Token questionToken;
   final Token colonToken;
 
-  Conditional(this.condition, this.thenExpression,
-              this.elseExpression, this.questionToken, this.colonToken);
+  Conditional(this.condition, this.thenExpression, this.elseExpression,
+      this.questionToken, this.colonToken);
 
   Conditional asConditional() => this;
 
   accept(Visitor visitor) => visitor.visitConditional(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitConditional(this, arg);
 
   visitChildren(Visitor visitor) {
     condition.accept(visitor);
     thenExpression.accept(visitor);
@@ skipping 14 matching lines @@
 class For extends Loop {
   /** Either a variable declaration or an expression. */
   final Node initializer;
   /** Either an expression statement or an empty statement. */
   final Statement conditionStatement;
   final NodeList update;
 
   final Token forToken;
 
   For(this.initializer, this.conditionStatement, this.update, body,
-      this.forToken) : super(body);
+      this.forToken)
+      : super(body);
 
   For asFor() => this;
 
   Expression get condition {
     ExpressionStatement expressionStatement =
         conditionStatement.asExpressionStatement();
     if (expressionStatement != null) {
       return expressionStatement.expression;
     } else {
       return null;
@@ skipping 92 matching lines @@
 
   final Statement body;
   final TypeAnnotation returnType;
   final Modifiers modifiers;
   final NodeList initializers;
 
   final Token getOrSet;
   final AsyncModifier asyncModifier;
 
   FunctionExpression(this.name, this.parameters, this.body, this.returnType,
-                     this.modifiers, this.initializers, this.getOrSet,
-                     this.asyncModifier) {
+      this.modifiers, this.initializers, this.getOrSet, this.asyncModifier) {
     assert(modifiers != null);
   }
 
   FunctionExpression asFunctionExpression() => this;
 
   accept(Visitor visitor) => visitor.visitFunctionExpression(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitFunctionExpression(this, arg);
 
   bool get isRedirectingFactory {
@@ skipping 83 matching lines @@
     }
   }
 
   accept(Visitor visitor) => visitor.visitLiteralInt(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitLiteralInt(this, arg);
 }
 
 class LiteralDouble extends Literal<double> {
   LiteralDouble(Token token, DecodeErrorHandler handler)
-    : super(token, handler);
+      : super(token, handler);
 
   LiteralDouble asLiteralDouble() => this;
 
   double get value {
     try {
       Token valueToken = token;
       if (identical(valueToken.kind, Tokens.PLUS_TOKEN)) {
         valueToken = valueToken.next;
       }
       return double.parse(valueToken.value);
@@ skipping 17 matching lines @@
     if (identical(token.stringValue, 'false')) return false;
     (this.handler)(token, "not a bool ${token.value}");
     throw false;
   }
 
   accept(Visitor visitor) => visitor.visitLiteralBool(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitLiteralBool(this, arg);
 }
 
-
 class StringQuoting {
-
   /// Cache of common quotings.
   static const List<StringQuoting> _mapping = const <StringQuoting>[
     const StringQuoting($SQ, raw: false, leftQuoteLength: 1),
     const StringQuoting($SQ, raw: true, leftQuoteLength: 1),
     const StringQuoting($DQ, raw: false, leftQuoteLength: 1),
     const StringQuoting($DQ, raw: true, leftQuoteLength: 1),
     // No string quotes with 2 characters.
     null,
     null,
     null,
@@ skipping 15 matching lines @@
     const StringQuoting($DQ, raw: true, leftQuoteLength: 5),
     const StringQuoting($SQ, raw: false, leftQuoteLength: 6),
     const StringQuoting($SQ, raw: true, leftQuoteLength: 6),
     const StringQuoting($DQ, raw: false, leftQuoteLength: 6),
     const StringQuoting($DQ, raw: true, leftQuoteLength: 6)
   ];
 
   final bool raw;
   final int leftQuoteCharCount;
   final int quote;
-  const StringQuoting(this.quote, { this.raw, int leftQuoteLength })
+  const StringQuoting(this.quote, {this.raw, int leftQuoteLength})
       : this.leftQuoteCharCount = leftQuoteLength;
   String get quoteChar => identical(quote, $DQ) ? '"' : "'";
 
   int get leftQuoteLength => (raw ? 1 : 0) + leftQuoteCharCount;
   int get rightQuoteLength => (leftQuoteCharCount > 2) ? 3 : 1;
   static StringQuoting getQuoting(int quote, bool raw, int leftQuoteLength) {
     int quoteKindOffset = (quote == $DQ) ? 2 : 0;
     int rawOffset = raw ? 1 : 0;
     int index = (leftQuoteLength - 1) * 4 + rawOffset + quoteKindOffset;
     if (index < _mapping.length) return _mapping[index];
@@ skipping 163 matching lines @@
   Token getEndToken() => identifiers.getEndToken();
 
   String get slowNameString {
     Unparser unparser = new Unparser();
     unparser.unparseNodeListOfIdentifiers(identifiers);
     return unparser.result;
   }
 }
 
 class Operator extends Identifier {
-  static const COMPLEX_OPERATORS =
-      const ["--", "++", '+=', "-=", "*=", "/=", "%=", "&=", "|=", "~/=", "^=",
-             ">>=", "<<=", "??="];
+  static const COMPLEX_OPERATORS = const [
+    "--",
+    "++",
+    '+=',
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "&=",
+    "|=",
+    "~/=",
+    "^=",
+    ">>=",
+    "<<=",
+    "??="
+  ];
 
   static const INCREMENT_OPERATORS = const <String>["++", "--"];
 
   Operator(Token token) : super(token);
 
   Operator asOperator() => this;
 
   accept(Visitor visitor) => visitor.visitOperator(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitOperator(this, arg);
@@ skipping 60 matching lines @@
   Token getBeginToken() => yieldToken;
 
   Token getEndToken() => endToken;
 }
 
 class RedirectingFactoryBody extends Statement with StoredTreeElementMixin {
   final Node constructorReference;
   final Token beginToken;
   final Token endToken;
 
-  RedirectingFactoryBody(this.beginToken, this.endToken,
-                         this.constructorReference);
+  RedirectingFactoryBody(
+      this.beginToken, this.endToken, this.constructorReference);
 
   RedirectingFactoryBody asRedirectingFactoryBody() => this;
 
   accept(Visitor visitor) => visitor.visitRedirectingFactoryBody(this);
 
   accept1(Visitor1 visitor, arg) {
     return visitor.visitRedirectingFactoryBody(this, arg);
   }
 
   visitChildren(Visitor visitor) {
@@ skipping 123 matching lines @@
   final Token endToken;
 
   Rethrow(this.throwToken, this.endToken);
 
   Rethrow asRethrow() => this;
 
   accept(Visitor visitor) => visitor.visitRethrow(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitRethrow(this, arg);
 
-  visitChildren(Visitor visitor) { }
+  visitChildren(Visitor visitor) {}
 
-  visitChildren1(Visitor1 visitor, arg) { }
+  visitChildren1(Visitor1 visitor, arg) {}
 
   Token getBeginToken() => throwToken;
   Token getEndToken() => endToken;
 }
 
 class TypeAnnotation extends Node {
   final Expression typeName;
   final NodeList typeArguments;
 
   TypeAnnotation(Expression this.typeName, NodeList this.typeArguments);
@@ skipping 53 matching lines @@
     return (bound != null) ? bound.getEndToken() : name.getEndToken();
   }
 }
 
 class VariableDefinitions extends Statement {
   final NodeList metadata;
   final TypeAnnotation type;
   final Modifiers modifiers;
   final NodeList definitions;
 
-  VariableDefinitions(this.type,
-                      this.modifiers,
-                      this.definitions)
+  VariableDefinitions(this.type, this.modifiers, this.definitions)
       : this.metadata = null {
     assert(modifiers != null);
   }
 
   // TODO(johnniwinther): Make this its own node type.
-  VariableDefinitions.forParameter(this.metadata,
-                                   this.type,
-                                   this.modifiers,
-                                   this.definitions) {
+  VariableDefinitions.forParameter(
+      this.metadata, this.type, this.modifiers, this.definitions) {
     assert(modifiers != null);
   }
 
   VariableDefinitions asVariableDefinitions() => this;
 
   accept(Visitor visitor) => visitor.visitVariableDefinitions(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitVariableDefinitions(this, arg);
 
   visitChildren(Visitor visitor) {
@@ skipping 28 matching lines @@
   bool isValidContinueTarget() => true;
 }
 
 class DoWhile extends Loop {
   final Token doKeyword;
   final Token whileKeyword;
   final Token endToken;
 
   final Expression condition;
 
-  DoWhile(Statement body, Expression this.condition,
-          Token this.doKeyword, Token this.whileKeyword, Token this.endToken)
-    : super(body);
+  DoWhile(Statement body, Expression this.condition, Token this.doKeyword,
+      Token this.whileKeyword, Token this.endToken)
+      : super(body);
 
   DoWhile asDoWhile() => this;
 
   accept(Visitor visitor) => visitor.visitDoWhile(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitDoWhile(this, arg);
 
   visitChildren(Visitor visitor) {
     if (condition != null) condition.accept(visitor);
     if (body != null) body.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
     if (condition != null) condition.accept1(visitor, arg);
     if (body != null) body.accept1(visitor, arg);
   }
 
   Token getBeginToken() => doKeyword;
 
   Token getEndToken() => endToken;
 }
 
 class While extends Loop {
   final Token whileKeyword;
   final Expression condition;
 
-  While(Expression this.condition, Statement body,
-        Token this.whileKeyword) : super(body);
+  While(Expression this.condition, Statement body, Token this.whileKeyword)
+      : super(body);
 
   While asWhile() => this;
 
   accept(Visitor visitor) => visitor.visitWhile(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitWhile(this, arg);
 
   visitChildren(Visitor visitor) {
     if (condition != null) condition.accept(visitor);
     if (body != null) body.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
     if (condition != null) condition.accept1(visitor, arg);
     if (body != null) body.accept1(visitor, arg);
   }
 
   Token getBeginToken() => whileKeyword;
 
   Token getEndToken() => body.getEndToken();
 }
 
 class ParenthesizedExpression extends Expression {
   final Expression expression;
   final BeginGroupToken beginToken;
 
-  ParenthesizedExpression(Expression this.expression,
-                          BeginGroupToken this.beginToken);
+  ParenthesizedExpression(
+      Expression this.expression, BeginGroupToken this.beginToken);
 
   ParenthesizedExpression asParenthesizedExpression() => this;
 
   accept(Visitor visitor) => visitor.visitParenthesizedExpression(this);
 
   accept1(Visitor1 visitor, arg) {
     return visitor.visitParenthesizedExpression(this, arg);
   }
 
   visitChildren(Visitor visitor) {
@@ skipping 36 matching lines @@
   static const int FLAG_EXTERNAL = FLAG_FACTORY << 1;
 
   Modifiers(NodeList nodes) : this.withFlags(nodes, computeFlags(nodes.nodes));
 
   Modifiers.withFlags(this.nodes, this.flags);
 
   static int computeFlags(Link<Node> nodes) {
     int flags = 0;
     for (; !nodes.isEmpty; nodes = nodes.tail) {
       String value = nodes.head.asIdentifier().source;
-      if (identical(value, 'static')) flags |= FLAG_STATIC;
-      else if (identical(value, 'abstract')) flags |= FLAG_ABSTRACT;
-      else if (identical(value, 'final')) flags |= FLAG_FINAL;
-      else if (identical(value, 'var')) flags |= FLAG_VAR;
-      else if (identical(value, 'const')) flags |= FLAG_CONST;
-      else if (identical(value, 'factory')) flags |= FLAG_FACTORY;
-      else if (identical(value, 'external')) flags |= FLAG_EXTERNAL;
-      else throw 'internal error: ${nodes.head}';
+      if (identical(value, 'static'))
+        flags |= FLAG_STATIC;
+      else if (identical(value, 'abstract'))
+        flags |= FLAG_ABSTRACT;
+      else if (identical(value, 'final'))
+        flags |= FLAG_FINAL;
+      else if (identical(value, 'var'))
+        flags |= FLAG_VAR;
+      else if (identical(value, 'const'))
+        flags |= FLAG_CONST;
+      else if (identical(value, 'factory'))
+        flags |= FLAG_FACTORY;
+      else if (identical(value, 'external'))
+        flags |= FLAG_EXTERNAL;
+      else
+        throw 'internal error: ${nodes.head}';
     }
     return flags;
   }
 
   Node findModifier(String modifier) {
     Link<Node> nodeList = nodes.nodes;
     for (; !nodeList.isEmpty; nodeList = nodeList.tail) {
       String value = nodeList.head.asIdentifier().source;
-      if(identical(value, modifier)) {
+      if (identical(value, modifier)) {
         return nodeList.head;
       }
     }
     return null;
   }
 
   Modifiers asModifiers() => this;
   Token getBeginToken() => nodes.getBeginToken();
   Token getEndToken() => nodes.getEndToken();
 
@@ skipping 15 matching lines @@
 
   Node getStatic() => findModifier('static');
 
   /**
    * Use this to check if the declaration is either explicitly or implicitly
    * final.
    */
   bool get isFinalOrConst => isFinal || isConst;
 
   String toString() {
-    return modifiersToString(isStatic: isStatic,
-                             isAbstract: isAbstract,
-                             isFinal: isFinal,
-                             isVar: isVar,
-                             isConst: isConst,
-                             isFactory: isFactory,
-                             isExternal: isExternal);
+    return modifiersToString(
+        isStatic: isStatic,
+        isAbstract: isAbstract,
+        isFinal: isFinal,
+        isVar: isVar,
+        isConst: isConst,
+        isFactory: isFactory,
+        isExternal: isExternal);
   }
 }
 
 class StringInterpolation extends StringNode {
   final LiteralString string;
   final NodeList parts;
 
   StringInterpolation(this.string, this.parts);
 
   StringInterpolation asStringInterpolation() => this;
@@ skipping 69 matching lines @@
    */
   DartString dartStringCache = null;
 
   StringJuxtaposition(this.first, this.second);
 
   StringJuxtaposition asStringJuxtaposition() => this;
 
   bool get isInterpolation {
     if (isInterpolationCache == null) {
       isInterpolationCache = (first.accept(const IsInterpolationVisitor()) ||
-                          second.accept(const IsInterpolationVisitor()));
+          second.accept(const IsInterpolationVisitor()));
     }
     return isInterpolationCache;
   }
 
   /**
    * Retrieve a single DartString that represents this entire juxtaposition
    * of string literals.
    * Should only be called if [isInterpolation] returns false.
    */
   DartString get dartString {
@@ skipping 142 matching lines @@
 
   Token getEndToken() => expression.getEndToken();
 }
 
 class SwitchStatement extends Statement {
   final ParenthesizedExpression parenthesizedExpression;
   final NodeList cases;
 
   final Token switchKeyword;
 
-  SwitchStatement(this.parenthesizedExpression, this.cases,
-                  this.switchKeyword);
+  SwitchStatement(this.parenthesizedExpression, this.cases, this.switchKeyword);
 
   SwitchStatement asSwitchStatement() => this;
 
   Expression get expression => parenthesizedExpression.expression;
 
   accept(Visitor visitor) => visitor.visitSwitchStatement(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitSwitchStatement(this, arg);
 
   visitChildren(Visitor visitor) {
@@ skipping 41 matching lines @@
 
   /** List of [Label] and [CaseMatch] nodes. */
   final NodeList labelsAndCases;
   /** A "default" keyword token, if applicable. */
   final Token defaultKeyword;
   /** List of statements, the body of the case. */
   final NodeList statements;
 
   final Token startToken;
 
-  SwitchCase(this.labelsAndCases, this.defaultKeyword,
-             this.statements, this.startToken);
+  SwitchCase(this.labelsAndCases, this.defaultKeyword, this.statements,
+      this.startToken);
 
   SwitchCase asSwitchCase() => this;
 
   bool get isDefaultCase => defaultKeyword != null;
 
   bool isValidContinueTarget() => true;
 
   accept(Visitor visitor) => visitor.visitSwitchCase(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitSwitchCase(this, arg);
@@ skipping 45 matching lines @@
   Token getBeginToken() => keywordToken;
 
   Token getEndToken() => semicolonToken;
 
   // TODO(ahe): make class abstract instead of adding an abstract method.
   accept(Visitor visitor);
 }
 
 class BreakStatement extends GotoStatement {
   BreakStatement(Identifier target, Token keywordToken, Token semicolonToken)
-    : super(target, keywordToken, semicolonToken);
+      : super(target, keywordToken, semicolonToken);
 
   BreakStatement asBreakStatement() => this;
 
   accept(Visitor visitor) => visitor.visitBreakStatement(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitBreakStatement(this, arg);
 }
 
 class ContinueStatement extends GotoStatement {
   ContinueStatement(Identifier target, Token keywordToken, Token semicolonToken)
-    : super(target, keywordToken, semicolonToken);
+      : super(target, keywordToken, semicolonToken);
 
   ContinueStatement asContinueStatement() => this;
 
   accept(Visitor visitor) => visitor.visitContinueStatement(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitContinueStatement(this, arg);
 }
 
 abstract class ForIn extends Loop {
   final Node declaredIdentifier;
   final Expression expression;
 
   final Token forToken;
   final Token inToken;
 
-  ForIn(this.declaredIdentifier, this.expression,
-        Statement body, this.forToken, this.inToken)
+  ForIn(this.declaredIdentifier, this.expression, Statement body, this.forToken,
+      this.inToken)
       : super(body);
 
   Expression get condition => null;
 
   ForIn asForIn() => this;
 
   Token getEndToken() => body.getEndToken();
 }
 
 class SyncForIn extends ForIn with StoredTreeElementMixin {
@@ skipping 17 matching lines @@
     expression.accept1(visitor, arg);
     body.accept1(visitor, arg);
   }
 
   Token getBeginToken() => forToken;
 }
 
 class AsyncForIn extends ForIn with StoredTreeElementMixin {
   final Token awaitToken;
 
-  AsyncForIn(declaredIdentifier, expression,
-        Statement body, this.awaitToken, forToken, inToken)
+  AsyncForIn(declaredIdentifier, expression, Statement body, this.awaitToken,
+      forToken, inToken)
       : super(declaredIdentifier, expression, body, forToken, inToken);
 
   AsyncForIn asAsyncForIn() => this;
 
   accept(Visitor visitor) => visitor.visitAsyncForIn(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitAsyncForIn(this, arg);
 
   visitChildren(Visitor visitor) {
     declaredIdentifier.accept(visitor);
@@ skipping 75 matching lines @@
   bool get isExport => false;
   bool get isPart => false;
   bool get isPartOf => false;
 }
 
 class LibraryName extends LibraryTag {
   final Expression name;
 
   final Token libraryKeyword;
 
-  LibraryName(this.libraryKeyword,
-              this.name,
-              List<MetadataAnnotation> metadata)
-    : super(metadata);
+  LibraryName(this.libraryKeyword, this.name, List<MetadataAnnotation> metadata)
+      : super(metadata);
 
   bool get isLibraryName => true;
 
   LibraryName asLibraryName() => this;
 
   accept(Visitor visitor) => visitor.visitLibraryName(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitLibraryName(this, arg);
 
   visitChildren(Visitor visitor) => name.accept(visitor);
 
   visitChildren1(Visitor1 visitor, arg) => name.accept1(visitor, arg);
 
   Token getBeginToken() => libraryKeyword;
 
   Token getEndToken() => name.getEndToken().next;
 }
 
 /**
  * This tag describes a dependency between one library and the exported
  * identifiers of another library. The other library is specified by the [uri].
  * Combinators filter away some identifiers from the other library.
  */
 abstract class LibraryDependency extends LibraryTag {
   final StringNode uri;
   final NodeList conditionalUris;
   final NodeList combinators;
 
-  LibraryDependency(this.uri,
-                    this.conditionalUris,
-                    this.combinators,
-                    List<MetadataAnnotation> metadata)
-    : super(metadata);
+  LibraryDependency(this.uri, this.conditionalUris, this.combinators,
+      List<MetadataAnnotation> metadata)
+      : super(metadata);
 
   LibraryDependency asLibraryDependency() => this;
 
   bool get hasConditionalUris => conditionalUris != null;
 }
 
 /**
  * An [:import:] library tag.
  *
  * An import tag is dependency on another library where the exported identifiers
  * are put into the import scope of the importing library. The import scope is
  * only visible inside the library.
  */
 class Import extends LibraryDependency {
   final Identifier prefix;
   final Token importKeyword;
   final bool isDeferred;
 
   Import(this.importKeyword, StringNode uri, NodeList conditionalUris,
-         this.prefix, NodeList combinators,
-         List<MetadataAnnotation> metadata,
-         {this.isDeferred})
+      this.prefix, NodeList combinators, List<MetadataAnnotation> metadata,
+      {this.isDeferred})
       : super(uri, conditionalUris, combinators, metadata);
 
   bool get isImport => true;
 
   Import asImport() => this;
 
   accept(Visitor visitor) => visitor.visitImport(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitImport(this, arg);
 
@@ skipping 97 matching lines @@
 /**
  * An [:export:] library tag.
  *
  * An export tag is dependency on another library where the exported identifiers
  * are put into the export scope of the exporting library. The export scope is
  * not visible inside the library.
  */
 class Export extends LibraryDependency {
   final Token exportKeyword;
 
-  Export(this.exportKeyword,
-         StringNode uri,
-         NodeList conditionalUris,
-         NodeList combinators,
-         List<MetadataAnnotation> metadata)
+  Export(this.exportKeyword, StringNode uri, NodeList conditionalUris,
+      NodeList combinators, List<MetadataAnnotation> metadata)
       : super(uri, conditionalUris, combinators, metadata);
 
   bool get isExport => true;
 
   Export asExport() => this;
 
   accept(Visitor visitor) => visitor.visitExport(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitExport(this, arg);
 
@@ skipping 15 matching lines @@
     return uri.getEndToken().next;
   }
 }
 
 class Part extends LibraryTag {
   final StringNode uri;
 
   final Token partKeyword;
 
   Part(this.partKeyword, this.uri, List<MetadataAnnotation> metadata)
-    : super(metadata);
+      : super(metadata);
 
   bool get isPart => true;
 
   Part asPart() => this;
 
   accept(Visitor visitor) => visitor.visitPart(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitPart(this, arg);
 
   visitChildren(Visitor visitor) => uri.accept(visitor);
@@ skipping 62 matching lines @@
 class Typedef extends Node {
   final TypeAnnotation returnType;
   final Identifier name;
   final NodeList typeParameters;
   final NodeList formals;
 
   final Token typedefKeyword;
   final Token endToken;
 
   Typedef(this.returnType, this.name, this.typeParameters, this.formals,
-          this.typedefKeyword, this.endToken);
+      this.typedefKeyword, this.endToken);
 
   Typedef asTypedef() => this;
 
   accept(Visitor visitor) => visitor.visitTypedef(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitTypedef(this, arg);
 
   visitChildren(Visitor visitor) {
     if (returnType != null) returnType.accept(visitor);
     name.accept(visitor);
@@ skipping 15 matching lines @@
 
 class TryStatement extends Statement {
   final Block tryBlock;
   final NodeList catchBlocks;
   final Block finallyBlock;
 
   final Token tryKeyword;
   final Token finallyKeyword;
 
   TryStatement(this.tryBlock, this.catchBlocks, this.finallyBlock,
-               this.tryKeyword, this.finallyKeyword);
+      this.tryKeyword, this.finallyKeyword);
 
   TryStatement asTryStatement() => this;
 
   accept(Visitor visitor) => visitor.visitTryStatement(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitTryStatement(this, arg);
 
   visitChildren(Visitor visitor) {
     tryBlock.accept(visitor);
     catchBlocks.accept(visitor);
@@ skipping 61 matching lines @@
 }
 
 class CatchBlock extends Node {
   final TypeAnnotation type;
   final NodeList formals;
   final Block block;
 
   final Token onKeyword;
   final Token catchKeyword;
 
-  CatchBlock(this.type, this.formals, this.block,
-             this.onKeyword, this.catchKeyword);
+  CatchBlock(
+      this.type, this.formals, this.block, this.onKeyword, this.catchKeyword);
 
   CatchBlock asCatchBlock() => this;
 
   accept(Visitor visitor) => visitor.visitCatchBlock(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitCatchBlock(this, arg);
 
   Node get exception {
     if (formals == null || formals.nodes.isEmpty) return null;
     VariableDefinitions declarations = formals.nodes.head;
@@ skipping 46 matching lines @@
   }
 
   Token getBeginToken() => token;
 
   Token getEndToken() => expression.getEndToken();
 }
 
 class Initializers {
   static bool isSuperConstructorCall(Send node) {
     return (node.receiver == null && node.selector.isSuper()) ||
-           (node.receiver != null &&
+        (node.receiver != null &&
             node.receiver.isSuper() &&
             !node.isConditional &&
             node.selector.asIdentifier() != null);
   }
 
   static bool isConstructorRedirect(Send node) {
     return (node.receiver == null && node.selector.isThis()) ||
-           (node.receiver != null &&
+        (node.receiver != null &&
             node.receiver.isThis() &&
             !node.isConditional &&
             node.selector.asIdentifier() != null);
   }
 }
 
 class GetDartStringVisitor extends Visitor<DartString> {
   const GetDartStringVisitor();
   DartString visitNode(Node node) => null;
-  DartString visitStringJuxtaposition(StringJuxtaposition node)
-      => node.dartString;
+  DartString visitStringJuxtaposition(StringJuxtaposition node) =>
+      node.dartString;
   DartString visitLiteralString(LiteralString node) => node.dartString;
 }
 
 class IsInterpolationVisitor extends Visitor<bool> {
   const IsInterpolationVisitor();
   bool visitNode(Node node) => false;
   bool visitStringInterpolation(StringInterpolation node) => true;
-  bool visitStringJuxtaposition(StringJuxtaposition node)
-      => node.isInterpolation;
+  bool visitStringJuxtaposition(StringJuxtaposition node) =>
+      node.isInterpolation;
 }
 
 /// Erroneous node used to recover from parser errors.  Implements various
 /// interfaces and provides bare minimum of implementation to avoid unnecessary
 /// messages.
-class ErrorNode
-    extends Node
+class ErrorNode extends Node
     implements FunctionExpression, VariableDefinitions, Typedef {
   final Token token;
   final String reason;
   final Identifier name;
   final NodeList definitions;
 
   ErrorNode.internal(this.token, this.reason, this.name, this.definitions);
 
   factory ErrorNode(Token token, String reason) {
     Identifier name = new Identifier(token);
-    NodeList definitions = new NodeList(
-        null, const Link<Node>().prepend(name), null, null);
+    NodeList definitions =
+        new NodeList(null, const Link<Node>().prepend(name), null, null);
     return new ErrorNode.internal(token, reason, name, definitions);
   }
 
   Token get beginToken => token;
   Token get endToken => token;
 
   Token getBeginToken() => token;
 
   Token getEndToken() => token;
 
@@ skipping 21 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }