Format all dart dev compiler files

pkg/dev_compiler/lib/src/js_ast/builder.dart

 // Copyright (c) 2013, 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.
 
 // Utilities for building JS ASTs at runtime.  Contains a builder class
 // and a parser that parses part of the language.
 
 part of js_ast;
 
-
 /**
  * Global template manager.  We should aim to have a fixed number of
  * templates. This implies that we do not use js('xxx') to parse text that is
  * constructed from values that depend on names in the Dart program.
  *
  * TODO(sra): Find the remaining places where js('xxx') used to parse an
  * unbounded number of expression, or institute a cache policy.
  */
 TemplateManager templateManager = new TemplateManager();
 
-
 /**
 
 [js] is a singleton instace of JsBuilder.  JsBuilder is a set of conveniences
 for constructing JavaScript ASTs.
 
 [string] and [number] are used to create leaf AST nodes:
 
     var s = js.string('hello');    //  s = new LiteralString('"hello"')
     var n = js.number(123);        //  n = new LiteralNumber(123)
 
@@ skipping 153 matching lines @@
     should be splice or is intended as a single value.
 
  -  There are no placeholders in definition contexts:
 
         function #(){}
         var # = 1;
 
 */
 const JsBuilder js = const JsBuilder();
 
-
 class JsBuilder {
   const JsBuilder();
 
   /**
    * Parses a bit of JavaScript, and returns an expression.
    *
    * See the MiniJsParser class.
    *
    * [arguments] can be a single [Node] (e.g. an [Expression] or [Statement]) or
    * a list of [Node]s, which will be interpolated into the source at the '#'
@@ skipping 54 matching lines @@
     }
     return template;
   }
 
   /**
    * Creates an Expression template without caching the result.
    */
   Template uncachedExpressionTemplate(String source) {
     MiniJsParser parser = new MiniJsParser(source);
     Expression expression = parser.expression();
-    return new Template(
-        source, expression, isExpression: true, forceCopy: false);
+    return new Template(source, expression,
+        isExpression: true, forceCopy: false);
   }
 
   /**
    * Creates a Statement template without caching the result.
    */
   Template uncachedStatementTemplate(String source) {
     MiniJsParser parser = new MiniJsParser(source);
     Statement statement = parser.statement();
-    return new Template(
-        source, statement, isExpression: false, forceCopy: false);
+    return new Template(source, statement,
+        isExpression: false, forceCopy: false);
   }
 
   /**
    * Create an Expression template which has [ast] as the result.  This is used
    * to wrap a generated AST in a zero-argument Template so it can be passed to
    * context that expects a template.
    */
   Template expressionTemplateYielding(Node ast) {
     return new Template.withExpressionResult(ast);
   }
 
   Template statementTemplateYielding(Node ast) {
     return new Template.withStatementResult(ast);
   }
 
   /// Creates a literal js string from [value].
   LiteralString escapedString(String value, [String quote = '"']) {
-   // Start by escaping the backslashes.
+    // Start by escaping the backslashes.
     String escaped = value.replaceAll('\\', '\\\\');
 
-
     // Replace $ in template strings:
     // http://www.ecma-international.org/ecma-262/6.0/#sec-template-literal-lexical-components
     var quoteReplace = quote == '`' ? r'`$' : quote;
 
     // http://www.ecma-international.org/ecma-262/6.0/#sec-literals-string-literals
     // > All code points may appear literally in a string literal except for the
     // > closing quote code points, U+005C (REVERSE SOLIDUS),
     // > U+000D (CARRIAGE RETURN), U+2028 (LINE SEPARATOR),
     // > U+2029 (PARAGRAPH SEPARATOR), and U+000A (LINE FEED).
     var re = new RegExp('[\n\r$quoteReplace\b\f\t\v\u2028\u2029]');
     escaped = escaped.replaceAllMapped(re, (m) {
       switch (m.group(0)) {
-        case "\n" : return r"\n";
-        case "\r" : return r"\r";
-        case "\u2028": return r"\u2028";
-        case "\u2029": return r"\u2029";
+        case "\n":
+          return r"\n";
+        case "\r":
+          return r"\r";
+        case "\u2028":
+          return r"\u2028";
+        case "\u2029":
+          return r"\u2029";
         // Quotes and $ are only replaced if they conflict with the containing
         // quote, see regex above.
-        case '"': return r'\"';
-        case "'": return r"\'";
-        case "`": return r"\`";
-        case r"$": return r"\$";
+        case '"':
+          return r'\"';
+        case "'":
+          return r"\'";
+        case "`":
+          return r"\`";
+        case r"$":
+          return r"\$";
         // TODO(jmesserly): these don't need to be escaped for correctness,
         // but they are conventionally escaped.
-        case "\b": return r"\b";
-        case "\t": return r"\t";
-        case "\f": return r"\f";
-        case "\v": return r"\v";
+        case "\b":
+          return r"\b";
+        case "\t":
+          return r"\t";
+        case "\f":
+          return r"\f";
+        case "\v":
+          return r"\v";
       }
     });
     LiteralString result = new LiteralString('$quote$escaped$quote');
     // We don't escape quotes of a different style under the assumption that the
     // string is wrapped into quotes. Verify that assumption.
     assert(result.value.codeUnitAt(0) == quote.codeUnitAt(0));
     return result;
   }
 
   /// Creates a literal js string from [value].
@@ skipping 12 matching lines @@
   ArrayInitializer numArray(Iterable<int> list) =>
       new ArrayInitializer(list.map(number).toList());
 
   ArrayInitializer stringArray(Iterable<String> list) =>
       new ArrayInitializer(list.map(string).toList());
 
   Comment comment(String text) => new Comment(text);
   CommentExpression commentExpression(String text, Expression expression) =>
       new CommentExpression(text, expression);
 
-  Call propertyCall(Expression receiver,
-                      String fieldName,
-                      List<Expression> arguments) {
+  Call propertyCall(
+      Expression receiver, String fieldName, List<Expression> arguments) {
     return new Call(new PropertyAccess.field(receiver, fieldName), arguments);
   }
 }
 
 LiteralString string(String value) => js.string(value);
 LiteralNumber number(num value) => js.number(value);
 ArrayInitializer numArray(Iterable<int> list) => js.numArray(list);
 ArrayInitializer stringArray(Iterable<String> list) => js.stringArray(list);
-Call propertyCall(Expression receiver,
-                  String fieldName,
-                  List<Expression> arguments) {
+Call propertyCall(
+    Expression receiver, String fieldName, List<Expression> arguments) {
   return js.propertyCall(receiver, fieldName, arguments);
 }
 
 class MiniJsParserError {
-  MiniJsParserError(this.parser, this.message) { }
+  MiniJsParserError(this.parser, this.message) {}
 
   final MiniJsParser parser;
   final String message;
 
   String toString() {
     int pos = parser.lastPosition;
 
     // Discard lines following the line containing lastPosition.
     String src = parser.src;
     int newlinePos = src.indexOf('\n', pos);
@@ skipping 41 matching lines @@
         lastToken = null,
         lastPosition = 0,
         position = 0 {
     getToken();
   }
 
   int lastCategory = NONE;
   String lastToken = null;
   int lastPosition = 0;
   int position = 0;
-  bool skippedNewline = false;  // skipped newline in last getToken?
+  bool skippedNewline = false; // skipped newline in last getToken?
   final String src;
 
   final List<InterpolatedNode> interpolatedValues = <InterpolatedNode>[];
   bool get hasNamedHoles =>
       interpolatedValues.isNotEmpty && interpolatedValues.first.isNamed;
   bool get hasPositionalHoles =>
       interpolatedValues.isNotEmpty && interpolatedValues.first.isPositional;
 
   static const NONE = -1;
   static const ALPHA = 0;
@@ skipping 19 matching lines @@
   static const OTHER = 20;
 
   // Make sure that ]] is two symbols.
   // TODO(jmesserly): => and ... are not single char tokens, should we change
   // their numbers? It shouldn't matter because this is only called on values
   // from the [CATEGORIES] table.
   bool singleCharCategory(int category) => category > DOT;
 
   static String categoryToString(int cat) {
     switch (cat) {
-      case NONE: return "NONE";
-      case ALPHA: return "ALPHA";
-      case NUMERIC: return "NUMERIC";
-      case SYMBOL: return "SYMBOL";
-      case ASSIGNMENT: return "ASSIGNMENT";
-      case DOT: return "DOT";
-      case LPAREN: return "LPAREN";
-      case RPAREN: return "RPAREN";
-      case LBRACE: return "LBRACE";
-      case RBRACE: return "RBRACE";
-      case LSQUARE: return "LSQUARE";
-      case RSQUARE: return "RSQUARE";
-      case STRING: return "STRING";
-      case COMMA: return "COMMA";
-      case QUERY: return "QUERY";
-      case COLON: return "COLON";
-      case SEMICOLON: return "SEMICOLON";
-      case ARROW: return "ARROW";
-      case ELLIPSIS: return "ELLIPSIS";
-      case HASH: return "HASH";
-      case WHITESPACE: return "WHITESPACE";
-      case OTHER: return "OTHER";
+      case NONE:
+        return "NONE";
+      case ALPHA:
+        return "ALPHA";
+      case NUMERIC:
+        return "NUMERIC";
+      case SYMBOL:
+        return "SYMBOL";
+      case ASSIGNMENT:
+        return "ASSIGNMENT";
+      case DOT:
+        return "DOT";
+      case LPAREN:
+        return "LPAREN";
+      case RPAREN:
+        return "RPAREN";
+      case LBRACE:
+        return "LBRACE";
+      case RBRACE:
+        return "RBRACE";
+      case LSQUARE:
+        return "LSQUARE";
+      case RSQUARE:
+        return "RSQUARE";
+      case STRING:
+        return "STRING";
+      case COMMA:
+        return "COMMA";
+      case QUERY:
+        return "QUERY";
+      case COLON:
+        return "COLON";
+      case SEMICOLON:
+        return "SEMICOLON";
+      case ARROW:
+        return "ARROW";
+      case ELLIPSIS:
+        return "ELLIPSIS";
+      case HASH:
+        return "HASH";
+      case WHITESPACE:
+        return "WHITESPACE";
+      case OTHER:
+        return "OTHER";
     }
     return "Unknown: $cat";
   }
 
   static const CATEGORIES = const <int>[
-      OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER,       // 0-7
-      OTHER, WHITESPACE, WHITESPACE, OTHER, OTHER, WHITESPACE,      // 8-13
-      OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER,       // 14-21
-      OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER,       // 22-29
-      OTHER, OTHER, WHITESPACE,                                     // 30-32
-      SYMBOL, OTHER, HASH, ALPHA, SYMBOL, SYMBOL, OTHER,            // !"#$%&´
-      LPAREN, RPAREN, SYMBOL, SYMBOL, COMMA, SYMBOL, DOT, SYMBOL,   // ()*+,-./
-      NUMERIC, NUMERIC, NUMERIC, NUMERIC, NUMERIC,                  // 01234
-      NUMERIC, NUMERIC, NUMERIC, NUMERIC, NUMERIC,                  // 56789
-      COLON, SEMICOLON, SYMBOL, SYMBOL, SYMBOL, QUERY, OTHER,       // :;<=>?@
-      ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA,       // ABCDEFGH
-      ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA,       // IJKLMNOP
-      ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA,       // QRSTUVWX
-      ALPHA, ALPHA, LSQUARE, OTHER, RSQUARE, SYMBOL, ALPHA, OTHER,  // YZ[\]^_'
-      ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA,       // abcdefgh
-      ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA,       // ijklmnop
-      ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA,       // qrstuvwx
-      ALPHA, ALPHA, LBRACE, SYMBOL, RBRACE, SYMBOL];                // yz{|}~
+    OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, // 0-7
+    OTHER, WHITESPACE, WHITESPACE, OTHER, OTHER, WHITESPACE, // 8-13
+    OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, // 14-21
+    OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, // 22-29
+    OTHER, OTHER, WHITESPACE, // 30-32
+    SYMBOL, OTHER, HASH, ALPHA, SYMBOL, SYMBOL, OTHER, // !"#$%&´
+    LPAREN, RPAREN, SYMBOL, SYMBOL, COMMA, SYMBOL, DOT, SYMBOL, // ()*+,-./
+    NUMERIC, NUMERIC, NUMERIC, NUMERIC, NUMERIC, // 01234
+    NUMERIC, NUMERIC, NUMERIC, NUMERIC, NUMERIC, // 56789
+    COLON, SEMICOLON, SYMBOL, SYMBOL, SYMBOL, QUERY, OTHER, // :;<=>?@
+    ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, // ABCDEFGH
+    ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, // IJKLMNOP
+    ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, // QRSTUVWX
+    ALPHA, ALPHA, LSQUARE, OTHER, RSQUARE, SYMBOL, ALPHA, OTHER, // YZ[\]^_'
+    ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, // abcdefgh
+    ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, // ijklmnop
+    ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, // qrstuvwx
+    ALPHA, ALPHA, LBRACE, SYMBOL, RBRACE, SYMBOL
+  ]; // yz{|}~
 
   // This must be a >= the highest precedence number handled by parseBinary.
   static var HIGHEST_PARSE_BINARY_PRECEDENCE = 16;
   static bool isAssignment(String symbol) => BINARY_PRECEDENCE[symbol] == 17;
 
   // From https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Operator_Precedence
   static final BINARY_PRECEDENCE = {
-      '+=': 17, '-=': 17, '*=': 17, '/=': 17, '%=': 17, '^=': 17, '|=': 17,
-      '&=': 17, '<<=': 17, '>>=': 17, '>>>=': 17, '=': 17,
-      '||': 14,
-      '&&': 13,
-      '|': 12,
-      '^': 11,
-      '&': 10,
-      '!=': 9, '==': 9, '!==': 9, '===': 9,
-      '<': 8, '<=': 8, '>=': 8, '>': 8, 'in': 8, 'instanceof': 8,
-      '<<': 7, '>>': 7, '>>>': 7,
-      '+': 6, '-': 6,
-      '*': 5, '/': 5, '%': 5
+    '+=': 17,
+    '-=': 17,
+    '*=': 17,
+    '/=': 17,
+    '%=': 17,
+    '^=': 17,
+    '|=': 17,
+    '&=': 17,
+    '<<=': 17,
+    '>>=': 17,
+    '>>>=': 17,
+    '=': 17,
+    '||': 14,
+    '&&': 13,
+    '|': 12,
+    '^': 11,
+    '&': 10,
+    '!=': 9,
+    '==': 9,
+    '!==': 9,
+    '===': 9,
+    '<': 8,
+    '<=': 8,
+    '>=': 8,
+    '>': 8,
+    'in': 8,
+    'instanceof': 8,
+    '<<': 7,
+    '>>': 7,
+    '>>>': 7,
+    '+': 6,
+    '-': 6,
+    '*': 5,
+    '/': 5,
+    '%': 5
   };
-  static final UNARY_OPERATORS =
-      ['++', '--', '+', '-', '~', '!', 'typeof', 'void', 'delete', 'await']
-        .toSet();
+  static final UNARY_OPERATORS = [
+    '++',
+    '--',
+    '+',
+    '-',
+    '~',
+    '!',
+    'typeof',
+    'void',
+    'delete',
+    'await'
+  ].toSet();
 
   static final ARROW_TOKEN = '=>';
   static final ELLIPSIS_TOKEN = '...';
 
   static final OPERATORS_THAT_LOOK_LIKE_IDENTIFIERS =
       ['typeof', 'void', 'delete', 'in', 'instanceof', 'await'].toSet();
 
   static int category(int code) {
     if (code >= CATEGORIES.length) return OTHER;
     return CATEGORIES[code];
   }
 
   String getDelimited(int startPosition) {
     position = startPosition;
     int delimiter = src.codeUnitAt(startPosition);
     int currentCode;
     do {
       position++;
       if (position >= src.length) error("Unterminated literal");
       currentCode = src.codeUnitAt(position);
       if (currentCode == charCodes.$LF) error("Unterminated literal");
       if (currentCode == charCodes.$BACKSLASH) {
         if (++position >= src.length) error("Unterminated literal");
         int escaped = src.codeUnitAt(position);
-        if (escaped == charCodes.$x || escaped == charCodes.$X ||
-            escaped == charCodes.$u || escaped == charCodes.$U ||
+        if (escaped == charCodes.$x ||
+            escaped == charCodes.$X ||
+            escaped == charCodes.$u ||
+            escaped == charCodes.$U ||
             category(escaped) == NUMERIC) {
           error('Numeric and hex escapes are not allowed in literals');
         }
       }
     } while (currentCode != delimiter);
     position++;
     return src.substring(lastPosition, position);
   }
 
   void getToken() {
     skippedNewline = false;
     for (;;) {
       if (position >= src.length) break;
       int code = src.codeUnitAt(position);
       //  Skip '//' and '/*' style comments.
-      if (code == charCodes.$SLASH &&
-          position + 1 < src.length) {
+      if (code == charCodes.$SLASH && position + 1 < src.length) {
         if (src.codeUnitAt(position + 1) == charCodes.$SLASH) {
           int nextPosition = src.indexOf('\n', position);
           if (nextPosition == -1) nextPosition = src.length;
           position = nextPosition;
           continue;
         } else if (src.codeUnitAt(position + 1) == charCodes.$STAR) {
           int nextPosition = src.indexOf('*/', position + 2);
           if (nextPosition == -1) error('Unterminated comment');
           position = nextPosition + 2;
           continue;
@@ skipping 10 matching lines @@
       lastPosition = position;
       return;
     }
     int code = src.codeUnitAt(position);
     lastPosition = position;
     if (code == charCodes.$SQ || code == charCodes.$DQ) {
       // String literal.
       lastCategory = STRING;
       lastToken = getDelimited(position);
     } else if (code == charCodes.$0 &&
-               position + 2 < src.length &&
-               src.codeUnitAt(position + 1) == charCodes.$x) {
+        position + 2 < src.length &&
+        src.codeUnitAt(position + 1) == charCodes.$x) {
       // Hex literal.
       for (position += 2; position < src.length; position++) {
         int cat = category(src.codeUnitAt(position));
         if (cat != NUMERIC && cat != ALPHA) break;
       }
       lastCategory = NUMERIC;
       lastToken = src.substring(lastPosition, position);
       int.parse(lastToken, onError: (_) {
         error("Unparseable number");
       });
@@ skipping 10 matching lines @@
       int cat = category(src.codeUnitAt(position));
       int newCat;
       do {
         position++;
         if (position == src.length) break;
         int code = src.codeUnitAt(position);
         // Special code to disallow ! and / in non-first position in token, so
         // that !! parses as two tokens and != parses as one, while =/ parses
         // as a an equals token followed by a regexp literal start.
         newCat = (code == charCodes.$BANG || code == charCodes.$SLASH)
-            ?  NONE
+            ? NONE
             : category(code);
       } while (!singleCharCategory(cat) &&
-               (cat == newCat ||
-                (cat == ALPHA && newCat == NUMERIC) ||    // eg. level42.
-                (cat == NUMERIC && newCat == DOT)));      // eg. 3.1415
+          (cat == newCat ||
+              (cat == ALPHA && newCat == NUMERIC) || // eg. level42.
+              (cat == NUMERIC && newCat == DOT))); // eg. 3.1415
       lastCategory = cat;
       lastToken = src.substring(lastPosition, position);
       if (cat == NUMERIC) {
         double.parse(lastToken, (_) {
           error("Unparseable number");
         });
       } else if (cat == DOT && lastToken.length > 1) {
         if (lastToken == ELLIPSIS_TOKEN) {
           lastCategory = ELLIPSIS;
         } else {
           error("Unknown operator");
         }
       } else if (cat == SYMBOL) {
         if (lastToken == ARROW_TOKEN) {
           lastCategory = ARROW;
         } else {
           int binaryPrecendence = BINARY_PRECEDENCE[lastToken];
-          if (binaryPrecendence == null && !UNARY_OPERATORS.contains(lastToken)) {
+          if (binaryPrecendence == null &&
+              !UNARY_OPERATORS.contains(lastToken)) {
             error("Unknown operator");
           }
           if (isAssignment(lastToken)) lastCategory = ASSIGNMENT;
         }
       } else if (cat == ALPHA) {
         if (OPERATORS_THAT_LOOK_LIKE_IDENTIFIERS.contains(lastToken)) {
           lastCategory = SYMBOL;
         }
       }
     }
@@ skipping 14 matching lines @@
 
   void expectSemicolon() {
     if (acceptSemicolon()) return;
     error('Expected SEMICOLON');
   }
 
   bool acceptSemicolon() {
     // Accept semicolon or automatically inserted semicolon before close brace.
     // Miniparser forbids other kinds of semicolon insertion.
     if (RBRACE == lastCategory) return true;
-    if (NONE == lastCategory) return true;  // end of input
+    if (NONE == lastCategory) return true; // end of input
     if (skippedNewline) {
       error('No automatic semicolon insertion at preceding newline');
     }
     return acceptCategory(SEMICOLON);
   }
 
   bool acceptString(String string) {
     if (lastToken == string) {
       getToken();
       return true;
@@ skipping 170 matching lines @@
     } else {
       body = parseAssignment();
     }
     return new ArrowFun(params, body);
   }
 
   Expression parseFunctionExpression() {
     String last = lastToken;
     if (acceptCategory(ALPHA)) {
       String functionName = last;
-      return new NamedFunction(new Identifier(functionName),
-          parseFun());
+      return new NamedFunction(new Identifier(functionName), parseFun());
     }
     return parseFun();
   }
 
   Expression parseFun() {
     List<Parameter> params = <Parameter>[];
 
     expectCategory(LPAREN);
     if (!acceptCategory(RPAREN)) {
       for (;;) {
@@ skipping 87 matching lines @@
             if (acceptCategory(ELLIPSIS)) {
               arguments.add(new Spread(parseAssignment()));
               expectCategory(RPAREN);
               break;
             }
             arguments.add(parseAssignment());
             if (acceptCategory(RPAREN)) break;
             expectCategory(COMMA);
           }
         }
-        receiver = constructor ?
-               new New(receiver, arguments) :
-               new Call(receiver, arguments);
+        receiver = constructor
+            ? new New(receiver, arguments)
+            : new Call(receiver, arguments);
         constructor = false;
       } else if (!constructor && acceptCategory(LSQUARE)) {
         Expression inBraces = parseExpression();
         expectCategory(RSQUARE);
         receiver = new PropertyAccess(receiver, inBraces);
       } else if (!constructor && acceptCategory(DOT)) {
         receiver = getDotRhs(receiver);
       } else {
         // JS allows new without (), but we don't.
         if (constructor) error("Parentheses are required for new");
@@ skipping 34 matching lines @@
       return new Postfix(operator, expression);
     }
     // If we don't accept '++' or '--' due to skippedNewline a newline, no other
     // part of the parser will accept the token and we will get an error at the
     // whole expression level.
     return expression;
   }
 
   Expression parseUnaryHigh() {
     String operator = lastToken;
-    if (lastCategory == SYMBOL && UNARY_OPERATORS.contains(operator) &&
+    if (lastCategory == SYMBOL &&
+        UNARY_OPERATORS.contains(operator) &&
         (acceptString("++") || acceptString("--") || acceptString('await'))) {
       if (operator == "await") return new Await(parsePostfix());
       return new Prefix(operator, parsePostfix());
     }
     return parsePostfix();
   }
 
   Expression parseUnaryLow() {
     String operator = lastToken;
-    if (lastCategory == SYMBOL && UNARY_OPERATORS.contains(operator) &&
-        operator != "++" && operator != "--") {
+    if (lastCategory == SYMBOL &&
+        UNARY_OPERATORS.contains(operator) &&
+        operator != "++" &&
+        operator != "--") {
       expectCategory(SYMBOL);
       if (operator == "await") return new Await(parsePostfix());
       return new Prefix(operator, parseUnaryLow());
     }
     return parseUnaryHigh();
   }
 
   Expression parseBinary(int maxPrecedence) {
     Expression lhs = parseUnaryLow();
     int minPrecedence;
     String lastSymbol;
-    Expression rhs;  // This is null first time around.
+    Expression rhs; // This is null first time around.
     while (true) {
       String symbol = lastToken;
       if (lastCategory != SYMBOL ||
           !BINARY_PRECEDENCE.containsKey(symbol) ||
           BINARY_PRECEDENCE[symbol] > maxPrecedence) {
         break;
       }
       expectCategory(SYMBOL);
       if (rhs == null || BINARY_PRECEDENCE[symbol] >= minPrecedence) {
         if (rhs != null) lhs = new Binary(lastSymbol, lhs, rhs);
@@ skipping 20 matching lines @@
 
   Expression parseLeftHandSide() => parseConditional();
 
   Expression parseAssignment() {
     Expression lhs = parseLeftHandSide();
     String assignmentOperator = lastToken;
     if (acceptCategory(ASSIGNMENT)) {
       Expression rhs = parseAssignment();
       if (assignmentOperator == "=") {
         return new Assignment(lhs, rhs);
-      } else  {
+      } else {
         // Handle +=, -=, etc.
         String operator =
             assignmentOperator.substring(0, assignmentOperator.length - 1);
         return new Assignment.compound(lhs, operator, rhs);
       }
     }
     return lhs;
   }
 
   Expression parseExpression() {
     Expression expression = parseAssignment();
     while (acceptCategory(COMMA)) {
       Expression right = parseAssignment();
       expression = new Binary(',', expression, right);
     }
     return expression;
   }
 
   /** Parse a variable declaration list, with `var` or `let` [keyword] */
-  VariableDeclarationList parseVariableDeclarationList(
-      String keyword, [String firstIdentifier])  {
+  VariableDeclarationList parseVariableDeclarationList(String keyword,
+      [String firstIdentifier]) {
     var initialization = <VariableInitialization>[];
 
     do {
       var declarator;
       if (firstIdentifier != null) {
         declarator = new Identifier(firstIdentifier);
         firstIdentifier = null;
       } else {
         declarator = parseVariableBinding();
       }
@@ skipping 35 matching lines @@
   }
 
   ArrayBindingPattern parseArrayBindingPattern() {
     var variables = <DestructuredVariable>[];
     do {
       var name;
       var structure;
       var defaultValue;
 
       var declarator = parseVariableBinding();
-      if (declarator is Identifier) name = declarator;
-      else if (declarator is BindingPattern) structure = declarator;
-      else error("Unexpected LHS: $declarator");
+      if (declarator is Identifier)
+        name = declarator;
+      else if (declarator is BindingPattern)
+        structure = declarator;
+      else
+        error("Unexpected LHS: $declarator");
 
       if (acceptString("=")) {
         defaultValue = parseExpression();
       }
       variables.add(new DestructuredVariable(
           name: name, structure: structure, defaultValue: defaultValue));
     } while (acceptCategory(COMMA));
 
     expectCategory(RSQUARE);
     return new ArrayBindingPattern(variables);
@@ skipping 106 matching lines @@
 
       if (lastToken == 'case') error("Case outside switch.");
 
       if (lastToken == 'default') error("Default outside switch.");
 
       if (lastToken == 'yield') return parseYield();
 
       if (lastToken == 'with') {
         error('Not implemented in mini parser');
       }
-
     }
 
     bool checkForInterpolatedStatement = lastCategory == HASH;
 
     Expression expression = parseExpression();
 
     if (expression is Identifier && acceptCategory(COLON)) {
       return new LabeledStatement(expression.name, parseStatement());
     }
 
@@ skipping 92 matching lines @@
 
     var keyword = acceptVarLetOrConst();
     if (keyword != null) {
       String identifier = lastToken;
       expectCategory(ALPHA);
 
       if (acceptString('in')) {
         Expression objectExpression = parseExpression();
         expectCategory(RPAREN);
         Statement body = parseStatement();
-        return new ForIn(
-            _createVariableDeclarationList(keyword, identifier),
-            objectExpression,
-            body);
+        return new ForIn(_createVariableDeclarationList(keyword, identifier),
+            objectExpression, body);
       } else if (acceptString('of')) {
         Expression iterableExpression = parseAssignment();
         expectCategory(RPAREN);
         Statement body = parseStatement();
-        return new ForOf(
-            _createVariableDeclarationList(keyword, identifier),
-            iterableExpression,
-            body);
+        return new ForOf(_createVariableDeclarationList(keyword, identifier),
+            iterableExpression, body);
       }
       var declarations = parseVariableDeclarationList(keyword, identifier);
       expectCategory(SEMICOLON);
       return finishFor(declarations);
     }
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
     return finishFor(init);
   }
 
   static VariableDeclarationList _createVariableDeclarationList(
       String keyword, String identifier) {
-    return new VariableDeclarationList(keyword, [
-        new VariableInitialization(
-            new Identifier(identifier), null)]);
+    return new VariableDeclarationList(keyword,
+        [new VariableInitialization(new Identifier(identifier), null)]);
   }
 
   Statement parseFunctionDeclaration() {
     String name = lastToken;
     expectCategory(ALPHA);
     Expression fun = parseFun();
     return new FunctionDeclaration(new Identifier(name), fun);
   }
 
   Statement parseTry() {
@@ skipping 17 matching lines @@
       expression = parseExpression();
       expectCategory(COLON);
     } else {
       if (!acceptString('default')) {
         error('expected case or default');
       }
       expectCategory(COLON);
     }
     var statements = <Statement>[];
     while (lastCategory != RBRACE &&
-           lastToken != 'case' &&
-           lastToken != 'default') {
+        lastToken != 'case' &&
+        lastToken != 'default') {
       statements.add(parseStatement());
     }
     return expression == null
         ? new Default(new Block(statements))
         : new Case(expression, new Block(statements));
   }
 
   Statement parseWhile() {
     expectCategory(LPAREN);
     Expression condition = parseExpression();
@@ skipping 12 matching lines @@
     expectSemicolon();
     return new Do(body, condition);
   }
 
   Statement parseSwitch() {
     expectCategory(LPAREN);
     Expression key = parseExpression();
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     List<SwitchClause> clauses = new List<SwitchClause>();
-    while(lastCategory != RBRACE) {
+    while (lastCategory != RBRACE) {
       clauses.add(parseSwitchClause());
     }
     expectCategory(RBRACE);
     return new Switch(key, clauses);
   }
 
   Catch parseCatch() {
     expectCategory(LPAREN);
     String identifier = lastToken;
     expectCategory(ALPHA);
@@ skipping 78 matching lines @@
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
       return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
 }