Add preliminary parser support for generic function types

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1517 matching lines @@
       _currentToken = _injectToken(
           new Parser_SyntheticKeywordToken(Keyword.GET, _currentToken.offset));
       return parseGetter(commentAndMetadata, modifiers.externalKeyword,
           modifiers.staticKeyword, type);
     }
     return parseInitializedIdentifierList(commentAndMetadata,
         modifiers.staticKeyword, _validateModifiersForField(modifiers), type);
   }
 
   /**
-   * Parse a class type alias. The [commentAndMetadata] is the metadata to be
-   * associated with the member. The [abstractKeyword] is the token representing
-   * the 'abstract' keyword. The [classKeyword] is the token representing the
-   * 'class' keyword. Return the class type alias that was parsed.
-   *
-   * This method assumes that the current token matches an identifier.
-   *
-   *     classTypeAlias ::=
-   *         identifier typeParameters? '=' 'abstract'? mixinApplication
-   *
-   *     mixinApplication ::=
-   *         type withClause implementsClause? ';'
-   */
-  ClassTypeAlias parseClassTypeAlias(CommentAndMetadata commentAndMetadata,
-      Token abstractKeyword, Token classKeyword) {
-    SimpleIdentifier className =
-        _parseSimpleIdentifierUnchecked(isDeclaration: true);
-    TypeParameterList typeParameters = null;
-    if (_matches(TokenType.LT)) {
-      typeParameters = parseTypeParameterList();
-    }
-    return _parseClassTypeAliasAfterName(commentAndMetadata, abstractKeyword,
-        classKeyword, className, typeParameters);
-  }
-
-  /**
    * Parse a single combinator. Return the combinator that was parsed, or `null`
    * if no combinator is found.
    *
    *     combinator ::=
    *         'show' identifier (',' identifier)*
    *       | 'hide' identifier (',' identifier)*
    */
   Combinator parseCombinator() {
     if (_matchesString(_SHOW)) {
       return astFactory.showCombinator(getAndAdvance(), parseIdentifierList());
@@ skipping 1199 matching lines @@
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration.
    * The [optional] is `true` if the keyword and type are optional. Return the
    * 'final', 'const', 'var' or type that was parsed.
    *
    *     finalConstVarOrType ::=
    *         'final' type?
    *       | 'const' type?
    *       | 'var'
    *       | type
    */
-  FinalConstVarOrType parseFinalConstVarOrType(bool optional) {
+  FinalConstVarOrType parseFinalConstVarOrType(bool optional,
+      {bool inFunctionType = false}) {
     Token keywordToken = null;
     TypeName type = null;
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.FINAL || keyword == Keyword.CONST) {
       keywordToken = getAndAdvance();
       if (_isTypedIdentifier(_currentToken)) {
         type = parseTypeName(false);
       } else {
         // Support `final/*=T*/ x;`
         type = _parseOptionalTypeNameComment();
       }
     } else if (keyword == Keyword.VAR) {
       keywordToken = getAndAdvance();
       // Support `var/*=T*/ x;`
       type = _parseOptionalTypeNameComment();
       if (type != null) {
         // Clear the keyword to prevent an error.
         keywordToken = null;
       }
     } else if (_isTypedIdentifier(_currentToken)) {
       type = parseReturnType();
+    } else if (inFunctionType && _matchesIdentifier()) {
+      type = parseTypeAnnotation();
     } else if (!optional) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
     } else {
       // Support parameters such as `(/*=K*/ key, /*=V*/ value)`
       // This is not supported if the type is required.
       type = _parseOptionalTypeNameComment();
     }
     return new FinalConstVarOrType(keywordToken, type);
   }
 
   /**
    * Parse a formal parameter. At most one of `isOptional` and `isNamed` can be
    * `true`. The [kind] is the kind of parameter being expected based on the
    * presence or absence of group delimiters. Return the formal parameter that
    * was parsed.
    *
    *     defaultFormalParameter ::=
    *         normalFormalParameter ('=' expression)?
    *
    *     defaultNamedParameter ::=
    *         normalFormalParameter ('=' expression)?
    *         normalFormalParameter (':' expression)?
    */
-  FormalParameter parseFormalParameter(ParameterKind kind) {
-    NormalFormalParameter parameter = parseNormalFormalParameter();
+  FormalParameter parseFormalParameter(ParameterKind kind,
+      {bool inFunctionType = false}) {
+    NormalFormalParameter parameter =
+        parseNormalFormalParameter(inFunctionType: inFunctionType);
     TokenType type = _currentToken.type;
     if (type == TokenType.EQ) {
+      if (inFunctionType) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE);
+      }
       Token separator = getAndAdvance();
       Expression defaultValue = parseExpression2();
       if (kind == ParameterKind.REQUIRED) {
         _reportErrorForNode(
             ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP, parameter);
         kind = ParameterKind.POSITIONAL;
+      } else if (kind == ParameterKind.NAMED &&
+          inFunctionType &&
+          parameter.identifier == null) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER);
       }
       return astFactory.defaultFormalParameter(
           parameter, kind, separator, defaultValue);
     } else if (type == TokenType.COLON) {
+      if (inFunctionType) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE);
+      }
       Token separator = getAndAdvance();
       Expression defaultValue = parseExpression2();
-      if (kind == ParameterKind.POSITIONAL) {
+      if (kind == ParameterKind.REQUIRED) {
+        _reportErrorForNode(
+            ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, parameter);
+        kind = ParameterKind.NAMED;
+      } else if (kind == ParameterKind.POSITIONAL) {
         _reportErrorForToken(
             ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
             separator);
-      } else if (kind == ParameterKind.REQUIRED) {
-        _reportErrorForNode(
-            ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, parameter);
-        kind = ParameterKind.NAMED;
+      } else if (kind == ParameterKind.NAMED &&
+          inFunctionType &&
+          parameter.identifier == null) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER);
       }
       return astFactory.defaultFormalParameter(
           parameter, kind, separator, defaultValue);
     } else if (kind != ParameterKind.REQUIRED) {
+      if (kind == ParameterKind.NAMED &&
+          inFunctionType &&
+          parameter.identifier == null) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER);
+      }
       return astFactory.defaultFormalParameter(parameter, kind, null, null);
     }
     return parameter;
   }
 
   /**
    * Parse a list of formal parameters. Return the formal parameters that were
    * parsed.
    *
    *     formalParameterList ::=
    *         '(' ')'
    *       | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
    *       | '(' optionalFormalParameters ')'
    *
    *     normalFormalParameters ::=
    *         normalFormalParameter (',' normalFormalParameter)*
    *
    *     optionalFormalParameters ::=
    *         optionalPositionalFormalParameters
    *       | namedFormalParameters
    *
    *     optionalPositionalFormalParameters ::=
    *         '[' defaultFormalParameter (',' defaultFormalParameter)* ']'
    *
    *     namedFormalParameters ::=
    *         '{' defaultNamedParameter (',' defaultNamedParameter)* '}'
    */
-  FormalParameterList parseFormalParameterList() {
+  FormalParameterList parseFormalParameterList({bool inFunctionType = false}) {
     if (_matches(TokenType.OPEN_PAREN)) {
-      return _parseFormalParameterListUnchecked();
+      return _parseFormalParameterListUnchecked(inFunctionType: inFunctionType);
     }
     // TODO(brianwilkerson) Improve the error message.
     _reportErrorForCurrentToken(
         ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_PAREN.lexeme]);
     // Recovery: Check for an unmatched closing paren and parse parameters until
     // it is reached.
     return _parseFormalParameterListAfterParen(
         _createSyntheticToken(TokenType.OPEN_PAREN));
   }
 
@@ skipping 363 matching lines @@
   FunctionExpression parseFunctionExpression() {
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true);
     return astFactory.functionExpression(typeParameters, parameters, body);
   }
 
   /**
+   * Parse the portion of a generic function type following the [returnType].
+   *
+   *     functionType ::=
+   *         returnType? 'Function' typeParameters? parameterTypeList
+   *     parameterTypeList ::=
+   *         '(' ')' |
+   *       | '(' normalParameterTypes ','? ')' |
+   *       | '(' normalParameterTypes ',' optionalParameterTypes ')' |
+   *       | '(' optionalParameterTypes ')'
+   *     normalParameterTypes ::=
+   *     normalParameterType (',' normalParameterType)*
+   *     normalParameterType ::=
+   *         type | typedIdentifier
+   *     optionalParameterTypes ::=
+   *         optionalPositionalParameterTypes | namedParameterTypes
+   *     optionalPositionalParameterTypes ::=
+   *         '[' normalParameterTypes ','? ']'
+   *     namedParameterTypes ::=
+   *         '{' typedIdentifier (',' typedIdentifier)* ','? '}'
+   *     typedIdentifier ::=
+   *         type identifier
+   */
+  GenericFunctionType parseGenericFunctionTypeAfterReturnType(
+      TypeAnnotation returnType) {
+    Token functionKeyword = null;
+    if (_matchesString('Function')) {
+      functionKeyword = getAndAdvance();
+    } else if (_matchesIdentifier()) {
+      _reportErrorForCurrentToken(ParserErrorCode.NAMED_FUNCTION_TYPE);
+    } else {
+      _reportErrorForCurrentToken(ParserErrorCode.MISSING_FUNCTION_KEYWORD);
+    }
+    TypeParameterList typeParameters = null;
+    if (_matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
+    FormalParameterList parameters =
+        parseFormalParameterList(inFunctionType: true);
+    return astFactory.genericFunctionType(
+        returnType, functionKeyword, typeParameters, parameters);
+  }
+
+  /**
+   * Parse a generic function type alias.
+   *
+   * This method assumes that the current token is an identifier.
+   *
+   *     genericTypeAlias ::=
+   *         'typedef' identifier typeParameterList? '=' functionType ';'
+   */
+  GenericTypeAlias parseGenericTypeAlias(
+      CommentAndMetadata commentAndMetadata, Token keyword) {
+    Identifier name = _parseSimpleIdentifierUnchecked(isDeclaration: true);
+    TypeParameterList typeParameters = null;
+    if (_matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
+    Token equals = _expect(TokenType.EQ);
+    TypeAnnotation functionType = parseTypeAnnotation();
+    Token semicolon = _expect(TokenType.SEMICOLON);
+    if (functionType is! GenericFunctionType) {
+      // TODO(brianwilkerson) Generate an error and recover (better than this).
+      return astFactory.genericTypeAlias(
+          commentAndMetadata.comment,
+          commentAndMetadata.metadata,
+          keyword,
+          name,
+          typeParameters,
+          equals,
+          null,
+          semicolon);
+    }
+    return astFactory.genericTypeAlias(
+        commentAndMetadata.comment,
+        commentAndMetadata.metadata,
+        keyword,
+        name,
+        typeParameters,
+        equals,
+        functionType,
+        semicolon);
+  }
+
+  /**
    * Parse a getter. The [commentAndMetadata] is the documentation comment and
    * metadata to be associated with the declaration. The externalKeyword] is the
    * 'external' token. The staticKeyword] is the static keyword, or `null` if
    * the getter is not static. The [returnType] the return type that has already
    * been parsed, or `null` if there was no return type. Return the getter that
    * was parsed.
    *
    * This method assumes that the current token matches `Keyword.GET`.
    *
    *     getter ::=
@@ skipping 728 matching lines @@
    *     functionSignature:
    *         metadata returnType? identifier typeParameters? formalParameterList
    *
    *     fieldFormalParameter ::=
    *         metadata finalConstVarOrType? 'this' '.' identifier
    *
    *     simpleFormalParameter ::=
    *         declaredIdentifier
    *       | metadata identifier
    */
-  NormalFormalParameter parseNormalFormalParameter() {
+  NormalFormalParameter parseNormalFormalParameter(
+      {bool inFunctionType = false}) {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
-    FinalConstVarOrType holder = parseFinalConstVarOrType(true);
+    FinalConstVarOrType holder = parseFinalConstVarOrType(!inFunctionType,
+        inFunctionType: inFunctionType);
     Token thisKeyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
       thisKeyword = getAndAdvance();
       period = _expect(TokenType.PERIOD);
     }
+    if (!_matchesIdentifier() && inFunctionType) {
+      return astFactory.simpleFormalParameter(commentAndMetadata.comment,
+          commentAndMetadata.metadata, holder.keyword, holder.type, null);
+    }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         Token question = null;
@@ skipping 816 matching lines @@
   }
 
   /**
    * Parse a type alias. The [commentAndMetadata] is the metadata to be
    * associated with the member. Return the type alias that was parsed.
    *
    * This method assumes that the current token matches [Keyword.TYPEDEF].
    *
    *     typeAlias ::=
    *         'typedef' typeAliasBody
+   *       | genericTypeAlias
    *
    *     typeAliasBody ::=
-   *         classTypeAlias
-   *       | functionTypeAlias
-   *
-   *     classTypeAlias ::=
-   *         identifier typeParameters? '=' 'abstract'? mixinApplication
-   *
-   *     mixinApplication ::=
-   *         qualified withClause implementsClause? ';'
+   *         functionTypeAlias
    *
    *     functionTypeAlias ::=
    *         functionPrefix typeParameterList? formalParameterList ';'
    *
    *     functionPrefix ::=
    *         returnType? name
    */
   TypeAlias parseTypeAlias(CommentAndMetadata commentAndMetadata) {
     Token keyword = getAndAdvance();
     if (_matchesIdentifier()) {
       Token next = _peek();
       if (_tokenMatches(next, TokenType.LT)) {
         next = _skipTypeParameterList(next);
         if (next != null && _tokenMatches(next, TokenType.EQ)) {
           TypeAlias typeAlias =
-              parseClassTypeAlias(commentAndMetadata, null, keyword);
-          _reportErrorForToken(
-              ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
+              parseGenericTypeAlias(commentAndMetadata, keyword);
           return typeAlias;
         }
       } else if (_tokenMatches(next, TokenType.EQ)) {
         TypeAlias typeAlias =
-            parseClassTypeAlias(commentAndMetadata, null, keyword);
-        _reportErrorForToken(
-            ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
+            parseGenericTypeAlias(commentAndMetadata, keyword);
         return typeAlias;
       }
     }
     return _parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
   /**
+   * Parse a type.
+   *
+   *     type ::=
+   *         typeWithoutFunction
+   *       | functionType
+   */
+  TypeAnnotation parseTypeAnnotation() {
+    if (_matchesString('Function')) {
+      // Generic function type with no return type.
+      return parseGenericFunctionTypeAfterReturnType(null);
+    }
+    TypeAnnotation type = parseReturnType();
+    while (_matchesString('Function')) {
+      type = parseGenericFunctionTypeAfterReturnType(type);
+    }
+    return type;
+  }
+
+  /**
    * Parse a list of type arguments. Return the type argument list that was
    * parsed.
    *
    * This method assumes that the current token matches `TokenType.LT`.
    *
    *     typeArguments ::=
    *         '<' typeList '>'
    *
    *     typeList ::=
    *         type (',' type)*
@@ skipping 1445 matching lines @@
           commentAndMetadata.metadata[0]);
     }
     return astFactory.enumConstantDeclaration(
         commentAndMetadata.comment, commentAndMetadata.metadata, name);
   }
 
   /**
    * Parse a list of formal parameters given that the list starts with the given
    * [leftParenthesis]. Return the formal parameters that were parsed.
    */
-  FormalParameterList _parseFormalParameterListAfterParen(
-      Token leftParenthesis) {
+  FormalParameterList _parseFormalParameterListAfterParen(Token leftParenthesis,
+      {bool inFunctionType = false}) {
     if (_matches(TokenType.CLOSE_PAREN)) {
       return astFactory.formalParameterList(
           leftParenthesis, null, null, null, getAndAdvance());
     }
     //
     // Even though it is invalid to have default parameters outside of brackets,
     // required parameters inside of brackets, or multiple groups of default and
     // named parameters, we allow all of these cases so that we can recover
     // better.
     //
@@ skipping 52 matching lines @@
         if (leftSquareBracket != null && !reportedMixedGroups) {
           _reportErrorForCurrentToken(ParserErrorCode.MIXED_PARAMETER_GROUPS);
           reportedMixedGroups = true;
         }
         leftCurlyBracket = getAndAdvance();
         kind = ParameterKind.NAMED;
       }
       //
       // Parse and record the parameter.
       //
-      FormalParameter parameter = parseFormalParameter(kind);
+      FormalParameter parameter =
+          parseFormalParameter(kind, inFunctionType: inFunctionType);
       parameters.add(parameter);
       if (kind == ParameterKind.REQUIRED && wasOptionalParameter) {
         _reportErrorForNode(
             ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS, parameter);
       }
       //
       // Handle the end of parameter groups.
       //
       // TODO(brianwilkerson) Improve the detection and reporting of missing and
       // mismatched delimiters.
@@ skipping 68 matching lines @@
     return astFactory.formalParameterList(leftParenthesis, parameters,
         leftSquareBracket, rightSquareBracket, rightParenthesis);
   }
 
   /**
    * Parse a list of formal parameters. Return the formal parameters that were
    * parsed.
    *
    * This method assumes that the current token matches `TokenType.OPEN_PAREN`.
    */
-  FormalParameterList _parseFormalParameterListUnchecked() {
-    return _parseFormalParameterListAfterParen(getAndAdvance());
+  FormalParameterList _parseFormalParameterListUnchecked(
+      {bool inFunctionType = false}) {
+    return _parseFormalParameterListAfterParen(getAndAdvance(),
+        inFunctionType: inFunctionType);
   }
 
   /**
    * Parse a function declaration statement. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [returnType] is the return type, or `null` if there is no return type.
    * Return the function declaration statement that was parsed.
    *
    *     functionDeclarationStatement ::=
    *         functionSignature functionBody
@@ skipping 1644 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }