Migration: add simple MethodInvocation support to FixBuilder.

Change-Id: Ice76583076a3f38d1cc0f9a3aacbac630a9a97c0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/121763
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: stereotype441

pkg/nnbd_migration/lib/src/fix_builder.dart

@@ -121,6 +121,20 @@ abstract class FixBuilder extends GeneralizingAstVisitor<DartType>
             _assignedVariables.capturedAnywhere);
   }
 
+  @override
+  DartType visitArgumentList(ArgumentList node) {
+    for (var argument in node.arguments) {
+      Expression expression;
+      if (argument is NamedExpression) {
+        expression = argument.expression;
+      } else {
+        expression = argument;
+      }
+      visitSubexpression(expression, UnknownInferredType.instance);
+    }
+    return null;
+  }
+
   @override
   DartType visitAssignmentExpression(AssignmentExpression node) {
     var operatorType = node.operator.type;
@@ -378,6 +392,44 @@ abstract class FixBuilder extends GeneralizingAstVisitor<DartType>
         .withNullability(NullabilitySuffix.none);
   }
 
+  @override
+  DartType visitMethodInvocation(MethodInvocation node) {
+    var target = node.realTarget;
+    var callee = node.methodName.staticElement;
+    bool isNullAware = node.isNullAware;
+    DartType targetType;
+    if (target != null) {
+      if (callee is ExecutableElement && callee.isStatic) {
+        target.accept(this);
+      } else {
+        targetType = visitSubexpression(
+            target,
+            isNullAware || isDeclaredOnObject(node.methodName.name)
+                ? typeProvider.dynamicType
+                : typeProvider.objectType);
+      }
+    }
+    if (callee == null) {
+      // Dynamic dispatch.  The return type is `dynamic`.
+      node.typeArguments?.accept(this);
+      node.argumentList.accept(this);
+      return typeProvider.dynamicType;
+    }
+    var calleeType = _computeMigratedType(callee, targetType: targetType);
+    var expressionType = _handleInvocationArguments(
+        node,
+        node.argumentList.arguments,
+        node.typeArguments,
+        node.typeArgumentTypes,
+        calleeType as FunctionType,
+        null,
+        invokeType: node.staticInvokeType);
+    if (isNullAware) {
+      expressionType = _typeSystem.makeNullable(expressionType as TypeImpl);
+    }
+    return expressionType;
+  }
+
   @override
   DartType visitNode(AstNode node) {
     // Every node type needs its own visit method.
@@ -665,6 +717,51 @@ abstract class FixBuilder extends GeneralizingAstVisitor<DartType>
     return combinedType;
   }
 
+  DartType _handleInvocationArguments(
+      AstNode node,
+      Iterable<AstNode> arguments,
+      TypeArgumentList typeArguments,
+      List<DartType> typeArgumentTypes,
+      FunctionType calleeType,
+      List<TypeParameterElement> constructorTypeParameters,
+      {DartType invokeType}) {
+    var typeFormals = constructorTypeParameters ?? calleeType.typeFormals;
+    if (typeFormals.isNotEmpty) {
+      throw UnimplementedError('TODO(paulberry): Invocation of generic method');
+    }
+    int i = 0;
+    var namedParameterTypes = <String, DartType>{};
+    var positionalParameterTypes = <DartType>[];
+    for (var parameter in calleeType.parameters) {
+      if (parameter.isNamed) {
+        namedParameterTypes[parameter.name] = parameter.type;
+      } else {
+        positionalParameterTypes.add(parameter.type);
+      }
+    }
+    for (var argument in arguments) {
+      String name;
+      Expression expression;
+      if (argument is NamedExpression) {
+        name = argument.name.label.name;
+        expression = argument.expression;
+      } else {
+        expression = argument as Expression;
+      }
+      DartType parameterType;
+      if (name != null) {
+        parameterType = namedParameterTypes[name];
+        assert(parameterType != null, 'Missing type for named parameter');
+      } else {
+        assert(i < positionalParameterTypes.length,
+            'Missing positional parameter at $i');
+        parameterType = positionalParameterTypes[i++];
+      }
+      visitSubexpression(expression, parameterType);
+    }
+    return calleeType.returnType;
+  }
+
   DartType _handlePropertyAccess(Expression node, Expression target,
       SimpleIdentifier propertyName, bool isNullAware) {
     var staticElement = propertyName.staticElement;

pkg/nnbd_migration/test/fix_builder_test.dart

@@ -1074,6 +1074,103 @@ _f(int/*?*/ x) => <int/*!*/>[x];
         changes: {findNode.simple('x]'): NullCheck()});
   }
 
+  test_methodInvocation_dynamic() async {
+    await analyze('''
+Object/*!*/ _f(dynamic d) => d.f();
+''');
+    visitSubexpression(findNode.methodInvocation('d.f'), 'dynamic',
+        contextType: objectType);
+  }
+
+  test_methodInvocation_namedParameter() async {
+    await analyze('''
+abstract class _C {
+  int f({int/*!*/ x});
+}
+_f(_C c, int/*?*/ y) => c.f(x: y);
+''');
+    visitSubexpression(findNode.methodInvocation('c.f'), 'int',
+        changes: {findNode.simple('y);'): NullCheck()});
+  }
+
+  test_methodInvocation_ordinaryParameter() async {
+    await analyze('''
+abstract class _C {
+  int f(int/*!*/ x);
+}
+_f(_C c, int/*?*/ y) => c.f(y);
+''');
+    visitSubexpression(findNode.methodInvocation('c.f'), 'int',
+        changes: {findNode.simple('y);'): NullCheck()});
+  }
+
+  test_methodInvocation_return_nonNullable() async {
+    await analyze('''
+abstract class _C {
+  int f();
+}
+_f(_C c) => c.f();
+''');
+    visitSubexpression(findNode.methodInvocation('c.f'), 'int');
+  }
+
+  test_methodInvocation_return_nonNullable_check_target() async {
+    await analyze('''
+abstract class _C {
+  int f();
+}
+_f(_C/*?*/ c) => c.f();
+''');
+    visitSubexpression(findNode.methodInvocation('c.f'), 'int',
+        changes: {findNode.simple('c.f'): NullCheck()});
+  }
+
+  test_methodInvocation_return_nonNullable_nullAware() async {
+    await analyze('''
+abstract class _C {
+  int f();
+}
+_f(_C/*?*/ c) => c?.f();
+''');
+    visitSubexpression(findNode.methodInvocation('c?.f'), 'int?');
+  }
+
+  test_methodInvocation_return_nullable() async {
+    await analyze('''
+abstract class _C {
+  int/*?*/ f();
+}
+_f(_C c) => c.f();
+''');
+    visitSubexpression(findNode.methodInvocation('c.f'), 'int?');
+  }
+
+  test_methodInvocation_static() async {
+    await analyze('''
+_f() => _C.g();
+class _C {
+  static int g() => 1;
+}
+''');
+    visitSubexpression(findNode.methodInvocation('_C.g();'), 'int');
+  }
+
+  test_methodInvocation_topLevel() async {
+    await analyze('''
+_f() => _g();
+int _g() => 1;
+''');
+    visitSubexpression(findNode.methodInvocation('_g();'), 'int');
+  }
+
+  test_methodInvocation_toString() async {
+    await analyze('''
+abstract class _C {}
+_f(_C/*?*/ c) => c.toString();
+''');
+    visitSubexpression(findNode.methodInvocation('c.toString'), 'String');
+  }
+
   test_nullAssertion_promotes() async {
     await analyze('''
 _f(bool/*?*/ x) => x && x;