Migration: add support for invocation of generic functions.

Change-Id: I56dbedad452e24aaf57ec1d622ce776089e28de7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/107449
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/nnbd_migration/lib/src/decorated_type.dart

@@ -170,6 +170,33 @@ class DecoratedType {
     }
   }
 
+  /// If this type is a function type, returns its generic formal parameters.
+  /// Otherwise returns `null`.
+  List<TypeParameterElement> get typeFormals {
+    var type = this.type;
+    if (type is FunctionType) {
+      return type.typeFormals;
+    } else {
+      return null;
+    }
+  }
+
+  /// Converts one function type into another by substituting the given
+  /// [argumentTypes] for the function's generic parameters.
+  DecoratedType instantiate(List<DecoratedType> argumentTypes) {
+    var type = this.type as FunctionType;
+    var typeFormals = type.typeFormals;
+    List<DartType> undecoratedArgumentTypes = [];
+    Map<TypeParameterElement, DecoratedType> substitution = {};
+    for (int i = 0; i < argumentTypes.length; i++) {
+      var argumentType = argumentTypes[i];
+      undecoratedArgumentTypes.add(argumentType.type);
+      substitution[typeFormals[i]] = argumentType;
+    }
+    return _substituteFunctionAfterFormals(
+        type.instantiate(undecoratedArgumentTypes), substitution);
+  }
+
   /// Apply the given [substitution] to this type.
   ///
   /// [undecoratedResult] is the result of the substitution, as determined by
@@ -204,11 +231,14 @@ class DecoratedType {
       }
       return '$name$args$trailing';
     } else if (type is FunctionType) {
-      assert(type.typeFormals.isEmpty); // TODO(paulberry)
+      String formals = '';
+      if (type.typeFormals.isNotEmpty) {
+        formals = '<${type.typeFormals.join(', ')}>';
+      }
       assert(type.namedParameterTypes.isEmpty &&
           namedParameters.isEmpty); // TODO(paulberry)
       var args = positionalParameters.map((p) => p.toString()).join(', ');
-      return '$returnType Function($args)$trailing';
+      return '$returnType Function$formals($args)$trailing';
     } else if (type is DynamicTypeImpl) {
       return 'dynamic';
     } else {
@@ -230,21 +260,7 @@ class DecoratedType {
     var type = this.type;
     if (type is FunctionType && undecoratedResult is FunctionType) {
       assert(type.typeFormals.isEmpty); // TODO(paulberry)
-      var newPositionalParameters = <DecoratedType>[];
-      for (int i = 0; i < positionalParameters.length; i++) {
-        var numRequiredParameters =
-            undecoratedResult.normalParameterTypes.length;
-        var undecoratedParameterType = i < numRequiredParameters
-            ? undecoratedResult.normalParameterTypes[i]
-            : undecoratedResult
-                .optionalParameterTypes[i - numRequiredParameters];
-        newPositionalParameters.add(positionalParameters[i]
-            ._substitute(substitution, undecoratedParameterType));
-      }
-      return DecoratedType(undecoratedResult, node,
-          returnType: returnType._substitute(
-              substitution, undecoratedResult.returnType),
-          positionalParameters: newPositionalParameters);
+      return _substituteFunctionAfterFormals(undecoratedResult, substitution);
     } else if (type is InterfaceType && undecoratedResult is InterfaceType) {
       List<DecoratedType> newTypeArguments = [];
       for (int i = 0; i < typeArguments.length; i++) {
@@ -266,6 +282,27 @@ class DecoratedType {
     }
     throw '$type.substitute($substitution)'; // TODO(paulberry)
   }
+
+  /// Performs the logic that is common to substitution and function type
+  /// instantiation.  Namely, a decorated type is formed whose undecorated type
+  /// is [undecoratedResult], and whose return type, positional parameters, and
+  /// named parameters are formed by performing the given [substitution].
+  DecoratedType _substituteFunctionAfterFormals(FunctionType undecoratedResult,
+      Map<TypeParameterElement, DecoratedType> substitution) {
+    var newPositionalParameters = <DecoratedType>[];
+    for (int i = 0; i < positionalParameters.length; i++) {
+      var numRequiredParameters = undecoratedResult.normalParameterTypes.length;
+      var undecoratedParameterType = i < numRequiredParameters
+          ? undecoratedResult.normalParameterTypes[i]
+          : undecoratedResult.optionalParameterTypes[i - numRequiredParameters];
+      newPositionalParameters.add(positionalParameters[i]
+          ._substitute(substitution, undecoratedParameterType));
+    }
+    return DecoratedType(undecoratedResult, node,
+        returnType:
+            returnType._substitute(substitution, undecoratedResult.returnType),
+        positionalParameters: newPositionalParameters);
+  }
 }
 
 /// A [DecoratedType] based on a type annotation appearing explicitly in the

pkg/nnbd_migration/lib/src/edge_builder.dart

@@ -472,7 +472,8 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType> {
       // TODO(brianwilkerson)
       _unimplemented(node, 'Instance creation expression with type arguments');
     }
-    _handleInvocationArguments(node.argumentList, calleeType);
+    _handleInvocationArguments(
+        node.argumentList, node.constructorName.type.typeArguments, calleeType);
     return calleeType.returnType;
   }
 
@@ -563,8 +564,8 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType> {
     }
     var calleeType = getOrComputeElementType(callee, targetType: targetType);
     // TODO(paulberry): substitute if necessary
-    _handleInvocationArguments(node.argumentList, calleeType);
-    var expressionType = calleeType.returnType;
+    var expressionType = _handleInvocationArguments(
+        node.argumentList, node.typeArguments, calleeType);
     if (isConditional) {
       expressionType = expressionType.withNode(
           NullabilityNode.forLUB(targetType.node, expressionType.node));
@@ -978,8 +979,21 @@ $stackTrace''');
 
   /// Creates the necessary constraint(s) for an [argumentList] when invoking an
   /// executable element whose type is [calleeType].
-  void _handleInvocationArguments(
-      ArgumentList argumentList, DecoratedType calleeType) {
+  ///
+  /// Returns the decorated return type of the invocation, after any necessary
+  /// substitutions.
+  DecoratedType _handleInvocationArguments(ArgumentList argumentList,
+      TypeArgumentList typeArguments, DecoratedType calleeType) {
+    var typeFormals = calleeType.typeFormals;
+    if (typeFormals.isNotEmpty) {
+      if (typeArguments != null) {
+        calleeType = calleeType.instantiate(typeArguments.arguments
+            .map((t) => _variables.decoratedTypeAnnotation(_source, t))
+            .toList());
+      } else {
+        _unimplemented(argumentList, 'Inferred type parameters in invocation');
+      }
+    }
     var arguments = argumentList.arguments;
     int i = 0;
     var suppliedNamedParameters = Set<String>();
@@ -1007,6 +1021,7 @@ $stackTrace''');
       entry.value.node.recordNamedParameterNotSupplied(_guards, _graph,
           NamedParameterNotSuppliedOrigin(_source, argumentList.offset));
     }
+    return calleeType.returnType;
   }
 
   DecoratedType _handlePropertyAccess(

pkg/nnbd_migration/test/api_test.dart

@@ -492,6 +492,29 @@ void test(C<int> c) {
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_data_flow_generic_contravariant_inward_function() async {
+    var content = '''
+T f<T>(T t) => t;
+int g(int x) => f<int>(x);
+void h() {
+  g(null);
+}
+''';
+
+    // As with the generic class case (see
+    // [test_data_flow_generic_contravariant_inward_function]), we favor adding
+    // nullability at the call site, so that other uses of `f` don't necessarily
+    // see a nullable return value.
+    var expected = '''
+T f<T>(T t) => t;
+int? g(int? x) => f<int?>(x);
+void h() {
+  g(null);
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   test_data_flow_generic_contravariant_inward_using_core_class() async {
     var content = '''
 void f(List<int> x, int i) {

pkg/nnbd_migration/test/edge_builder_test.dart

@@ -1264,6 +1264,25 @@ void f(List<int> x, int i) {
         assertEdge(nullable_i, nullable_list_t_or_nullable_t, hard: true));
   }
 
+  test_methodInvocation_parameter_contravariant_function() async {
+    await analyze('''
+void f<T>(T t) {}
+void g(int i) {
+  f<int>(i/*check*/);
+}
+''');
+    var nullable_i = decoratedTypeAnnotation('int i').node;
+    var nullable_f_t = decoratedTypeAnnotation('int>').node;
+    var nullable_t = decoratedTypeAnnotation('T t').node;
+    var check_i = checkExpression('i/*check*/');
+    var nullable_f_t_or_nullable_t =
+        check_i.edges.single.destinationNode as NullabilityNodeForSubstitution;
+    expect(nullable_f_t_or_nullable_t.innerNode, same(nullable_f_t));
+    expect(nullable_f_t_or_nullable_t.outerNode, same(nullable_t));
+    assertNullCheck(check_i,
+        assertEdge(nullable_i, nullable_f_t_or_nullable_t, hard: true));
+  }
+
   test_methodInvocation_parameter_generic() async {
     await analyze('''
 class C<T> {}
@@ -1327,6 +1346,23 @@ bool f(C c) => c.m();
         hard: false);
   }
 
+  test_methodInvocation_return_type_generic_function() async {
+    await analyze('''
+T f<T>(T t) => t;
+int g() => (f<int>(1));
+''');
+    var check_i = checkExpression('(f<int>(1))');
+    var nullable_f_t = decoratedTypeAnnotation('int>').node;
+    var nullable_f_t_or_nullable_t =
+        check_i.edges.single.primarySource as NullabilityNodeForSubstitution;
+    var nullable_t = decoratedTypeAnnotation('T f').node;
+    expect(nullable_f_t_or_nullable_t.innerNode, same(nullable_f_t));
+    expect(nullable_f_t_or_nullable_t.outerNode, same(nullable_t));
+    var nullable_return = decoratedTypeAnnotation('int g').node;
+    assertNullCheck(check_i,
+        assertEdge(nullable_f_t_or_nullable_t, nullable_return, hard: false));
+  }
+
   test_methodInvocation_return_type_null_aware() async {
     await analyze('''
 class C {