[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

include/swift/AST/TypeMatcher.h

@@ -375,7 +375,8 @@ class TypeMatcher {
         if (firstFunc->isNoEscape() != secondFunc->isNoEscape())
           return mismatch(firstFunc.getPointer(), secondFunc, sugaredFirstType);
 
-        if (firstFunc->isSendable() != secondFunc->isSendable())
+        if (!Matcher.asDerived().allowSendableFunctionMismatch() &&
+            firstFunc->isSendable() != secondFunc->isSendable())
           return mismatch(firstFunc.getPointer(), secondFunc, sugaredFirstType);
 
         auto sugaredFirstFunc = sugaredFirstType->castTo<AnyFunctionType>();
@@ -554,6 +555,8 @@ class TypeMatcher {
 
   bool alwaysMismatchTypeParameters() const { return false; }
 
+  bool allowSendableFunctionMismatch() const { return false; }
+
   void pushPosition(Position pos) {}
   void popPosition(Position pos) {}
 

lib/Sema/AssociatedTypeInference.cpp

@@ -2269,6 +2269,25 @@ AssociatedTypeInference::getPotentialTypeWitnessesByMatchingTypes(ValueDecl *req
       return true;
     }
 
+    bool allowSendableFunctionMismatch() const {
+      // Allow mismatches on `@Sendable` only 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) {}
+      // }
+      //
+      // Currently, there is only one binding for `T` - `Int`.
+      return Inferred.Witness && Inferred.Witness->hasClangNode();
+    }
+
     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
+}