Format all dart dev compiler files

pkg/dev_compiler/lib/src/js_ast/printer.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;
 
-
 class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
   final bool minifyLocalVariables;
   final bool preferSemicolonToNewlineInMinifiedOutput;
   final bool emitTypes;
   final bool allowSingleLineIfStatements;
 
   /// True to allow keywords in properties, such as `obj.var` or `obj.function`
   /// Modern JS engines support this.
   final bool allowKeywordsInProperties;
 
   JavaScriptPrintingOptions(
       {this.shouldCompressOutput: false,
-       this.minifyLocalVariables: false,
-       this.preferSemicolonToNewlineInMinifiedOutput: false,
-       this.emitTypes: false,
-       this.allowKeywordsInProperties: false,
-       this.allowSingleLineIfStatements: false});
+      this.minifyLocalVariables: false,
+      this.preferSemicolonToNewlineInMinifiedOutput: false,
+      this.emitTypes: false,
+      this.allowKeywordsInProperties: false,
+      this.allowSingleLineIfStatements: false});
 }
 
-
 /// An environment in which JavaScript printing is done.  Provides emitting of
 /// text and pre- and post-visit callbacks.
 abstract class JavaScriptPrintingContext {
   /// Signals an error.  This should happen only for serious internal errors.
-  void error(String message) { throw message; }
+  void error(String message) {
+    throw message;
+  }
 
   /// Adds [string] to the output.
   void emit(String string);
 
   /// Callback immediately before printing [node].  Whitespace may be printed
   /// after this callback before the first non-whitespace character for [node].
   void enterNode(Node node) {}
+
   /// Callback after printing the last character representing [node].
   void exitNode(Node node) {}
 }
 
 /// A simple implementation of [JavaScriptPrintingContext] suitable for tests.
 class SimpleJavaScriptPrintingContext extends JavaScriptPrintingContext {
   final StringBuffer buffer = new StringBuffer();
 
   void emit(String string) {
     buffer.write(string);
@@ skipping 14 matching lines @@
   bool inForInit = false;
   bool atStatementBegin = false;
   bool inNewTarget = false;
   bool pendingSemicolon = false;
   bool pendingSpace = false;
 
   // The current indentation level.
   int _indentLevel = 0;
   // A cache of all indentation strings used so far.
   List<String> _indentList = <String>[""];
+
   /// Whether the next call to [indent] should just be a no-op.
   bool _skipNextIndent = false;
 
   static final identifierCharacterRegExp = new RegExp(r'^[a-zA-Z_0-9$]');
   static final expressionContinuationRegExp = new RegExp(r'^[-+([]');
 
-  Printer(JavaScriptPrintingOptions options,
-          JavaScriptPrintingContext context,
-          {LocalNamer localNamer})
+  Printer(JavaScriptPrintingOptions options, JavaScriptPrintingContext context,
+      {LocalNamer localNamer})
       : options = options,
         context = context,
         shouldCompressOutput = options.shouldCompressOutput,
         danglingElseVisitor = new DanglingElseVisitor(context),
         localNamer = determineRenamer(localNamer, options);
 
-  static LocalNamer determineRenamer(LocalNamer localNamer,
-                                     JavaScriptPrintingOptions options) {
+  static LocalNamer determineRenamer(
+      LocalNamer localNamer, JavaScriptPrintingOptions options) {
     if (localNamer != null) return localNamer;
     return (options.shouldCompressOutput && options.minifyLocalVariables)
-        ? new MinifyRenamer() : new IdentityNamer();
+        ? new MinifyRenamer()
+        : new IdentityNamer();
   }
 
-
   // The current indentation string.
   String get indentation {
     // Lazily add new indentation strings as required.
     while (_indentList.length <= _indentLevel) {
       _indentList.add(_indentList.last + "  ");
     }
     return _indentList[_indentLevel];
   }
 
   void indentMore() {
     _indentLevel++;
   }
 
   void indentLess() {
     _indentLevel--;
   }
 
-
   /// Always emit a newline, even under `enableMinification`.
   void forceLine() {
     out("\n");
   }
+
   /// Emits a newline for readability.
   void lineOut() {
     if (!shouldCompressOutput) forceLine();
   }
+
   void spaceOut() {
     if (!shouldCompressOutput) out(" ");
   }
 
   String lastAddedString = null;
   int get lastCharCode {
     if (lastAddedString == null) return 0;
     assert(lastAddedString.length != "");
     return lastAddedString.codeUnitAt(lastAddedString.length - 1);
   }
@@ skipping 41 matching lines @@
 
   void outSemicolonLn() {
     if (shouldCompressOutput) {
       pendingSemicolon = true;
     } else {
       out(";");
       forceLine();
     }
   }
 
-  void outIndent(String str) { indent(); out(str); }
-  void outIndentLn(String str) { indent(); outLn(str); }
+  void outIndent(String str) {
+    indent();
+    out(str);
+  }
+
+  void outIndentLn(String str) {
+    indent();
+    outLn(str);
+  }
 
   void skipNextIndent() {
     _skipNextIndent = true;
   }
 
   void indent() {
     if (_skipNextIndent) {
       _skipNextIndent = false;
       return;
     }
     if (!shouldCompressOutput) {
       out(indentation);
     }
   }
 
   visit(Node node) {
     context.enterNode(node);
     node.accept(this);
     context.exitNode(node);
   }
 
   visitCommaSeparated(List<Node> nodes, int hasRequiredType,
-                      {bool newInForInit, bool newAtStatementBegin}) {
+      {bool newInForInit, bool newAtStatementBegin}) {
     for (int i = 0; i < nodes.length; i++) {
       if (i != 0) {
         atStatementBegin = false;
         out(",");
         spaceOut();
       }
       visitNestedExpression(nodes[i], hasRequiredType,
-                            newInForInit: newInForInit,
-                            newAtStatementBegin: newAtStatementBegin);
+          newInForInit: newInForInit, newAtStatementBegin: newAtStatementBegin);
     }
   }
 
   visitAll(List<Node> nodes) {
     nodes.forEach(visit);
   }
 
   visitProgram(Program program) {
     if (program.scriptTag != null) {
       out('#!${program.scriptTag}\n');
@@ skipping 46 matching lines @@
   }
 
   visitBlock(Block block) {
     blockOut(block, true, true);
   }
 
   visitExpressionStatement(ExpressionStatement expressionStatement) {
     indent();
     outClosureAnnotation(expressionStatement);
     visitNestedExpression(expressionStatement.expression, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: true);
+        newInForInit: false, newAtStatementBegin: true);
     outSemicolonLn();
   }
 
   visitEmptyStatement(EmptyStatement nop) {
     outIndentLn(";");
   }
 
   void ifOut(If node, bool shouldIndent) {
     Node then = node.then;
     Node elsePart = node.otherwise;
     bool hasElse = node.hasElse;
 
     // Handle dangling elses and a work-around for Android 4.0 stock browser.
     // Android 4.0 requires braces for a single do-while in the `then` branch.
     // See issue 10923.
     if (hasElse) {
       bool needsBraces = node.then.accept(danglingElseVisitor) || then is Do;
       if (needsBraces) {
         then = new Block(<Statement>[then]);
       }
     }
     if (shouldIndent) indent();
     out("if");
     spaceOut();
     out("(");
     visitNestedExpression(node.condition, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     bool thenWasBlock;
     if (options.allowSingleLineIfStatements && !hasElse && then is! Block) {
       thenWasBlock = false;
       spaceOut();
       skipNextIndent();
       visit(then);
     } else {
       thenWasBlock =
           blockBody(then, needsSeparation: false, needsNewline: !hasElse);
@@ skipping 17 matching lines @@
   visitIf(If node) {
     ifOut(node, true);
   }
 
   visitFor(For loop) {
     outIndent("for");
     spaceOut();
     out("(");
     if (loop.init != null) {
       visitNestedExpression(loop.init, EXPRESSION,
-                            newInForInit: true, newAtStatementBegin: false);
+          newInForInit: true, newAtStatementBegin: false);
     }
     out(";");
     if (loop.condition != null) {
       spaceOut();
       visitNestedExpression(loop.condition, EXPRESSION,
-                            newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
     }
     out(";");
     if (loop.update != null) {
       spaceOut();
       visitNestedExpression(loop.update, EXPRESSION,
-                            newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
     blockBody(loop.body, needsSeparation: false, needsNewline: true);
   }
 
   visitForIn(ForIn loop) {
     outIndent("for");
     spaceOut();
     out("(");
     visitNestedExpression(loop.leftHandSide, EXPRESSION,
-                          newInForInit: true, newAtStatementBegin: false);
+        newInForInit: true, newAtStatementBegin: false);
     out(" in");
     pendingSpace = true;
     visitNestedExpression(loop.object, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     blockBody(loop.body, needsSeparation: false, needsNewline: true);
   }
 
   visitForOf(ForOf loop) {
     outIndent("for");
     spaceOut();
     out("(");
     visitNestedExpression(loop.leftHandSide, EXPRESSION,
-    newInForInit: true, newAtStatementBegin: false);
+        newInForInit: true, newAtStatementBegin: false);
     out(" of");
     pendingSpace = true;
     visitNestedExpression(loop.iterable, EXPRESSION,
-    newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     blockBody(loop.body, needsSeparation: false, needsNewline: true);
   }
 
   visitWhile(While loop) {
     outIndent("while");
     spaceOut();
     out("(");
     visitNestedExpression(loop.condition, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     blockBody(loop.body, needsSeparation: false, needsNewline: true);
   }
 
   visitDo(Do loop) {
     outIndent("do");
     if (blockBody(loop.body, needsSeparation: true, needsNewline: false)) {
       spaceOut();
     } else {
       indent();
     }
     out("while");
     spaceOut();
     out("(");
     visitNestedExpression(loop.condition, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     outSemicolonLn();
   }
 
   visitContinue(Continue node) {
     if (node.targetLabel == null) {
       outIndent("continue");
     } else {
       outIndent("continue ${node.targetLabel}");
     }
     outSemicolonLn();
   }
 
   visitBreak(Break node) {
     if (node.targetLabel == null) {
       outIndent("break");
     } else {
       outIndent("break ${node.targetLabel}");
     }
     outSemicolonLn();
   }
 
   visitReturn(Return node) {
     if (node.value == null) {
       outIndent("return");
     } else {
       outIndent("return");
       pendingSpace = true;
       visitNestedExpression(node.value, EXPRESSION,
-                            newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
     }
     outSemicolonLn();
   }
 
   visitDartYield(DartYield node) {
     if (node.hasStar) {
       outIndent("yield*");
     } else {
       outIndent("yield");
     }
     pendingSpace = true;
     visitNestedExpression(node.expression, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     outSemicolonLn();
   }
 
-
   visitThrow(Throw node) {
     outIndent("throw");
     pendingSpace = true;
     visitNestedExpression(node.expression, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     outSemicolonLn();
   }
 
   visitTry(Try node) {
     outIndent("try");
     blockBody(node.body, needsSeparation: true, needsNewline: false);
     if (node.catchPart != null) {
       visit(node.catchPart);
     }
     if (node.finallyPart != null) {
       spaceOut();
       out("finally");
       blockBody(node.finallyPart, needsSeparation: true, needsNewline: true);
     } else {
       lineOut();
     }
   }
 
   visitCatch(Catch node) {
     spaceOut();
     out("catch");
     spaceOut();
     out("(");
     visitNestedExpression(node.declaration, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     blockBody(node.body, needsSeparation: false, needsNewline: true);
   }
 
   visitSwitch(Switch node) {
     outIndent("switch");
     spaceOut();
     out("(");
     visitNestedExpression(node.key, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
     spaceOut();
     outLn("{");
     indentMore();
     visitAll(node.cases);
     indentLess();
     outIndentLn("}");
   }
 
   visitCase(Case node) {
     outIndent("case");
     pendingSpace = true;
     visitNestedExpression(node.expression, EXPRESSION,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     outLn(":");
     if (!node.body.statements.isEmpty) {
       blockOut(node.body, true, true);
     }
   }
 
   visitDefault(Default node) {
     outIndentLn("default:");
     if (!node.body.statements.isEmpty) {
       blockOut(node.body, true, true);
     }
   }
 
   visitLabeledStatement(LabeledStatement node) {
     outIndent("${node.label}:");
     blockBody(node.body, needsSeparation: false, needsNewline: true);
   }
 
   void functionOut(Fun fun, Node name) {
     out("function");
     if (fun.isGenerator) out("*");
     if (name != null) {
       out(" ");
       // Name must be a [Decl]. Therefore only test for primary expressions.
       visitNestedExpression(name, PRIMARY,
-                            newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
     }
     localNamer.enterScope(fun);
     outTypeParams(fun.typeParams);
     out("(");
     if (fun.params != null) {
       visitCommaSeparated(fun.params, PRIMARY,
-                          newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
     outTypeAnnotation(fun.returnType);
     switch (fun.asyncModifier) {
       case const AsyncModifier.sync():
         break;
       case const AsyncModifier.async():
         out(' async');
         break;
       case const AsyncModifier.syncStar():
         out(' sync*');
         break;
       case const AsyncModifier.asyncStar():
         out(' async*');
         break;
     }
     blockBody(fun.body, needsSeparation: false, needsNewline: false);
     localNamer.leaveScope();
   }
 
   visitFunctionDeclaration(FunctionDeclaration declaration) {
     indent();
     outClosureAnnotation(declaration);
     functionOut(declaration.function, declaration.name);
     lineOut();
   }
 
   visitNestedExpression(Expression node, int requiredPrecedence,
-                        {bool newInForInit, bool newAtStatementBegin}) {
+      {bool newInForInit, bool newAtStatementBegin}) {
     int nodePrecedence = node.precedenceLevel;
     bool needsParentheses =
         // a - (b + c).
         (requiredPrecedence != EXPRESSION &&
-         nodePrecedence < requiredPrecedence) ||
-        // for (a = (x in o); ... ; ... ) { ... }
-        (newInForInit && node is Binary && node.op == "in") ||
-        // (function() { ... })().
-        // ({a: 2, b: 3}.toString()).
-        (newAtStatementBegin && (node is NamedFunction ||
-                                 node is FunctionExpression ||
-                                 node is ObjectInitializer));
+                nodePrecedence < requiredPrecedence) ||
+            // for (a = (x in o); ... ; ... ) { ... }
+            (newInForInit && node is Binary && node.op == "in") ||
+            // (function() { ... })().
+            // ({a: 2, b: 3}.toString()).
+            (newAtStatementBegin &&
+                (node is NamedFunction ||
+                    node is FunctionExpression ||
+                    node is ObjectInitializer));
     if (needsParentheses) {
       inForInit = false;
       atStatementBegin = false;
       inNewTarget = false;
       out("(");
       visit(node);
       out(")");
     } else {
       inForInit = newInForInit;
       atStatementBegin = newAtStatementBegin;
       visit(node);
     }
   }
 
   visitVariableDeclarationList(VariableDeclarationList list) {
     outClosureAnnotation(list);
     // Note: keyword can be null for non-static field declarations.
     if (list.keyword != null) {
       out(list.keyword);
       out(" ");
     }
     visitCommaSeparated(list.declarations, ASSIGNMENT,
-                        newInForInit: inForInit, newAtStatementBegin: false);
+        newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitArrayBindingPattern(ArrayBindingPattern node) {
     out("[");
     visitCommaSeparated(node.variables, EXPRESSION,
-                        newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out("]");
   }
+
   visitObjectBindingPattern(ObjectBindingPattern node) {
     out("{");
     visitCommaSeparated(node.variables, EXPRESSION,
-                        newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out("}");
   }
 
   visitDestructuredVariable(DestructuredVariable node) {
     var name = node.name;
     var hasName = name != null;
     if (hasName) {
       if (name is LiteralString) {
         out("[");
         out(name.value);
         out("]");
       } else {
         visit(name);
       }
     }
     if (node.structure != null) {
       if (hasName) {
         out(":");
         spaceOut();
       }
       visit(node.structure);
     }
     outTypeAnnotation(node.type);
     if (node.defaultValue != null) {
       spaceOut();
       out("=");
       spaceOut();
       visitNestedExpression(node.defaultValue, EXPRESSION,
-                            newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
     }
   }
 
   visitSimpleBindingPattern(SimpleBindingPattern node) {
     visit(node.name);
   }
 
   visitAssignment(Assignment assignment) {
     visitNestedExpression(assignment.leftHandSide, LEFT_HAND_SIDE,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: atStatementBegin);
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
     if (assignment.value != null) {
       spaceOut();
       String op = assignment.op;
       if (op != null) out(op);
       out("=");
       spaceOut();
       visitNestedExpression(assignment.value, ASSIGNMENT,
-                            newInForInit: inForInit,
-                            newAtStatementBegin: false);
+          newInForInit: inForInit, newAtStatementBegin: false);
     }
   }
 
   visitVariableInitialization(VariableInitialization initialization) {
     outClosureAnnotation(initialization);
     visitAssignment(initialization);
   }
 
   visitConditional(Conditional cond) {
     visitNestedExpression(cond.condition, LOGICAL_OR,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: atStatementBegin);
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
     spaceOut();
     out("?");
     spaceOut();
     // The then part is allowed to have an 'in'.
     visitNestedExpression(cond.then, ASSIGNMENT,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     spaceOut();
     out(":");
     spaceOut();
     visitNestedExpression(cond.otherwise, ASSIGNMENT,
-                          newInForInit: inForInit, newAtStatementBegin: false);
+        newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitNew(New node) {
     out("new ");
     inNewTarget = true;
     visitNestedExpression(node.target, ACCESS,
-                          newInForInit: inForInit, newAtStatementBegin: false);
+        newInForInit: inForInit, newAtStatementBegin: false);
     inNewTarget = false;
     out("(");
     visitCommaSeparated(node.arguments, SPREAD,
-                        newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
   }
 
   visitCall(Call call) {
     visitNestedExpression(call.target, LEFT_HAND_SIDE,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: atStatementBegin);
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
     out("(");
     visitCommaSeparated(call.arguments, SPREAD,
-                        newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
     out(")");
   }
 
   visitBinary(Binary binary) {
     Expression left = binary.left;
     Expression right = binary.right;
     String op = binary.op;
     int leftPrecedenceRequirement;
     int rightPrecedenceRequirement;
-    bool leftSpace = true;   // left<HERE>op right
+    bool leftSpace = true; // left<HERE>op right
     switch (op) {
       case ',':
         //  x, (y, z) <=> (x, y), z.
         leftPrecedenceRequirement = EXPRESSION;
         rightPrecedenceRequirement = EXPRESSION;
         leftSpace = false;
         break;
       case "||":
         leftPrecedenceRequirement = LOGICAL_OR;
         // x || (y || z) <=> (x || y) || z.
@@ skipping 56 matching lines @@
       case "%":
         leftPrecedenceRequirement = MULTIPLICATIVE;
         // We cannot remove parenthesis for "*" because of precision issues.
         rightPrecedenceRequirement = UNARY;
         break;
       default:
         context.error("Forgot operator: $op");
     }
 
     visitNestedExpression(left, leftPrecedenceRequirement,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: atStatementBegin);
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
 
     if (op == "in" || op == "instanceof") {
       // There are cases where the space is not required but without further
       // analysis we cannot know.
       out(" ");
       out(op);
       out(" ");
     } else {
       if (leftSpace) spaceOut();
       out(op);
       spaceOut();
     }
     visitNestedExpression(right, rightPrecedenceRequirement,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: false);
+        newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitPrefix(Prefix unary) {
     String op = unary.op;
     switch (op) {
       case "delete":
       case "void":
       case "typeof":
         // There are cases where the space is not required but without further
         // analysis we cannot know.
         out(op);
         out(" ");
         break;
       case "+":
       case "++":
         if (lastCharCode == charCodes.$PLUS) out(" ");
         out(op);
         break;
       case "-":
       case "--":
         if (lastCharCode == charCodes.$MINUS) out(" ");
         out(op);
         break;
       default:
         out(op);
     }
     visitNestedExpression(unary.argument, unary.precedenceLevel,
-                          newInForInit: inForInit, newAtStatementBegin: false);
+        newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitSpread(Spread unary) => visitPrefix(unary);
 
   visitYield(Yield yield) {
     out(yield.star ? "yield*" : "yield");
     if (yield.value == null) return;
     out(" ");
     visitNestedExpression(yield.value, yield.precedenceLevel,
         newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitPostfix(Postfix postfix) {
     visitNestedExpression(postfix.argument, LEFT_HAND_SIDE,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: atStatementBegin);
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
     out(postfix.op);
   }
 
   visitThis(This node) {
     out("this");
   }
 
   visitSuper(Super node) {
     out("super");
   }
@@ skipping 12 matching lines @@
     return charCodes.$0 <= charCode && charCode <= charCodes.$9;
   }
 
   bool isValidJavaScriptId(String field) {
     if (field.length < 3) return false;
     // Ignore the leading and trailing string-delimiter.
     for (int i = 1; i < field.length - 1; i++) {
       // TODO(floitsch): allow more characters.
       int charCode = field.codeUnitAt(i);
       if (!(charCodes.$a <= charCode && charCode <= charCodes.$z ||
-            charCodes.$A <= charCode && charCode <= charCodes.$Z ||
-            charCode == charCodes.$$ ||
-            charCode == charCodes.$_ ||
-            i != 1 && isDigit(charCode))) {
+          charCodes.$A <= charCode && charCode <= charCodes.$Z ||
+          charCode == charCodes.$$ ||
+          charCode == charCodes.$_ ||
+          i != 1 && isDigit(charCode))) {
         return false;
       }
     }
 
     // TODO(floitsch): normally we should also check that the field is not a
     // reserved word.  We don't generate fields with reserved word names except
     // for 'super'.
     return options.allowKeywordsInProperties || field != '"super"';
   }
 
   visitAccess(PropertyAccess access) {
     // Normally we can omit parens on the receiver if it is a Call, even though
     // Call expressions have lower precedence. However this optimization doesn't
     // work inside New expressions:
     //
     //     new obj.foo().bar()
     //
     // This will be parsed as:
     //
     //     (new obj.foo()).bar()
     //
     // Which is incorrect. So we must have parenthesis in this case:
     //
     //     new (obj.foo()).bar()
     //
     int precedence = inNewTarget ? ACCESS : CALL;
 
     visitNestedExpression(access.receiver, precedence,
-                          newInForInit: inForInit,
-                          newAtStatementBegin: atStatementBegin);
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
     propertyNameOut(access.selector, inAccess: true);
   }
 
   visitNamedFunction(NamedFunction namedFunction) {
     functionOut(namedFunction.function, namedFunction.name);
   }
 
   visitFun(Fun fun) {
     functionOut(fun, null);
   }
@@ skipping 64 matching lines @@
         // and [1,,] (array with 1 and a hole) would become [1,] = [1].
         out(",");
         continue;
       }
       if (i != 0 && !multiline) spaceOut();
       if (multiline) {
         forceLine();
         indent();
       }
       visitNestedExpression(element, ASSIGNMENT,
-                            newInForInit: false, newAtStatementBegin: false);
+          newInForInit: false, newAtStatementBegin: false);
       // We can skip the trailing "," for the last element (since it's not
       // an array hole).
       if (i != elements.length - 1) out(",");
     }
     indentLess();
     if (multiline) {
       lineOut();
       indent();
     }
     out("]");
@@ skipping 26 matching lines @@
       indent();
     }
     out("}");
   }
 
   visitProperty(Property node) {
     propertyNameOut(node.name);
     out(":");
     spaceOut();
     visitNestedExpression(node.value, ASSIGNMENT,
-                          newInForInit: false, newAtStatementBegin: false);
+        newInForInit: false, newAtStatementBegin: false);
   }
 
   visitRegExpLiteral(RegExpLiteral node) {
     out(node.pattern);
   }
 
   visitTemplateString(TemplateString node) {
     out('`');
     for (var element in node.elements) {
       if (element is String) {
@@ skipping 101 matching lines @@
     if (node != null && node.closureAnnotation != null) {
       String comment = node.closureAnnotation.toString(indentation);
       if (comment.isNotEmpty) {
         out(comment);
         lineOut();
         indent();
       }
     }
   }
 
-  void propertyNameOut(Expression node, {bool inMethod: false,
-      bool inAccess: false}) {
-
+  void propertyNameOut(Expression node,
+      {bool inMethod: false, bool inAccess: false}) {
     if (node is LiteralNumber) {
       LiteralNumber nameNumber = node;
       if (inAccess) out('[');
       out(nameNumber.value);
       if (inAccess) out(']');
     } else {
       if (node is LiteralString) {
         if (isValidJavaScriptId(node.value)) {
           if (inAccess) out('.');
           out(node.valueWithoutQuotes);
         } else {
           if (inMethod || inAccess) out("[");
           out(node.value);
           if (inMethod || inAccess) out("]");
         }
       } else {
         // ComputedPropertyName
         out("[");
         visitNestedExpression(node, EXPRESSION,
-                              newInForInit: false, newAtStatementBegin: false);
+            newInForInit: false, newAtStatementBegin: false);
         out("]");
       }
     }
   }
 
   visitImportDeclaration(ImportDeclaration node) {
     indent();
     out('import ');
     if (node.defaultBinding != null) {
       visit(node.defaultBinding);
@@ skipping 168 matching lines @@
   }
 }
 
 // Collects all the var declarations in the function.  We need to do this in a
 // separate pass because JS vars are lifted to the top of the function.
 class VarCollector extends BaseVisitor {
   bool nested;
   final Set<String> vars;
   final Set<String> params;
 
-  VarCollector() : nested = false,
-                   vars = new Set<String>(),
-                   params = new Set<String>();
+  VarCollector()
+      : nested = false,
+        vars = new Set<String>(),
+        params = new Set<String>();
 
   void forEachVar(void fn(String v)) => vars.forEach(fn);
   void forEachParam(void fn(String p)) => params.forEach(fn);
 
   void collectVarsInFunction(FunctionExpression fun) {
     if (!nested) {
       nested = true;
       if (fun.params != null) {
         for (var param in fun.params) {
           // TODO(jmesserly): add ES6 support. Currently not needed because
@@ skipping 42 matching lines @@
   void visitVariableInitialization(VariableInitialization node) {
     declareVariable(node.declaration);
     if (node.value != null) node.value.accept(this);
   }
 
   void declareVariable(Identifier decl) {
     if (decl.allowRename) vars.add(decl.name);
   }
 }
 
-
 /**
  * Returns true, if the given node must be wrapped into braces when used
  * as then-statement in an [If] that has an else branch.
  */
 class DanglingElseVisitor extends BaseVisitor<bool> {
   JavaScriptPrintingContext context;
 
   DanglingElseVisitor(this.context);
 
   bool visitProgram(Program node) => false;
 
   bool visitNode(Node node) {
     context.error("Forgot node: $node");
     return null;
   }
 
   bool visitBlock(Block node) => false;
   bool visitExpressionStatement(ExpressionStatement node) => false;
   bool visitEmptyStatement(EmptyStatement node) => false;
   bool visitIf(If node) {
     if (!node.hasElse) return true;
     return node.otherwise.accept(this);
   }
+
   bool visitFor(For node) => node.body.accept(this);
   bool visitForIn(ForIn node) => node.body.accept(this);
   bool visitForOf(ForOf node) => node.body.accept(this);
   bool visitWhile(While node) => node.body.accept(this);
   bool visitDo(Do node) => false;
   bool visitContinue(Continue node) => false;
   bool visitBreak(Break node) => false;
   bool visitReturn(Return node) => false;
   bool visitThrow(Throw node) => false;
   bool visitTry(Try node) {
     if (node.finallyPart != null) {
       return node.finallyPart.accept(this);
     } else {
       return node.catchPart.accept(this);
     }
   }
+
   bool visitCatch(Catch node) => node.body.accept(this);
   bool visitSwitch(Switch node) => false;
   bool visitCase(Case node) => false;
   bool visitDefault(Default node) => false;
   bool visitFunctionDeclaration(FunctionDeclaration node) => false;
-  bool visitLabeledStatement(LabeledStatement node)
-      => node.body.accept(this);
+  bool visitLabeledStatement(LabeledStatement node) => node.body.accept(this);
   bool visitLiteralStatement(LiteralStatement node) => true;
   bool visitClassDeclaration(ClassDeclaration node) => false;
 
   bool visitExpression(Expression node) => false;
 }
 
-
 abstract class LocalNamer {
   String getName(Identifier node);
   void enterScope(FunctionExpression node);
   void leaveScope();
 }
 
-
 class IdentityNamer implements LocalNamer {
   String getName(Identifier node) => node.name;
   void enterScope(FunctionExpression node) {}
   void leaveScope() {}
 }
 
-
 class MinifyRenamer implements LocalNamer {
   final List<Map<String, String>> maps = [];
   final List<int> parameterNumberStack = [];
   final List<int> variableNumberStack = [];
   int parameterNumber = 0;
   int variableNumber = 0;
 
   void enterScope(FunctionExpression node) {
     var vars = new VarCollector();
     node.accept(vars);
@@ skipping 19 matching lines @@
       if (replacement != null) return replacement;
     }
     return oldName;
   }
 
   static const LOWER_CASE_LETTERS = 26;
   static const LETTERS = LOWER_CASE_LETTERS;
   static const DIGITS = 10;
 
   static int nthLetter(int n) {
-    return (n < LOWER_CASE_LETTERS) ?
-           charCodes.$a + n :
-           charCodes.$A + n - LOWER_CASE_LETTERS;
+    return (n < LOWER_CASE_LETTERS)
+        ? charCodes.$a + n
+        : charCodes.$A + n - LOWER_CASE_LETTERS;
   }
 
   // Parameters go from a to z and variables go from z to a.  This makes each
   // argument list and each top-of-function var declaration look similar and
   // helps gzip compress the file.  If we have more than 26 arguments and
   // variables then we meet somewhere in the middle of the alphabet.  After
   // that we give up trying to be nice to the compression algorithm and just
   // use the same namespace for arguments and variables, starting with A, and
   // moving on to a0, a1, etc.
   String declareVariable(String oldName) {
@@ skipping 71 matching lines @@
 /// [visitIdentifier] otherwise.
 abstract class VariableDeclarationVisitor<T> extends BaseVisitor<T> {
   declare(Identifier node);
 
   visitFunctionExpression(FunctionExpression node) {
     node.params.forEach(_scanVariableBinding);
     node.body.accept(this);
   }
 
   _scanVariableBinding(VariableBinding d) {
-    if (d is Identifier) declare(d);
-    else d.accept(this);
+    if (d is Identifier)
+      declare(d);
+    else
+      d.accept(this);
   }
 
   visitRestParameter(RestParameter node) {
     _scanVariableBinding(node.parameter);
     super.visitRestParameter(node);
   }
 
   visitDestructuredVariable(DestructuredVariable node) {
     var name = node.name;
     if (name is Identifier) _scanVariableBinding(name);
@@ skipping 24 matching lines @@
     declare(node.name);
     node.function.accept(this);
   }
 
   visitClassExpression(ClassExpression node) {
     declare(node.name);
     if (node.heritage != null) node.heritage.accept(this);
     for (Method element in node.methods) element.accept(this);
   }
 }