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)) {
+    if (optional('extends', token) ||
+        (enableGenericMethodSyntax && optional('super', token))) {
+      listener.handleExtendsOrSuper(token);
       token = parseType(token.next);
     } else {
+      listener.handleNoExtendsNorSuper(token);
       listener.handleNoType(token);
     }
     listener.endTypeVariable(token);

[Johnni Winther, 2016/04/13 11:50:19]

Remove 'handleExtendsOrSuper' and 'handleNoExtendsNorSuper' and pass and
'extendsOrSuperToken' to [endTypeVariable].

[eernst, 2016/04/13 17:08:26]

Done.

     return token;
   }
 
   /**
    * Returns true if the stringValue of the [token] is [value].
    */
   bool optional(String value, Token token) {
     return identical(value, token.stringValue);
   }
 
@@ skipping 1051 matching lines @@
       Token afterId = identifier.next;
       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;

[karlklose, 2016/04/13 12:26:55]

Consider creating an issue for this and change the TODOs to use the issue
number. This way you know when you are done resolving these cases.

[eernst, 2016/04/13 17:08:26]

Done.

+        // TODO(eernst): Check this, looks like an NPE with unbalanced parens.

[Johnni Winther, 2016/04/13 11:50:19]

Do you have examples that trigger this (and others)?

[eernst, 2016/04/13 17:08:26]

No, I hoped to get a quick confirmation like "That invariant can be trusted,
it's never null". But I'll clarify this in an upcoming CL, using the issue
number 26252 that I just created.

         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 this, looks like an NPE with unbalanced parens.
         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 251 matching lines @@
         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);
+      return parseLiteralListOrMapOrFunction(token);
     } else {
       return listener.expectedExpression(token);
     }
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
+    // TODO(eernst): Check this, looks like an NPE with unbalanced parens.
     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 parseLiteralListOrMapOrFunction(Token token) {
     Token constKeyword = null;
     if (optional('const', token)) {
       constKeyword = token;
       token = token.next;
     }
-    token = parseTypeArgumentsOpt(token);
+    if (enableGenericMethodSyntax &&
+        constKeyword == null &&
+        optional('<', token) &&
+        token is BeginGroupToken &&
+        token.endGroup != null &&
+        identical(token.endGroup.next.kind, OPEN_PAREN_TOKEN)) {
+      token = parseTypeVariablesOpt(token);
+    } else {
+      // [parseLiteralListOrMapOrFunction] is only called when [token] is one
+      // of `<`, '{', `[`, so we are not looking at a non-generic literal
+      // function, so we are looking at a map or list literal, and they may
+      // or may not have a `<..>` part, but if it is present it contains type
+      // arguments.
+      token = parseTypeArgumentsOpt(token);
+    }
     Token beginToken = token;
     int count = 0;
     if (optional('{', token)) {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       do {
         if (optional('}', token.next)) {
           token = token.next;
           break;
         }
@@ skipping 13 matching lines @@
         }
         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;
-    } else {
-      listener.unexpected(token);
-      return null;
+    } else if (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;
   }
 
   Token parseMapLiteralEntry(Token token) {
     listener.beginLiteralMapEntry(token);
     // Assume the listener rejects non-string keys.
     token = parseExpression(token);
     Token colon = token;
     token = expect(':', token);
     token = parseExpression(token);
     listener.endLiteralMapEntry(colon, token);
     return token;
   }
 
   Token parseSendOrFunctionLiteral(Token token) {
     if (!mayParseFunctionExpressions) return parseSend(token);
     Token peek = peekAfterIfType(token);
     if (peek != null &&
         identical(peek.kind, IDENTIFIER_TOKEN) &&
         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 this, looks like an NPE with unbalanced parens.
       String afterParens = begin.endGroup.next.stringValue;
       if (identical(afterParens, '{') ||
           identical(afterParens, '=>') ||
           identical(afterParens, 'async') ||
           identical(afterParens, 'sync')) {
         return true;
       }
     }
     return false;
   }
@@ skipping 18 matching lines @@
   }
 
   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);
+      return parseLiteralListOrMapOrFunction(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);
   }
 }