Adds support for remaining generic method syntax constructs.

pkg/compiler/lib/src/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 dart2js.parser;
 
 import '../options.dart' show ParserOptions;
 import '../common.dart';
 import '../tokens/keyword.dart' show Keyword;
 import '../tokens/precedence.dart' show PrecedenceInfo;
@@ skipping 445 matching lines @@
     token = parseReturnTypeOpt(token);
     Token thisKeyword = null;
     if (optional('this', token)) {
       thisKeyword = token;
       // TODO(ahe): Validate field initializers are only used in
       // constructors, and not for function-typed arguments.
       token = expect('.', token.next);
     }
     token = parseIdentifier(token);
     if (optional('(', token)) {
+      listener.handleNoTypeVariables(token);
+      token = parseFormalParameters(token);
+      listener.handleFunctionTypedFormalParameter(token);
+    } else if (enableGenericMethodSyntax && optional('<', token)) {
+      token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
       listener.handleFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
@@ skipping 284 matching lines @@
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
       return listener.expected(string, token);
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseIdentifier(token);
-    if (optional('extends', token)) {
+    Token extendsOrSuper = null;
+    if (optional('extends', token) ||
+        (enableGenericMethodSyntax && optional('super', token))) {
+      extendsOrSuper = token;
       token = parseType(token.next);
     } else {
       listener.handleNoType(token);
     }
-    listener.endTypeVariable(token);
+    listener.endTypeVariable(token, extendsOrSuper);
     return token;
   }
 
   /**
    * Returns true if the stringValue of the [token] is [value].
    */
   bool optional(String value, Token token) {
     return identical(value, token.stringValue);
   }
 
@@ skipping 1052 matching lines @@
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) ||
           identical(afterIdKind, SEMICOLON_TOKEN) ||
           identical(afterIdKind, COMMA_TOKEN)) {
         // We are looking at "type identifier" followed by '=', ';', ','.
         return parseVariablesDeclaration(token);
       } else if (identical(afterIdKind, OPEN_PAREN_TOKEN)) {
         // We are looking at "type identifier '('".
         BeginGroupToken beginParen = afterId;
         Token endParen = beginParen.endGroup;
+        // TODO(eernst): Check for NPE as described in issue 26252.
         Token afterParens = endParen.next;
         if (optional('{', afterParens) ||
             optional('=>', afterParens) ||
             optional('async', afterParens) ||
             optional('sync', afterParens)) {
           // We are looking at "type identifier '(' ... ')'" followed
-          // by '=>' or '{'.
+          // by '{', '=>', 'async', or 'sync'.
           return parseFunctionDeclaration(token);
         }
+      } else if (enableGenericMethodSyntax &&
+          identical(afterIdKind, LT_TOKEN)) {
+        // We are looking at "type identifier '<'".
+        BeginGroupToken beginAngle = afterId;
+        Token endAngle = beginAngle.endGroup;
+        if (endAngle != null &&
+            identical(endAngle.next.kind, OPEN_PAREN_TOKEN)) {
+          BeginGroupToken beginParen = endAngle.next;
+          Token endParen = beginParen.endGroup;
+          if (endParen != null) {
+            Token afterParens = endParen.next;
+            if (optional('{', afterParens) ||
+                optional('=>', afterParens) ||
+                optional('async', afterParens) ||
+                optional('sync', afterParens)) {
+              // We are looking at "type identifier '<' ... '>' '(' ... ')'"
+              // followed by '{', '=>', 'async', or 'sync'.
+              return parseFunctionDeclaration(token);
+            }
+          }
+        }
       }
       // Fall-through to expression statement.
     } else {
       if (optional(':', token.next)) {
         return parseLabeledStatement(token);
       } else if (optional('(', token.next)) {
         BeginGroupToken begin = token.next;
+        // TODO(eernst): Check for NPE as described in issue 26252.
         String afterParens = begin.endGroup.next.stringValue;
         if (identical(afterParens, '{') ||
             identical(afterParens, '=>') ||
             identical(afterParens, 'async') ||
             identical(afterParens, 'sync')) {
           return parseFunctionDeclaration(token);
         }
+      } else if (enableGenericMethodSyntax && optional('<', token.next)) {
+        BeginGroupToken beginAngle = token.next;
+        Token endAngle = beginAngle.endGroup;
+        if (endAngle != null &&
+            identical(endAngle.next.kind, OPEN_PAREN_TOKEN)) {
+          BeginGroupToken beginParen = endAngle.next;
+          Token endParen = beginParen.endGroup;
+          if (endParen != null) {
+            String afterParens = endParen.next.stringValue;
+            if (identical(afterParens, '{') ||
+                identical(afterParens, '=>') ||
+                identical(afterParens, 'async') ||
+                identical(afterParens, 'sync')) {
+              return parseFunctionDeclaration(token);
+            }
+          }
+        }
+        // Fall through to expression statement.
       }
     }
     return parseExpressionStatement(token);
   }
 
   Token parseExpressionStatementOrConstDeclaration(Token token) {
     assert(identical(token.stringValue, 'const'));
     if (isModifier(token.next)) {
       return parseVariablesDeclaration(token);
     }
@@ skipping 247 matching lines @@
       } else if (asyncAwaitKeywordsEnabled &&
           (value == 'yield' || value == 'async')) {
         return listener.expectedExpression(token);
       } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
         return listener.expectedExpression(token);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
-    } else if ((kind == LT_TOKEN) ||
-        (kind == OPEN_SQUARE_BRACKET_TOKEN) ||
-        (kind == OPEN_CURLY_BRACKET_TOKEN) ||
-        token.stringValue == '[]') {
-      return parseLiteralListOrMap(token);
+    } else if (kind == OPEN_SQUARE_BRACKET_TOKEN || token.stringValue == '[]') {
+      listener.handleNoTypeArguments(token);
+      return parseLiteralListSuffix(token, null);
+    } else if (kind == OPEN_CURLY_BRACKET_TOKEN) {
+      listener.handleNoTypeArguments(token);
+      return parseLiteralMapSuffix(token, null);
+    } else if (kind == LT_TOKEN) {
+      return parseLiteralListOrMapOrFunction(token, null);
     } else {
       return listener.expectedExpression(token);
     }
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
+    // TODO(eernst): Check for NPE as described in issue 26252.
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
         (identical(kind, FUNCTION_TOKEN) ||
             identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
             (identical(kind, KEYWORD_TOKEN) &&
                 (nextToken.value == 'async' || nextToken.value == 'sync')))) {
+      listener.handleNoTypeVariables(token);
       return parseUnnamedFunction(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
 
@@ skipping 29 matching lines @@
     token = token.next;
     if (optional('(', token)) {
       // Super constructor.
       listener.handleNoTypeArguments(token);
       token = parseArguments(token);
       listener.endSend(token);
     }
     return token;
   }
 
-  Token parseLiteralListOrMap(Token token) {
-    Token constKeyword = null;
-    if (optional('const', token)) {
-      constKeyword = token;
-      token = token.next;
-    }
-    token = parseTypeArgumentsOpt(token);
+  /// '[' (expressionList ','?)? ']'.
+  ///
+  /// Provide [constKeyword] if preceded by 'const', null if not.
+  /// This is a suffix parser because it is assumed that type arguments have
+  /// been parsed, or `listener.handleNoTypeArguments(..)` has been executed.
+  Token parseLiteralListSuffix(Token token, Token constKeyword) {
+    assert(optional('[', token) || optional('[]', token));
     Token beginToken = token;
     int count = 0;
-    if (optional('{', token)) {
+    if (optional('[', token)) {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       do {
-        if (optional('}', token.next)) {
-          token = token.next;
-          break;
-        }
-        token = parseMapLiteralEntry(token.next);
-        ++count;
-      } while (optional(',', token));
-      mayParseFunctionExpressions = old;
-      listener.handleLiteralMap(count, beginToken, constKeyword, token);
-      return expect('}', token);
-    } else if (optional('[', token)) {
-      bool old = mayParseFunctionExpressions;
-      mayParseFunctionExpressions = true;
-      do {
         if (optional(']', token.next)) {
           token = token.next;
           break;
         }
         token = parseExpression(token.next);
         ++count;
       } while (optional(',', token));
       mayParseFunctionExpressions = old;
       listener.handleLiteralList(count, beginToken, constKeyword, token);
       return expect(']', token);
-    } else if (optional('[]', token)) {
-      listener.handleLiteralList(0, token, constKeyword, token);
-      return token.next;
+    }
+    // Looking at '[]'.
+    listener.handleLiteralList(0, token, constKeyword, token);
+    return token.next;
+  }
+
+  /// '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'.
+  ///
+  /// Provide token for [constKeyword] if preceded by 'const', null if not.
+  /// This is a suffix parser because it is assumed that type arguments have
+  /// been parsed, or `listener.handleNoTypeArguments(..)` has been executed.
+  Token parseLiteralMapSuffix(Token token, Token constKeyword) {
+    assert(optional('{', token));
+    Token beginToken = token;
+    int count = 0;
+    bool old = mayParseFunctionExpressions;
+    mayParseFunctionExpressions = true;
+    do {
+      if (optional('}', token.next)) {
+        token = token.next;
+        break;
+      }
+      token = parseMapLiteralEntry(token.next);
+      ++count;
+    } while (optional(',', token));
+    mayParseFunctionExpressions = old;
+    listener.handleLiteralMap(count, beginToken, constKeyword, token);
+    return expect('}', token);
+  }
+
+  /// formalParameterList functionBody.
+  ///
+  /// This is a suffix parser because it is assumed that type arguments have
+  /// been parsed, or `listener.handleNoTypeArguments(..)` has been executed.
+  Token parseLiteralFunctionSuffix(Token token) {
+    assert(optional('(',token));
+    BeginGroupToken beginGroup = token;
+    if (beginGroup.endGroup != null) {
+      Token nextToken = beginGroup.endGroup.next;
+      int kind = nextToken.kind;
+      if (identical(kind, FUNCTION_TOKEN) ||
+          identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
+          (identical(kind, KEYWORD_TOKEN) &&
+              (nextToken.value == 'async' || nextToken.value == 'sync'))) {
+        return parseUnnamedFunction(token);
+      }
+      // Fall through.
+    }
+    listener.unexpected(token);
+    return null;
+  }
+
+  /// (typeArguments (
+  ///     '[' (expressionList ','?)? ']' |
+  ///     '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}')) |
+  /// typeParameters formalParameterList functionBody.
+  ///
+  /// Provide token for [constKeyword] if preceded by 'const', null if not.
+  Token parseLiteralListOrMapOrFunction(Token token, Token constKeyword) {
+    assert(optional('<', token));
+    BeginGroupToken begin = token;
+    if (enableGenericMethodSyntax &&
+        constKeyword == null &&
+        begin.endGroup != null &&
+        identical(begin.endGroup.next.kind, OPEN_PAREN_TOKEN)) {
+      token = parseTypeVariablesOpt(token);
+      return parseLiteralFunctionSuffix(token);
     } else {
+      token = parseTypeArgumentsOpt(token);
+      if (optional('{', token)) {
+        return parseLiteralMapSuffix(token, constKeyword);
+      } else if ((optional('[', token)) || (optional('[]', token))) {
+        return parseLiteralListSuffix(token, constKeyword);
+      }
       listener.unexpected(token);
       return null;
     }
   }
 
   Token parseMapLiteralEntry(Token token) {
     listener.beginLiteralMapEntry(token);
     // Assume the listener rejects non-string keys.
     token = parseExpression(token);
     Token colon = token;
@@ skipping 11 matching lines @@
         isFunctionDeclaration(peek.next)) {
       return parseFunctionExpression(token);
     } else if (isFunctionDeclaration(token.next)) {
       return parseFunctionExpression(token);
     } else {
       return parseSend(token);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
+    if (enableGenericMethodSyntax && optional('<', token)) {
+      BeginGroupToken begin = token;
+      if (begin.endGroup == null) return false;
+      token = begin.endGroup.next;
+    }
     if (optional('(', token)) {
       BeginGroupToken begin = token;
+      // TODO(eernst): Check for NPE as described in issue 26252.
       String afterParens = begin.endGroup.next.stringValue;
       if (identical(afterParens, '{') ||
           identical(afterParens, '=>') ||
           identical(afterParens, 'async') ||
           identical(afterParens, 'sync')) {
         return true;
       }
     }
     return false;
   }
@@ skipping 14 matching lines @@
     token = parseConstructorReference(token);
     token = parseRequiredArguments(token);
     listener.handleNewExpression(newKeyword);
     return token;
   }
 
   Token parseConstExpression(Token token) {
     Token constKeyword = token;
     token = expect('const', token);
     final String value = token.stringValue;
-    if ((identical(value, '<')) ||
-        (identical(value, '[')) ||
-        (identical(value, '[]')) ||
-        (identical(value, '{'))) {
-      return parseLiteralListOrMap(constKeyword);
+    if ((identical(value, '[')) || (identical(value, '[]'))) {
+      listener.handleNoTypeArguments(token);
+      return parseLiteralListSuffix(token, constKeyword);
+    }
+    if (identical(value, '{')) {
+      listener.handleNoTypeArguments(token);
+      return parseLiteralMapSuffix(token, constKeyword);
+    }
+    if (identical(value, '<')) {
+      return parseLiteralListOrMapOrFunction(token, constKeyword);
     }
     token = parseConstructorReference(token);
     token = parseRequiredArguments(token);
     listener.handleConstExpression(constKeyword);
     return token;
   }
 
   Token parseLiteralInt(Token token) {
     listener.handleLiteralInt(token);
     return token.next;
@@ skipping 532 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }