Implement Generic Function Instantiation via wrapping node

This is a re-land for https://dart-review.googlesource.com/c/sdk/+/217880.

The primary difference is the call-sites of
insertGenericFunctionInstantiation. There are more, and many more test
cases.

This is a non-breaking change (when analyzing code at language version
2.14 and earlier). If constructor-tearoffs is enabled (language version
2.15), then FunctionReference nodes are inserted, to represent generic
function instantiation. Constant evaluation can then use the
`typeArgumentTypes` to instantiate arbitrary function-typed
expressions.

If constructor-tearoffs is not enabled, generic function instantiation
continues to take place at a SimpleIdentifier, PrefixedIdentifier, or
PropertyAccess only, with constant evaluation using
SimpleIdentifier.tearOffTypeArgumentTypes.


Bug: #46020
Change-Id: Icf876cb6866bc1030e0cefaaafe221757d5b5639
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/218221
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: srawlins

pkg/analyzer/lib/src/dart/constant/evaluation.dart

@@ -682,27 +682,37 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
     if (functionResult == null) {
       return functionResult;
     }
+
+    // Report an error if any of the _inferred_ type argument types refer to a
+    // type parameter. If, however, `node.typeArguments` is not `null`, then
+    // any type parameters contained therein are reported as non-constant in
+    // [ConstantVerifier].
+    if (node.typeArguments == null &&
+        (node.typeArgumentTypes?.any(hasTypeParameterReference) ?? false)) {
+      _error(node, null);
+    }
+
     var typeArgumentList = node.typeArguments;
     if (typeArgumentList == null) {
-      return functionResult;
-    } else {
-      var typeArguments = <DartType>[];
-      for (var typeArgument in typeArgumentList.arguments) {
-        var object = typeArgument.accept(this);
-        if (object == null) {
-          return null;
-        }
-        var typeArgumentType = object.toTypeValue();
-        if (typeArgumentType == null) {
-          return null;
-        }
-        // TODO(srawlins): Test type alias types (`typedef i = int`) used as
-        // type arguments. Possibly change implementation based on
-        // canonicalization rules.
-        typeArguments.add(typeArgumentType);
+      return _instantiateFunctionType(node, functionResult);
+    }
+
+    var typeArguments = <DartType>[];
+    for (var typeArgument in typeArgumentList.arguments) {
+      var object = typeArgument.accept(this);
+      if (object == null) {
+        return null;
       }
-      return _dartObjectComputer.typeInstantiate(functionResult, typeArguments);
+      var typeArgumentType = object.toTypeValue();
+      if (typeArgumentType == null) {
+        return null;
+      }
+      // TODO(srawlins): Test type alias types (`typedef i = int`) used as
+      // type arguments. Possibly change implementation based on
+      // canonicalization rules.
+      typeArguments.add(typeArgumentType);
     }
+    return _dartObjectComputer.typeInstantiate(functionResult, typeArguments);
   }
 
   @override
@@ -1000,7 +1010,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
   DartObjectImpl? visitSimpleIdentifier(SimpleIdentifier node) {
     var value = _lexicalEnvironment?[node.name];
     if (value != null) {
-      return _instantiateFunctionType(node, value);
+      return _instantiateFunctionTypeForSimpleIdentifier(node, value);
     }
 
     return _getConstantValue(node, node);
@@ -1212,6 +1222,8 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
     var variableElement =
         element is PropertyAccessorElement ? element.variable : element;
 
+    // TODO(srawlins): Remove this check when [FunctionReference]s are inserted
+    // for generic function instantiation for pre-constructor-references code.
     if (node is SimpleIdentifier &&
         (node.tearOffTypeArgumentTypes?.any(hasTypeParameterReference) ??
             false)) {
@@ -1230,7 +1242,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
         if (value == null) {
           return value;
         }
-        return _instantiateFunctionType(identifier, value);
+        return _instantiateFunctionTypeForSimpleIdentifier(identifier, value);
       }
     } else if (variableElement is ConstructorElement) {
       return DartObjectImpl(
@@ -1246,7 +1258,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
           function.type,
           FunctionState(function),
         );
-        return _instantiateFunctionType(identifier, rawType);
+        return _instantiateFunctionTypeForSimpleIdentifier(identifier, rawType);
       }
     } else if (variableElement is ClassElement) {
       var type = variableElement.instantiate(
@@ -1305,12 +1317,41 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
     return null;
   }
 
+  /// If the type of [value] is a generic [FunctionType], and [node] has type
+  /// argument types, returns [value] type-instantiated with those [node]'s
+  /// type argument types, otherwise returns [value].
+  DartObjectImpl? _instantiateFunctionType(
+      FunctionReference node, DartObjectImpl value) {
+    var functionElement = value.toFunctionValue();
+    if (functionElement is! ExecutableElement) {
+      return value;
+    }
+    var valueType = functionElement.type;
+    if (valueType.typeFormals.isNotEmpty) {
+      var typeArgumentTypes = node.typeArgumentTypes;
+      if (typeArgumentTypes != null && typeArgumentTypes.isNotEmpty) {
+        var instantiatedType =
+            functionElement.type.instantiate(typeArgumentTypes);
+        var substitution = _substitution;
+        if (substitution != null) {
+          instantiatedType =
+              substitution.substituteType(instantiatedType) as FunctionType;
+        }
+        return value.typeInstantiate(
+            typeSystem, instantiatedType, typeArgumentTypes);
+      }
+    }
+    return value;
+  }
+
   /// If the type of [value] is a generic [FunctionType], and [node] is a
   /// [SimpleIdentifier] with tear-off type argument types, returns [value]
   /// type-instantiated with those [node]'s tear-off type argument types,
   /// otherwise returns [value].
-  DartObjectImpl? _instantiateFunctionType(
+  DartObjectImpl? _instantiateFunctionTypeForSimpleIdentifier(
       SimpleIdentifier node, DartObjectImpl value) {
+    // TODO(srawlins): When all code uses [FunctionReference]s generated via
+    // generic function instantiation, remove this method and all call sites.
     var functionElement = value.toFunctionValue();
     if (functionElement is! ExecutableElement) {
       return value;

pkg/analyzer/lib/src/dart/resolver/function_reference_resolver.dart

@@ -242,15 +242,21 @@ class FunctionReferenceResolver {
       if (node.function is ConstructorReference) {
         node.staticType = DynamicTypeImpl.instance;
       } else {
-        var typeArguments = _checkTypeArguments(
-          // `node.typeArguments`, coming from the parser, is never null.
-          node.typeArguments!, name, rawType.typeFormals,
-          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION,
-        );
+        var typeArguments = node.typeArguments;
+        if (typeArguments == null) {
+          node.staticType = rawType;
+        } else {
+          var typeArgumentTypes = _checkTypeArguments(
+            typeArguments,
+            name,
+            rawType.typeFormals,
+            CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION,
+          );
 
-        var invokeType = rawType.instantiate(typeArguments);
-        node.typeArgumentTypes = typeArguments;
-        node.staticType = invokeType;
+          var invokeType = rawType.instantiate(typeArgumentTypes);
+          node.typeArgumentTypes = typeArgumentTypes;
+          node.staticType = invokeType;
+        }
       }
     } else {
       if (_resolver.isConstructorTearoffsEnabled) {

pkg/analyzer/lib/src/dart/resolver/prefixed_identifier_resolver.dart

@@ -83,8 +83,15 @@ class PrefixedIdentifierResolver {
       type = result.functionTypeCallType!;
     }
 
-    type = _inferenceHelper.inferTearOff(node, identifier, type);
-
+    if (!_resolver.isConstructorTearoffsEnabled) {
+      // Only perform a generic function instantiation on a [PrefixedIdentifier]
+      // in pre-constructor-tearoffs code. In constructor-tearoffs-enabled code,
+      // generic function instantiation is performed at assignability check
+      // sites.
+      // TODO(srawlins): Switch all resolution to use the latter method, in a
+      // breaking change release.
+      type = _inferenceHelper.inferTearOff(node, identifier, type);
+    }
     _recordStaticType(identifier, type);
     _recordStaticType(node, type);
   }

pkg/analyzer/lib/src/dart/resolver/simple_identifier_resolver.dart

@@ -12,7 +12,6 @@ import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
-import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
 import 'package:analyzer/src/dart/resolver/property_element_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -25,8 +24,6 @@ class SimpleIdentifierResolver {
 
   ErrorReporter get _errorReporter => _resolver.errorReporter;
 
-  InvocationInferenceHelper get _inferenceHelper => _resolver.inferenceHelper;
-
   TypeProviderImpl get _typeProvider => _resolver.typeProvider;
 
   void resolve(SimpleIdentifierImpl node) {
@@ -259,7 +256,17 @@ class SimpleIdentifierResolver {
     } else {
       staticType = DynamicTypeImpl.instance;
     }
-    staticType = _inferenceHelper.inferTearOff(node, node, staticType);
+
+    if (!_resolver.isConstructorTearoffsEnabled) {
+      // Only perform a generic function instantiation on a [PrefixedIdentifier]
+      // in pre-constructor-tearoffs code. In constructor-tearoffs-enabled code,
+      // generic function instantiation is performed at assignability check
+      // sites.
+      // TODO(srawlins): Switch all resolution to use the latter method, in a
+      // breaking change release.
+      staticType =
+          _resolver.inferenceHelper.inferTearOff(node, node, staticType);
+    }
     _recordStaticType(node, staticType);
   }
 

pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart

@@ -65,17 +65,14 @@ class VariableDeclarationResolver {
       _resolver.flowAnalysis.flow?.lateInitializer_end();
     }
 
+    initializer = _resolver.insertImplicitCallReference(initializer);
+
     // Initializers of top-level variables and fields are already included
     // into elements during linking.
     if (element is ConstLocalVariableElementImpl) {
       element.constantInitializer = initializer;
     }
 
-    var callReference = _resolver.insertImplicitCallReference(initializer);
-    if (callReference != initializer) {
-      initializer = callReference;
-    }
-
     _resolver.checkForInvalidAssignment(node.name, initializer,
         whyNotPromoted: whyNotPromoted);
   }