Merge pull request #69890 from xedin/rdar-99758612

[ClangImporter] Add support for `swift_attr(“@sendable”)` on ObjC protocols

Author: xedin

lib/AST/NameLookup.cpp

@@ -3186,18 +3186,16 @@ SuperclassDeclRequest::evaluate(Evaluator &evaluator,
 ArrayRef<ProtocolDecl *>
 InheritedProtocolsRequest::evaluate(Evaluator &evaluator,
                                     ProtocolDecl *PD) const {
-  llvm::SmallVector<ProtocolDecl *, 2> result;
-  SmallPtrSet<const ProtocolDecl *, 2> known;
-  known.insert(PD);
+  llvm::SmallSetVector<ProtocolDecl *, 2> inherited;
   bool anyObject = false;
-  for (const auto &found : getDirectlyInheritedNominalTypeDecls(PD, anyObject)) {
-    if (auto proto = dyn_cast<ProtocolDecl>(found.Item)) {
-      if (known.insert(proto).second)
-        result.push_back(proto);
-    }
+  for (const auto &found :
+       getDirectlyInheritedNominalTypeDecls(PD, anyObject)) {
+    auto proto = dyn_cast<ProtocolDecl>(found.Item);
+    if (proto && proto != PD)
+      inherited.insert(proto);
   }
 
-  return PD->getASTContext().AllocateCopy(result);
+  return PD->getASTContext().AllocateCopy(inherited.getArrayRef());
 }
 
 ArrayRef<ValueDecl *>
@@ -3712,6 +3710,16 @@ swift::getDirectlyInheritedNominalTypeDecls(
     return result;
   }
 
+  // Check for SynthesizedProtocolAttrs on the protocol. ClangImporter uses
+  // these to add `Sendable` conformances to protocols without modifying the
+  // inherited type list.
+  for (auto attr :
+       protoDecl->getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
+    auto loc = attr->getLocation();
+    result.push_back(
+        {attr->getProtocol(), loc, attr->isUnchecked() ? loc : SourceLoc()});
+  }
+
   // Else we have access to this information on the where clause.
   auto selfBounds = getSelfBoundsFromWhereClause(decl);
   anyObject |= selfBounds.anyObject;

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -858,7 +858,7 @@ void swift::rewriting::expandDefaultRequirements(ASTContext &ctx,
 }
 
 /// Collect structural requirements written in the inheritance clause of an
-/// AssociatedTypeDecl or GenericTypeParamDecl.
+/// AssociatedTypeDecl, GenericTypeParamDecl, or ProtocolDecl.
 void swift::rewriting::realizeInheritedRequirements(
     TypeDecl *decl, Type type, bool shouldInferRequirements,
     SmallVectorImpl<StructuralRequirement> &result,
@@ -891,6 +891,17 @@ void swift::rewriting::realizeInheritedRequirements(
 
     realizeTypeRequirement(dc, type, inheritedType, loc, result, errors);
   }
+
+  // Also check for `SynthesizedProtocolAttr`s with additional constraints added
+  // by ClangImporter. This is how imported protocols are marked `Sendable`
+  // without changing their inheritance lists.
+  auto attrs = decl->getAttrs().getAttributes<SynthesizedProtocolAttr>();
+  for (auto attr : attrs) {
+    auto inheritedType = attr->getProtocol()->getDeclaredType();
+    auto loc = attr->getLocation();
+
+    realizeTypeRequirement(dc, type, inheritedType, loc, result, errors);
+  }
 }
 
 /// StructuralRequirementsRequest realizes all the user-written requirements

lib/Sema/TypeCheckConcurrency.cpp

@@ -5132,11 +5132,14 @@ bool swift::checkSendableConformance(
       // we allow `NSObject` for Objective-C interoperability.
       if (auto superclassDecl = classDecl->getSuperclassDecl()) {
         if (!superclassDecl->isNSObject()) {
-          classDecl->diagnose(
-              diag::concurrent_value_inherit,
-              nominal->getASTContext().LangOpts.EnableObjCInterop,
-              classDecl->getName());
-          return true;
+          classDecl
+              ->diagnose(diag::concurrent_value_inherit,
+                         nominal->getASTContext().LangOpts.EnableObjCInterop,
+                         classDecl->getName())
+              .limitBehavior(behavior);
+
+          if (behavior == DiagnosticBehavior::Unspecified)
+            return true;
         }
       }
     }

test/Concurrency/sendable_objc_protocol_attr.swift

@@ -0,0 +1,106 @@
+// RUN: %empty-directory(%t/src)
+// RUN: %empty-directory(%t/sdk)
+// RUN: split-file %s %t/src
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck %t/src/main.swift \
+// RUN:   -import-objc-header %t/src/Test.h \
+// RUN:   -strict-concurrency=complete \
+// RUN:   -module-name main -I %t -verify
+
+// REQUIRES: objc_interop
+// REQUIRES: concurrency
+
+//--- Test.h
+#define NS_SWIFT_SENDABLE __attribute__((__swift_attr__("@Sendable")))
+
+#pragma clang assume_nonnull begin
+
+@import Foundation;
+
+NS_SWIFT_SENDABLE
+@protocol MyObjCProtocol <NSObject>
+@property (readonly, nonatomic) NSString *test;
+@end
+
+@protocol MyRefinedObjCProtocol <MyObjCProtocol>
+@end
+
+#pragma clang assume_nonnull end
+
+//--- main.swift
+struct MyStruct: Sendable {
+  let value: any MyObjCProtocol // Ok
+}
+
+extension Sendable {
+  func compute() {}
+}
+
+extension MyObjCProtocol {
+  func test() {
+    compute() // Ok
+  }
+}
+
+class K : NSObject, MyObjCProtocol {
+  // expected-warning@-1 {{non-final class 'K' cannot conform to 'Sendable'; use '@unchecked Sendable'}}
+  let test: String = "k"
+}
+
+class UncheckedK : NSObject, MyObjCProtocol, @unchecked Sendable { // ok
+  let test: String = "unchecked"
+}
+
+class KRefined : NSObject, MyRefinedObjCProtocol {
+  // expected-warning@-1 {{non-final class 'KRefined' cannot conform to 'Sendable'; use '@unchecked Sendable'}}
+  let test: String = "refined"
+}
+
+class KUncheckedRefined : NSObject, MyRefinedObjCProtocol, @unchecked Sendable { // Ok
+  let test: String = "refined unchecked"
+}
+
+@preconcurrency
+protocol P : Sendable {
+}
+
+protocol Q : Sendable {
+}
+
+do {
+  class A : NSObject {}
+
+  final class B : A, P {
+    // expected-warning@-1 {{'Sendable' class 'B' cannot inherit from another class other than 'NSObject'}}
+  }
+
+  final class UncheckedB : A, P, @unchecked Sendable { // Ok
+  }
+
+  class C : A, MyObjCProtocol {
+    // expected-warning@-1 {{non-final class 'C' cannot conform to 'Sendable'; use '@unchecked Sendable'}}
+    // expected-warning@-2 {{'Sendable' class 'C' cannot inherit from another class other than 'NSObject'}}
+    let test: String = "c"
+  }
+
+  class UncheckedC : A, MyObjCProtocol, @unchecked Sendable { // Ok
+    let test: String = "c"
+  }
+
+  // A warning until `-swift-version 6`
+  final class D : A, Q {
+    // expected-warning@-1 {{'Sendable' class 'D' cannot inherit from another class other than 'NSObject'}}
+  }
+
+  final class UncheckedD : A, Q, @unchecked Sendable { // Ok
+  }
+}
+
+do {
+  func testSendable<T: Sendable>(_: T) {}
+
+  testSendable(K()) // Ok
+  testSendable(UncheckedK()) // Ok
+  testSendable(KRefined()) // Ok
+  testSendable(KUncheckedRefined()) // Ok
+}

test/IDE/print_objc_concurrency_interface.swift

@@ -43,6 +43,9 @@ import _Concurrency
 // CHECK: @available(*, unavailable)
 // CHECK-NEXT: extension AuditedBoth : @unchecked Sendable {
 
+// CHECK-LABEL: public protocol SendableProtocol
+// CHECK-SAME: : Sendable
+
 // CHECK-LABEL: enum SendableEnum :
 // CHECK-SAME: @unchecked Sendable
 

test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h

@@ -225,6 +225,9 @@ SENDABLE @interface AuditedSendable : NSObject @end
 @interface AuditedNonSendable : NSObject @end
 NONSENDABLE SENDABLE @interface AuditedBoth : NSObject @end
 
+SENDABLE @protocol SendableProtocol @end
+@protocol SendableProtocolRefined <SendableProtocol> @end
+
 typedef NS_ENUM(unsigned, SendableEnum) {
   SendableEnumFoo, SendableEnumBar
 };