Run dartfmt on js_ast

pkg/js_ast/lib/src/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.
 
 part of js_ast;
 
 abstract class NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 77 matching lines @@
     return null;
   }
 
   T visitProgram(Program node) => visitNode(node);
 
   T visitStatement(Statement node) => visitNode(node);
   T visitLoop(Loop node) => visitStatement(node);
   T visitJump(Statement node) => visitStatement(node);
 
   T visitBlock(Block node) => visitStatement(node);
-  T visitExpressionStatement(ExpressionStatement node)
-      => visitStatement(node);
+  T visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
   T visitEmptyStatement(EmptyStatement node) => visitStatement(node);
   T visitIf(If node) => visitStatement(node);
   T visitFor(For node) => visitLoop(node);
   T visitForIn(ForIn node) => visitLoop(node);
   T visitWhile(While node) => visitLoop(node);
   T visitDo(Do node) => visitLoop(node);
   T visitContinue(Continue node) => visitJump(node);
   T visitBreak(Break node) => visitJump(node);
   T visitReturn(Return node) => visitJump(node);
   T visitThrow(Throw node) => visitJump(node);
   T visitTry(Try node) => visitStatement(node);
   T visitSwitch(Switch node) => visitStatement(node);
-  T visitFunctionDeclaration(FunctionDeclaration node)
-      => visitStatement(node);
+  T visitFunctionDeclaration(FunctionDeclaration node) => visitStatement(node);
   T visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   T visitLiteralStatement(LiteralStatement node) => visitStatement(node);
 
   T visitCatch(Catch node) => visitNode(node);
   T visitCase(Case node) => visitNode(node);
   T visitDefault(Default node) => visitNode(node);
 
   T visitExpression(Expression node) => visitNode(node);
   T visitVariableReference(VariableReference node) => visitExpression(node);
 
   T visitLiteralExpression(LiteralExpression node) => visitExpression(node);
-  T visitVariableDeclarationList(VariableDeclarationList node)
-      => visitExpression(node);
+  T visitVariableDeclarationList(VariableDeclarationList node) =>
+      visitExpression(node);
   T visitAssignment(Assignment node) => visitExpression(node);
   T visitVariableInitialization(VariableInitialization node) {
     if (node.value != null) {
       return visitAssignment(node);
     } else {
       return visitExpression(node);
     }
   }
+
   T visitConditional(Conditional node) => visitExpression(node);
   T visitNew(New node) => visitExpression(node);
   T visitCall(Call node) => visitExpression(node);
   T visitBinary(Binary node) => visitExpression(node);
   T visitPrefix(Prefix node) => visitExpression(node);
   T visitPostfix(Postfix node) => visitExpression(node);
   T visitAccess(PropertyAccess node) => visitExpression(node);
 
   T visitVariableUse(VariableUse node) => visitVariableReference(node);
-  T visitVariableDeclaration(VariableDeclaration node)
-      => visitVariableReference(node);
+  T visitVariableDeclaration(VariableDeclaration node) =>
+      visitVariableReference(node);
   T visitParameter(Parameter node) => visitVariableDeclaration(node);
   T visitThis(This node) => visitParameter(node);
 
   T visitNamedFunction(NamedFunction node) => visitExpression(node);
   T visitFun(Fun node) => visitExpression(node);
 
   T visitToken(DeferredToken node) => visitExpression(node);
 
   T visitDeferredExpression(DeferredExpression node) => visitExpression(node);
   T visitDeferredNumber(DeferredNumber node) => visitToken(node);
@@ skipping 11 matching lines @@
   T visitName(Name node) => visitNode(node);
 
   T visitArrayInitializer(ArrayInitializer node) => visitExpression(node);
   T visitArrayHole(ArrayHole node) => visitExpression(node);
   T visitObjectInitializer(ObjectInitializer node) => visitExpression(node);
   T visitProperty(Property node) => visitNode(node);
   T visitRegExpLiteral(RegExpLiteral node) => visitExpression(node);
 
   T visitInterpolatedNode(InterpolatedNode node) => visitNode(node);
 
-  T visitInterpolatedExpression(InterpolatedExpression node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedLiteral(InterpolatedLiteral node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedParameter(InterpolatedParameter node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedSelector(InterpolatedSelector node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedStatement(InterpolatedStatement node)
-      => visitInterpolatedNode(node);
+  T visitInterpolatedExpression(InterpolatedExpression node) =>
+      visitInterpolatedNode(node);
+  T visitInterpolatedLiteral(InterpolatedLiteral node) =>
+      visitInterpolatedNode(node);
+  T visitInterpolatedParameter(InterpolatedParameter node) =>
+      visitInterpolatedNode(node);
+  T visitInterpolatedSelector(InterpolatedSelector node) =>
+      visitInterpolatedNode(node);
+  T visitInterpolatedStatement(InterpolatedStatement node) =>
+      visitInterpolatedNode(node);
   T visitInterpolatedDeclaration(InterpolatedDeclaration node) {
     return visitInterpolatedNode(node);
   }
 
   // Ignore comments by default.
   T visitComment(Comment node) => null;
 
   T visitAwait(Await node) => visitExpression(node);
   T visitDartYield(DartYield node) => visitStatement(node);
 }
@@ skipping 40 matching lines @@
 }
 
 class Program extends Node {
   final List<Statement> body;
   Program(this.body);
 
   accept(NodeVisitor visitor) => visitor.visitProgram(this);
   void visitChildren(NodeVisitor visitor) {
     for (Statement statement in body) statement.accept(visitor);
   }
+
   Program _clone() => new Program(body);
 }
 
 abstract class Statement extends Node {
   Statement toStatement() => this;
 }
 
 class Block extends Statement {
   final List<Statement> statements;
   Block(this.statements);
   Block.empty() : this.statements = <Statement>[];
 
   accept(NodeVisitor visitor) => visitor.visitBlock(this);
   void visitChildren(NodeVisitor visitor) {
     for (Statement statement in statements) statement.accept(visitor);
   }
+
   Block _clone() => new Block(statements);
 }
 
 class ExpressionStatement extends Statement {
   final Expression expression;
   ExpressionStatement(this.expression) {
     assert(this.expression != null);
   }
 
   accept(NodeVisitor visitor) => visitor.visitExpressionStatement(this);
-  void visitChildren(NodeVisitor visitor) { expression.accept(visitor); }
+  void visitChildren(NodeVisitor visitor) {
+    expression.accept(visitor);
+  }
+
   ExpressionStatement _clone() => new ExpressionStatement(expression);
 }
 
 class EmptyStatement extends Statement {
   EmptyStatement();
 
   accept(NodeVisitor visitor) => visitor.visitEmptyStatement(this);
   void visitChildren(NodeVisitor visitor) {}
   EmptyStatement _clone() => new EmptyStatement();
 }
 
 class If extends Statement {
   final Expression condition;
   final Statement then;
   final Statement otherwise;
 
   If(this.condition, this.then, this.otherwise);
   If.noElse(this.condition, this.then) : this.otherwise = new EmptyStatement();
 
-  bool get hasElse => otherwise is !EmptyStatement;
+  bool get hasElse => otherwise is! EmptyStatement;
 
   accept(NodeVisitor visitor) => visitor.visitIf(this);
 
   void visitChildren(NodeVisitor visitor) {
     condition.accept(visitor);
     then.accept(visitor);
     otherwise.accept(visitor);
   }
 
   If _clone() => new If(condition, then, otherwise);
@@ skipping 66 matching lines @@
 
   void visitChildren(NodeVisitor visitor) {
     body.accept(visitor);
     condition.accept(visitor);
   }
 
   Do _clone() => new Do(body, condition);
 }
 
 class Continue extends Statement {
-  final String targetLabel;  // Can be null.
+  final String targetLabel; // Can be null.
 
   Continue(this.targetLabel);
 
   accept(NodeVisitor visitor) => visitor.visitContinue(this);
   void visitChildren(NodeVisitor visitor) {}
 
   Continue _clone() => new Continue(targetLabel);
 }
 
 class Break extends Statement {
-  final String targetLabel;  // Can be null.
+  final String targetLabel; // Can be null.
 
   Break(this.targetLabel);
 
   accept(NodeVisitor visitor) => visitor.visitBreak(this);
   void visitChildren(NodeVisitor visitor) {}
 
   Break _clone() => new Break(targetLabel);
 }
 
 class Return extends Statement {
-  final Expression value;  // Can be null.
+  final Expression value; // Can be null.
 
   Return([this.value = null]);
 
   accept(NodeVisitor visitor) => visitor.visitReturn(this);
 
   void visitChildren(NodeVisitor visitor) {
     if (value != null) value.accept(visitor);
   }
 
   Return _clone() => new Return(value);
 }
 
 class Throw extends Statement {
   final Expression expression;
 
   Throw(this.expression);
 
   accept(NodeVisitor visitor) => visitor.visitThrow(this);
 
   void visitChildren(NodeVisitor visitor) {
     expression.accept(visitor);
   }
 
   Throw _clone() => new Throw(expression);
 }
 
 class Try extends Statement {
   final Block body;
-  final Catch catchPart;  // Can be null if [finallyPart] is non-null.
-  final Block finallyPart;  // Can be null if [catchPart] is non-null.
+  final Catch catchPart; // Can be null if [finallyPart] is non-null.
+  final Block finallyPart; // Can be null if [catchPart] is non-null.
 
   Try(this.body, this.catchPart, this.finallyPart) {
     assert(catchPart != null || finallyPart != null);
   }
 
   accept(NodeVisitor visitor) => visitor.visitTry(this);
 
   void visitChildren(NodeVisitor visitor) {
     body.accept(visitor);
     if (catchPart != null) catchPart.accept(visitor);
@@ skipping 98 matching lines @@
 
   LabeledStatement _clone() => new LabeledStatement(label, body);
 }
 
 class LiteralStatement extends Statement {
   final String code;
 
   LiteralStatement(this.code);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralStatement(this);
-  void visitChildren(NodeVisitor visitor) { }
+  void visitChildren(NodeVisitor visitor) {}
 
   LiteralStatement _clone() => new LiteralStatement(code);
 }
 
 // Not a real JavaScript node, but represents the yield statement from a dart
 // program translated to JavaScript.
 class DartYield extends Statement {
   final Expression expression;
 
   final bool hasStar;
 
   DartYield(this.expression, this.hasStar);
 
   accept(NodeVisitor visitor) => visitor.visitDartYield(this);
 
   void visitChildren(NodeVisitor visitor) {
     expression.accept(visitor);
   }
 
   DartYield _clone() => new DartYield(expression, hasStar);
 }
 
 abstract class Expression extends Node {
   int get precedenceLevel;
 
   Statement toStatement() => new ExpressionStatement(this);
 }
 
-abstract class Declaration implements VariableReference {
-
-}
+abstract class Declaration implements VariableReference {}
 
 /// An implementation of [Name] represents a potentially late bound name in
 /// the generated ast.
 ///
 /// While [Name] implements comparable, there is no requirement on the actual
 /// implementation of [compareTo] other than that it needs to be stable.
 /// In particular, there is no guarantee that implementations of [compareTo]
 /// will implement some form of lexicographic ordering like [String.compareTo].
 abstract class Name extends Literal
     implements Declaration, Parameter, Comparable {
@@ skipping 60 matching lines @@
     }
   }
 
   VariableDeclarationList _clone() => new VariableDeclarationList(declarations);
 
   int get precedenceLevel => EXPRESSION;
 }
 
 class Assignment extends Expression {
   final Expression leftHandSide;
-  final String op;         // Null, if the assignment is not compound.
-  final Expression value;  // May be null, for [VariableInitialization]s.
+  final String op; // Null, if the assignment is not compound.
+  final Expression value; // May be null, for [VariableInitialization]s.
 
-  Assignment(leftHandSide, value)
-      : this.compound(leftHandSide, null, value);
+  Assignment(leftHandSide, value) : this.compound(leftHandSide, null, value);
   // If `this.op == null` this will be a non-compound assignment.
   Assignment.compound(this.leftHandSide, this.op, this.value);
 
   int get precedenceLevel => ASSIGNMENT;
 
   bool get isCompound => op != null;
 
   accept(NodeVisitor visitor) => visitor.visitAssignment(this);
 
   void visitChildren(NodeVisitor visitor) {
     leftHandSide.accept(visitor);
     if (value != null) value.accept(visitor);
   }
 
-  Assignment _clone() =>
-      new Assignment.compound(leftHandSide, op, value);
+  Assignment _clone() => new Assignment.compound(leftHandSide, op, value);
 }
 
 class VariableInitialization extends Assignment {
   /** [value] may be null. */
   VariableInitialization(Declaration declaration, Expression value)
       : super(declaration, value);
 
   Declaration get declaration => leftHandSide;
 
   accept(NodeVisitor visitor) => visitor.visitVariableInitialization(this);
@@ skipping 20 matching lines @@
   Conditional _clone() => new Conditional(condition, then, otherwise);
 
   int get precedenceLevel => ASSIGNMENT;
 }
 
 class Call extends Expression {
   Expression target;
   List<Expression> arguments;
 
   Call(this.target, this.arguments,
-       {JavaScriptNodeSourceInformation sourceInformation}) {
+      {JavaScriptNodeSourceInformation sourceInformation}) {
     this._sourceInformation = sourceInformation;
   }
 
   accept(NodeVisitor visitor) => visitor.visitCall(this);
 
   void visitChildren(NodeVisitor visitor) {
     target.accept(visitor);
     for (Expression arg in arguments) {
       arg.accept(visitor);
     }
@@ skipping 98 matching lines @@
   Postfix(this.op, this.argument);
 
   accept(NodeVisitor visitor) => visitor.visitPostfix(this);
 
   Postfix _clone() => new Postfix(op, argument);
 
   void visitChildren(NodeVisitor visitor) {
     argument.accept(visitor);
   }
 
-
   int get precedenceLevel => UNARY;
 }
 
 abstract class VariableReference extends Expression {
   final String name;
 
   VariableReference(this.name) {
     assert(_identifierRE.hasMatch(name));
   }
   static RegExp _identifierRE = new RegExp(r'^[A-Za-z_$][A-Za-z_$0-9]*$');
@@ skipping 41 matching lines @@
   final Fun function;
 
   NamedFunction(this.name, this.function);
 
   accept(NodeVisitor visitor) => visitor.visitNamedFunction(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     function.accept(visitor);
   }
+
   NamedFunction _clone() => new NamedFunction(name, function);
 
   int get precedenceLevel => LEFT_HAND_SIDE;
 }
 
 class Fun extends Expression {
   final List<Parameter> params;
   final Block body;
   final AsyncModifier asyncModifier;
 
@@ skipping 152 matching lines @@
   accept(NodeVisitor visitor) => visitor.visitStringConcatenation(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Literal part in parts) part.accept(visitor);
   }
 
   StringConcatenation _clone() => new StringConcatenation(this.parts);
 }
 
 class LiteralNumber extends Literal {
-  final String value;  // Must be a valid JavaScript number literal.
+  final String value; // Must be a valid JavaScript number literal.
 
   LiteralNumber(this.value);
 
   int get precedenceLevel => value.startsWith('-') ? UNARY : PRIMARY;
 
   accept(NodeVisitor visitor) => visitor.visitLiteralNumber(this);
   LiteralNumber _clone() => new LiteralNumber(value);
 }
 
 class ArrayInitializer extends Expression {
@@ skipping 75 matching lines @@
   bool get isPositional => nameOrPosition is int;
 }
 
 class InterpolatedExpression extends Expression with InterpolatedNode {
   final nameOrPosition;
 
   InterpolatedExpression(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedExpression(this);
   void visitChildren(NodeVisitor visitor) {}
-  InterpolatedExpression _clone() =>
-      new InterpolatedExpression(nameOrPosition);
+  InterpolatedExpression _clone() => new InterpolatedExpression(nameOrPosition);
 
   int get precedenceLevel => PRIMARY;
 }
 
 class InterpolatedLiteral extends Literal with InterpolatedNode {
   final nameOrPosition;
 
   InterpolatedLiteral(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedLiteral(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedLiteral _clone() => new InterpolatedLiteral(nameOrPosition);
 }
 
-class InterpolatedParameter extends Expression with InterpolatedNode
+class InterpolatedParameter extends Expression
+    with InterpolatedNode
     implements Parameter {
   final nameOrPosition;
 
-  String get name { throw "InterpolatedParameter.name must not be invoked"; }
+  String get name {
+    throw "InterpolatedParameter.name must not be invoked";
+  }
+
   bool get allowRename => false;
 
   InterpolatedParameter(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedParameter(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedParameter _clone() => new InterpolatedParameter(nameOrPosition);
 
   int get precedenceLevel => PRIMARY;
 }
@@ skipping 14 matching lines @@
   final nameOrPosition;
 
   InterpolatedStatement(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedStatement(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedStatement _clone() => new InterpolatedStatement(nameOrPosition);
 }
 
 class InterpolatedDeclaration extends Expression
-                              with InterpolatedNode
-                              implements Declaration {
+    with InterpolatedNode
+    implements Declaration {
   final nameOrPosition;
 
   InterpolatedDeclaration(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedDeclaration(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedDeclaration _clone() {
     return new InterpolatedDeclaration(nameOrPosition);
   }
 
@@ skipping 49 matching lines @@
 class Comment extends Statement {
   final String comment;
 
   Comment(this.comment);
 
   accept(NodeVisitor visitor) => visitor.visitComment(this);
   Comment _clone() => new Comment(comment);
 
   void visitChildren(NodeVisitor visitor) {}
 }