Format all dart dev compiler files

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

Index: pkg/dev_compiler/lib/src/js_ast/builder.dart
diff --git a/pkg/dev_compiler/lib/src/js_ast/builder.dart b/pkg/dev_compiler/lib/src/js_ast/builder.dart
index 8b5f58a3d63d643bf9bb88514d555afa4594aad3..9239aeaedde9f9e326bc945752de57904204ff85 100644
--- a/pkg/dev_compiler/lib/src/js_ast/builder.dart
+++ b/pkg/dev_compiler/lib/src/js_ast/builder.dart
@@ -7,7 +7,6 @@
 
 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
@@ -18,7 +17,6 @@ part of js_ast;
  */
 TemplateManager templateManager = new TemplateManager();
 
-
 /**
 
 [js] is a singleton instace of JsBuilder.  JsBuilder is a set of conveniences
@@ -192,7 +190,6 @@ What is not implemented:
 */
 const JsBuilder js = const JsBuilder();
 
-
 class JsBuilder {
   const JsBuilder();
 
@@ -267,8 +264,8 @@ class JsBuilder {
   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);
   }
 
   /**
@@ -277,8 +274,8 @@ class JsBuilder {
   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);
   }
 
   /**
@@ -296,10 +293,9 @@ class JsBuilder {
 
   /// 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;
@@ -312,22 +308,34 @@ class JsBuilder {
     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');
@@ -360,9 +368,8 @@ class JsBuilder {
   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);
   }
 }
@@ -371,14 +378,13 @@ 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;
@@ -440,7 +446,7 @@ class MiniJsParser {
   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>[];
@@ -480,51 +486,74 @@ class MiniJsParser {
 
   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;
@@ -532,22 +561,54 @@ class MiniJsParser {
 
   // 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 = '...';
@@ -572,8 +633,10 @@ class MiniJsParser {
       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');
         }
@@ -589,8 +652,7 @@ class MiniJsParser {
       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;
@@ -621,8 +683,8 @@ class MiniJsParser {
       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));
@@ -653,12 +715,12 @@ class MiniJsParser {
         // 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) {
@@ -676,7 +738,8 @@ class MiniJsParser {
           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;
@@ -711,7 +774,7 @@ class MiniJsParser {
     // 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');
     }
@@ -902,8 +965,7 @@ class MiniJsParser {
     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();
   }
@@ -1011,9 +1073,9 @@ class MiniJsParser {
             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();
@@ -1068,7 +1130,8 @@ class MiniJsParser {
 
   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());
@@ -1078,8 +1141,10 @@ class MiniJsParser {
 
   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());
@@ -1091,7 +1156,7 @@ class MiniJsParser {
     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 ||
@@ -1132,7 +1197,7 @@ class MiniJsParser {
       Expression rhs = parseAssignment();
       if (assignmentOperator == "=") {
         return new Assignment(lhs, rhs);
-      } else  {
+      } else {
         // Handle +=, -=, etc.
         String operator =
             assignmentOperator.substring(0, assignmentOperator.length - 1);
@@ -1152,8 +1217,8 @@ class MiniJsParser {
   }
 
   /** 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 {
@@ -1209,9 +1274,12 @@ class MiniJsParser {
       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();
@@ -1338,7 +1406,6 @@ class MiniJsParser {
       if (lastToken == 'with') {
         error('Not implemented in mini parser');
       }
-
     }
 
     bool checkForInterpolatedStatement = lastCategory == HASH;
@@ -1451,18 +1518,14 @@ class MiniJsParser {
         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);
@@ -1476,9 +1539,8 @@ class MiniJsParser {
 
   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() {
@@ -1516,8 +1578,8 @@ class MiniJsParser {
     }
     var statements = <Statement>[];
     while (lastCategory != RBRACE &&
-           lastToken != 'case' &&
-           lastToken != 'default') {
+        lastToken != 'case' &&
+        lastToken != 'default') {
       statements.add(parseStatement());
     }
     return expression == null
@@ -1550,7 +1612,7 @@ class MiniJsParser {
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     List<SwitchClause> clauses = new List<SwitchClause>();
-    while(lastCategory != RBRACE) {
+    while (lastCategory != RBRACE) {
       clauses.add(parseSwitchClause());
     }
     expectCategory(RBRACE);