Add parsing support for generic methods

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import 'dart:collection';
@@ skipping 2315 matching lines @@
         return _parseSetter(commentAndMetadata, modifiers.externalKeyword,
             modifiers.staticKeyword, returnType);
       } else if (_matchesKeyword(Keyword.OPERATOR) && _isOperator(_peek())) {
         _validateModifiersForOperator(modifiers);
         return _parseOperator(
             commentAndMetadata, modifiers.externalKeyword, returnType);
       } else if (_matchesIdentifier() &&
           _peek().matchesAny([
         TokenType.OPEN_PAREN,
         TokenType.OPEN_CURLY_BRACKET,
-        TokenType.FUNCTION
+        TokenType.FUNCTION,
+        TokenType.LT
       ])) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
             modifiers.externalKeyword, modifiers.staticKeyword, returnType);
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
         if (_matchesIdentifier()) {
           if (_peek().matchesAny(
@@ skipping 134 matching lines @@
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
       return _parseInitializedIdentifierList(commentAndMetadata,
           modifiers.staticKeyword, _validateModifiersForField(modifiers), null);
     } else if (_matchesKeyword(Keyword.TYPEDEF)) {
       _reportErrorForCurrentToken(ParserErrorCode.TYPEDEF_IN_CLASS);
       // TODO(brianwilkerson) We don't currently have any way to capture the
       // function type alias that was parsed.
       _parseFunctionTypeAlias(commentAndMetadata, getAndAdvance());
       return null;
+    } else if (parseGenericMethods) {
+      Token token = _skipTypeParameterList(_peek());
+      if (token != null && _tokenMatches(token, TokenType.OPEN_PAREN)) {
+        return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
+            modifiers.externalKeyword, modifiers.staticKeyword, null);
+      }
     }
     TypeName type = parseTypeName();
     if (_matchesKeyword(Keyword.GET) && _tokenMatchesIdentifier(_peek())) {
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       return _parseGetter(commentAndMetadata, modifiers.externalKeyword,
           modifiers.staticKeyword, type);
     } else if (_matchesKeyword(Keyword.SET) &&
         _tokenMatchesIdentifier(_peek())) {
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       return _parseSetter(commentAndMetadata, modifiers.externalKeyword,
@@ skipping 44 matching lines @@
         _reportErrorForNode(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, type);
         return _parseConstructor(commentAndMetadata, modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword, methodName, null, null, parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(commentAndMetadata,
           modifiers.externalKeyword, modifiers.staticKeyword, type, methodName,
           null, parameters);
+    } else if (parseGenericMethods && _tokenMatches(_peek(), TokenType.LT)) {
+      return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
+          modifiers.externalKeyword, modifiers.staticKeyword, type);
     } else if (_tokenMatches(_peek(), TokenType.OPEN_CURLY_BRACKET)) {
       // We have found "TypeName identifier {", and are guessing that this is a
       // getter without the keyword 'get'.
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_GET);
       _currentToken = _injectToken(
           new Parser_SyntheticKeywordToken(Keyword.GET, _currentToken.offset));
       return _parseGetter(commentAndMetadata, modifiers.externalKeyword,
           modifiers.staticKeyword, type);
     }
@@ skipping 469 matching lines @@
     }
     return new FormalParameterList(leftParenthesis, parameters,
         leftSquareBracket, rightSquareBracket, rightParenthesis);
   }
 
   /**
    * Parse a function expression. Return the function expression that was
    * parsed.
    *
    *     functionExpression ::=
-   *         formalParameterList functionExpressionBody
+   *         typeParameters? formalParameterList functionExpressionBody
    */
   FunctionExpression parseFunctionExpression() {
+    TypeParameterList typeParameters = null;
+    if (parseGenericMethods && _matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         _parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true);
-    return new FunctionExpression(null, parameters, body);
+    return new FunctionExpression(typeParameters, parameters, body);
   }
 
   /**
    * Parse an if-null expression.  Return the if-null expression that was
    * parsed.
    *
    *     ifNullExpression ::= logicalOrExpression ('??' logicalOrExpression)*
    */
   Expression parseIfNullExpression() {
     Expression expression = parseLogicalOrExpression();
@@ skipping 82 matching lines @@
   /**
    * Parse a normal formal parameter. Return the normal formal parameter that
    * was parsed.
    *
    *     normalFormalParameter ::=
    *         functionSignature
    *       | fieldFormalParameter
    *       | simpleFormalParameter
    *
    *     functionSignature:
-   *         metadata returnType? identifier formalParameterList
+   *         metadata returnType? identifier typeParameters? formalParameterList
    *
    *     fieldFormalParameter ::=
    *         metadata finalConstVarOrType? 'this' '.' identifier
    *
    *     simpleFormalParameter ::=
    *         declaredIdentifier
    *       | metadata identifier
    */
   NormalFormalParameter parseNormalFormalParameter() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     FinalConstVarOrType holder = _parseFinalConstVarOrType(true);
     Token thisKeyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
       thisKeyword = getAndAdvance();
       period = _expect(TokenType.PERIOD);
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
+    TypeParameterList typeParameters = null;
+    if (parseGenericMethods && _matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = parseFormalParameterList();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         return new FunctionTypedFormalParameter(commentAndMetadata.comment,
-            commentAndMetadata.metadata, holder.type, identifier, null,
-            parameters);
+            commentAndMetadata.metadata, holder.type, identifier,
+            typeParameters, parameters);
       } else {
         return new FieldFormalParameter(commentAndMetadata.comment,
             commentAndMetadata.metadata, holder.keyword, holder.type,
-            thisKeyword, period, identifier, null, parameters);
+            thisKeyword, period, identifier, typeParameters, parameters);
       }
+    } else if (typeParameters != null) {
+      // TODO(brianwilkerson) Report an error. It looks like a function-typed
+      // parameter with no parameter list.
+      //_reportErrorForToken(ParserErrorCode.MISSING_PARAMETERS, typeParameters.endToken);
     }
     TypeName type = holder.type;
     if (type != null) {
       if (_tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
         _reportErrorForToken(
             ParserErrorCode.VOID_PARAMETER, type.name.beginToken);
       } else if (holder.keyword != null &&
           _tokenMatchesKeyword(holder.keyword, Keyword.VAR)) {
         _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, holder.keyword);
       }
     }
     if (thisKeyword != null) {
+      // TODO(brianwilkerson) If there are type parameters but no parameters,
+      // should we create a synthetic empty parameter list here so we can
+      // capture the type parameters?
       return new FieldFormalParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, holder.keyword, holder.type, thisKeyword,
           period, identifier, null, null);
     }
     return new SimpleFormalParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, holder.keyword, holder.type, identifier);
   }
 
   /**
    * Parse a prefixed identifier. Return the prefixed identifier that was
@@ skipping 629 matching lines @@
 
   /**
    * Return `true` if the given [token] appears to be the beginning of a
    * function expression.
    */
   bool _isFunctionExpression(Token token) {
     // Function expressions aren't allowed in initializer lists.
     if (_inInitializer) {
       return false;
     }
-    Token afterParameters = _skipFormalParameterList(token);
+    Token afterTypeParameters = _skipTypeParameterList(token);
+    if (afterTypeParameters == null) {
+      afterTypeParameters = token;
+    }
+    Token afterParameters = _skipFormalParameterList(afterTypeParameters);
     if (afterParameters == null) {
       return false;
     }
     if (afterParameters
         .matchesAny([TokenType.OPEN_CURLY_BRACKET, TokenType.FUNCTION])) {
       return true;
     }
     String lexeme = afterParameters.lexeme;
     return lexeme == ASYNC || lexeme == SYNC;
   }
@@ skipping 56 matching lines @@
     if (token == null) {
       return false;
     }
     TokenType type = token.type;
     return type == TokenType.EQ ||
         type == TokenType.COMMA ||
         type == TokenType.SEMICOLON ||
         _tokenMatchesKeyword(token, Keyword.IN);
   }
 
+  bool _isLikelyParameterList() {
+    if (_matches(TokenType.OPEN_PAREN)) {
+      return true;
+    }
+    if (!parseGenericMethods) {
+      return false;
+    }
+    Token token = _skipTypeArgumentList(_currentToken);
+    return token != null && _tokenMatches(token, TokenType.OPEN_PAREN);
+  }
+
   /**
    * Given that we have just found bracketed text within the given [comment],
    * look to see whether that text is (a) followed by a parenthesized link
    * address, (b) followed by a colon, or (c) followed by optional whitespace
    * and another square bracket. The [rightIndex] is the index of the right
    * bracket. Return `true` if the bracketed text is followed by a link address.
    *
    * This method uses the syntax described by the
    * <a href="http://daringfireball.net/projects/markdown/syntax">markdown</a>
    * project.
@@ skipping 68 matching lines @@
     } else if (_tokenMatchesIdentifier(token)) {
       return true;
     } else if (_tokenMatchesKeyword(token, Keyword.THIS) &&
         _tokenMatches(token.next, TokenType.PERIOD) &&
         _tokenMatchesIdentifier(token.next.next)) {
       return true;
     } else if (_tokenMatchesKeyword(startToken, Keyword.VOID)) {
       // The keyword 'void' isn't a valid identifier, so it should be assumed to
       // be a type name.
       return true;
-    } else if (startToken.next != token) {
+    } else if (startToken.next != token &&
+        !_tokenMatches(token, TokenType.OPEN_PAREN)) {
       // The type is more than a simple identifier, so it should be assumed to
       // be a type name.
       return true;
     }
     return false;
   }
 
   /**
    * Increments the error reporting lock level. If level is more than `0`, then
    * [reportError] wont report any error.
@@ skipping 152 matching lines @@
           new SuperExpression(getAndAdvance()), false, allowConditional: false);
     }
     //
     // A primary expression can start with an identifier. We resolve the
     // ambiguity by determining whether the primary consists of anything other
     // than an identifier and/or is followed by an assignableSelector.
     //
     Expression expression = _parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
-      while (_matches(TokenType.OPEN_PAREN)) {
+      while (_isLikelyParameterList()) {
+        TypeArgumentList typeArguments = null;
+        if (_matches(TokenType.LT)) {
+          typeArguments = parseTypeArgumentList();
+        }
         ArgumentList argumentList = parseArgumentList();
         if (expression is SimpleIdentifier) {
-          expression = new MethodInvocation(
-              null, null, expression as SimpleIdentifier, null, argumentList);
+          expression = new MethodInvocation(null, null,
+              expression as SimpleIdentifier, typeArguments, argumentList);
         } else if (expression is PrefixedIdentifier) {
           PrefixedIdentifier identifier = expression as PrefixedIdentifier;
           expression = new MethodInvocation(identifier.prefix,
-              identifier.period, identifier.identifier, null, argumentList);
+              identifier.period, identifier.identifier, typeArguments,
+              argumentList);
         } else if (expression is PropertyAccess) {
           PropertyAccess access = expression as PropertyAccess;
           expression = new MethodInvocation(access.target, access.operator,
-              access.propertyName, null, argumentList);
+              access.propertyName, typeArguments, argumentList);
         } else {
-          expression =
-              new FunctionExpressionInvocation(expression, null, argumentList);
+          expression = new FunctionExpressionInvocation(
+              expression, typeArguments, argumentList);
         }
         if (!primaryAllowed) {
           isOptional = false;
         }
       }
       Expression selectorExpression = _parseAssignableSelector(
           expression, isOptional || (expression is PrefixedIdentifier));
       if (identical(selectorExpression, expression)) {
         if (!isOptional && (expression is PrefixedIdentifier)) {
           PrefixedIdentifier identifier = expression as PrefixedIdentifier;
@@ skipping 131 matching lines @@
     }
     Token semicolon = _expect(TokenType.SEMICOLON);
     return new BreakStatement(breakKeyword, label, semicolon);
   }
 
   /**
    * Parse a cascade section. Return the expression representing the cascaded
    * method invocation.
    *
    *     cascadeSection ::=
-   *         '..' (cascadeSelector arguments*) (assignableSelector arguments*)* cascadeAssignment?
+   *         '..' (cascadeSelector typeArguments? arguments*)
+   *         (assignableSelector typeArguments? arguments*)* cascadeAssignment?
    *
    *     cascadeSelector ::=
    *         '[' expression ']'
    *       | identifier
    *
    *     cascadeAssignment ::=
    *         assignmentOperator expressionWithoutCascade
    */
   Expression _parseCascadeSection() {
     Token period = _expect(TokenType.PERIOD_PERIOD);
@@ skipping 14 matching lines @@
       } finally {
         _inInitializer = wasInInitializer;
       }
     } else {
       _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken,
           [_currentToken.lexeme]);
       functionName = _createSyntheticIdentifier();
     }
     assert((expression == null && functionName != null) ||
         (expression != null && functionName == null));
-    if (_currentToken.type == TokenType.OPEN_PAREN) {
-      while (_currentToken.type == TokenType.OPEN_PAREN) {
+    if (_isLikelyParameterList()) {
+      while (_isLikelyParameterList()) {
+        TypeArgumentList typeArguments = null;
+        if (_matches(TokenType.LT)) {
+          typeArguments = parseTypeArgumentList();
+        }
         if (functionName != null) {
-          expression = new MethodInvocation(
-              expression, period, functionName, null, parseArgumentList());
+          expression = new MethodInvocation(expression, period, functionName,
+              typeArguments, parseArgumentList());
           period = null;
           functionName = null;
         } else if (expression == null) {
           // It should not be possible to get here.
           expression = new MethodInvocation(expression, period,
-              _createSyntheticIdentifier(), null, parseArgumentList());
+              _createSyntheticIdentifier(), typeArguments, parseArgumentList());
         } else {
           expression = new FunctionExpressionInvocation(
-              expression, null, parseArgumentList());
+              expression, typeArguments, parseArgumentList());
         }
       }
     } else if (functionName != null) {
       expression = new PropertyAccess(expression, period, functionName);
       period = null;
     }
     assert(expression != null);
     bool progress = true;
     while (progress) {
       progress = false;
       Expression selector = _parseAssignableSelector(expression, true);
       if (!identical(selector, expression)) {
         expression = selector;
         progress = true;
-        while (_currentToken.type == TokenType.OPEN_PAREN) {
+        while (_isLikelyParameterList()) {
+          TypeArgumentList typeArguments = null;
+          if (_matches(TokenType.LT)) {
+            typeArguments = parseTypeArgumentList();
+          }
           if (expression is PropertyAccess) {
             PropertyAccess propertyAccess = expression as PropertyAccess;
             expression = new MethodInvocation(propertyAccess.target,
-                propertyAccess.operator, propertyAccess.propertyName, null,
-                parseArgumentList());
+                propertyAccess.operator, propertyAccess.propertyName,
+                typeArguments, parseArgumentList());
           } else {
             expression = new FunctionExpressionInvocation(
-                expression, null, parseArgumentList());
+                expression, typeArguments, parseArgumentList());
           }
         }
       }
     }
     if (_currentToken.type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
       expression = new AssignmentExpression(
           expression, operator, parseExpressionWithoutCascade());
     }
@@ skipping 1315 matching lines @@
     bool isGetter = false;
     if (_matchesKeyword(Keyword.GET) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       keyword = getAndAdvance();
       isGetter = true;
     } else if (_matchesKeyword(Keyword.SET) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       keyword = getAndAdvance();
     }
     SimpleIdentifier name = parseSimpleIdentifier();
+    TypeParameterList typeParameters = null;
+    if (parseGenericMethods && _matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
     FormalParameterList parameters = null;
     if (!isGetter) {
       if (_matches(TokenType.OPEN_PAREN)) {
         parameters = parseFormalParameterList();
         _validateFormalParameterList(parameters);
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
         parameters = new FormalParameterList(
             _createSyntheticToken(TokenType.OPEN_PAREN), null, null, null,
@@ skipping 10 matching lines @@
     } else {
       body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON));
     }
 //        if (!isStatement && matches(TokenType.SEMICOLON)) {
 //          // TODO(brianwilkerson) Improve this error message.
 //          reportError(ParserErrorCode.UNEXPECTED_TOKEN, currentToken.getLexeme());
 //          advance();
 //        }
     return new FunctionDeclaration(commentAndMetadata.comment,
         commentAndMetadata.metadata, externalKeyword, returnType, keyword, name,
-        new FunctionExpression(null, parameters, body));
+        new FunctionExpression(typeParameters, parameters, body));
   }
 
   /**
    * Parse a function declaration statement. Return the function declaration
    * statement that was parsed.
    *
    *     functionDeclarationStatement ::=
    *         functionSignature functionBody
    */
   Statement _parseFunctionDeclarationStatement() {
@@ skipping 461 matching lines @@
    * parsed.
    *
    *     functionDeclaration ::=
    *         'external'? 'static'? functionSignature functionBody
    *       | 'external'? functionSignature ';'
    */
   MethodDeclaration _parseMethodDeclarationAfterReturnType(
       CommentAndMetadata commentAndMetadata, Token externalKeyword,
       Token staticKeyword, TypeName returnType) {
     SimpleIdentifier methodName = parseSimpleIdentifier();
+    TypeParameterList typeParameters = null;
+    if (parseGenericMethods && _matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
     FormalParameterList parameters;
     if (!_matches(TokenType.OPEN_PAREN) &&
         (_matches(TokenType.OPEN_CURLY_BRACKET) ||
             _matches(TokenType.FUNCTION))) {
       _reportErrorForToken(
           ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous);
       parameters = new FormalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN), null, null, null,
           _createSyntheticToken(TokenType.CLOSE_PAREN));
     } else {
       parameters = parseFormalParameterList();
     }
     _validateFormalParameterList(parameters);
     return _parseMethodDeclarationAfterParameters(commentAndMetadata,
-        externalKeyword, staticKeyword, returnType, methodName, null,
+        externalKeyword, staticKeyword, returnType, methodName, typeParameters,
         parameters);
   }
 
   /**
    * Parse the modifiers preceding a declaration. This method allows the
    * modifiers to appear in any order but does generate errors for duplicated
    * modifiers. Checks for other problems, such as having the modifiers appear
    * in the wrong order or specifying both 'const' and 'final', are reported in
    * one of the methods whose name is prefixed with `validateModifiersFor`.
    * Return the modifiers that were parsed.
@@ skipping 407 matching lines @@
    *
    *     selector ::=
    *         assignableSelector
    *       | argumentList
    */
   Expression _parsePostfixExpression() {
     Expression operand = _parseAssignableExpression(true);
     if (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
         _matches(TokenType.PERIOD) ||
         _matches(TokenType.QUESTION_PERIOD) ||
-        _matches(TokenType.OPEN_PAREN)) {
+        _matches(TokenType.OPEN_PAREN) ||
+        (parseGenericMethods && _matches(TokenType.LT))) {
       do {
-        if (_matches(TokenType.OPEN_PAREN)) {
+        if (_isLikelyParameterList()) {
+          TypeArgumentList typeArguments = null;
+          if (_matches(TokenType.LT)) {
+            typeArguments = parseTypeArgumentList();
+          }
           ArgumentList argumentList = parseArgumentList();
           if (operand is PropertyAccess) {
             PropertyAccess access = operand as PropertyAccess;
             operand = new MethodInvocation(access.target, access.operator,
-                access.propertyName, null, argumentList);
+                access.propertyName, typeArguments, argumentList);
           } else {
-            operand =
-                new FunctionExpressionInvocation(operand, null, argumentList);
+            operand = new FunctionExpressionInvocation(
+                operand, typeArguments, argumentList);
           }
         } else {
           operand = _parseAssignableSelector(operand, true);
         }
       } while (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
           _matches(TokenType.PERIOD) ||
           _matches(TokenType.QUESTION_PERIOD) ||
           _matches(TokenType.OPEN_PAREN));
       return operand;
     }
@@ skipping 3860 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }