[NameLookup] SendableCompletionHandlers: Inject @Sendable into Swift decls that could shadow ObjC ones

When `SendableCompletionHandlers` feature is enabled, ClangImporter
is going to inject `@Sendable` attribute into the completion handler
parameter's function type. We need to match this behavior in Swift
declarations that could shadow ObjC declarations otherwise it would
result in ambiguities.

Author: xedin

lib/AST/NameLookup.cpp

@@ -800,6 +800,77 @@ static CanType removeThrownError(Type type) {
   })->getCanonicalType();
 }
 
+/// When `SendableCompletionHandlers` feature is enabled, ClangImporter
+/// is going to inject `@Sendable` attribute into the completion handler
+/// parameter's function type. We need to match this behavior in Swift
+/// declarations that could shadow ObjC declarations otherwise it would
+/// result in ambiguities.
+static CanType injectSendableToCompletionHandler(ValueDecl *decl,
+                                                 CanType type) {
+  auto &ctx = decl->getASTContext();
+
+  if (!ctx.LangOpts.hasFeature(Feature::SendableCompletionHandlers))
+    return type;
+
+  if (!decl->isObjC() || decl->isObjCImplementation())
+    return type;
+
+  auto *paramList = getParameterList(decl);
+  if (!paramList || paramList->size() == 0)
+    return type;
+
+  // Check if the last parameter expects "completionHandler" argument.
+  auto *lastParam = paramList->back();
+  if (!isCompletionHandlerParamName(lastParam->getArgumentName().str()))
+    return type;
+
+  return type
+      .transformRec([](TypeBase *type) -> std::optional<Type> {
+        auto funcType = type->getAs<AnyFunctionType>();
+        if (!funcType || funcType->isAsync() || funcType->getNumParams() == 0)
+          return std::nullopt;
+
+        auto &lastParam = funcType->getParams().back();
+        if (!(lastParam.hasLabel() &&
+              isCompletionHandlerParamName(lastParam.getLabel().str())))
+          return std::nullopt;
+
+        auto completionType = lastParam.getPlainType();
+        // Completion handler could be wrapped in a number of optionals.
+        auto newCompletionType = completionType.transformRec(
+            [](TypeBase *type) -> std::optional<Type> {
+              if (auto *funcType = type->getAs<AnyFunctionType>()) {
+                auto extInfo = funcType->getExtInfo();
+                if (!extInfo.isSendable())
+                  return funcType->withExtInfo(extInfo.withSendable(true));
+                return type;
+              }
+              return std::nullopt;
+            });
+
+        if (newCompletionType->isEqual(completionType))
+          return type;
+
+        SmallVector<AnyFunctionType::Param, 2> newParams;
+        newParams.append(funcType->getParams().begin(),
+                         funcType->getParams().end() - 1);
+        newParams.push_back(lastParam.withType(newCompletionType));
+
+        if (auto *concreteFn = funcType->getAs<FunctionType>()) {
+          return FunctionType::get(newParams, funcType->getResult(),
+                                   funcType->getExtInfo())
+              ->getCanonicalType();
+        }
+
+        return GenericFunctionType::get(funcType->castTo<GenericFunctionType>()
+                                            ->getGenericSignature(),
+                                        newParams, funcType->getResult(),
+                                        funcType->getExtInfo())
+            ->getCanonicalType();
+      })
+      ->getCanonicalType();
+}
+
 /// Given a set of declarations whose names and generic signatures have matched,
 /// figure out which of these declarations have been shadowed by others.
 static void recordShadowedDeclsAfterSignatureMatch(
@@ -826,6 +897,8 @@ static void recordShadowedDeclsAfterSignatureMatch(
     else
       type = removeThrownError(decl->getInterfaceType()->getCanonicalType());
 
+    type = injectSendableToCompletionHandler(decl, type);
+
     // Record this declaration based on its signature.
     auto &known = collisions[type];
     if (known.size() == 1) {

test/Concurrency/sendable_objc_attr_in_type_context_swift5.swift

@@ -68,6 +68,11 @@ void doSomethingConcurrently(__attribute__((noescape)) void SWIFT_SENDABLE (^blo
 -(void)computeWithCompletionHandler: (void (^)(void)) handler;
 @end
 
+@interface Shadowing : NSObject
+-(void)computeWithCompletion: (void (^)(void)) completion;
+-(void)updateWithCompletionHandler: (void (^_Nullable)(void)) handler;
+@end
+
 #pragma clang assume_nonnull end
 
 //--- main.swift
@@ -154,3 +159,16 @@ class TestConformanceWithoutStripping : InnerSendableTypes {
   @objc func compute(completionHandler: @escaping () -> Void) {}
   // expected-warning@-1 {{sendability of function types in instance method 'compute(completionHandler:)' of type '(@escaping () -> Void) -> ()' does not match type '(@escaping @Sendable () -> Void) -> Void' declared by the header}}
 }
+
+// Methods deliberately has no `@Sendable` to make sure that
+// shadowing rules are preserved when SendableCompletionHandlers feature is enabled.
+@objc extension Shadowing {
+  @objc func compute(completion: @escaping () -> Void) {}
+
+  @objc func update(completionHandler: (() -> Void)? = nil) {}
+
+  func testCompute() {
+    self.compute { } // Ok - no ambiguity
+    self.update { }  // Ok - no ambiguity
+  }
+}

test/Concurrency/sendable_objc_attr_in_type_context_swift6.swift

@@ -68,6 +68,11 @@ void doSomethingConcurrently(__attribute__((noescape)) void SWIFT_SENDABLE (^blo
 -(void)computeWithCompletionHandler: (void (^)(void)) handler;
 @end
 
+@interface Shadowing : NSObject
+-(void)computeWithCompletion: (void (^)(void)) completion;
+-(void)updateWithCompletionHandler: (void (^_Nullable)(void)) handler;
+@end
+
 #pragma clang assume_nonnull end
 
 //--- main.swift
@@ -161,3 +166,15 @@ class TestConformanceWithoutStripping : InnerSendableTypes {
   @objc func compute(completionHandler: @escaping () -> Void) {}
   // expected-warning@-1 {{sendability of function types in instance method 'compute(completionHandler:)' of type '(@escaping () -> Void) -> ()' does not match type '(@escaping @Sendable () -> Void) -> Void' declared by the header}}
 }
+
+// Methods deliberately has no `@Sendable` to make sure that
+// shadowing rules are preserved when SendableCompletionHandlers feature is enabled.
+@objc extension Shadowing {
+  @objc func compute(completion: @escaping () -> Void) {}
+
+  @objc func update(completionHandler: (() -> Void)? = nil) {}
+
+  func testCompute() {
+    self.compute { } // Ok - no ambiguity
+  }
+}