dartfmt pkg/compiler

pkg/compiler/lib/src/parser/parser.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.
 
 library dart2js.parser;
 
-import '../options.dart' show
-    ParserOptions;
+import '../options.dart' show ParserOptions;
 import '../common.dart';
-import '../tokens/keyword.dart' show
-    Keyword;
-import '../tokens/precedence.dart' show
-    PrecedenceInfo;
-import '../tokens/precedence_constants.dart' show
-    AS_INFO,
-    ASSIGNMENT_PRECEDENCE,
-    CASCADE_PRECEDENCE,
-    EQUALITY_PRECEDENCE,
-    GT_INFO,
-    GT_GT_INFO,
-    IS_INFO,
-    MINUS_MINUS_INFO,
-    OPEN_PAREN_INFO,
-    OPEN_SQUARE_BRACKET_INFO,
-    PERIOD_INFO,
-    PLUS_PLUS_INFO,
-    POSTFIX_PRECEDENCE,
-    QUESTION_INFO,
-    QUESTION_PERIOD_INFO,
-    RELATIONAL_PRECEDENCE;
-import '../tokens/token.dart' show
-    BeginGroupToken,
-    isUserDefinableOperator,
-    KeywordToken,
-    SymbolToken,
-    Token;
-import '../tokens/token_constants.dart' show
-    BAD_INPUT_TOKEN,
-    COMMA_TOKEN,
-    DOUBLE_TOKEN,
-    EOF_TOKEN,
-    EQ_TOKEN,
-    FUNCTION_TOKEN,
-    HASH_TOKEN,
-    HEXADECIMAL_TOKEN,
-    IDENTIFIER_TOKEN,
-    INT_TOKEN,
-    KEYWORD_TOKEN,
-    LT_TOKEN,
-    OPEN_CURLY_BRACKET_TOKEN,
-    OPEN_PAREN_TOKEN,
-    OPEN_SQUARE_BRACKET_TOKEN,
-    PERIOD_TOKEN,
-    SEMICOLON_TOKEN,
-    STRING_INTERPOLATION_IDENTIFIER_TOKEN,
-    STRING_INTERPOLATION_TOKEN,
-    STRING_TOKEN;
-import '../util/characters.dart' as Characters show
-    $CLOSE_CURLY_BRACKET;
-import '../util/util.dart' show
-    Link;
+import '../tokens/keyword.dart' show Keyword;
+import '../tokens/precedence.dart' show PrecedenceInfo;
+import '../tokens/precedence_constants.dart'
+    show
+        AS_INFO,
+        ASSIGNMENT_PRECEDENCE,
+        CASCADE_PRECEDENCE,
+        EQUALITY_PRECEDENCE,
+        GT_INFO,
+        GT_GT_INFO,
+        IS_INFO,
+        MINUS_MINUS_INFO,
+        OPEN_PAREN_INFO,
+        OPEN_SQUARE_BRACKET_INFO,
+        PERIOD_INFO,
+        PLUS_PLUS_INFO,
+        POSTFIX_PRECEDENCE,
+        QUESTION_INFO,
+        QUESTION_PERIOD_INFO,
+        RELATIONAL_PRECEDENCE;
+import '../tokens/token.dart'
+    show
+        BeginGroupToken,
+        isUserDefinableOperator,
+        KeywordToken,
+        SymbolToken,
+        Token;
+import '../tokens/token_constants.dart'
+    show
+        BAD_INPUT_TOKEN,
+        COMMA_TOKEN,
+        DOUBLE_TOKEN,
+        EOF_TOKEN,
+        EQ_TOKEN,
+        FUNCTION_TOKEN,
+        HASH_TOKEN,
+        HEXADECIMAL_TOKEN,
+        IDENTIFIER_TOKEN,
+        INT_TOKEN,
+        KEYWORD_TOKEN,
+        LT_TOKEN,
+        OPEN_CURLY_BRACKET_TOKEN,
+        OPEN_PAREN_TOKEN,
+        OPEN_SQUARE_BRACKET_TOKEN,
+        PERIOD_TOKEN,
+        SEMICOLON_TOKEN,
+        STRING_INTERPOLATION_IDENTIFIER_TOKEN,
+        STRING_INTERPOLATION_TOKEN,
+        STRING_TOKEN;
+import '../util/characters.dart' as Characters show $CLOSE_CURLY_BRACKET;
+import '../util/util.dart' show Link;
 
-import 'listener.dart' show
-    Listener;
+import 'listener.dart' show Listener;
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
   bool get isPositional => this == POSITIONAL;
   bool get isNamed => this == NAMED;
   static final REQUIRED = const FormalParameterType('required');
   static final POSITIONAL = const FormalParameterType('positional');
   static final NAMED = const FormalParameterType('named');
@@ skipping 39 matching lines @@
       listener.endTopLevelDeclaration(token);
       count++;
     }
     listener.endCompilationUnit(count, token);
     return token;
   }
 
   Token parseTopLevelDeclaration(Token token) {
     token = parseMetadataStar(token);
     final String value = token.stringValue;
-    if ((identical(value, 'abstract') && optional('class', token.next))
-        || identical(value, 'class')) {
+    if ((identical(value, 'abstract') && optional('class', token.next)) ||
+        identical(value, 'class')) {
       return parseClassOrNamedMixinApplication(token);
     } else if (identical(value, 'enum')) {
       return parseEnum(token);
     } else if (identical(value, 'typedef')) {
       return parseTypedef(token);
     } else if (identical(value, 'library')) {
       return parseLibraryName(token);
     } else if (identical(value, 'import')) {
       return parseImport(token);
     } else if (identical(value, 'export')) {
@@ skipping 327 matching lines @@
       token = parseFormalParameters(token);
       listener.handleFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
-        listener.reportError(equal,
-            MessageKind.REQUIRED_PARAMETER_WITH_DEFAULT);
+        listener.reportError(
+            equal, MessageKind.REQUIRED_PARAMETER_WITH_DEFAULT);
       } else if (type.isNamed && identical('=', value)) {
         listener.reportError(equal, MessageKind.NAMED_PARAMETER_WITH_EQUALS);
       } else if (type.isPositional && identical(':', value)) {
-        listener.reportError(equal,
-            MessageKind.POSITIONAL_PARAMETER_WITH_EQUALS);
+        listener.reportError(
+            equal, MessageKind.POSITIONAL_PARAMETER_WITH_EQUALS);
       }
     }
     listener.endFormalParameter(thisKeyword);
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
       token = token.next;
-      var type = isNamed ? FormalParameterType.NAMED
-                         : FormalParameterType.POSITIONAL;
+      var type =
+          isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
       token = parseFormalParameter(token, type);
       ++parameterCount;
     } while (optional(',', token));
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
     Token peek = peekAfterIfType(token);
     if (peek != null && (peek.isIdentifier() || optional('this', peek))) {
       return parseType(token);
     }
     listener.handleNoType(token);
     return token;
   }
 
   bool isValidTypeReference(Token token) {
     final kind = token.kind;
     if (identical(kind, IDENTIFIER_TOKEN)) return true;
     if (identical(kind, KEYWORD_TOKEN)) {
       Keyword keyword = (token as KeywordToken).keyword;
       String value = keyword.syntax;
-      return keyword.isPseudo
-          || (identical(value, 'dynamic'))
-          || (identical(value, 'void'));
+      return keyword.isPseudo ||
+          (identical(value, 'dynamic')) ||
+          (identical(value, 'void'));
     }
     return false;
   }
 
   Token parseQualified(Token token) {
     token = parseIdentifier(token);
     while (optional('.', token)) {
       token = parseQualifiedRest(token);
     }
     return token;
@@ skipping 87 matching lines @@
     }
   }
 
   Token parseNamedMixinApplication(Token token, Token classKeyword) {
     token = parseMixinApplication(token);
     Token implementsKeyword = null;
     if (optional('implements', token)) {
       implementsKeyword = token;
       token = parseTypeList(token.next);
     }
-    listener.endNamedMixinApplication(
-        classKeyword, implementsKeyword, token);
+    listener.endNamedMixinApplication(classKeyword, implementsKeyword, token);
     return expect(';', token);
   }
 
   Token parseClass(Token begin, Token classKeyword) {
     Token token = parseIdentifier(classKeyword.next);
     token = parseTypeVariablesOpt(token);
     Token extendsKeyword;
     if (optional('extends', token)) {
       extendsKeyword = token;
       if (optional('with', peekAfterType(token.next))) {
         token = parseMixinApplication(token.next);
       } else {
         token = parseType(token.next);
       }
     } else {
       extendsKeyword = null;
       listener.handleNoType(token);
     }
     Token implementsKeyword;
     int interfacesCount = 0;
     if (optional('implements', token)) {
       implementsKeyword = token;
       do {
         token = parseType(token.next);
         ++interfacesCount;
       } while (optional(',', token));
     }
     token = parseClassBody(token);
-    listener.endClassDeclaration(interfacesCount, begin, extendsKeyword,
-                                 implementsKeyword, token);
+    listener.endClassDeclaration(
+        interfacesCount, begin, extendsKeyword, implementsKeyword, token);
     return token.next;
   }
 
   Token parseStringPart(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       listener.handleStringPart(token);
       return token.next;
     } else {
       return listener.expected('string', token);
     }
@@ skipping 32 matching lines @@
   bool optional(String value, Token token) {
     return identical(value, token.stringValue);
   }
 
   /**
    * Returns true if the stringValue of the [token] is either [value1],
    * [value2], or [value3].
    */
   bool isOneOf3(Token token, String value1, String value2, String value3) {
     String stringValue = token.stringValue;
-    return
-        value1 == stringValue ||
+    return value1 == stringValue ||
         value2 == stringValue ||
         value3 == stringValue;
   }
 
   /**
    * Returns true if the stringValue of the [token] is either [value1],
    * [value2], [value3], or [value4].
    */
-  bool isOneOf4(Token token,
-                String value1, String value2, String value3, String value4) {
+  bool isOneOf4(
+      Token token, String value1, String value2, String value3, String value4) {
     String stringValue = token.stringValue;
     return value1 == stringValue ||
-           value2 == stringValue ||
-           value3 == stringValue ||
-           value4 == stringValue;
+        value2 == stringValue ||
+        value3 == stringValue ||
+        value4 == stringValue;
   }
 
   bool notEofOrValue(String value, Token token) {
     return !identical(token.kind, EOF_TOKEN) &&
-           !identical(value, token.stringValue);
+        !identical(value, token.stringValue);
   }
 
   Token parseType(Token token) {
     Token begin = token;
     if (isValidTypeReference(token)) {
       token = parseIdentifier(token);
       token = parseQualifiedRestOpt(token);
     } else {
       token = listener.expectedType(token);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(begin, token);
     return token;
   }
 
   Token parseTypeArgumentsOpt(Token token) {
-    return parseStuff(token,
-                      (t) => listener.beginTypeArguments(t),
-                      (t) => parseType(t),
-                      (c, bt, et) => listener.endTypeArguments(c, bt, et),
-                      (t) => listener.handleNoTypeArguments(t));
+    return parseStuff(
+        token,
+        (t) => listener.beginTypeArguments(t),
+        (t) => parseType(t),
+        (c, bt, et) => listener.endTypeArguments(c, bt, et),
+        (t) => listener.handleNoTypeArguments(t));
   }
 
   Token parseTypeVariablesOpt(Token token) {
-    return parseStuff(token,
-                      (t) => listener.beginTypeVariables(t),
-                      (t) => parseTypeVariable(t),
-                      (c, bt, et) => listener.endTypeVariables(c, bt, et),
-                      (t) => listener.handleNoTypeVariables(t));
+    return parseStuff(
+        token,
+        (t) => listener.beginTypeVariables(t),
+        (t) => parseTypeVariable(t),
+        (c, bt, et) => listener.endTypeVariables(c, bt, et),
+        (t) => listener.handleNoTypeVariables(t));
   }
 
   // TODO(ahe): Clean this up.
   Token parseStuff(Token token, Function beginStuff, Function stuffParser,
-                   Function endStuff, Function handleNoStuff) {
+      Function endStuff, Function handleNoStuff) {
     if (optional('<', token)) {
       Token begin = token;
       beginStuff(begin);
       int count = 0;
       do {
         token = stuffParser(token.next);
         ++count;
       } while (optional(',', token));
       Token next = token.next;
       if (identical(token.stringValue, '>>')) {
@@ skipping 39 matching lines @@
         identifiers = identifiers.tail;
       }
     }
 
     token = afterName;
     bool isField;
     while (true) {
       // Loop to allow the listener to rewrite the token stream for
       // error handling.
       final String value = token.stringValue;
-      if ((identical(value, '(')) || (identical(value, '{'))
-          || (identical(value, '=>'))) {
+      if ((identical(value, '(')) ||
+          (identical(value, '{')) ||
+          (identical(value, '=>'))) {
         isField = false;
         break;
       } else if ((identical(value, '=')) || (identical(value, ','))) {
         isField = true;
         break;
       } else if (identical(value, ';')) {
         if (getOrSet != null) {
           // If we found a "get" keyword, this must be an abstract
           // getter.
           isField = (!identical(getOrSet.stringValue, 'get'));
           // TODO(ahe): This feels like a hack.
         } else {
           isField = true;
         }
         break;
       } else {
         token = listener.unexpected(token);
         if (identical(token.kind, EOF_TOKEN)) return token;
       }
     }
     var modifiers = identifiers.reverse();
     return isField
         ? parseFields(start, modifiers, type, getOrSet, name, true)
         : parseTopLevelMethod(start, modifiers, type, getOrSet, name);
   }
 
   bool isVarFinalOrConst(Token token) {
     String value = token.stringValue;
-    return identical('var', value)
-        || identical('final', value)
-        || identical('const', value);
+    return identical('var', value) ||
+        identical('final', value) ||
+        identical('const', value);
   }
 
-  Token expectVarFinalOrConst(Link<Token> modifiers,
-                              bool hasType,
-                              bool allowStatic) {
+  Token expectVarFinalOrConst(
+      Link<Token> modifiers, bool hasType, bool allowStatic) {
     int modifierCount = 0;
     Token staticModifier;
-    if (allowStatic && !modifiers.isEmpty
-        && optional('static', modifiers.head)) {
+    if (allowStatic &&
+        !modifiers.isEmpty &&
+        optional('static', modifiers.head)) {
       staticModifier = modifiers.head;
       modifierCount++;
       parseModifier(staticModifier);
       modifiers = modifiers.tail;
     }
     if (modifiers.isEmpty) {
       listener.handleModifiers(modifierCount);
       return null;
     }
     if (modifiers.tail.isEmpty) {
       Token modifier = modifiers.head;
       if (isVarFinalOrConst(modifier)) {
         modifierCount++;
         parseModifier(modifier);
         listener.handleModifiers(modifierCount);
         // TODO(ahe): The caller checks for "var Type name", perhaps we should
         // check here instead.
         return modifier;
       }
     }
 
     // Slow case to report errors.
     List<Token> modifierList = modifiers.toList();
     Token varFinalOrConst =
         modifierList.firstWhere(isVarFinalOrConst, orElse: () => null);
     if (allowStatic && staticModifier == null) {
-      staticModifier =
-          modifierList.firstWhere(
-              (modifier) => optional('static', modifier), orElse: () => null);
+      staticModifier = modifierList.firstWhere(
+          (modifier) => optional('static', modifier),
+          orElse: () => null);
       if (staticModifier != null) {
         modifierCount++;
         parseModifier(staticModifier);
         modifierList.remove(staticModifier);
       }
     }
     bool hasTypeOrModifier = hasType;
     if (varFinalOrConst != null) {
       parseModifier(varFinalOrConst);
       modifierCount++;
       hasTypeOrModifier = true;
       modifierList.remove(varFinalOrConst);
     }
     listener.handleModifiers(modifierCount);
     var kind = hasTypeOrModifier
         ? MessageKind.EXTRANEOUS_MODIFIER
         : MessageKind.EXTRANEOUS_MODIFIER_REPLACE;
     for (Token modifier in modifierList) {
       listener.reportError(modifier, kind, {'modifier': modifier});
     }
     return null;
   }
 
-  Token parseFields(Token start,
-                    Link<Token> modifiers,
-                    Token type,
-                    Token getOrSet,
-                    Token name,
-                    bool isTopLevel) {
+  Token parseFields(Token start, Link<Token> modifiers, Token type,
+      Token getOrSet, Token name, bool isTopLevel) {
     bool hasType = type != null;
     Token varFinalOrConst =
         expectVarFinalOrConst(modifiers, hasType, !isTopLevel);
     bool isVar = false;
     bool hasModifier = false;
     if (varFinalOrConst != null) {
       hasModifier = true;
       isVar = optional('var', varFinalOrConst);
     }
 
     if (getOrSet != null) {
       var kind = (hasModifier || hasType)
           ? MessageKind.EXTRANEOUS_MODIFIER
           : MessageKind.EXTRANEOUS_MODIFIER_REPLACE;
       listener.reportError(getOrSet, kind, {'modifier': getOrSet});
     }
 
     if (!hasType) {
       listener.handleNoType(name);
     } else if (optional('void', type)) {
       listener.handleNoType(name);
       // TODO(ahe): This error is reported twice, second time is from
       // [parseVariablesDeclarationMaybeSemicolon] via
       // [PartialFieldListElement.parseNode].
       listener.reportError(type, MessageKind.VOID_NOT_ALLOWED);
     } else {
       parseType(type);
       if (isVar) {
-        listener.reportError(
-            modifiers.head, MessageKind.EXTRANEOUS_MODIFIER,
+        listener.reportError(modifiers.head, MessageKind.EXTRANEOUS_MODIFIER,
             {'modifier': modifiers.head});
       }
     }
 
     Token token = parseIdentifier(name);
 
     int fieldCount = 1;
     token = parseVariableInitializerOpt(token);
     while (optional(',', token)) {
       token = parseIdentifier(token.next);
       token = parseVariableInitializerOpt(token);
       ++fieldCount;
     }
     Token semicolon = token;
     token = expectSemicolon(token);
     if (isTopLevel) {
       listener.endTopLevelFields(fieldCount, start, semicolon);
     } else {
       listener.endFields(fieldCount, start, semicolon);
     }
     return token;
   }
 
-  Token parseTopLevelMethod(Token start,
-                            Link<Token> modifiers,
-                            Token type,
-                            Token getOrSet,
-                            Token name) {
-
+  Token parseTopLevelMethod(Token start, Link<Token> modifiers, Token type,
+      Token getOrSet, Token name) {
     Token externalModifier;
     // TODO(johnniwinther): Move error reporting to resolution to give more
     // specific error messages.
     for (Token modifier in modifiers) {
       if (externalModifier == null && optional('external', modifier)) {
         externalModifier = modifier;
       } else {
         listener.reportError(
             modifier, MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
       }
@@ skipping 56 matching lines @@
 
     // `true` if 'get' has been seen.
     bool isGetter = false;
     // `true` if an identifier has been seen after 'get'.
     bool hasName = false;
 
     while (token.kind != EOF_TOKEN) {
       String value = token.stringValue;
       if (value == 'get') {
         isGetter = true;
-      } else if (hasName &&
-                 (value == 'sync' || value == 'async')) {
+      } else if (hasName && (value == 'sync' || value == 'async')) {
         // Skip.
         token = token.next;
         value = token.stringValue;
         if (value == '*') {
           // Skip.
           token = token.next;
         }
         continue;
-      } else if (value == '(' ||
-                 value == '{' ||
-                 value == '=>') {
+      } else if (value == '(' || value == '{' || value == '=>') {
         // A method.
         identifiers = identifiers.prepend(token);
         return identifiers;
-      } else if (value == '=' ||
-                 value == ';' ||
-                 value == ',') {
+      } else if (value == '=' || value == ';' || value == ',') {
         // A field or abstract getter.
         identifiers = identifiers.prepend(token);
         return identifiers;
       } else if (isGetter) {
         hasName = true;
       }
       identifiers = identifiers.prepend(token);
       if (isValidTypeReference(token)) {
         // type ...
         if (optional('.', token.next)) {
@@ skipping 62 matching lines @@
     }
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
   bool isModifier(Token token) {
     final String value = token.stringValue;
     return (identical('final', value)) ||
-           (identical('var', value)) ||
-           (identical('const', value)) ||
-           (identical('abstract', value)) ||
-           (identical('static', value)) ||
-           (identical('external', value));
+        (identical('var', value)) ||
+        (identical('const', value)) ||
+        (identical('abstract', value)) ||
+        (identical('static', value)) ||
+        (identical('external', value));
   }
 
   Token parseModifier(Token token) {
     assert(isModifier(token));
     listener.handleModifier(token);
     return token.next;
   }
 
   void parseModifierList(Link<Token> tokens) {
     int count = 0;
     for (; !tokens.isEmpty; tokens = tokens.tail) {
       Token token = tokens.head;
       if (isModifier(token)) {
         parseModifier(token);
       } else {
         listener.unexpected(token);
         // Skip the remaining modifiers.
         break;
       }
       count++;
     }
     listener.handleModifiers(count);
   }
 
   Token parseModifiers(Token token) {
     int count = 0;
     while (identical(token.kind, KEYWORD_TOKEN)) {
-      if (!isModifier(token))
-        break;
+      if (!isModifier(token)) break;
       token = parseModifier(token);
       count++;
     }
     listener.handleModifiers(count);
     return token;
   }
 
   /**
    * Returns the first token after the type starting at [token].
    * This method assumes that [token] is an identifier (or void).
@@ skipping 101 matching lines @@
         identifiers = identifiers.tail;
       }
     }
 
     token = afterName;
     bool isField;
     while (true) {
       // Loop to allow the listener to rewrite the token stream for
       // error handling.
       final String value = token.stringValue;
-      if ((identical(value, '(')) || (identical(value, '.'))
-          || (identical(value, '{')) || (identical(value, '=>'))) {
+      if ((identical(value, '(')) ||
+          (identical(value, '.')) ||
+          (identical(value, '{')) ||
+          (identical(value, '=>'))) {
         isField = false;
         break;
       } else if (identical(value, ';')) {
         if (getOrSet != null) {
           // If we found a "get" keyword, this must be an abstract
           // getter.
           isField = (!identical(getOrSet.stringValue, 'get'));
           // TODO(ahe): This feels like a hack.
         } else {
           isField = true;
         }
         break;
       } else if ((identical(value, '=')) || (identical(value, ','))) {
         isField = true;
         break;
       } else {
         token = listener.unexpected(token);
         if (identical(token.kind, EOF_TOKEN)) {
           // TODO(ahe): This is a hack, see parseTopLevelMember.
           listener.endFields(1, start, token);
           return token;
         }
       }
     }
 
     var modifiers = identifiers.reverse();
     return isField
         ? parseFields(start, modifiers, type, getOrSet, name, false)
         : parseMethod(start, modifiers, type, getOrSet, name);
-
   }
 
-  Token parseMethod(Token start,
-                    Link<Token> modifiers,
-                    Token type,
-                    Token getOrSet,
-                    Token name) {
+  Token parseMethod(Token start, Link<Token> modifiers, Token type,
+      Token getOrSet, Token name) {
     Token externalModifier;
     Token staticModifier;
     Token constModifier;
     int modifierCount = 0;
     int allowedModifierCount = 1;
     // TODO(johnniwinther): Move error reporting to resolution to give more
     // specific error messages.
     for (Token modifier in modifiers) {
       if (externalModifier == null && optional('external', modifier)) {
         modifierCount++;
         externalModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(
-              modifier,
-              MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+          listener.reportError(modifier, MessageKind.EXTRANEOUS_MODIFIER,
+              {'modifier': modifier});
         }
         allowedModifierCount++;
       } else if (staticModifier == null && optional('static', modifier)) {
         modifierCount++;
         staticModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(
-              modifier,
-              MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+          listener.reportError(modifier, MessageKind.EXTRANEOUS_MODIFIER,
+              {'modifier': modifier});
         }
       } else if (constModifier == null && optional('const', modifier)) {
         modifierCount++;
         constModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(
-              modifier,
-              MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+          listener.reportError(modifier, MessageKind.EXTRANEOUS_MODIFIER,
+              {'modifier': modifier});
         }
       } else {
         listener.reportError(
             modifier, MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
       }
     }
-    if (getOrSet != null &&  constModifier != null) {
-      listener.reportError(
-          constModifier, MessageKind.EXTRANEOUS_MODIFIER,
+    if (getOrSet != null && constModifier != null) {
+      listener.reportError(constModifier, MessageKind.EXTRANEOUS_MODIFIER,
           {'modifier': constModifier});
     }
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
-        listener.reportError(
-            staticModifier, MessageKind.EXTRANEOUS_MODIFIER,
+        listener.reportError(staticModifier, MessageKind.EXTRANEOUS_MODIFIER,
             {'modifier': staticModifier});
       }
     } else {
       token = parseIdentifier(name);
     }
 
     token = parseQualifiedRestOpt(token);
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
@@ skipping 205 matching lines @@
         token = token.next;
       }
     } else if (optional('sync', token)) {
       async = token;
       token = token.next;
       if (optional('*', token)) {
         asyncAwaitKeywordsEnabled = true;
         star = token;
         token = token.next;
       } else {
-        listener.reportError(async,
-            MessageKind.INVALID_SYNC_MODIFIER);
+        listener.reportError(async, MessageKind.INVALID_SYNC_MODIFIER);
       }
     }
     listener.handleAsyncModifier(async, star);
     return token;
   }
 
   Token parseStatement(Token token) {
     final value = token.stringValue;
     if (identical(token.kind, IDENTIFIER_TOKEN)) {
       return parseExpressionStatementOrDeclaration(token);
@@ skipping 55 matching lines @@
     Token starToken;
     if (optional('*', token)) {
       starToken = token;
       token = token.next;
     }
     token = parseExpression(token);
     listener.endYieldStatement(begin, starToken, token);
     return expectSemicolon(token);
   }
 
-
   Token parseReturnStatement(Token token) {
     Token begin = token;
     listener.beginReturnStatement(begin);
     assert(identical('return', token.stringValue));
     token = token.next;
     if (optional(';', token)) {
       listener.endReturnStatement(false, begin, token);
     } else {
       token = parseExpression(token);
       listener.endReturnStatement(true, begin, token);
@@ skipping 134 matching lines @@
     assert(optional('?', token));
     Token question = token;
     token = parseExpressionWithoutCascade(token.next);
     Token colon = token;
     token = expect(':', token);
     token = parseExpressionWithoutCascade(token);
     listener.handleConditionalExpression(question, colon);
     return token;
   }
 
-  Token parsePrecedenceExpression(Token token, int precedence,
-                                  bool allowCascades) {
+  Token parsePrecedenceExpression(
+      Token token, int precedence, bool allowCascades) {
     assert(precedence >= 1);
     assert(precedence <= POSTFIX_PRECEDENCE);
     token = parseUnaryExpression(token, allowCascades);
     PrecedenceInfo info = token.info;
     int tokenLevel = info.precedence;
     for (int level = tokenLevel; level >= precedence; --level) {
       while (identical(tokenLevel, level)) {
         Token operator = token;
         if (identical(tokenLevel, CASCADE_PRECEDENCE)) {
           if (!allowCascades) {
             return token;
           }
           token = parseCascadeExpression(token);
         } else if (identical(tokenLevel, ASSIGNMENT_PRECEDENCE)) {
           // Right associative, so we recurse at the same precedence
           // level.
           token = parsePrecedenceExpression(token.next, level, allowCascades);
           listener.handleAssignmentExpression(operator);
         } else if (identical(tokenLevel, POSTFIX_PRECEDENCE)) {
           if (identical(info, PERIOD_INFO) ||
               identical(info, QUESTION_PERIOD_INFO)) {
             // Left associative, so we recurse at the next higher
             // precedence level. However, POSTFIX_PRECEDENCE is the
             // highest level, so we just call parseUnaryExpression
             // directly.
             token = parseUnaryExpression(token.next, allowCascades);
             listener.handleBinaryExpression(operator);
           } else if ((identical(info, OPEN_PAREN_INFO)) ||
-                     (identical(info, OPEN_SQUARE_BRACKET_INFO))) {
+              (identical(info, OPEN_SQUARE_BRACKET_INFO))) {
             token = parseArgumentOrIndexStar(token);
           } else if ((identical(info, PLUS_PLUS_INFO)) ||
-                     (identical(info, MINUS_MINUS_INFO))) {
+              (identical(info, MINUS_MINUS_INFO))) {
             listener.handleUnaryPostfixAssignmentExpression(token);
             token = token.next;
           } else {
             token = listener.unexpected(token);
           }
         } else if (identical(info, IS_INFO)) {
           token = parseIsOperatorRest(token);
         } else if (identical(info, AS_INFO)) {
           token = parseAsOperatorRest(token);
         } else if (identical(info, QUESTION_INFO)) {
           token = parseConditionalExpressionRest(token);
         } else {
           // Left associative, so we recurse at the next higher
           // precedence level.
-          token = parsePrecedenceExpression(token.next, level + 1,
-                                            allowCascades);
+          token =
+              parsePrecedenceExpression(token.next, level + 1, allowCascades);
           listener.handleBinaryExpression(operator);
         }
         info = token.info;
         tokenLevel = info.precedence;
         if (level == EQUALITY_PRECEDENCE || level == RELATIONAL_PRECEDENCE) {
           // We don't allow (a == b == c) or (a < b < c).
           // Continue the outer loop if we have matched one equality or
           // relational operator.
           break;
         }
@@ skipping 38 matching lines @@
   Token parseUnaryExpression(Token token, bool allowCascades) {
     String value = token.stringValue;
     // Prefix:
     if (asyncAwaitKeywordsEnabled && optional('await', token)) {
       return parseAwaitExpression(token, allowCascades);
     } else if (identical(value, '+')) {
       // Dart no longer allows prefix-plus.
       listener.reportError(token, MessageKind.UNSUPPORTED_PREFIX_PLUS);
       return parseUnaryExpression(token.next, allowCascades);
     } else if ((identical(value, '!')) ||
-               (identical(value, '-')) ||
-               (identical(value, '~'))) {
+        (identical(value, '-')) ||
+        (identical(value, '~'))) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
-      token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
-                                        allowCascades);
+      token = parsePrecedenceExpression(
+          token.next, POSTFIX_PRECEDENCE, allowCascades);
       listener.handleUnaryPrefixExpression(operator);
     } else if ((identical(value, '++')) || identical(value, '--')) {
       // TODO(ahe): Validate this is used correctly.
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
-      token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
-                                        allowCascades);
+      token = parsePrecedenceExpression(
+          token.next, POSTFIX_PRECEDENCE, allowCascades);
       listener.handleUnaryPrefixAssignmentExpression(operator);
     } else {
       token = parsePrimary(token);
     }
     return token;
   }
 
   Token parseArgumentOrIndexStar(Token token) {
     while (true) {
       if (optional('[', token)) {
@@ skipping 11 matching lines @@
         break;
       }
     }
     return token;
   }
 
   Token parsePrimary(Token token) {
     final kind = token.kind;
     if (kind == IDENTIFIER_TOKEN) {
       return parseSendOrFunctionLiteral(token);
-    } else if (kind == INT_TOKEN
-        || kind == HEXADECIMAL_TOKEN) {
+    } else if (kind == INT_TOKEN || kind == HEXADECIMAL_TOKEN) {
       return parseLiteralInt(token);
     } else if (kind == DOUBLE_TOKEN) {
       return parseLiteralDouble(token);
     } else if (kind == STRING_TOKEN) {
       return parseLiteralString(token);
     } else if (kind == HASH_TOKEN) {
       return parseLiteralSymbol(token);
     } else if (kind == KEYWORD_TOKEN) {
       final value = token.stringValue;
       if (value == 'true' || value == 'false') {
         return parseLiteralBool(token);
       } else if (value == 'null') {
         return parseLiteralNull(token);
       } else if (value == 'this') {
         return parseThisExpression(token);
       } else if (value == 'super') {
         return parseSuperExpression(token);
       } else if (value == 'new') {
         return parseNewExpression(token);
       } else if (value == 'const') {
         return parseConstExpression(token);
       } else if (value == 'void') {
         return parseFunctionExpression(token);
       } else if (asyncAwaitKeywordsEnabled &&
-                 (value == 'yield' || value == 'async')) {
+          (value == 'yield' || value == 'async')) {
         return listener.expectedExpression(token);
       } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
         return listener.expectedExpression(token);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
     } else if ((kind == LT_TOKEN) ||
-               (kind == OPEN_SQUARE_BRACKET_TOKEN) ||
-               (kind == OPEN_CURLY_BRACKET_TOKEN) ||
-               token.stringValue == '[]') {
+        (kind == OPEN_SQUARE_BRACKET_TOKEN) ||
+        (kind == OPEN_CURLY_BRACKET_TOKEN) ||
+        token.stringValue == '[]') {
       return parseLiteralListOrMap(token);
     } else {
       return listener.expectedExpression(token);
     }
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
         (identical(kind, FUNCTION_TOKEN) ||
-         identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
-         (identical(kind, KEYWORD_TOKEN) &&
-             (nextToken.value == 'async' || nextToken.value == 'sync')))) {
+            identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
+            (identical(kind, KEYWORD_TOKEN) &&
+                (nextToken.value == 'async' || nextToken.value == 'sync')))) {
       return parseUnnamedFunction(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
 
@@ skipping 318 matching lines @@
 
   Token parseVariablesDeclaration(Token token) {
     return parseVariablesDeclarationMaybeSemicolon(token, true);
   }
 
   Token parseVariablesDeclarationNoSemicolon(Token token) {
     // Only called when parsing a for loop, so this is for parsing locals.
     return parseVariablesDeclarationMaybeSemicolon(token, false);
   }
 
-  Token parseVariablesDeclarationMaybeSemicolon(Token token,
-                                                bool endWithSemicolon) {
+  Token parseVariablesDeclarationMaybeSemicolon(
+      Token token, bool endWithSemicolon) {
     int count = 1;
     listener.beginVariablesDeclaration(token);
     token = parseModifiers(token);
     token = parseTypeOpt(token);
     token = parseOptionallyInitializedIdentifier(token);
     while (optional(',', token)) {
       token = parseOptionallyInitializedIdentifier(token.next);
       ++count;
     }
     if (endWithSemicolon) {
@@ skipping 130 matching lines @@
       ++statementCount;
     }
     listener.endBlock(statementCount, begin, token);
     return expect('}', token);
   }
 
   Token parseAwaitExpression(Token token, bool allowCascades) {
     Token awaitToken = token;
     listener.beginAwaitExpression(awaitToken);
     token = expect('await', token);
-    token = parsePrecedenceExpression(token, POSTFIX_PRECEDENCE,
-                                      allowCascades);
+    token = parsePrecedenceExpression(token, POSTFIX_PRECEDENCE, allowCascades);
     listener.endAwaitExpression(awaitToken, token);
     return token;
   }
 
   Token parseThrowExpression(Token token, bool allowCascades) {
     Token throwToken = token;
     listener.beginThrowExpression(throwToken);
     token = expect('throw', token);
     token = allowCascades
         ? parseExpression(token)
@@ skipping 142 matching lines @@
           ((identical(value, '}')) && (identical(token, peek)))) {
         // A label just before "}" will be handled as a statement error.
         break;
       } else {
         token = parseStatement(token);
       }
       statementCount++;
       peek = peekPastLabels(token);
     }
     listener.handleSwitchCase(labelCount, expressionCount, defaultKeyword,
-                              statementCount, begin, token);
+        statementCount, begin, token);
     return token;
   }
 
   Token parseBreakStatement(Token token) {
     assert(optional('break', token));
     Token breakKeyword = token;
     token = token.next;
     bool hasTarget = false;
     if (token.isIdentifier()) {
       token = parseIdentifier(token);
@@ skipping 33 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }