Run dartfmt on js_ast

pkg/js_ast/lib/src/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 148 matching lines @@
 
 What is not implemented:
 
  -  Array initializers and object initializers could support splicing.  In the
     array case, we would need some way to know if an ArrayInitializer argument
     should be splice or is intended as a single value.
 
 */
 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 63 matching lines @@
   Template expressionTemplateFor(String source) {
     return _findExpressionTemplate(source);
   }
 
   /**
    * 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 _legacyEscapedString(String value) {
-   // Start by escaping the backslashes.
+    // Start by escaping the backslashes.
     String escaped = value.replaceAll('\\', '\\\\');
     // Do not escape unicode characters and ' because they are allowed in the
     // string literal anyway.
     escaped = escaped.replaceAllMapped(new RegExp('\n|"|\b|\t|\v|\r'), (match) {
       switch (match.group(0)) {
-        case "\n" : return r"\n";
-        case "\"" : return r'\"';
-        case "\b" : return r"\b";
-        case "\t" : return r"\t";
-        case "\f" : return r"\f";
-        case "\r" : return r"\r";
-        case "\v" : return r"\v";
+        case "\n":
+          return r"\n";
+        case "\"":
+          return r'\"';
+        case "\b":
+          return r"\b";
+        case "\t":
+          return r"\t";
+        case "\f":
+          return r"\f";
+        case "\r":
+          return r"\r";
+        case "\v":
+          return r"\v";
       }
     });
     LiteralString result = string(escaped);
     // We don't escape ' under the assumption that the string is wrapped
     // into ". Verify that assumption.
     assert(result.value.codeUnitAt(0) == '"'.codeUnitAt(0));
     return result;
   }
 
   /// Creates a literal js string from [value].
   LiteralString escapedString(String value,
-       {bool utf8: false, bool ascii: false}) {
+      {bool utf8: false, bool ascii: false}) {
     if (utf8 == false && ascii == false) return _legacyEscapedString(value);
     if (utf8 && ascii) throw new ArgumentError('Cannot be both UTF8 and ASCII');
 
     int singleQuotes = 0;
     int doubleQuotes = 0;
     int otherEscapes = 0;
     int unpairedSurrogates = 0;
 
     for (int rune in value.runes) {
       if (rune == charCodes.$BACKSLASH) {
         ++otherEscapes;
       } else if (rune == charCodes.$SQ) {
         ++singleQuotes;
       } else if (rune == charCodes.$DQ) {
         ++doubleQuotes;
-      } else if (rune == charCodes.$LF || rune == charCodes.$CR ||
-                 rune == charCodes.$LS || rune == charCodes.$PS) {
+      } else if (rune == charCodes.$LF ||
+          rune == charCodes.$CR ||
+          rune == charCodes.$LS ||
+          rune == charCodes.$PS) {
         // Line terminators.
         ++otherEscapes;
-      } else if (rune == charCodes.$BS || rune == charCodes.$TAB ||
-                 rune == charCodes.$VTAB || rune == charCodes.$FF) {
+      } else if (rune == charCodes.$BS ||
+          rune == charCodes.$TAB ||
+          rune == charCodes.$VTAB ||
+          rune == charCodes.$FF) {
         ++otherEscapes;
       } else if (_isUnpairedSurrogate(rune)) {
         ++unpairedSurrogates;
       } else {
         if (ascii && (rune < charCodes.$SPACE || rune >= charCodes.$DEL)) {
           ++otherEscapes;
         }
       }
     }
 
@@ skipping 42 matching lines @@
       }
     }
 
     return finish(useSingleQuotes ? "'" : '"', sb.toString());
   }
 
   static bool _isUnpairedSurrogate(int code) => (code & 0xFFFFF800) == 0xD800;
 
   static String _irregularEscape(int code, bool useSingleQuotes) {
     switch (code) {
-      case charCodes.$SQ: return useSingleQuotes ? r"\'" : r"'";
-      case charCodes.$DQ: return useSingleQuotes ? r'"' : r'\"';
-      case charCodes.$BACKSLASH: return r'\\';
-      case charCodes.$BS: return r'\b';
-      case charCodes.$TAB: return r'\t';
-      case charCodes.$LF: return r'\n';
-      case charCodes.$VTAB: return r'\v';
-      case charCodes.$FF: return r'\f';
-      case charCodes.$CR: return r'\r';
+      case charCodes.$SQ:
+        return useSingleQuotes ? r"\'" : r"'";
+      case charCodes.$DQ:
+        return useSingleQuotes ? r'"' : r'\"';
+      case charCodes.$BACKSLASH:
+        return r'\\';
+      case charCodes.$BS:
+        return r'\b';
+      case charCodes.$TAB:
+        return r'\t';
+      case charCodes.$LF:
+        return r'\n';
+      case charCodes.$VTAB:
+        return r'\v';
+      case charCodes.$FF:
+        return r'\f';
+      case charCodes.$CR:
+        return r'\r';
     }
     return null;
   }
 
   /// Creates a literal js string from [value].
   ///
   /// Note that this function only puts quotes around [value]. It does not do
   /// any escaping, so use only when you can guarantee that [value] does not
   /// contain newlines or backslashes. For escaping the string use
   /// [escapedString].
   LiteralString string(String value) => new LiteralString('"$value"');
 
   /// Creates an instance of [LiteralString] from [value].
   ///
   /// Does not add quotes or do any escaping.
   LiteralString stringPart(String value) => new LiteralString(value);
 
   StringConcatenation concatenateStrings(Iterable<Literal> parts,
-                                         {addQuotes: false}) {
+      {addQuotes: false}) {
     List<Literal> _parts;
     if (addQuotes) {
       Literal quote = stringPart('"');
       _parts = <Literal>[quote]
-          ..addAll(parts)
-          ..add(quote);
+        ..addAll(parts)
+        ..add(quote);
     } else {
       _parts = new List.from(parts, growable: false);
     }
     return new StringConcatenation(_parts);
   }
 
   Iterable<Literal> joinLiterals(Iterable<Literal> list, Literal separator) {
     return new _InterleaveIterable(list, separator);
   }
 
@@ skipping 10 matching lines @@
   LiteralBool boolean(bool value) => new LiteralBool(value);
 
   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);
 
-  Call propertyCall(Expression receiver,
-                    Expression fieldName,
-                    List<Expression> arguments) {
+  Call propertyCall(
+      Expression receiver, Expression fieldName, List<Expression> arguments) {
     return new Call(new PropertyAccess(receiver, fieldName), arguments);
   }
 
   ObjectInitializer objectLiteral(Map<String, Expression> map) {
     List<Property> properties = <Property>[];
     map.forEach((name, value) {
       properties.add(new Property(string(name), value));
     });
     return new ObjectInitializer(properties);
   }
 }
 
 LiteralString string(String value) => js.string(value);
 LiteralString quoteName(Name name, {allowNull: false}) {
   return js.quoteName(name, allowNull: allowNull);
 }
+
 LiteralString stringPart(String value) => js.stringPart(value);
 Iterable<Literal> joinLiterals(Iterable<Literal> list, Literal separator) {
   return js.joinLiterals(list, separator);
 }
+
 StringConcatenation concatenateStrings(Iterable<Literal> parts,
-                                       {addQuotes: false}) {
+    {addQuotes: false}) {
   return js.concatenateStrings(parts, addQuotes: addQuotes);
 }
 
 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,
-                  Expression fieldName,
-                  List<Expression> arguments) {
+Call propertyCall(
+    Expression receiver, Expression fieldName, List<Expression> arguments) {
   return js.propertyCall(receiver, fieldName, arguments);
 }
+
 ObjectInitializer objectLiteral(Map<String, Expression> map) {
   return js.objectLiteral(map);
 }
 
 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 14 matching lines @@
   static const SEMICOLON = 15;
   static const HASH = 16;
   static const WHITESPACE = 17;
   static const OTHER = 18;
 
   // Make sure that ]] is two symbols.
   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 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 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 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");
       });
     } else if (code == charCodes.$SLASH) {
       // Tokens that start with / are special due to regexp literals.
       lastCategory = SYMBOL;
       position++;
       if (position < src.length && src.codeUnitAt(position) == charCodes.$EQ) {
         position++;
       }
       lastToken = src.substring(lastPosition, position);
     } else {
       // All other tokens handled here.
       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 !! and ~~ parse 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 ||
-             code == charCodes.$TILDE)
+        newCat = (code == charCodes.$BANG ||
+                code == charCodes.$SLASH ||
+                code == charCodes.$TILDE)
             ? 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 == SYMBOL) {
         int binaryPrecendence = BINARY_PRECEDENCE[lastToken];
         if (binaryPrecendence == null && !UNARY_OPERATORS.contains(lastToken)) {
           error("Unknown operator");
@@ skipping 22 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 134 matching lines @@
     List<Property> properties = <Property>[];
     for (;;) {
       if (acceptCategory(RBRACE)) break;
       // Limited subset: keys are identifiers, no 'get' or 'set' properties.
       Literal propertyName;
       String identifier = lastToken;
       if (acceptCategory(ALPHA)) {
         propertyName = new LiteralString('"$identifier"');
       } else if (acceptCategory(STRING)) {
         propertyName = new LiteralString(identifier);
-      } else if (acceptCategory(SYMBOL)) {  // e.g. void
+      } else if (acceptCategory(SYMBOL)) {
+        // e.g. void
         propertyName = new LiteralString('"$identifier"');
       } else if (acceptCategory(HASH)) {
         var nameOrPosition = parseHash();
         InterpolatedLiteral interpolatedLiteral =
             new InterpolatedLiteral(nameOrPosition);
         interpolatedValues.add(interpolatedLiteral);
         propertyName = interpolatedLiteral;
       } else {
         error('Expected property name');
       }
@@ skipping 29 matching lines @@
       if (acceptCategory(LPAREN)) {
         final arguments = <Expression>[];
         if (!acceptCategory(RPAREN)) {
           while (true) {
             Expression argument = parseAssignment();
             arguments.add(argument);
             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 11 matching lines @@
 
   Expression parseConditional() {
     Expression lhs = parseBinary(HIGHEST_PARSE_BINARY_PRECEDENCE);
     if (!acceptCategory(QUERY)) return lhs;
     Expression ifTrue = parseAssignment();
     expectCategory(COLON);
     Expression ifFalse = parseAssignment();
     return new Conditional(lhs, ifTrue, ifFalse);
   }
 
-
   Expression parseAssignment() {
     Expression lhs = parseConditional();
     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() {
@@ skipping 105 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 VariableUse && acceptCategory(COLON)) {
       return new LabeledStatement(expression.name, parseStatement());
     }
 
@@ skipping 86 matching lines @@
       return finishFor(null);
     }
 
     if (acceptString('var')) {
       Declaration declaration = parseVariableDeclaration();
       if (acceptString('in')) {
         Expression objectExpression = parseExpression();
         expectCategory(RPAREN);
         Statement body = parseStatement();
         return new ForIn(
-            new VariableDeclarationList([
-                new VariableInitialization(declaration, null)]),
+            new VariableDeclarationList(
+                [new VariableInitialization(declaration, null)]),
             objectExpression,
             body);
       }
       Expression declarations = finishVariableDeclarationList(declaration);
       expectCategory(SEMICOLON);
       return finishFor(declarations);
     }
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
@@ skipping 41 matching lines @@
       expression = parseExpression();
       expectCategory(COLON);
     } else {
       if (!acceptString('default')) {
         error('expected case or default');
       }
       expectCategory(COLON);
     }
     List statements = new List<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);
     Declaration errorName = parseVariableDeclaration();
     expectCategory(RPAREN);
@@ skipping 32 matching lines @@
 class _InterleaveIterable extends IterableBase {
   Iterable<Node> source;
   Node separator;
 
   _InterleaveIterable(this.source, this.separator);
 
   Iterator<Node> get iterator {
     return new _InterleaveIterator(source.iterator, separator);
   }
 }