[TypeChecker] TypeChecker::isSubtypeOf should recognize Sendable subtyping

A sendable type can be a subtype of a non-Sendable type, i.e.
`any X & Sendable` vs. `X` where `X` is a class. The solver
adjusts `MissingSynthesizableConformance` to indicate that
one of the types is missing `Sendable` and that needs to be
recognized by `TypeChecker::isSubtypeOf`.

Author: xedin

lib/Sema/TypeCheckConstraints.cpp

@@ -1034,13 +1034,17 @@ bool TypeChecker::typesSatisfyConstraint(Type type1, Type type2,
   }
 
   if (auto solution = cs.solveSingle()) {
+    const auto &score = solution->getFixedScore();
     if (unwrappedIUO)
-      *unwrappedIUO = solution->getFixedScore().Data[SK_ForceUnchecked] > 0;
+      *unwrappedIUO = score.Data[SK_ForceUnchecked] > 0;
 
     // Make sure that Sendable vs. no-Sendable mismatches are
     // failures here to establish subtyping relationship
     // (unlike in the solver where they are warnings until Swift 6).
     if (kind == ConstraintKind::Subtype) {
+      if (score.Data[SK_MissingSynthesizableConformance] > 0)
+        return false;
+
       if (llvm::any_of(solution->Fixes, [](const auto *fix) {
             return fix->getKind() == FixKind::AddSendableAttribute;
           }))

test/Concurrency/sendable_keypaths.swift

@@ -217,3 +217,16 @@ do {
   let _: [PartialKeyPath<S>] = [\.a, \.b] // Ok
   let _: [any PartialKeyPath<S> & Sendable] = [\.a, \.b] // Ok
 }
+
+do {
+  func kp() -> KeyPath<String, Int> & Sendable {
+    fatalError()
+  }
+
+  func test() -> KeyPath<String, Int> {
+    true ? kp() : kp() // Ok
+  }
+
+  func forward<T>(_ v: T) -> T { v }
+  let _: KeyPath<String, Int> = forward(kp()) // Ok
+}