Revert "[TypeChecker] TypeChecker::isSubtypeOf should recognize Sendable/@Sendable subtyping"

lib/Sema/TypeCheckConstraints.cpp

@@ -1068,22 +1068,8 @@ bool TypeChecker::typesSatisfyConstraint(Type type1, Type type2,
   }
 
   if (auto solution = cs.solveSingle()) {
-    const auto &score = solution->getFixedScore();
     if (unwrappedIUO)
-      *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;
-          }))
-        return false;
-    }
+      *unwrappedIUO = solution->getFixedScore().Data[SK_ForceUnchecked] > 0;
 
     return true;
   }

test/Concurrency/sendable_keypaths.swift

@@ -221,12 +221,14 @@ do {
     fatalError()
   }
 
+  // TODO(rdar://125948508): This shouldn't be ambiguous (@Sendable version should be preferred)
   func test() -> KeyPath<String, Int> {
-    true ? kp() : kp() // Ok
+    true ? kp() : kp() // expected-error {{type of expression is ambiguous without a type annotation}}
   }
 
   func forward<T>(_ v: T) -> T { v }
-  let _: KeyPath<String, Int> = forward(kp()) // Ok
+  // TODO(rdar://125948508): This shouldn't be ambiguous (@Sendable version should be preferred)
+  let _: KeyPath<String, Int> = forward(kp()) // expected-error {{conflicting arguments to generic parameter 'T' ('any KeyPath<String, Int> & Sendable' vs. 'KeyPath<String, Int>')}}
 }
 
 do {
@@ -236,3 +238,22 @@ do {
 
   _ = \C<Int>.immutable as? ReferenceWritableKeyPath // Ok
 }
+
+// Should be moved back to sendable_methods.swift once ambiguities are fixed
+do {
+  struct Test {
+    static func fn() {}
+    static func otherFn() {}
+  }
+
+  // TODO(rdar://125948508): This shouldn't be ambiguous (@Sendable version should be preferred)
+  func fnRet(cond: Bool) -> () -> Void {
+    cond ? Test.fn : Test.otherFn // expected-error {{type of expression is ambiguous without a type annotation}}
+  }
+
+  func forward<T>(_: T) -> T {
+  }
+
+  // TODO(rdar://125948508): This shouldn't be ambiguous (@Sendable version should be preferred)
+  let _: () -> Void = forward(Test.fn) // expected-error {{conflicting arguments to generic parameter 'T' ('@Sendable () -> ()' vs. '() -> Void')}}
+}

test/Concurrency/sendable_methods.swift

@@ -229,23 +229,6 @@ do {
   }
 }
 
-do {
-  struct Test {
-    static func fn() {}
-    static func otherFn() {}
-  }
-
-  func fnRet(cond: Bool) -> () -> Void {
-    cond ? Test.fn : Test.otherFn // Ok
-  }
-
-  func forward<T>(_: T) -> T {
-  }
-
-  let _: () -> Void = forward(Test.fn) // Ok
-}
-
-
 func test_initializer_ref() {
   func test<T>(_: @Sendable (T, T) -> Array<T>) {
   }
@@ -277,3 +260,12 @@ do {
     }
   }
 }
+
+// rdar://125932231 - incorrect `error: type of expression is ambiguous without a type annotation`
+do {
+  class C {}
+
+  func test(c: C) -> (any Sendable)? {
+    true ? nil : c // Ok
+  }
+}