[TypeChecker] Adjust witness matching to strip concurrency from ObjC requirements

`swift_attr` attributes in the type context were ignored before,
which means that we need to maintain status quo to avoid breaking
witness matching by stripping everything concurrency related from
inner types.

Resolves: rdar://122592751

Author: xedin

lib/Sema/TypeCheckProtocol.cpp

@@ -1169,6 +1169,33 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
   // Match a type in the requirement to a type in the witness.
   auto matchTypes = [&](Type reqType,
                         Type witnessType) -> llvm::Optional<RequirementMatch> {
+    // `swift_attr` attributes in the type context were ignored before,
+    // which means that we need to maintain status quo to avoid breaking
+    // witness matching by stripping everything concurrency related from
+    // inner types.
+    if (req->isObjC()) {
+      if (reqType->is<FunctionType>()) {
+        auto *fnTy = reqType->castTo<FunctionType>();
+        SmallVector<AnyFunctionType::Param, 4> params;
+        llvm::transform(fnTy->getParams(), std::back_inserter(params),
+                        [&](const AnyFunctionType::Param &param) {
+                          return param.withType(
+                              param.getPlainType()->stripConcurrency(
+                                  /*recursive=*/true,
+                                  /*dropGlobalActor=*/true));
+                        });
+
+        auto resultTy =
+            fnTy->getResult()->stripConcurrency(/*recursive=*/true,
+                                                /*dropGlobalActor=*/true);
+
+        reqType = FunctionType::get(params, resultTy, fnTy->getExtInfo());
+      } else {
+        reqType = reqType->stripConcurrency(/*recursive=*/true,
+                                            /*dropGlobalActor=*/true);
+      }
+    }
+
     cs->addConstraint(ConstraintKind::Bind, reqType, witnessType, locator);
     // FIXME: Check whether this has already failed.
     return llvm::None;

test/Concurrency/sendable_objc_attr_in_type_context.swift

@@ -14,6 +14,7 @@
 //--- Test.h
 #define SWIFT_SENDABLE __attribute__((__swift_attr__("@Sendable")))
 #define NONSENDABLE __attribute__((__swift_attr__("@_nonSendable")))
+#define MAIN_ACTOR __attribute__((__swift_attr__("@MainActor")))
 
 #pragma clang assume_nonnull begin
 
@@ -56,6 +57,11 @@ void doSomethingConcurrently(__attribute__((noescape)) void SWIFT_SENDABLE (^blo
 -(void) add: (T) object;
 @end
 
+@protocol InnerSendableTypes
+-(void) test:(NSDictionary<NSString *, SWIFT_SENDABLE id> *)options;
+-(void) testWithCallback:(NSString *)name handler:(MAIN_ACTOR void (^)(NSDictionary<NSString *, SWIFT_SENDABLE id> *, NSError * _Nullable))handler;
+@end
+
 #pragma clang assume_nonnull end
 
 //--- main.swift
@@ -105,3 +111,11 @@ func test_sendable_attr_in_type_context(test: Test) {
   TestWithSendableSuperclass().add(MyValue())
   // expected-warning@-1 3 {{type 'MyValue' does not conform to the 'Sendable' protocol}}
 }
+
+class TestConformanceWithStripping : InnerSendableTypes {
+  func test(_ options: [String: Any]) { // Ok
+  }
+
+  func test(withCallback name: String, handler: @escaping @MainActor ([String : Any], (any Error)?) -> Void) { // Ok
+  }
+}