Move parser helper classes to own files and clean them up.

pkg/front_end/lib/src/fasta/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 fasta.parser.parser;
 
 import '../fasta_codes.dart' show Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 34 matching lines @@
         PERIOD_TOKEN,
         SEMICOLON_TOKEN,
         STRING_INTERPOLATION_IDENTIFIER_TOKEN,
         STRING_INTERPOLATION_TOKEN,
         STRING_TOKEN;
 
 import '../scanner/characters.dart' show $CLOSE_CURLY_BRACKET;
 
 import '../util/link.dart' show Link;
 
+import 'assert.dart' show Assert;
+
 import 'async_modifier.dart' show AsyncModifier;
 
+import 'formal_parameter_kind.dart'
+    show
+        FormalParameterKind,
+        isMandatoryFormalParameterKind,
+        isOptionalPositionalFormalParameterKind;
+
+import 'identifier_context.dart' show IdentifierContext;
+
 import 'listener.dart' show Listener;
 
-import 'identifier_context.dart' show IdentifierContext;
+import 'member_kind.dart' show MemberKind;
 
-/// Returns true if [token] is the symbol or keyword [value].
-bool optional(String value, Token token) {
-  return identical(value, token.stringValue);
-}
+import 'type_continuation.dart'
+    show TypeContinuation, typeContiunationFromFormalParameterKind;
 
-// TODO(ahe): Convert this to an enum.
-class FormalParameterType {
-  final String type;
-
-  final TypeContinuation typeContinuation;
-
-  const FormalParameterType(this.type, this.typeContinuation);
-
-  bool get isRequired => this == REQUIRED;
-
-  bool get isPositional => this == POSITIONAL;
-
-  bool get isNamed => this == NAMED;
-
-  static final REQUIRED = const FormalParameterType(
-      'required', TypeContinuation.NormalFormalParameter);
-
-  static final POSITIONAL = const FormalParameterType(
-      'positional', TypeContinuation.OptionalPositionalFormalParameter);
-
-  static final NAMED =
-      const FormalParameterType('named', TypeContinuation.NamedFormalParameter);
-}
-
-enum MemberKind {
-  /// A catch block, not a real member.
-  Catch,
-
-  /// A factory
-  Factory,
-
-  /// Old-style typedef.
-  FunctionTypeAlias,
-
-  /// Old-style function-typed parameter, not a real member.
-  FunctionTypedParameter,
-
-  /// A generalized function type, not a real member.
-  GeneralizedFunctionType,
-
-  /// A local function.
-  Local,
-
-  /// A non-static method in a class (including constructors).
-  NonStaticMethod,
-
-  /// A static method in a class.
-  StaticMethod,
-
-  /// A top-level method.
-  TopLevelMethod,
-
-  /// An instance field in a class.
-  NonStaticField,
-
-  /// A static field in a class.
-  StaticField,
-
-  /// A top-level field.
-  TopLevelField,
-}
-
-/// Syntactic forms of `assert`.
-///
-/// An assertion can legally occur as a statement. However, assertions are also
-/// experimentally allowed in initializers. For improved error recovery, we
-/// also attempt to parse asserts as expressions.
-enum Assert {
-  Expression,
-  Initializer,
-  Statement,
-}
-
-/// Indication of how the parser should continue after (attempting) to parse a
-/// type.
-///
-/// Depending on the continuation, the parser may not parse a type at all.
-enum TypeContinuation {
-  /// Indicates that a type is unconditionally expected.
-  Required,
-
-  /// Indicates that a type may follow. If the following matches one of these
-  /// productions, it is parsed as a type:
-  ///
-  ///  - `'void'`
-  ///  - `'Function' ( '(' | '<' )`
-  ///  - `identifier ('.' identifier)? ('<' ... '>')? identifer`
-  ///
-  /// Otherwise, do nothing.
-  Optional,
-
-  /// Same as [Optional], but we have seen `var`.
-  OptionalAfterVar,
-
-  /// Indicates that the keyword `typedef` has just been seen, and the parser
-  /// should parse the following as a type unless it is followed by `=`.
-  Typedef,
-
-  /// Indicates that what follows is either a local declaration or an
-  /// expression.
-  ExpressionStatementOrDeclaration,
-
-  /// Indicates that the keyword `const` has just been seen, and what follows
-  /// may be a local variable declaration or an expression.
-  ExpressionStatementOrConstDeclaration,
-
-  /// Indicates that the parser is parsing an expression and has just seen an
-  /// identifier.
-  SendOrFunctionLiteral,
-
-  /// Indicates that the parser has just parsed `for '('` and is looking to
-  /// parse a variable declaration or expression.
-  VariablesDeclarationOrExpression,
-
-  /// Indicates that an optional type followed by a normal formal parameter is
-  /// expected.
-  NormalFormalParameter,
-
-  /// Indicates that an optional type followed by an optional positional formal
-  /// parameter is expected.
-  OptionalPositionalFormalParameter,
-
-  /// Indicates that an optional type followed by a named formal parameter is
-  /// expected.
-  NamedFormalParameter,
-
-  /// Same as [NormalFormalParameter], but we have seen `var`.
-  NormalFormalParameterAfterVar,
-
-  /// Same as [OptionalPositionalFormalParameter], but we have seen `var`.
-  OptionalPositionalFormalParameterAfterVar,
-
-  /// Same as [NamedFormalParameter], but we have seen `var`.
-  NamedFormalParameterAfterVar,
-}
+import 'util.dart' show optional;
 
 /// An event generating parser of Dart programs. This parser expects all tokens
 /// in a linked list (aka a token stream).
 ///
 /// The class [Scanner] is used to generate a token stream. See the file
 /// [scanner.dart](../scanner.dart).
 ///
 /// Subclasses of the class [Listener] are used to listen to events.
 ///
 /// Most methods of this class belong in one of three major categories: parse
@@ skipping 501 matching lines @@
         break;
       } else if (identical(value, '{')) {
         token = parseOptionalFormalParameters(token, true, kind);
         break;
       } else if (identical(value, '[]')) {
         --parameterCount;
         reportRecoverableError(token, fasta.messageEmptyOptionalParameterList);
         token = token.next;
         break;
       }
-      token = parseFormalParameter(token, FormalParameterType.REQUIRED, kind);
+      token = parseFormalParameter(token, FormalParameterKind.mandatory, kind);
     } while (optional(',', token));
     listener.endFormalParameters(parameterCount, begin, token, kind);
     return expect(')', token);
   }
 
   Token parseFormalParameter(
-      Token token, FormalParameterType parameterKind, MemberKind memberKind) {
+      Token token, FormalParameterKind parameterKind, MemberKind memberKind) {
     token = parseMetadataStar(token, forParameter: true);
     listener.beginFormalParameter(token, memberKind);
     token = parseModifiers(token, memberKind, parameterKind: parameterKind);
     return token;
   }
 
   Token parseOptionalFormalParameters(
       Token token, bool isNamed, MemberKind kind) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
       token = token.next;
       if (isNamed && optional('}', token)) {
         break;
       } else if (!isNamed && optional(']', token)) {
         break;
       }
-      var type =
-          isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
+      var type = isNamed
+          ? FormalParameterKind.optionalNamed
+          : FormalParameterKind.optionalPositional;
       token = parseFormalParameter(token, type, kind);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
       reportRecoverableError(
           token,
           isNamed
               ? fasta.messageEmptyNamedParameterList
               : fasta.messageEmptyOptionalParameterList);
     }
@@ skipping 500 matching lines @@
     }
 
     /// Returns true if [token] could be the start of a function body.
     bool looksLikeFunctionBody(Token token) {
       return optional('{', token) ||
           optional('=>', token) ||
           optional('async', token) ||
           optional('sync', token);
     }
 
-    FormalParameterType parameterKind;
+    FormalParameterKind parameterKind;
     switch (continuation) {
       case TypeContinuation.Required:
         return commitType();
 
       optional:
       case TypeContinuation.Optional:
         if (looksLikeType) {
           if (functionTypes > 0) {
             return commitType(); // Parse function type.
           }
@@ skipping 118 matching lines @@
             token.isIdentifier &&
             isOneOf4(token.next, '=', ';', ',', 'in')) {
           // TODO(ahe): Generate type events and call
           // parseVariablesDeclarationNoSemicolonRest instead.
           return parseVariablesDeclarationNoSemicolon(begin);
         }
         return parseExpression(begin);
 
       case TypeContinuation.NormalFormalParameter:
       case TypeContinuation.NormalFormalParameterAfterVar:
-        parameterKind = FormalParameterType.REQUIRED;
+        parameterKind = FormalParameterKind.mandatory;
         hasVar = continuation == TypeContinuation.NormalFormalParameterAfterVar;
         continue handleParameters;
 
       case TypeContinuation.OptionalPositionalFormalParameter:
       case TypeContinuation.OptionalPositionalFormalParameterAfterVar:
-        parameterKind = FormalParameterType.POSITIONAL;
+        parameterKind = FormalParameterKind.optionalPositional;
         hasVar = continuation ==
             TypeContinuation.OptionalPositionalFormalParameterAfterVar;
         continue handleParameters;
 
       case TypeContinuation.NamedFormalParameterAfterVar:
         hasVar = true;
         continue handleParameters;
 
       handleParameters:
       case TypeContinuation.NamedFormalParameter:
-        parameterKind ??= FormalParameterType.NAMED;
+        parameterKind ??= FormalParameterKind.optionalNamed;
         bool inFunctionType = memberKind == MemberKind.GeneralizedFunctionType;
-        bool isNamedParameter = parameterKind == FormalParameterType.NAMED;
+        bool isNamedParameter =
+            parameterKind == FormalParameterKind.optionalNamed;
 
         bool untyped = false;
         if (!looksLikeType || optional("this", begin)) {
           untyped = true;
           token = begin;
         }
 
         Token thisKeyword;
         Token nameToken = token;
         IdentifierContext nameContext =
@@ skipping 76 matching lines @@
           parseIdentifier(nameToken, nameContext);
         } else {
           listener.handleNoName(nameToken);
         }
 
         String value = token.stringValue;
         if ((identical('=', value)) || (identical(':', value))) {
           Token equal = token;
           token = parseExpression(token.next);
           listener.handleValuedFormalParameter(equal, token);
-          if (parameterKind.isRequired) {
+          if (isMandatoryFormalParameterKind(parameterKind)) {
             reportRecoverableError(
                 equal, fasta.messageRequiredParameterWithDefault);
-          } else if (parameterKind.isPositional && identical(':', value)) {
+          } else if (isOptionalPositionalFormalParameterKind(parameterKind) &&
+              identical(':', value)) {
             reportRecoverableError(
                 equal, fasta.messagePositionalParameterWithEquals);
           } else if (inFunctionType ||
               memberKind == MemberKind.FunctionTypeAlias ||
               memberKind == MemberKind.FunctionTypedParameter) {
             reportRecoverableError(
                 equal.next, fasta.messageFunctionTypeDefaultValue);
           }
         } else {
           listener.handleFormalParameterWithoutValue(token);
@@ skipping 484 matching lines @@
   }
 
   /// This method is used in most locations where modifiers can occur. However,
   /// it isn't used when parsing a class or when parsing the modifiers of a
   /// member function (non-local), but is used when parsing their formal
   /// parameters.
   ///
   /// When parsing the formal parameters of any function, [parameterKind] is
   /// non-null.
   Token parseModifiers(Token token, MemberKind memberKind,
-      {FormalParameterType parameterKind, bool isVarAllowed: false}) {
+      {FormalParameterKind parameterKind, bool isVarAllowed: false}) {
     int count = 0;
 
     int currentOrder = -1;
-    TypeContinuation typeContinuation = parameterKind?.typeContinuation;
+    TypeContinuation typeContinuation =
+        typeContiunationFromFormalParameterKind(parameterKind);
 
     while (token.kind == KEYWORD_TOKEN) {
       if (token.type.isPseudo) {
         // A pseudo keyword is never a modifier.
         break;
       }
       if (token.type.isBuiltIn) {
         // A built-in identifier can only be a modifier as long as it is
         // followed by another modifier or an identifier. Otherwise, it is the
         // identifier.
@@ skipping 2086 matching lines @@
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableErrorWithToken(
         token, fasta.templateUnexpectedToken);
   }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = Message Function(T);