Merge pull request #58778 from xedin/rdar-92912878

[CSSimplify] Avoid filtering `init` overloads of a callable type

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -10946,6 +10946,24 @@ bool ConstraintSystem::simplifyAppliedOverloadsImpl(
 
   auto *argList = getArgumentList(getConstraintLocator(locator));
 
+  // If argument list has trailing closures and this is `init` call to
+  // a callable type, let's not filter anything since there is a possibility
+  // that it needs an implicit `.callAsFunction` to work.
+  if (argList && argList->hasAnyTrailingClosures()) {
+    if (disjunction->getLocator()
+            ->isLastElement<LocatorPathElt::ConstructorMember>()) {
+      auto choice = disjunction->getNestedConstraints()[0]->getOverloadChoice();
+      if (auto *decl = choice.getDeclOrNull()) {
+        auto *dc = decl->getDeclContext();
+        if (auto *parent = dc->getSelfNominalTypeDecl()) {
+          auto type = parent->getDeclaredInterfaceType();
+          if (type->isCallableNominalType(DC))
+            return false;
+        }
+      }
+    }
+  }
+
   // Consider each of the constraints in the disjunction.
 retry_after_fail:
   bool hasUnhandledConstraints = false;

test/Constraints/callAsFunction.swift

@@ -29,3 +29,25 @@ struct Test {
     }
   }
 }
+
+// rdar://92912878 - filtering prevents disambiguation of `.callAsFunction`
+func test_no_filtering_of_overloads() {
+  struct S {
+    init() {}
+    init(_: String) {}
+
+    func callAsFunction<T>(_ fn: () -> T) -> T {
+      fn()
+    }
+  }
+
+  func test(_: () -> Void) {
+  }
+
+  test {
+    _ = S() { // Ok
+      _ = 42
+      print("Hello")
+    }
+  }
+}