Add ImplicitCallReference AST node subtype and visit methods

Bug: #47443

Change-Id: I70f9fda3256f963b805ba379d79f706010f0c2fa
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/216269
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: srawlins

pkg/analyzer/lib/dart/ast/ast.dart

@@ -479,6 +479,8 @@ abstract class AstVisitor<R> {
 
   R? visitImplementsClause(ImplementsClause node);
 
+  R? visitImplicitCallReference(ImplicitCallReference node);
+
   R? visitImportDirective(ImportDirective node);
 
   R? visitIndexExpression(IndexExpression node);
@@ -2599,6 +2601,33 @@ abstract class ImplementsClause implements AstNode {
   NodeList<NamedType> get interfaces2;
 }
 
+/// An expression representing an implicit 'call' method reference.
+///
+/// Objects of this type are not produced directly by the parser (because the
+/// parser cannot tell whether an expression refers to a callable type); they
+/// are produced at resolution time.
+///
+/// Clients may not extend, implement or mix-in this class.
+abstract class ImplicitCallReference implements MethodReferenceExpression {
+  /// Return the expression from which a `call` method is being referenced.
+  Expression get expression;
+
+  /// Return the element associated with the implicit 'call' reference based on
+  /// the static types.
+  @override
+  MethodElement get staticElement;
+
+  /// The type arguments being applied to the tear-off, or `null` if there are
+  /// no type arguments.
+  TypeArgumentList? get typeArguments;
+
+  /// The actual type arguments being applied to the tear-off, either explicitly
+  /// specified in [typeArguments], or inferred.
+  ///
+  /// Returns an empty list if the 'call' method does not have type parameters.
+  List<DartType> get typeArgumentTypes;
+}
+
 /// An import directive.
 ///
 ///    importDirective ::=

pkg/analyzer/lib/dart/ast/ast_factory.dart

@@ -5,6 +5,8 @@
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /// A collection of factory methods which may be used to create concrete
@@ -580,6 +582,17 @@ abstract class AstFactory {
   ImplementsClause implementsClause(
       Token implementsKeyword, List<NamedType> interfaces);
 
+  /// Returns a newly created implicit call reference.
+  ///
+  /// The [typeArguments] can be `null` if there are no type arguments being
+  /// applied to the reference.
+  ImplicitCallReference implicitCallReference({
+    required Expression expression,
+    required MethodElement staticElement,
+    required TypeArgumentList? typeArguments,
+    required List<DartType> typeArgumentTypes,
+  });
+
   /// Returns a newly created import directive. Either or both of the
   /// [comment] and [metadata] can be `null` if the function does not have the
   /// corresponding attribute. The [deferredKeyword] can be `null` if the import

pkg/analyzer/lib/dart/ast/visitor.dart

@@ -382,6 +382,9 @@ class GeneralizingAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitImplementsClause(ImplementsClause node) => visitNode(node);
 
+  @override
+  R? visitImplicitCallReference(ImplicitCallReference node) => visitNode(node);
+
   @override
   R? visitImportDirective(ImportDirective node) =>
       visitNamespaceDirective(node);
@@ -1034,6 +1037,12 @@ class RecursiveAstVisitor<R> implements AstVisitor<R> {
     return null;
   }
 
+  @override
+  R? visitImplicitCallReference(ImplicitCallReference node) {
+    node.visitChildren(this);
+    return null;
+  }
+
   @override
   R? visitImportDirective(ImportDirective node) {
     node.visitChildren(this);
@@ -1623,6 +1632,9 @@ class SimpleAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitImplementsClause(ImplementsClause node) => null;
 
+  @override
+  R? visitImplicitCallReference(ImplicitCallReference node) => null;
+
   @override
   R? visitImportDirective(ImportDirective node) => null;
 
@@ -2031,6 +2043,9 @@ class ThrowingAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitImplementsClause(ImplementsClause node) => _throw(node);
 
+  @override
+  R? visitImplicitCallReference(ImplicitCallReference node) => _throw(node);
+
   @override
   R? visitImportDirective(ImportDirective node) => _throw(node);
 
@@ -2768,6 +2783,14 @@ class TimedAstVisitor<T> implements AstVisitor<T> {
     return result;
   }
 
+  @override
+  T? visitImplicitCallReference(ImplicitCallReference node) {
+    stopwatch.start();
+    T? result = _baseVisitor.visitImplicitCallReference(node);
+    stopwatch.stop();
+    return result;
+  }
+
   @override
   T? visitImportDirective(ImportDirective node) {
     stopwatch.start();
@@ -3497,6 +3520,9 @@ class UnifyingAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitImplementsClause(ImplementsClause node) => visitNode(node);
 
+  @override
+  R? visitImplicitCallReference(ImplicitCallReference node) => visitNode(node);
+
   @override
   R? visitImportDirective(ImportDirective node) => visitNode(node);
 

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -5803,6 +5803,69 @@ class ImplementsClauseImpl extends AstNodeImpl implements ImplementsClause {
   }
 }
 
+class ImplicitCallReferenceImpl extends ExpressionImpl
+    implements ImplicitCallReference {
+  ExpressionImpl _expression;
+
+  TypeArgumentListImpl? _typeArguments;
+
+  @override
+  List<DartType> typeArgumentTypes;
+
+  @override
+  MethodElement staticElement;
+
+  ImplicitCallReferenceImpl(
+    this._expression, {
+    required this.staticElement,
+    required TypeArgumentListImpl? typeArguments,
+    required this.typeArgumentTypes,
+  }) : _typeArguments = typeArguments {
+    _becomeParentOf(_expression);
+    _becomeParentOf(_typeArguments);
+  }
+
+  @override
+  Token get beginToken => expression.beginToken;
+
+  @override
+  Iterable<SyntacticEntity> get childEntities => ChildEntities()
+    ..add(expression)
+    ..add(typeArguments);
+
+  @override
+  Token get endToken => typeArguments?.endToken ?? expression.endToken;
+
+  @override
+  ExpressionImpl get expression => _expression;
+
+  set expression(ExpressionImpl value) {
+    _expression = _becomeParentOf(value);
+  }
+
+  @override
+  Precedence get precedence =>
+      typeArguments == null ? expression.precedence : Precedence.postfix;
+
+  @override
+  TypeArgumentListImpl? get typeArguments => _typeArguments;
+
+  set typeArguments(TypeArgumentListImpl? value) {
+    _typeArguments = _becomeParentOf(value);
+  }
+
+  @override
+  E? accept<E>(AstVisitor<E> visitor) {
+    return visitor.visitImplicitCallReference(this);
+  }
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    expression.accept(visitor);
+    typeArguments?.accept(visitor);
+  }
+}
+
 /// An import directive.
 ///
 ///    importDirective ::=

pkg/analyzer/lib/src/dart/ast/ast_factory.dart

@@ -6,6 +6,8 @@ import 'package:_fe_analyzer_shared/src/scanner/token.dart';
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
@@ -785,6 +787,18 @@ class AstFactoryImpl extends AstFactory {
           Token implementsKeyword, List<NamedType> interfaces) =>
       ImplementsClauseImpl(implementsKeyword, interfaces);
 
+  @override
+  ImplicitCallReferenceImpl implicitCallReference({
+    required Expression expression,
+    required MethodElement staticElement,
+    required TypeArgumentList? typeArguments,
+    required List<DartType> typeArgumentTypes,
+  }) =>
+      ImplicitCallReferenceImpl(expression as ExpressionImpl,
+          staticElement: staticElement,
+          typeArguments: typeArguments as TypeArgumentListImpl?,
+          typeArgumentTypes: typeArgumentTypes);
+
   @override
   ImportDirectiveImpl importDirective(
           Comment? comment,

pkg/analyzer/lib/src/dart/ast/to_source_visitor.dart

@@ -603,6 +603,12 @@ class ToSourceVisitor implements AstVisitor<void> {
     _visitNodeList(node.interfaces2, separator: ', ');
   }
 
+  @override
+  void visitImplicitCallReference(ImplicitCallReference node) {
+    _visitNode(node.expression);
+    _visitNode(node.typeArguments);
+  }
+
   @override
   void visitImportDirective(ImportDirective node) {
     _visitNodeList(node.metadata, separator: ' ', suffix: ' ');

pkg/analyzer/lib/src/dart/ast/utilities.dart

@@ -722,6 +722,13 @@ class AstComparator implements AstVisitor<bool> {
         _isEqualNodeLists(node.interfaces2, other.interfaces2);
   }
 
+  @override
+  bool visitImplicitCallReference(ImplicitCallReference node) {
+    ImplicitCallReference other = _other as ImplicitCallReference;
+    return isEqualNodes(node.expression, other.expression) &&
+        isEqualNodes(node.typeArguments, other.typeArguments);
+  }
+
   @override
   bool visitImportDirective(ImportDirective node) {
     ImportDirective other = _other as ImportDirective;
@@ -2344,6 +2351,18 @@ class NodeReplacer implements AstVisitor<bool> {
     return visitNode(node);
   }
 
+  @override
+  bool visitImplicitCallReference(covariant ImplicitCallReferenceImpl node) {
+    if (identical(node.expression, _oldNode)) {
+      node.expression = _newNode as ExpressionImpl;
+      return true;
+    } else if (identical(node.typeArguments, _oldNode)) {
+      node.typeArguments = _newNode as TypeArgumentListImpl;
+      return true;
+    }
+    return visitNode(node);
+  }
+
   @override
   bool visitImportDirective(covariant ImportDirectiveImpl node) {
     if (identical(node.prefix, _oldNode)) {