Format all dart dev compiler files

pkg/dev_compiler/lib/src/js_ast/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> implements TypeRefVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 102 matching lines @@
     return null;
   }
 
   T visitProgram(Program node) => visitNode(node);
 
   T visitStatement(Statement node) => visitModuleItem(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 visitForOf(ForOf 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 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 visitSpread(Spread node) => visitPrefix(node);
   T visitYield(Yield node) => visitExpression(node);
   T visitAccess(PropertyAccess node) => visitExpression(node);
 
@@ skipping 29 matching lines @@
 
   T visitModuleItem(ModuleItem node) => visitNode(node);
   T visitImportDeclaration(ImportDeclaration node) => visitModuleItem(node);
   T visitExportDeclaration(ExportDeclaration node) => visitModuleItem(node);
   T visitExportClause(ExportClause node) => visitNode(node);
   T visitNameSpecifier(NameSpecifier node) => visitNode(node);
   T visitModule(Module node) => visitNode(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 visitInterpolatedMethod(InterpolatedMethod node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedIdentifier(InterpolatedIdentifier 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 visitInterpolatedMethod(InterpolatedMethod node) =>
+      visitInterpolatedNode(node);
+  T visitInterpolatedIdentifier(InterpolatedIdentifier node) =>
+      visitInterpolatedNode(node);
 
   // Ignore comments by default.
   T visitComment(Comment node) => null;
   T visitCommentExpression(CommentExpression node) => null;
 
   T visitAwait(Await node) => visitExpression(node);
   T visitDartYield(DartYield node) => visitStatement(node);
 
   T visitBindingPattern(BindingPattern node) => visitNode(node);
-  T visitArrayBindingPattern(ArrayBindingPattern node)
-      => visitBindingPattern(node);
-  T visitObjectBindingPattern(ObjectBindingPattern node)
-      => visitBindingPattern(node);
+  T visitArrayBindingPattern(ArrayBindingPattern node) =>
+      visitBindingPattern(node);
+  T visitObjectBindingPattern(ObjectBindingPattern node) =>
+      visitBindingPattern(node);
   T visitDestructuredVariable(DestructuredVariable node) => visitNode(node);
   T visitSimpleBindingPattern(SimpleBindingPattern node) => visitNode(node);
 
   T visitTypeRef(TypeRef node) => visitNode(node);
   T visitQualifiedTypeRef(QualifiedTypeRef node) => visitTypeRef(node);
   T visitGenericTypeRef(GenericTypeRef node) => visitTypeRef(node);
   T visitOptionalTypeRef(OptionalTypeRef node) => visitTypeRef(node);
   T visitRecordTypeRef(RecordTypeRef node) => visitTypeRef(node);
   T visitUnionTypeRef(UnionTypeRef node) => visitTypeRef(node);
   T visitFunctionTypeRef(FunctionTypeRef node) => visitTypeRef(node);
   T visitAnyTypeRef(AnyTypeRef node) => visitTypeRef(node);
   T visitUnknownTypeRef(UnknownTypeRef node) => visitTypeRef(node);
   T visitArrayTypeRef(ArrayTypeRef node) => visitTypeRef(node);
 }
 
 abstract class Node {
   /// Sets the source location of this node. For performance reasons, we allow
   /// setting this after construction.
   Object sourceInformation;
 
   ClosureAnnotation _closureAnnotation;
+
   /// Closure annotation of this node.
   ClosureAnnotation get closureAnnotation => _closureAnnotation;
 
   accept(NodeVisitor visitor);
   void visitChildren(NodeVisitor visitor);
 
   // Shallow clone of node.  Does not clone positions since the only use of this
   // private method is create a copy with a new position.
   Node _clone();
 
   withClosureAnnotation(ClosureAnnotation closureAnnotation) {
     if (this.closureAnnotation == closureAnnotation) return this;
 
     return _clone()
-        ..sourceInformation = sourceInformation
-        .._closureAnnotation = closureAnnotation;
+      ..sourceInformation = sourceInformation
+      .._closureAnnotation = closureAnnotation;
   }
+
   // Returns a node equivalent to [this], but with new source position and end
   // source position.
   Node withSourceInformation(sourceInformation) {
     if (sourceInformation == this.sourceInformation) {
       return this;
     }
     Node clone = _clone();
     // TODO(sra): Should existing data be 'sticky' if we try to overwrite with
     // `null`?
     clone.sourceInformation = sourceInformation;
     return clone;
   }
 
   bool get isCommaOperator => false;
 
   Statement toStatement() {
     throw new UnsupportedError('toStatement');
   }
+
   Statement toReturn() {
     throw new UnsupportedError('toReturn');
   }
 
   // For debugging
   String toString() {
     var context = new SimpleJavaScriptPrintingContext();
     var opts = new JavaScriptPrintingOptions(allowKeywordsInProperties: true);
     context.buffer.write('js_ast `');
     accept(new Printer(opts, context));
@@ skipping 14 matching lines @@
   ///
   /// This is not used in ES6, but is provided to allow module lowering.
   final String name;
 
   Program(this.body, {this.scriptTag, this.name});
 
   accept(NodeVisitor visitor) => visitor.visitProgram(this);
   void visitChildren(NodeVisitor visitor) {
     for (ModuleItem statement in body) statement.accept(visitor);
   }
+
   Program _clone() => new Program(body);
 }
 
 abstract class Statement extends ModuleItem {
   Statement toStatement() => this;
   Statement toReturn() => new Block([this, new Return()]);
 }
 
 class Block extends Statement {
   final List<Statement> statements;
 
   /// True to preserve this [Block] for scoping reasons.
   final bool isScope;
 
   Block(this.statements, {this.isScope: false}) {
     assert(!statements.any((s) => s is! Statement));
   }
-  Block.empty() : statements = <Statement>[], isScope = false;
+  Block.empty()
+      : statements = <Statement>[],
+        isScope = false;
 
   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);
 
   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();
 }
@@ skipping 105 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]);
 
   Statement toReturn() => this;
 
   accept(NodeVisitor visitor) => visitor.visitReturn(this);
 
   void visitChildren(NodeVisitor visitor) {
     if (value != null) value.accept(visitor);
   }
 
   Return _clone() => new Return(value);
 
   static bool foundIn(Node node) {
     _returnFinder.found = false;
     node.accept(_returnFinder);
     return _returnFinder.found;
   }
 }
 
 final _returnFinder = new _ReturnFinder();
+
 class _ReturnFinder extends BaseVisitor {
   bool found = false;
   visitReturn(Return node) {
     found = true;
   }
+
   visitNode(Node node) {
     if (!found) super.visitNode(node);
   }
 }
 
-
 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;
@@ skipping 23 matching lines @@
   int get precedenceLevel;
 
   Statement toStatement() => new ExpressionStatement(toVoidExpression());
   Statement toReturn() => new Return(this);
   Statement toYieldStatement({bool star: false}) =>
       new ExpressionStatement(new Yield(this, star: star));
 
   Expression toVoidExpression() => this;
   Expression toAssignExpression(Expression left) => new Assignment(left, this);
   Statement toVariableDeclaration(Identifier name) =>
-      new VariableDeclarationList('let',
-          [new VariableInitialization(name, this)]).toStatement();
+      new VariableDeclarationList(
+          'let', [new VariableInitialization(name, this)]).toStatement();
 }
 
 class LiteralExpression extends Expression {
   final String template;
   final List<Expression> inputs;
 
   LiteralExpression(this.template) : inputs = const [];
   LiteralExpression.withData(this.template, this.inputs);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralExpression(this);
@@ skipping 35 matching lines @@
   }
 
   VariableDeclarationList _clone() =>
       new VariableDeclarationList(keyword, 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);
   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(VariableBinding declaration, Expression value)
       : super(declaration, value);
 
   VariableBinding get declaration => leftHandSide;
 
   accept(NodeVisitor visitor) => visitor.visitVariableInitialization(this);
 
   VariableInitialization _clone() =>
       new VariableInitialization(declaration, value);
 }
 
-abstract class VariableBinding extends Expression {
-}
+abstract class VariableBinding extends Expression {}
 
 class DestructuredVariable extends Expression implements Parameter {
   /// [LiteralString] or [Identifier].
   final Expression name;
   final BindingPattern structure;
   final Expression defaultValue;
   final TypeRef type;
-  DestructuredVariable({this.name, this.structure, this.defaultValue, this.type}) {
+  DestructuredVariable(
+      {this.name, this.structure, this.defaultValue, this.type}) {
     assert(name != null || structure != null);
   }
 
   accept(NodeVisitor visitor) => visitor.visitDestructuredVariable(this);
   void visitChildren(NodeVisitor visitor) {
     name?.accept(visitor);
     structure?.accept(visitor);
     defaultValue?.accept(visitor);
   }
 
   /// Avoid parenthesis when pretty-printing.
-  @override int get precedenceLevel => PRIMARY;
-  @override Node _clone() =>
-      new DestructuredVariable(
-          name: name, structure: structure, defaultValue: defaultValue);
+  @override
+  int get precedenceLevel => PRIMARY;
+  @override
+  Node _clone() => new DestructuredVariable(
+      name: name, structure: structure, defaultValue: defaultValue);
 }
 
 abstract class BindingPattern extends Expression implements VariableBinding {
   final List<DestructuredVariable> variables;
   BindingPattern(this.variables);
 
   void visitChildren(NodeVisitor visitor) {
     for (DestructuredVariable v in variables) v.accept(visitor);
   }
 }
 
 class SimpleBindingPattern extends BindingPattern {
   final Identifier name;
   SimpleBindingPattern(Identifier name)
       : name = name,
         super([new DestructuredVariable(name: name)]);
 
   accept(NodeVisitor visitor) => visitor.visitSimpleBindingPattern(this);
 
   /// Avoid parenthesis when pretty-printing.
-  @override int get precedenceLevel => PRIMARY;
-  @override Node _clone() => new SimpleBindingPattern(name);
+  @override
+  int get precedenceLevel => PRIMARY;
+  @override
+  Node _clone() => new SimpleBindingPattern(name);
 }
 
 class ObjectBindingPattern extends BindingPattern {
-  ObjectBindingPattern(List<DestructuredVariable> variables)
-      : super(variables);
+  ObjectBindingPattern(List<DestructuredVariable> variables) : super(variables);
   accept(NodeVisitor visitor) => visitor.visitObjectBindingPattern(this);
 
   /// Avoid parenthesis when pretty-printing.
-  @override int get precedenceLevel => PRIMARY;
-  @override Node _clone() => new ObjectBindingPattern(variables);
+  @override
+  int get precedenceLevel => PRIMARY;
+  @override
+  Node _clone() => new ObjectBindingPattern(variables);
 }
 
 class ArrayBindingPattern extends BindingPattern {
-  ArrayBindingPattern(List<DestructuredVariable> variables)
-      : super(variables);
+  ArrayBindingPattern(List<DestructuredVariable> variables) : super(variables);
   accept(NodeVisitor visitor) => visitor.visitArrayBindingPattern(this);
 
   /// Avoid parenthesis when pretty-printing.
-  @override int get precedenceLevel => PRIMARY;
-  @override Node _clone() => new ObjectBindingPattern(variables);
+  @override
+  int get precedenceLevel => PRIMARY;
+  @override
+  Node _clone() => new ObjectBindingPattern(variables);
 }
 
 class Conditional extends Expression {
   final Expression condition;
   final Expression then;
   final Expression otherwise;
 
   Conditional(this.condition, this.then, this.otherwise);
 
   accept(NodeVisitor visitor) => visitor.visitConditional(this);
@@ skipping 193 matching lines @@
   final bool allowRename;
   final TypeRef type;
 
   Identifier(this.name, {this.allowRename: true, this.type}) {
     if (!_identifierRE.hasMatch(name)) {
       throw new ArgumentError.value(name, "name", "not a valid identifier");
     }
   }
   static RegExp _identifierRE = new RegExp(r'^[A-Za-z_$][A-Za-z_$0-9]*$');
 
-  Identifier _clone() =>
-      new Identifier(name, allowRename: allowRename);
+  Identifier _clone() => new Identifier(name, allowRename: allowRename);
   accept(NodeVisitor visitor) => visitor.visitIdentifier(this);
   int get precedenceLevel => PRIMARY;
   void visitChildren(NodeVisitor visitor) {}
 }
 
 // This is an expression for convenience in the AST.
 class RestParameter extends Expression implements Parameter {
   final Identifier parameter;
   TypeRef get type => null;
 
   RestParameter(this.parameter);
 
   RestParameter _clone() => new RestParameter(parameter);
   accept(NodeVisitor visitor) => visitor.visitRestParameter(this);
   void visitChildren(NodeVisitor visitor) {
     parameter.accept(visitor);
   }
+
   int get precedenceLevel => PRIMARY;
 }
 
 class This extends Expression {
   accept(NodeVisitor visitor) => visitor.visitThis(this);
   This _clone() => new This();
   int get precedenceLevel => PRIMARY;
   void visitChildren(NodeVisitor visitor) {}
 
   static bool foundIn(Node node) {
     _thisFinder.found = false;
     node.accept(_thisFinder);
     return _thisFinder.found;
   }
 }
 
 final _thisFinder = new _ThisFinder();
+
 class _ThisFinder extends BaseVisitor {
   bool found = false;
   visitThis(This node) {
     found = true;
   }
+
   visitNode(Node node) {
     if (!found) super.visitNode(node);
   }
 }
 
-
 // `super` is more restricted in the ES6 spec, but for simplicity we accept
 // it anywhere that `this` is accepted.
 class Super extends Expression {
   accept(NodeVisitor visitor) => visitor.visitSuper(this);
   Super _clone() => new Super();
   int get precedenceLevel => PRIMARY;
   void visitChildren(NodeVisitor visitor) {}
 }
 
 class NamedFunction extends Expression {
   final Identifier name;
   final Fun function;
   // A heuristic to force extra parens around this function.  V8 and other
   // engines use this IIFE (immediately invoked function expression) heuristic
   // to eagerly parse a function.
   final bool immediatelyInvoked;
 
   NamedFunction(this.name, this.function, [this.immediatelyInvoked = false]);
 
   accept(NodeVisitor visitor) => visitor.visitNamedFunction(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     function.accept(visitor);
   }
-  NamedFunction _clone() => new NamedFunction(name, function, immediatelyInvoked);
 
-  int get precedenceLevel => immediatelyInvoked ? EXPRESSION : PRIMARY_LOW_PRECEDENCE;
+  NamedFunction _clone() =>
+      new NamedFunction(name, function, immediatelyInvoked);
+
+  int get precedenceLevel =>
+      immediatelyInvoked ? EXPRESSION : PRIMARY_LOW_PRECEDENCE;
 }
 
 abstract class FunctionExpression extends Expression {
   List<Parameter> get params;
 
   get body; // Expression or block
   /// Type parameters passed to this generic function, if any. `null` otherwise.
   // TODO(ochafik): Support type bounds.
   List<Identifier> get typeParams;
+
   /// Return type of this function, if any. `null` otherwise.
   TypeRef get returnType;
 }
 
 class Fun extends FunctionExpression {
   final List<Parameter> params;
   final Block body;
-  @override final List<Identifier> typeParams;
-  @override final TypeRef returnType;
+  @override
+  final List<Identifier> typeParams;
+  @override
+  final TypeRef returnType;
 
   /** Whether this is a JS generator (`function*`) that may contain `yield`. */
   final bool isGenerator;
 
   final AsyncModifier asyncModifier;
 
-  Fun(this.params, this.body, {this.isGenerator: false,
+  Fun(this.params, this.body,
+      {this.isGenerator: false,
       this.asyncModifier: const AsyncModifier.sync(),
-      this.typeParams, this.returnType});
+      this.typeParams,
+      this.returnType});
 
   accept(NodeVisitor visitor) => visitor.visitFun(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Parameter param in params) param.accept(visitor);
     body.accept(visitor);
   }
 
   Fun _clone() => new Fun(params, body,
       isGenerator: isGenerator, asyncModifier: asyncModifier);
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 }
 
 class ArrowFun extends FunctionExpression {
   final List<Parameter> params;
   final body; // Expression or Block
-  @override final List<Identifier> typeParams;
-  @override final TypeRef returnType;
+  @override
+  final List<Identifier> typeParams;
+  @override
+  final TypeRef returnType;
 
   ArrowFun(this.params, this.body, {this.typeParams, this.returnType});
 
   accept(NodeVisitor visitor) => visitor.visitArrowFun(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Parameter param in params) param.accept(visitor);
     body.accept(visitor);
   }
 
@@ skipping 93 matching lines @@
   LiteralString(this.value);
 
   /// Gets the value inside the string without the beginning and end quotes.
   String get valueWithoutQuotes => value.substring(1, value.length - 1);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralString(this);
   LiteralString _clone() => new LiteralString(value);
 }
 
 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);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralNumber(this);
   LiteralNumber _clone() => new LiteralNumber(value);
 
   /**
    * Use a different precedence level depending on whether the value contains a
    * dot to ensure we generate `(1).toString()` and `1.0.toString()`.
    */
@@ skipping 154 matching lines @@
 
   accept(NodeVisitor visitor) => visitor.visitClassDeclaration(this);
   visitChildren(NodeVisitor visitor) => classExpr.accept(visitor);
   ClassDeclaration _clone() => new ClassDeclaration(classExpr);
 }
 
 class ClassExpression extends Expression {
   final Identifier name;
   final Expression heritage; // Can be null.
   final List<Method> methods;
+
   /// Type parameters of this class, if any. `null` otherwise.
   // TODO(ochafik): Support type bounds.
   final List<Identifier> typeParams;
+
   /// Field declarations of this class (TypeScript / ES6_TYPED).
   final List<VariableDeclarationList> fields;
 
   ClassExpression(this.name, this.heritage, this.methods,
       {this.typeParams, this.fields});
 
   accept(NodeVisitor visitor) => visitor.visitClassExpression(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     if (heritage != null) heritage.accept(visitor);
     for (Method element in methods) element.accept(visitor);
     if (fields != null) {
       for (var field in fields) {
         field.accept(visitor);
       }
     }
     if (typeParams != null) {
       for (var typeParam in typeParams) {
         typeParam.accept(visitor);
       }
     }
   }
 
-  ClassExpression _clone() => new ClassExpression(
-      name, heritage, methods, typeParams: typeParams, fields: fields);
+  ClassExpression _clone() => new ClassExpression(name, heritage, methods,
+      typeParams: typeParams, fields: fields);
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 }
 
 class Method extends Property {
   final bool isGetter;
   final bool isSetter;
   final bool isStatic;
 
   Method(Expression name, Fun function,
@@ skipping 25 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 Identifier {
   final nameOrPosition;
   TypeRef get type => null;
 
-  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);
 }
 
 // TODO(jmesserly): generalize this to InterpolatedProperty?
-class InterpolatedMethod extends Expression with InterpolatedNode
+class InterpolatedMethod extends Expression
+    with InterpolatedNode
     implements Method {
   final nameOrPosition;
 
   InterpolatedMethod(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedMethod(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedMethod _clone() => new InterpolatedMethod(nameOrPosition);
 
   int get precedenceLevel => PRIMARY;
   Expression get name => _unsupported;
   Expression get value => _unsupported;
   bool get isGetter => _unsupported;
   bool get isSetter => _unsupported;
   bool get isStatic => _unsupported;
   Fun get function => _unsupported;
   get _unsupported => throw '$runtimeType does not support this member.';
 }
 
-class InterpolatedIdentifier extends Expression with InterpolatedNode
+class InterpolatedIdentifier extends Expression
+    with InterpolatedNode
     implements Identifier {
   final nameOrPosition;
   TypeRef get type => null;
 
   InterpolatedIdentifier(this.nameOrPosition);
 
-  accept(NodeVisitor visitor) =>
-      visitor.visitInterpolatedIdentifier(this);
+  accept(NodeVisitor visitor) => visitor.visitInterpolatedIdentifier(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedIdentifier _clone() => new InterpolatedIdentifier(nameOrPosition);
 
   int get precedenceLevel => PRIMARY;
   String get name => throw '$runtimeType does not support this member.';
   bool get allowRename => false;
 }
 
 /**
  * [RegExpLiteral]s, despite being called "Literal", do not inherit from
@@ skipping 83 matching lines @@
 
   ImportDeclaration({this.defaultBinding, this.namedImports, this.from}) {
     assert(from != null);
   }
 
   /** The `import "name.js"` form of import */
   ImportDeclaration.all(LiteralString module) : this(from: module);
 
   /** If this import has `* as name` returns the name, otherwise null. */
   Identifier get importStarAs {
-    if (namedImports != null && namedImports.length == 1 &&
+    if (namedImports != null &&
+        namedImports.length == 1 &&
         namedImports[0].isStar) {
       return namedImports[0].asName;
     }
     return null;
   }
 
   accept(NodeVisitor visitor) => visitor.visitImportDeclaration(this);
   void visitChildren(NodeVisitor visitor) {
     if (namedImports != null) {
       for (NameSpecifier name in namedImports) name.accept(visitor);
     }
     from.accept(visitor);
   }
+
   ImportDeclaration _clone() => new ImportDeclaration(
       defaultBinding: defaultBinding, namedImports: namedImports, from: from);
 }
 
 class ExportDeclaration extends ModuleItem {
   /**
    * Exports a name from this module.
    *
    * This can be a [ClassDeclaration] or [FunctionDeclaration].
    * If [isDefault] is true, it can also be an [Expression].
    * Otherwise it can be a [VariableDeclarationList] or an [ExportClause].
    */
   final Node exported;
 
   /** True if this is an `export default`. */
   final bool isDefault;
 
   ExportDeclaration(this.exported, {this.isDefault: false}) {
     assert(exported is ClassDeclaration ||
-        exported is FunctionDeclaration ||
-        isDefault
-            ? exported is Expression
-            : exported is VariableDeclarationList ||
-              exported is ExportClause);
+            exported is FunctionDeclaration ||
+            isDefault
+        ? exported is Expression
+        : exported is VariableDeclarationList || exported is ExportClause);
   }
 
   /// Gets the list of names exported by this export declaration, or `null`
   /// if this is an `export *`.
   ///
   /// This can be useful for lowering to other module formats.
   List<Identifier> get exportedNames {
     if (isDefault) return [new Identifier('default')];
 
     var exported = this.exported;
@@ skipping 26 matching lines @@
       : this([new NameSpecifier.star()], from: from);
 
   /** True if this is an `export *`. */
   bool get exportStar => exports.length == 1 && exports[0].isStar;
 
   accept(NodeVisitor visitor) => visitor.visitExportClause(this);
   void visitChildren(NodeVisitor visitor) {
     for (NameSpecifier name in exports) name.accept(visitor);
     if (from != null) from.accept(visitor);
   }
+
   ExportClause _clone() => new ExportClause(exports, from: from);
 }
 
 /** An import or export specifier. */
 class NameSpecifier extends Node {
   final Identifier name;
   final Identifier asName; // Can be null.
 
   NameSpecifier(this.name, {this.asName});
   NameSpecifier.star() : this(null);
@@ skipping 13 matching lines @@
   // We use this because some ES5 desugarings require it.
   final String name;
 
   final List<ModuleItem> body;
   Module(this.body, {this.name});
 
   accept(NodeVisitor visitor) => visitor.visitModule(this);
   void visitChildren(NodeVisitor visitor) {
     for (ModuleItem item in body) item.accept(visitor);
   }
+
   Module _clone() => new Module(body);
 }