[Sema] Allow associated type inference to skip @Sendable on ObjC witnesses

Witness checking itself is allowed to skip `@Sendable` mismatch in this
situation. This is a narrow fix for `SendableCompletionHandlers` feature
to make sure that the behavior doesn't change for non-ObjC witnesses

Author: xedin

lib/Sema/AssociatedTypeInference.cpp

@@ -2269,6 +2269,61 @@ AssociatedTypeInference::getPotentialTypeWitnessesByMatchingTypes(ValueDecl *req
       return true;
     }
 
+    bool mismatch(AnyFunctionType *firstType, AnyFunctionType *secondType,
+                  Type sugaredFirstType) {
+      // Mismatch on sendability could be okay if everything else matches.
+      if (firstType->isSendable() != secondType->isSendable()) {
+        auto firstExtInfo = firstType->getExtInfo();
+        auto secondExtInfo = secondType->getExtInfo();
+
+        // If the requirement is Sendable, it's always okay because
+        // having witnesses differ only on `@Sendable` is already
+        // ambiguous, for example:
+        //
+        // protocol P {
+        //   associatedtype T
+        //   func test(_: @Sendable (T) -> Void)
+        // }
+
+        // struct S : P {
+        //   func test(_: @Sendable (String) -> Void) {}
+        //   func test(_: (Int) -> Void) {}
+        // }
+        //
+        // This infers `T` as `Int` and `String`.
+        if (firstType->isSendable()) {
+          return match(
+              firstType->withExtInfo(secondExtInfo.withSendable(false)),
+              secondType);
+        }
+
+        // If it's a witness that is Sendable but requirement isn't
+        // let's only allow matches if the witness comes from ObjC
+        // as a very narrow fix to avoid introducing new ambiguities
+        // like this:
+        //
+        // protocol P {
+        //   associatedtype T
+        //   func test(_: (T) -> Void)
+        // }
+        //
+        // struct S : P {
+        //   func test(_: @Sendable (Int) -> Void) {}
+        //   func test(_: (Int) -> Void) {}
+        // }
+        //
+        // This currently infers `T := Int`.
+        if (auto *witness = Inferred.Witness) {
+          if (witness->hasClangNode()) {
+            return match(firstType, secondType->withExtInfo(
+                                        firstExtInfo.withSendable(false)));
+          }
+        }
+      }
+
+      return false;
+    }
+
     bool mismatch(GenericTypeParamType *selfParamType,
                   TypeBase *secondType, Type sugaredFirstType) {
       if (selfParamType->isEqual(Conformance->getProtocol()->getSelfInterfaceType())) {

test/Concurrency/sendable_objc_attr_in_type_context_swift5.swift

@@ -78,6 +78,10 @@ void doSomethingConcurrently(__attribute__((noescape)) void SWIFT_SENDABLE (^blo
 -(void)willSendDataWithCompletion: (void (^)(void)) completion;
 @end
 
+@interface DataHandler : NSObject
++(void)sendDataWithCompletion: (void (^)(MyValue *)) completion;
+@end
+
 #pragma clang assume_nonnull end
 
 //--- main.swift
@@ -189,3 +193,13 @@ class ImplicitShadowing : NSObject, TestWitnesses {
     (self as AnyObject).willSendData { } // Ok
   }
 }
+
+protocol CompletionWithoutSendable {
+  associatedtype T
+  static func sendData(completion: @escaping (T) -> Void) // expected-note {{expected sendability to match requirement here}}
+}
+
+extension DataHandler : CompletionWithoutSendable {
+  // expected-warning@-1 {{sendability of function types in class method 'sendData(completion:)' does not match requirement in protocol 'CompletionWithoutSendable'}}
+  // It should be possible to infer `T` from method that mismatches on @Sendable in Swift 5 mode
+}

test/Concurrency/sendable_objc_attr_in_type_context_swift6.swift

@@ -78,6 +78,10 @@ void doSomethingConcurrently(__attribute__((noescape)) void SWIFT_SENDABLE (^blo
 -(void)willSendDataWithCompletion: (void (^)(void)) completion;
 @end
 
+@interface DataHandler : NSObject
++(void)sendDataWithCompletion: (void (^)(MyValue *)) completion;
+@end
+
 #pragma clang assume_nonnull end
 
 //--- main.swift
@@ -196,3 +200,13 @@ class ImplicitShadowing : NSObject, TestWitnesses {
     (self as AnyObject).willSendData { } // Ok
   }
 }
+
+protocol CompletionWithoutSendable {
+  associatedtype T
+  static func sendData(completion: @escaping (T) -> Void) // expected-note {{expected sendability to match requirement here}}
+}
+
+extension DataHandler : CompletionWithoutSendable {
+  // expected-error@-1 {{sendability of function types in class method 'sendData(completion:)' does not match requirement in protocol 'CompletionWithoutSendable'}}
+  // It should be possible to infer `T` from method that mismatches on @Sendable in Swift 5 mode
+}