Initial parser support for constructor tear-offs.

This CL adds parser support for use of `<typeArguments>` as a
selector.  This allows expressions like `List<int>` (type literal with
type arguments), `f<int>` (function tear-off with type arguments),
`C.m<int>` (static method tear-off with type arguments), `EXPR.m<int>`
(instance method tear-off with type arguments), and `EXPR<int>`
(tear-off of `.call` method with type arguments).

I will add parser support for `.new` as a constructor name in a
follow-up CL.

Change-Id: I157e732276421e8c3fd20c38c67ae9643993bd85
Bug: #46020, #46044.
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/197102
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart

@@ -780,6 +780,11 @@ class ForwardingListener implements Listener {
     listener?.endFunctionTypedFormalParameter(nameToken, question);
   }
 
+  @override
+  void handleTypeArgumentApplication(Token openAngleBracket) {
+    listener?.handleTypeArgumentApplication(openAngleBracket);
+  }
+
   @override
   void endHide(Token hideKeyword) {
     listener?.endHide(hideKeyword);

pkg/_fe_analyzer_shared/lib/src/parser/listener.dart

@@ -1727,4 +1727,19 @@ class Listener implements UnescapeErrorListener {
   /// This event is generated by the parser when the parser's
   /// `parseOneCommentReference` method is called.
   void handleNoCommentReference() {}
+
+  /// An expression was encountered consisting of type arguments applied to a
+  /// subexpression.  This could validly represent any of the following:
+  /// - A type literal (`var x = List<int>;`)
+  /// - A function tear-off with type arguments (`var x = f<int>;` or
+  ///   `var x = importPrefix.f<int>;`)
+  /// - A static method tear-off with type arguments (`var x = ClassName.m<int>`
+  ///   or `var x = importPrefix.ClassName.m<int>;`)
+  /// - An instance method tear-off with type arguments (`var x = EXPR.m<int>;`)
+  ///
+  /// Or, in the event of invalid code, it could represent type arguments
+  /// erroneously applied to some other expression type (e.g.
+  /// `var x = (f)<int>;`).  The client is responsible for reporting an error if
+  /// this occurs.
+  void handleTypeArgumentApplication(Token openAngleBracket) {}
 }

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -4793,7 +4793,10 @@ class Parser {
         listener.handleNonNullAssertExpression(bangToken);
       }
       token = typeArg.parseArguments(bangToken, this);
-      assert(optional('(', token.next!));
+      if (!optional('(', token.next!)) {
+        listener.handleTypeArgumentApplication(bangToken.next!);
+        typeArg = noTypeParamOrArg;
+      }
     }
 
     return _parsePrecedenceExpressionLoop(
@@ -4861,7 +4864,10 @@ class Parser {
                 listener.handleNonNullAssertExpression(bangToken);
               }
               token = typeArg.parseArguments(bangToken, this);
-              assert(optional('(', token.next!));
+              if (!optional('(', token.next!)) {
+                listener.handleTypeArgumentApplication(bangToken.next!);
+                typeArg = noTypeParamOrArg;
+              }
             }
           } else if (identical(type, TokenType.OPEN_PAREN) ||
               identical(type, TokenType.OPEN_SQUARE_BRACKET)) {
@@ -5174,8 +5180,13 @@ class Parser {
           TypeParamOrArgInfo typeArg = computeTypeParamOrArg(identifier);
           if (typeArg != noTypeParamOrArg) {
             Token endTypeArguments = typeArg.skip(identifier);
-            if (optional(".", endTypeArguments.next!)) {
-              return parseImplicitCreationExpression(token, typeArg);
+            Token afterTypeArguments = endTypeArguments.next!;
+            if (optional(".", afterTypeArguments)) {
+              Token afterPeriod = afterTypeArguments.next!;
+              if (afterPeriod.isIdentifier &&
+                  optional('(', afterPeriod.next!)) {
+                return parseImplicitCreationExpression(token, typeArg);
+              }
             }
           }
         }

pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart

@@ -348,7 +348,53 @@ TypeParamOrArgInfo computeTypeParamOrArg(Token token,
 /// possible other constructs will pass (e.g., 'a < C, D > 3').
 TypeParamOrArgInfo computeMethodTypeArguments(Token token) {
   TypeParamOrArgInfo typeArg = computeTypeParamOrArg(token);
-  return optional('(', typeArg.skip(token).next!) && !typeArg.recovered
+  return mayFollowTypeArgs(typeArg.skip(token).next!) && !typeArg.recovered
       ? typeArg
       : noTypeParamOrArg;
 }
+
+/// Indicates whether the given [token] is allowed to follow a list of type
+/// arguments used as a selector after an expression.
+///
+/// This is used for disambiguating constructs like `f(a<b,c>(d))` and
+/// `f(a<b,c>-d)`.  In the case of `f(a<b,c>(d))`, `true` will be returned,
+/// indicating that the `<` and `>` should be interpreted as delimiting type
+/// arguments (so one argument is being passed to `f` -- a call to the generic
+/// function `a`).  In the case of `f(a<b,c>-d)`, `false` will be returned,
+/// indicating that the `<` and `>` should be interpreted as operators (so two
+/// arguments are being passed to `f`: `a < b` and `c > -d`).
+bool mayFollowTypeArgs(Token token) {
+  const Set<String> tokensThatMayFollowTypeArg = {
+    '(',
+    ')',
+    ']',
+    '}',
+    ':',
+    ';',
+    ',',
+    '.',
+    '?',
+    '==',
+    '!=',
+    '..',
+    '?.',
+    '??',
+    '?..',
+    '&',
+    '|',
+    '^',
+    '+',
+    '*',
+    '%',
+    '/',
+    '~/'
+  };
+  if (token.type == TokenType.EOF) {
+    // The spec doesn't have anything to say about this case, since an
+    // expression can't occur at the end of a file, but for testing it's to our
+    // advantage to allow EOF after type arguments, so that an isolated `f<x>`
+    // can be parsed as an expression.
+    return true;
+  }
+  return tokensThatMayFollowTypeArg.contains(token.lexeme);
+}

pkg/analyzer/lib/dart/analysis/features.dart

@@ -16,6 +16,9 @@ abstract class Feature {
   /// Feature information for non-nullability by default.
   static final non_nullable = ExperimentalFeatures.non_nullable;
 
+  /// Feature information for constructor tear-offs.
+  static final constructor_tearoffs = ExperimentalFeatures.constructor_tearoffs;
+
   /// Feature information for control flow collections.
   static final control_flow_collections =
       ExperimentalFeatures.control_flow_collections;

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -140,6 +140,9 @@ class AstBuilder extends StackListener {
   /// `true` if variance behavior is enabled
   final bool enableVariance;
 
+  /// `true` if constructor tearoffs are enabled
+  final bool enableConstructorTearoffs;
+
   final FeatureSet _featureSet;
 
   AstBuilder(ErrorReporter errorReporter, this.fileUri, this.isFullAst,
@@ -155,6 +158,8 @@ class AstBuilder extends StackListener {
         enableNonFunctionTypeAliases =
             _featureSet.isEnabled(Feature.nonfunction_type_aliases),
         enableVariance = _featureSet.isEnabled(Feature.variance),
+        enableConstructorTearoffs =
+            _featureSet.isEnabled(Feature.constructor_tearoffs),
         uri = uri ?? fileUri;
 
   NodeList<ClassMember> get currentDeclarationMembers {
@@ -3513,6 +3518,39 @@ class AstBuilder extends StackListener {
     push(ast.typeName(name, arguments, question: questionMark));
   }
 
+  @override
+  void handleTypeArgumentApplication(Token openAngleBracket) {
+    var typeArguments = pop() as TypeArgumentList;
+    var receiver = pop() as Expression;
+    if (!enableConstructorTearoffs) {
+      var feature = ExperimentalFeatures.constructor_tearoffs;
+      handleRecoverableError(
+        templateExperimentNotEnabled.withArguments(
+          feature.enableString,
+          _versionAsString(ExperimentStatus.currentVersion),
+        ),
+        typeArguments.leftBracket,
+        typeArguments.rightBracket,
+      );
+      // Since analyzer visitors don't yet support constructor tear-offs, create
+      // a FunctionExpressionInvocation with a synthetic argument list instead.
+      // TODO(paulberry): once we have visitor support for constructor
+      // tear-offs, fall through and return a FunctionReference instead since
+      // that should lead to better quality error recovery.
+      var syntheticOffset = typeArguments.rightBracket.end;
+      push(ast.functionExpressionInvocation(
+          receiver,
+          typeArguments,
+          ast.argumentList(
+              SyntheticToken(TokenType.OPEN_PAREN, syntheticOffset),
+              [],
+              SyntheticToken(TokenType.CLOSE_PAREN, syntheticOffset))));
+      return;
+    }
+    push(ast.functionReference(
+        function: receiver, typeArguments: typeArguments));
+  }
+
   @override
   void handleTypeVariablesDefined(Token token, int count) {
     debugEvent("handleTypeVariablesDefined");