[CodeCompletion] Don’t report a call pattern as convertible if its result type doesn’t match

To compute the expected type of a call pattern (which is the return type of the function if that call pattern is being used), we called `getTypeForCompletion` for the entire call, in the same way that we do for the code completion token. However, this pattern does not generally work. For the code completion token it worked because the code completion expression doesn’t have an inherent type and it inherits the type solely from its context. Calls, however, have an inherent return type and that type gets assigned as the `typeForCompletion`.

To fix this, check if we recorded a fix that allowed a type mismatch between `ParentCall` and its surrounding context. If this is the case use the surrounding type as the `ExpectedCallType`. Finally, to make this work, we need to ensure that we don’t suppress the recording of such type mismatch fixes in code completion mode.

Author: ahoppen

include/swift/Sema/CSFix.h

@@ -2467,9 +2467,10 @@ class AllowInOutConversion final : public ContextualMismatch {
 class AllowArgumentMismatch : public ContextualMismatch {
 protected:
   AllowArgumentMismatch(ConstraintSystem &cs, Type argType, Type paramType,
-                        ConstraintLocator *locator)
+                        ConstraintLocator *locator,
+                        FixBehavior fixBehavior = FixBehavior::Error)
       : AllowArgumentMismatch(cs, FixKind::AllowArgumentTypeMismatch, argType,
-                              paramType, locator) {}
+                              paramType, locator, fixBehavior) {}
 
   AllowArgumentMismatch(ConstraintSystem &cs, FixKind kind, Type argType,
                         Type paramType, ConstraintLocator *locator,
@@ -2486,9 +2487,10 @@ class AllowArgumentMismatch : public ContextualMismatch {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
-  static AllowArgumentMismatch *create(ConstraintSystem &cs, Type argType,
-                                       Type paramType,
-                                       ConstraintLocator *locator);
+  static AllowArgumentMismatch *
+  create(ConstraintSystem &cs, Type argType, Type paramType,
+         ConstraintLocator *locator,
+         FixBehavior fixBehavior = FixBehavior::Error);
 
   static bool classof(const ConstraintFix *fix) {
     return fix->getKind() == FixKind::AllowArgumentTypeMismatch;

lib/IDE/ArgumentCompletion.cpp

@@ -175,6 +175,21 @@ void ArgumentTypeCheckCompletionCallback::sawSolutionImpl(const Solution &S) {
   if (!isExpressionResultTypeUnconstrained(S, ParentCall)) {
     ExpectedCallType = getTypeForCompletion(S, ParentCall);
   }
+  // If we recorded a fix to allow a type mismatch for the ParentCall,
+  // use the type `ParentCall` should have had as the expected call type.
+  // For example, in the following the call to `bar` gets assigned a type
+  // of `String` but we want to report `Int` as the expected call type.
+  //
+  // func foo(_ x: Int) {}
+  // func bar() -> String {}
+  // foo(bar(#^COMPLETE^#))
+  for (auto Fix : S.Fixes) {
+    if (auto CM = dyn_cast<AllowArgumentMismatch>(Fix)) {
+      if (simplifyLocatorToAnchor(CM->getLocator()) == ASTNode(ParentCall)) {
+        ExpectedCallType = CM->getToType();
+      }
+    }
+  }
 
   auto *CallLocator = CS.getConstraintLocator(ParentCall);
   auto *CalleeLocator = S.getCalleeLocator(CallLocator);

lib/Sema/CSFix.cpp

@@ -1842,11 +1842,13 @@ bool AllowArgumentMismatch::diagnose(const Solution &solution,
   return failure.diagnose(asNote);
 }
 
-AllowArgumentMismatch *
-AllowArgumentMismatch::create(ConstraintSystem &cs, Type argType,
-                              Type paramType, ConstraintLocator *locator) {
+AllowArgumentMismatch *AllowArgumentMismatch::create(ConstraintSystem &cs,
+                                                     Type argType,
+                                                     Type paramType,
+                                                     ConstraintLocator *locator,
+                                                     FixBehavior fixBehavior) {
   return new (cs.getAllocator())
-      AllowArgumentMismatch(cs, argType, paramType, locator);
+      AllowArgumentMismatch(cs, argType, paramType, locator, fixBehavior);
 }
 
 bool RemoveInvalidCall::diagnose(const Solution &solution, bool asNote) const {

lib/Sema/CSSimplify.cpp

@@ -5663,23 +5663,6 @@ bool ConstraintSystem::repairFailures(
       }
     }
 
-    if (isForCodeCompletion()) {
-      // If the argument contains the code completion location, the user has not
-      // finished typing out this argument yet. Treat the mismatch as valid so
-      // we don't penalize this solution.
-      if (auto *arg = getAsExpr(simplifyLocatorToAnchor(loc))) {
-        // Ignore synthesized args like $match in implicit pattern match
-        // operator calls. Their source location is usually the same as the
-        // other (explicit) argument's so source range containment alone isn't
-        // sufficient.
-        bool isSynthesizedArg = arg->isImplicit() && isa<DeclRefExpr>(arg);
-        if (!isSynthesizedArg && isForCodeCompletion() &&
-            containsIDEInspectionTarget(arg) && !lhs->isVoid() &&
-            !lhs->isUninhabited())
-          return true;
-      }
-    }
-
     if (repairByInsertingExplicitCall(lhs, rhs))
       break;
 
@@ -5947,8 +5930,27 @@ bool ConstraintSystem::repairFailures(
       }
     }
 
+    FixBehavior fixBehavior = FixBehavior::Error;
+
+    if (isForCodeCompletion()) {
+      // If the argument contains the code completion location, the user has not
+      // finished typing out this argument yet. Treat the mismatch as valid so
+      // we don't penalize this solution.
+      if (auto *arg = getAsExpr(simplifyLocatorToAnchor(loc))) {
+        // Ignore synthesized args like $match in implicit pattern match
+        // operator calls. Their source location is usually the same as the
+        // other (explicit) argument's so source range containment alone isn't
+        // sufficient.
+        bool isSynthesizedArg = arg->isImplicit() && isa<DeclRefExpr>(arg);
+        if (!isSynthesizedArg && isForCodeCompletion() &&
+            containsIDEInspectionTarget(arg) && !lhs->isVoid() &&
+            !lhs->isUninhabited())
+          fixBehavior = FixBehavior::Suppress;
+      }
+    }
+
     conversionsOrFixes.push_back(
-        AllowArgumentMismatch::create(*this, lhs, rhs, loc));
+        AllowArgumentMismatch::create(*this, lhs, rhs, loc, fixBehavior));
     break;
   }
 

test/IDE/expected_type_of_call_pattern.swift

@@ -0,0 +1,15 @@
+// RUN: %batch-code-completion
+
+func foo(_ x: Int) {}
+
+struct Bar {
+  func bar(withString: String) -> String {}
+  func bar(withInt: Int) -> Int {}
+}
+
+func test() {
+  foo(Bar().bar(#^COMPLETE^#))
+}
+// Ensure that we don't report the call pattern for `bar` as `Convertible`
+// COMPLETE-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#withString: String#}[')'][#String#]; name=withString:
+// COMPLETE-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]/TypeRelation[Convertible]: ['(']{#withInt: Int#}[')'][#Int#]; name=withInt: