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

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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.body_builder;
 
 import 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
 import '../../scanner/token.dart' show BeginToken, Token;
 
 import '../fasta_codes.dart' as fasta;
 
 import '../fasta_codes.dart' show LocatedMessage, Message;
 
 import '../messages.dart' as messages show getLocationFromUri;
 
 import '../modifier.dart' show Modifier, constMask, finalMask;
 
-import '../parser/identifier_context.dart' show IdentifierContext;
-
 import '../parser/native_support.dart' show skipNativeClause;
 
-import '../parser/parser.dart'
-    show Assert, FormalParameterType, MemberKind, optional;
+import '../parser.dart'
+    show Assert, FormalParameterKind, IdentifierContext, MemberKind, optional;
+
+import '../parser/formal_parameter_kind.dart'
+    show isOptionalPositionalFormalParameterKind;
 
 import '../problems.dart'
     show internalProblem, unexpected, unhandled, unsupported;
 
 import '../quote.dart'
     show
         Quote,
         analyzeQuote,
         unescape,
         unescapeFirstStringPart,
@@ skipping 1761 matching lines @@
       push(deprecated_buildCompileTimeError(
           "Not a constant expression.", throwToken.charOffset));
     } else {
       push(
           new KernelThrow(expression)..fileOffset = offsetForToken(throwToken));
     }
   }
 
   @override
   void endFormalParameter(Token thisKeyword, Token nameToken,
-      FormalParameterType kind, MemberKind memberKind) {
+      FormalParameterKind kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       if (!inConstructor) {
         deprecated_addCompileTimeError(thisKeyword.charOffset,
             "'this' parameters can only be used on constructors.");
         thisKeyword = null;
       }
     }
     Identifier name = pop();
     DartType type = pop();
@@ skipping 31 matching lines @@
         variable.fileOffset = offsetForToken(name.token);
       }
     }
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
-    FormalParameterType kind = optional("{", beginToken)
-        ? FormalParameterType.NAMED
-        : FormalParameterType.POSITIONAL;
+    FormalParameterKind kind = optional("{", beginToken)
+        ? FormalParameterKind.optionalNamed
+        : FormalParameterKind.optionalPositional;
     push(new OptionalFormals(kind, popList(count) ?? []));
   }
 
   @override
   void beginFunctionTypedFormalParameter(Token token) {
     debugEvent("beginFunctionTypedFormalParameter");
     functionNestingLevel++;
     enterFunctionTypeScope();
   }
 
@@ skipping 1766 matching lines @@
 
   void resolveGotos(SwitchCase target) {
     unsupported("resolveGotos", charOffset, fileUri);
   }
 
   @override
   String get fullNameForErrors => "<label-target>";
 }
 
 class OptionalFormals {
-  final FormalParameterType kind;
+  final FormalParameterKind kind;
 
   final List<VariableDeclaration> formals;
 
   OptionalFormals(this.kind, this.formals);
 }
 
 class FormalParameters {
   final List<VariableDeclaration> required;
   final OptionalFormals optional;
   final int charOffset;
 
   FormalParameters(this.required, this.optional, this.charOffset);
 
   FunctionNode addToFunction(FunctionNode function) {
     function.requiredParameterCount = required.length;
     function.positionalParameters.addAll(required);
     if (optional != null) {
-      if (optional.kind.isPositional) {
+      if (isOptionalPositionalFormalParameterKind(optional.kind)) {
         function.positionalParameters.addAll(optional.formals);
       } else {
         function.namedParameters.addAll(optional.formals);
         setParents(function.namedParameters, function);
       }
     }
     setParents(function.positionalParameters, function);
     return function;
   }
 
   FunctionType toFunctionType(DartType returnType,
       [List<TypeParameter> typeParameters]) {
     returnType ??= const DynamicType();
     typeParameters ??= const <TypeParameter>[];
     int requiredParameterCount = required.length;
     List<DartType> positionalParameters = <DartType>[];
     List<NamedType> namedParameters = const <NamedType>[];
     for (VariableDeclaration parameter in required) {
       positionalParameters.add(parameter.type);
     }
     if (optional != null) {
-      if (optional.kind.isPositional) {
+      if (isOptionalPositionalFormalParameterKind(optional.kind)) {
         for (VariableDeclaration parameter in optional.formals) {
           positionalParameters.add(parameter.type);
         }
       } else {
         namedParameters = <NamedType>[];
         for (VariableDeclaration parameter in optional.formals) {
           namedParameters.add(new NamedType(parameter.name, parameter.type));
         }
         namedParameters.sort();
       }
@@ skipping 81 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }