Merge pull request #69549 from xedin/rdar-117227549

[ConstraintSystem] Rework overload ranking based on Sendable conformances

Author: xedin

include/swift/AST/TypeCheckRequests.h

@@ -2658,7 +2658,8 @@ class SynthesizeDefaultInitRequest
 
 class CompareDeclSpecializationRequest
     : public SimpleRequest<CompareDeclSpecializationRequest,
-                           bool(DeclContext *, ValueDecl *, ValueDecl *, bool),
+                           bool(DeclContext *, ValueDecl *, ValueDecl *, bool,
+                                bool),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2667,9 +2668,9 @@ class CompareDeclSpecializationRequest
   friend SimpleRequest;
 
   // Evaluation.
-  bool evaluate(Evaluator &evaluator, DeclContext *DC,
-                ValueDecl *VD1, ValueDecl *VD2,
-                bool dynamic) const;
+  bool evaluate(Evaluator &evaluator, DeclContext *DC, ValueDecl *VD1,
+                ValueDecl *VD2, bool dynamic,
+                bool allowMissingConformances) const;
 
 public:
   // Caching.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -47,8 +47,8 @@ SWIFT_REQUEST(TypeChecker, ClassAncestryFlagsRequest,
 SWIFT_REQUEST(TypeChecker, IDEInspectionFileRequest,
               SourceFile *(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CompareDeclSpecializationRequest,
-              bool (DeclContext *, ValueDecl *, ValueDecl *, bool), Cached,
-              NoLocationInfo)
+              bool (DeclContext *, ValueDecl *, ValueDecl *, bool, bool),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ConditionalRequirementsRequest,
               ArrayRef<Requirement> (NormalProtocolConformance *),
               Cached, NoLocationInfo)

include/swift/Sema/ConstraintSystem.h

@@ -984,6 +984,10 @@ enum ScoreKind: unsigned int {
   SK_ValueToPointerConversion,
   /// A closure/function conversion to an autoclosure parameter.
   SK_FunctionToAutoClosureConversion,
+  /// A type with a missing conformance(s) that has be synthesized
+  /// or diagnosed later, such types are allowed to appear in
+  /// a valid solution.
+  SK_MissingSynthesizableConformance,
   /// An unapplied reference to a function. The purpose of this
   /// score bit is to prune overload choices that are functions
   /// when a solution has already been found using property.
@@ -1159,6 +1163,9 @@ struct Score {
 
     case SK_UnappliedFunction:
       return "use of overloaded unapplied function";
+
+    case SK_MissingSynthesizableConformance:
+      return "type with missing synthesizable conformance";
     }
   }
 

lib/Sema/CSRanking.cpp

@@ -417,16 +417,18 @@ static bool paramIsIUO(const ValueDecl *decl, int paramNum) {
 /// "Specialized" is essentially a form of subtyping, defined below.
 static bool isDeclAsSpecializedAs(DeclContext *dc, ValueDecl *decl1,
                                   ValueDecl *decl2,
-                                  bool isDynamicOverloadComparison = false) {
+                                  bool isDynamicOverloadComparison = false,
+                                  bool allowMissingConformances = true) {
   return evaluateOrDefault(decl1->getASTContext().evaluator,
                            CompareDeclSpecializationRequest{
-                               dc, decl1, decl2, isDynamicOverloadComparison},
+                               dc, decl1, decl2, isDynamicOverloadComparison,
+                               allowMissingConformances},
                            false);
 }
 
 bool CompareDeclSpecializationRequest::evaluate(
     Evaluator &eval, DeclContext *dc, ValueDecl *decl1, ValueDecl *decl2,
-    bool isDynamicOverloadComparison) const {
+    bool isDynamicOverloadComparison, bool allowMissingConformances) const {
   auto &C = decl1->getASTContext();
   // Construct a constraint system to compare the two declarations.
   ConstraintSystem cs(dc, ConstraintSystemOptions());
@@ -759,9 +761,16 @@ bool CompareDeclSpecializationRequest::evaluate(
     // Solve the system.
     auto solution = cs.solveSingle(FreeTypeVariableBinding::Allow);
 
-    // Ban value-to-optional conversions.
-    if (solution && solution->getFixedScore().Data[SK_ValueToOptional] == 0)
-      return completeResult(true);
+    if (solution) {
+      auto score = solution->getFixedScore();
+
+      // Ban value-to-optional conversions and
+      // missing conformances if they are disallowed.
+      if (score.Data[SK_ValueToOptional] == 0 &&
+          (allowMissingConformances ||
+           score.Data[SK_MissingSynthesizableConformance] == 0))
+        return completeResult(true);
+    }
   }
 
   // If the first function has fewer effective parameters than the
@@ -1121,12 +1130,14 @@ SolutionCompareResult ConstraintSystem::compareSolutions(
     bool firstAsSpecializedAs = false;
     bool secondAsSpecializedAs = false;
     if (isDeclAsSpecializedAs(cs.DC, decl1, decl2,
-                              isDynamicOverloadComparison)) {
+                              isDynamicOverloadComparison,
+                              /*allowMissingConformances=*/false)) {
       score1 += weight;
       firstAsSpecializedAs = true;
     }
     if (isDeclAsSpecializedAs(cs.DC, decl2, decl1,
-                              isDynamicOverloadComparison)) {
+                              isDynamicOverloadComparison,
+                              /*allowMissingConformances=*/false)) {
       score2 += weight;
       secondAsSpecializedAs = true;
     }

lib/Sema/CSSimplify.cpp

@@ -8413,6 +8413,16 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     if (isConformanceUnavailable(conformance, loc))
       increaseScore(SK_Unavailable, locator);
 
+    unsigned numMissing = 0;
+    conformance.forEachMissingConformance(DC->getParentModule(),
+                                          [&numMissing](auto *missing) {
+                                            ++numMissing;
+                                            return false;
+                                          });
+
+    if (numMissing > 0)
+      increaseScore(SK_MissingSynthesizableConformance, locator, numMissing);
+
     // This conformance may be conditional, in which case we need to consider
     // those requirements as constraints too.
     if (conformance.isConcrete()) {

test/Concurrency/sendable_disambiguation.swift

@@ -0,0 +1,48 @@
+// RUN: %target-swift-frontend %s -emit-sil -o /dev/null -verify -strict-concurrency=complete
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+// REQUIRES: OS=macosx
+
+do {
+  struct Test {
+    init<T: Sendable>(value: T) {}
+    init<T>(value: T) {}
+  }
+
+  struct SendableOnly {
+    init<T: Sendable>(value: T) {}
+  }
+
+  func testNonSendable<T>(v: T) { // expected-note {{consider making generic parameter 'T' conform to the 'Sendable' protocol}}
+    _ = Test(value: v) // Ok (non-Sendable overload)
+    _ = SendableOnly(value: v)
+    // expected-warning@-1 {{type 'T' does not conform to the 'Sendable' protocol}}
+  }
+
+  func testSendable<T: Sendable>(v: T) {
+    _ = Test(value: v) // Ok
+    _ = SendableOnly(value: v) // Ok
+  }
+}
+
+do {
+  class K {
+    func value() {}
+  }
+
+  struct X {
+    var fn: (Int) -> K
+    func fn(_: Int) -> Int { 42 }
+  }
+
+  func sendable<T>(_ fn: (Int) -> T) -> T { fn(42) }
+  func sendable<T: Sendable>(_ fn: (Int) -> T) -> T { fn(0) }
+
+  func test(x: X) {
+    let res = sendable(x.fn) // Ok (non-ambiguous and non-Sendable overload)
+    res.value() // To make sure that previous expression picks a property
+    let _: K = sendable(x.fn) // Ok (picks `sendable<T>` with a property)
+    let _: Int = sendable(x.fn) // Ok (picks `sendable<T: Sendable>` with a method)
+  }
+}