Implement type variables on old style function-typed formal parameters.

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 FastaCode, FastaMessage;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 45 matching lines @@
 
 import 'listener.dart' show Listener;
 
 import 'identifier_context.dart' show IdentifierContext;
 
 /// Returns true if [token] is the symbol or keyword [value].
 bool optional(String value, Token token) {
   return identical(value, token.stringValue);
 }
 
+// TODO(ahe): Convert this to an enum.
 class FormalParameterType {
   final String type;
-  const FormalParameterType(this.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');
-  static final POSITIONAL = const FormalParameterType('positional');
-  static final NAMED = const FormalParameterType('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.
@@ skipping 49 matching lines @@
   /// 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,
 }
 
 /// 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.
 ///
@@ skipping 373 matching lines @@
           IdentifierContext.partNameContinuation);
     } else {
       token = parseLiteralStringOrRecoverExpression(token);
     }
     Token semicolon = token;
     token = expect(';', token);
     listener.endPartOf(partKeyword, semicolon, hasName);
     return token;
   }
 
-  Token parseMetadataStar(Token token, {bool forParameter: false}) {
+  Token parseMetadataStar(Token token,
+      // TODO(ahe): Remove [forParameter].
+      {bool forParameter: false}) {
     token = listener.injectGenericCommentTypeAssign(token);
     listener.beginMetadataStar(token);
     int count = 0;
     while (optional('@', token)) {
       token = parseMetadata(token);
       count++;
     }
     listener.endMetadataStar(count, forParameter);
     return token;
   }
@@ skipping 116 matching lines @@
       token = parseFormalParameter(token, FormalParameterType.REQUIRED, kind);
     } while (optional(',', token));
     listener.endFormalParameters(parameterCount, begin, token, kind);
     return expect(')', token);
   }
 
   Token parseFormalParameter(
       Token token, FormalParameterType parameterKind, MemberKind memberKind) {
     token = parseMetadataStar(token, forParameter: true);
     listener.beginFormalParameter(token, memberKind);
-
-    bool inFunctionType = memberKind == MemberKind.GeneralizedFunctionType;
     token = parseModifiers(token, memberKind, parameterKind: parameterKind);
-    bool isNamedParameter = parameterKind == FormalParameterType.NAMED;
-
-    Token thisKeyword = null;
-    Token nameToken;
-    if (inFunctionType) {
-      if (isNamedParameter || token.isIdentifier) {
-        nameToken = token;
-        token = parseIdentifier(
-            token, IdentifierContext.formalParameterDeclaration);
-      } else {
-        listener.handleNoName(token);
-      }
-    } else {
-      if (optional('this', token)) {
-        thisKeyword = token;
-        token = expect('.', token.next);
-        nameToken = token;
-        token = parseIdentifier(token, IdentifierContext.fieldInitializer);
-      } else {
-        nameToken = token;
-        token = parseIdentifier(
-            token, IdentifierContext.formalParameterDeclaration);
-      }
-    }
-    if (isNamedParameter && nameToken.lexeme.startsWith("_")) {
-      reportRecoverableErrorCode(nameToken, fasta.codePrivateNamedParameter);
-    }
-
-    token = listener.injectGenericCommentTypeList(token);
-    if (optional('(', token)) {
-      Token inlineFunctionTypeStart = token;
-      listener.beginFunctionTypedFormalParameter(token);
-      listener.handleNoTypeVariables(token);
-      token = parseFormalParameters(token, MemberKind.FunctionTypedParameter);
-      listener.endFunctionTypedFormalParameter(thisKeyword, parameterKind);
-      // Generalized function types don't allow inline function types.
-      // The following isn't allowed:
-      //    int Function(int bar(String x)).
-      if (memberKind == MemberKind.GeneralizedFunctionType) {
-        reportRecoverableErrorCode(
-            inlineFunctionTypeStart, fasta.codeInvalidInlineFunctionType);
-      }
-    } else if (optional('<', token)) {
-      Token inlineFunctionTypeStart = token;
-      listener.beginFunctionTypedFormalParameter(token);
-      token = parseTypeVariablesOpt(token);
-      token = parseFormalParameters(token, MemberKind.FunctionTypedParameter);
-      listener.endFunctionTypedFormalParameter(thisKeyword, parameterKind);
-      // Generalized function types don't allow inline function types.
-      // The following isn't allowed:
-      //    int Function(int bar(String x)).
-      if (memberKind == MemberKind.GeneralizedFunctionType) {
-        reportRecoverableErrorCode(
-            inlineFunctionTypeStart, fasta.codeInvalidInlineFunctionType);
-      }
-    }
-    String value = token.stringValue;
-    if ((identical('=', value)) || (identical(':', value))) {
-      Token equal = token;
-      token = parseExpression(token.next);
-      listener.handleValuedFormalParameter(equal, token);
-      if (parameterKind.isRequired) {
-        reportRecoverableErrorCode(
-            equal, fasta.codeRequiredParameterWithDefault);
-      } else if (parameterKind.isPositional && identical(':', value)) {
-        reportRecoverableErrorCode(
-            equal, fasta.codePositionalParameterWithEquals);
-      } else if (inFunctionType ||
-          memberKind == MemberKind.FunctionTypeAlias ||
-          memberKind == MemberKind.FunctionTypedParameter) {
-        reportRecoverableErrorCode(
-            equal.next, fasta.codeFunctionTypeDefaultValue);
-      }
-    } else {
-      listener.handleFormalParameterWithoutValue(token);
-    }
-    listener.endFormalParameter(
-        thisKeyword, nameToken, parameterKind, memberKind);
     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 {
@@ skipping 336 matching lines @@
     return optional('Function', token) &&
         (optional('<', token.next) || optional('(', token.next));
   }
 
   /// Parse a type, if it is appropriate to do so.
   ///
   /// If this method can parse a type, it will return the next (non-null) token
   /// after the type. Otherwise, it returns null.
   Token parseType(Token token,
       [TypeContinuation continuation = TypeContinuation.Required,
-      IdentifierContext continuationContext]) {
+      IdentifierContext continuationContext,
+      MemberKind memberKind]) {
     /// Returns the close brace, bracket, or parenthesis of [left]. For '<', it
     /// may return null.
     Token getClose(BeginToken left) => left.endToken;
 
+    /// True if we've seen the `var` keyword.
+    bool hasVar = false;
+
     /// Where the type begins.
     Token begin;
 
     /// Non-null if 'void' is the first token.
     Token voidToken;
 
     /// True if the tokens at [begin] looks like a type.
     bool looksLikeType = false;
 
     /// True if a type that could be a return type for a generalized function
@@ skipping 132 matching lines @@
         token = token.next;
         if (optional("<", token)) {
           // Skip type parameters, they were parsed above.
           token = getClose(token).next;
         }
         token =
             parseFormalParameters(token, MemberKind.GeneralizedFunctionType);
         listener.endFunctionType(functionToken, token);
       }
 
+      if (hasVar) {
+        reportRecoverableErrorCode(begin, fasta.codeTypeAfterVar);
+      }
+
       return token;
     }
 
     /// Returns true if [kind] is '=', ';', or ',', that is, if [kind] could be
     /// the end of a variable declaration.
     bool looksLikeVariableDeclarationEnd(int kind) {
       return EQ_TOKEN == kind || SEMICOLON_TOKEN == kind || COMMA_TOKEN == kind;
     }
 
     /// 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;
     switch (continuation) {
       case TypeContinuation.Required:
         return commitType();
 
       optional:
       case TypeContinuation.Optional:
         if (looksLikeType) {
           if (functionTypes > 0) {
             return commitType(); // Parse function type.
           }
           if (voidToken != null) {
             listener.handleVoidKeyword(voidToken);
             return voidToken.next;
           }
           if (token.isIdentifier || optional('this', token)) {
             return commitType(); // Parse type.
           }
         }
         listener.handleNoType(begin);
         return begin;
 
+      case TypeContinuation.OptionalAfterVar:
+        hasVar = true;
+        continue optional;
+
       case TypeContinuation.Typedef:
         if (optional('=', token)) {
           return null; // This isn't a type, it's a new-style typedef.
         }
         continue optional;
 
       case TypeContinuation.ExpressionStatementOrDeclaration:
         assert(begin.isIdentifier || identical(begin.stringValue, 'void'));
         if (!inPlainSync && optional("await", begin)) {
           return parseExpressionStatement(begin);
@@ skipping 90 matching lines @@
 
       case TypeContinuation.VariablesDeclarationOrExpression:
         if (looksLikeType &&
             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;
+        hasVar = continuation == TypeContinuation.NormalFormalParameterAfterVar;
+        continue handleParameters;
+
+      case TypeContinuation.OptionalPositionalFormalParameter:
+      case TypeContinuation.OptionalPositionalFormalParameterAfterVar:
+        parameterKind = FormalParameterType.POSITIONAL;
+        hasVar = continuation ==
+            TypeContinuation.OptionalPositionalFormalParameterAfterVar;
+        continue handleParameters;
+
+      case TypeContinuation.NamedFormalParameterAfterVar:
+        hasVar = true;
+        continue handleParameters;
+
+      handleParameters:
+      case TypeContinuation.NamedFormalParameter:
+        parameterKind ??= FormalParameterType.NAMED;
+        bool inFunctionType = memberKind == MemberKind.GeneralizedFunctionType;
+        bool isNamedParameter = parameterKind == FormalParameterType.NAMED;
+
+        bool untyped = false;
+        if (!looksLikeType || optional("this", begin)) {
+          untyped = true;
+          token = begin;
+        }
+
+        Token thisKeyword;
+        Token nameToken = token;
+        IdentifierContext nameContext =
+            IdentifierContext.formalParameterDeclaration;
+        token = token.next;
+        if (inFunctionType) {
+          if (isNamedParameter || nameToken.isIdentifier) {
+            nameContext = IdentifierContext.formalParameterDeclaration;
+          } else {
+            // No name required in a function type.
+            nameContext = null;
+            token = nameToken;
+          }
+        } else if (optional('this', nameToken)) {
+          thisKeyword = nameToken;
+          token = expect('.', token);
+          nameToken = token;
+          nameContext = IdentifierContext.fieldInitializer;
+          token = token.next;
+        } else if (!nameToken.isIdentifier) {
+          untyped = true;
+          nameToken = begin;
+          token = nameToken.next;
+        }
+        if (isNamedParameter && nameToken.lexeme.startsWith("_")) {
+          // TODO(ahe): Move this to after commiting the type.
+          reportRecoverableErrorCode(
+              nameToken, fasta.codePrivateNamedParameter);
+        }
+
+        token = listener.injectGenericCommentTypeList(token);
+
+        Token inlineFunctionTypeStart;
+        if (optional("<", token)) {
+          Token closer = getClose(token);
+          if (closer != null) {
+            if (optional("(", closer.next)) {
+              inlineFunctionTypeStart = token;
+              token = token.next;
+            }
+          }
+        } else if (optional("(", token)) {
+          inlineFunctionTypeStart = token;
+          token = getClose(token).next;
+        }
+
+        if (inlineFunctionTypeStart != null) {
+          token = parseTypeVariablesOpt(inlineFunctionTypeStart);
+          listener.beginFunctionTypedFormalParameter(inlineFunctionTypeStart);
+          if (!untyped) {
+            if (voidToken != null) {
+              listener.handleVoidKeyword(voidToken);
+            } else {
+              Token saved = token;
+              commitType();
+              token = saved;
+            }
+          } else {
+            listener.handleNoType(begin);
+          }
+          token =
+              parseFormalParameters(token, MemberKind.FunctionTypedParameter);
+          listener.endFunctionTypedFormalParameter();
+
+          // Generalized function types don't allow inline function types.
+          // The following isn't allowed:
+          //    int Function(int bar(String x)).
+          if (memberKind == MemberKind.GeneralizedFunctionType) {
+            reportRecoverableErrorCode(
+                inlineFunctionTypeStart, fasta.codeInvalidInlineFunctionType);
+          }
+        } else if (untyped) {
+          listener.handleNoType(begin);
+        } else {
+          Token saved = token;
+          commitType();
+          token = saved;
+        }
+
+        if (nameContext != null) {
+          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) {
+            reportRecoverableErrorCode(
+                equal, fasta.codeRequiredParameterWithDefault);
+          } else if (parameterKind.isPositional && identical(':', value)) {
+            reportRecoverableErrorCode(
+                equal, fasta.codePositionalParameterWithEquals);
+          } else if (inFunctionType ||
+              memberKind == MemberKind.FunctionTypeAlias ||
+              memberKind == MemberKind.FunctionTypedParameter) {
+            reportRecoverableErrorCode(
+                equal.next, fasta.codeFunctionTypeDefaultValue);
+          }
+        } else {
+          listener.handleFormalParameterWithoutValue(token);
+        }
+        listener.endFormalParameter(
+            thisKeyword, nameToken, parameterKind, memberKind);
+
+        return token;
     }
 
     throw "Internal error: Unhandled continuation '$continuation'.";
   }
 
   Token parseTypeArgumentsOpt(Token token) {
     return parseStuff(
         token,
         (t) => listener.beginTypeArguments(t),
         (t) => parseType(t),
@@ skipping 112 matching lines @@
     for (Token modifier in modifiers) {
       if (optional("var", modifier) ||
           optional("final", modifier) ||
           optional("const", modifier)) {
         varFinalOrConst = modifier;
         break;
       }
     }
     Token token = parseModifiers(start,
         isTopLevel ? MemberKind.TopLevelField : MemberKind.NonStaticField,
-        isVariable: true);
+        isVarAllowed: true);
 
     if (token != name) {
       reportRecoverableErrorCodeWithToken(token, fasta.codeExtraneousModifier);
       token = name;
     }
 
     IdentifierContext context = isTopLevel
         ? IdentifierContext.topLevelVariableDeclaration
         : IdentifierContext.fieldDeclaration;
     token = parseIdentifier(token, context);
@@ skipping 334 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 isVariable: false}) {
-    bool returnTypeAllowed =
-        !isVariable && memberKind != MemberKind.GeneralizedFunctionType;
-    bool typeRequired =
-        isVariable || memberKind == MemberKind.GeneralizedFunctionType;
+      {FormalParameterType parameterKind, bool isVarAllowed: false}) {
     int count = 0;
 
     int currentOrder = -1;
-    bool hasVar = false;
+    TypeContinuation typeContinuation = parameterKind?.typeContinuation;
+
     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.
         if (token.next.kind != KEYWORD_TOKEN && !token.next.isIdentifier) {
           break;
         }
       }
       int order = modifierOrder(token);
       if (order < 3) {
         // `abstract` isn't parsed with this method.
         if (order > currentOrder) {
           currentOrder = order;
           if (optional("var", token)) {
-            if (!isVariable && parameterKind == null) {
+            if (!isVarAllowed && parameterKind == null) {
               reportRecoverableErrorCodeWithToken(
                   token, fasta.codeExtraneousModifier);
             }
-            hasVar = true;
-            typeRequired = false;
+            switch (typeContinuation ?? TypeContinuation.Required) {
+              case TypeContinuation.NormalFormalParameter:
+                typeContinuation =
+                    TypeContinuation.NormalFormalParameterAfterVar;
+                break;
+
+              case TypeContinuation.OptionalPositionalFormalParameter:
+                typeContinuation =
+                    TypeContinuation.OptionalPositionalFormalParameterAfterVar;
+                break;
+
+              case TypeContinuation.NamedFormalParameter:
+                typeContinuation =
+                    TypeContinuation.NamedFormalParameterAfterVar;
+                break;
+
+              default:
+                typeContinuation = TypeContinuation.OptionalAfterVar;
+                break;
+            }
           } else if (optional("final", token)) {
-            if (!isVariable && parameterKind == null) {
+            if (!isVarAllowed && parameterKind == null) {
               reportRecoverableErrorCodeWithToken(
                   token, fasta.codeExtraneousModifier);
             }
-            typeRequired = false;
+            typeContinuation ??= TypeContinuation.Optional;
           } else if (optional("const", token)) {
-            if (!isVariable) {
+            if (!isVarAllowed) {
               reportRecoverableErrorCodeWithToken(
                   token, fasta.codeExtraneousModifier);
             }
-            typeRequired = false;
+            typeContinuation ??= TypeContinuation.Optional;
           } else if (optional("static", token)) {
             if (parameterKind != null) {
               reportRecoverableErrorCodeWithToken(
                   token, fasta.codeExtraneousModifier);
             } else if (memberKind == MemberKind.NonStaticMethod) {
               memberKind = MemberKind.StaticMethod;
             } else if (memberKind == MemberKind.NonStaticField) {
               memberKind = MemberKind.StaticField;
             } else {
               reportRecoverableErrorCodeWithToken(
@@ skipping 36 matching lines @@
           reportRecoverableErrorCodeWithToken(
               token, fasta.codeExtraneousModifier);
           token = token.next;
         }
       } else {
         break;
       }
     }
     listener.handleModifiers(count);
 
-    Token beforeType = token;
-    token = parseType(
-        token,
-        returnTypeAllowed || !typeRequired
-            ? TypeContinuation.Optional
-            : TypeContinuation.Required);
-    if (typeRequired && beforeType == token) {
-      reportRecoverableErrorCode(token, fasta.codeTypeRequired);
-    }
-    if (hasVar && beforeType != token) {
-      reportRecoverableErrorCode(beforeType, fasta.codeTypeAfterVar);
-    }
+    typeContinuation ??=
+        (isVarAllowed || memberKind == MemberKind.GeneralizedFunctionType)
+            ? TypeContinuation.Required
+            : TypeContinuation.Optional;
+
+    token = parseType(token, typeContinuation, null, memberKind);
     return token;
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableErrorCodeWithToken(
               token, fasta.codeExpectedClassBodyToSkip)
           .next;
     }
     BeginToken beginGroupToken = token;
@@ skipping 1446 matching lines @@
       Token token, bool endWithSemicolon) {
     token = parseMetadataStar(token);
 
     // If the next token has a type substitution comment /*=T*/, then
     // the current 'var' token should be repealed and replaced.
     if (optional('var', token)) {
       token =
           listener.replaceTokenWithGenericCommentTypeAssign(token, token.next);
     }
 
-    token = parseModifiers(token, MemberKind.Local, isVariable: true);
+    token = parseModifiers(token, MemberKind.Local, isVarAllowed: true);
     return parseVariablesDeclarationMaybeSemicolonRest(token, endWithSemicolon);
   }
 
   Token parseVariablesDeclarationMaybeSemicolonRest(
       Token token, bool endWithSemicolon) {
     int count = 1;
     listener.beginVariablesDeclaration(token);
     token = parseOptionallyInitializedIdentifier(token);
     while (optional(',', token)) {
       token = parseOptionallyInitializedIdentifier(token.next);
@@ skipping 516 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);