Allow imported types to add a Sendable conformance

...by using `__attribute__((swift_attr("@sendable")))`. `@_nonSendable` will "beat" `@Sendable`, while `@_nonSendable(_assumed)` will not.

This commit also checks if `SwiftAttr` supports `#pragma clang attribute` and, if it does, defines `__SWIFT_ATTR_SUPPORTS_SENDABLE_DECLS` in imported headers so they know they can apply these attributes in an auditing style.

Author: beccadax

include/swift/AST/Attr.def

@@ -605,7 +605,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
   106)
 
 SIMPLE_DECL_ATTR(Sendable, Sendable,
-  OnFunc | OnConstructor | OnAccessor |
+  OnFunc | OnConstructor | OnAccessor | OnAnyClangDecl |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   107)

include/swift/AST/Attr.h

@@ -289,6 +289,9 @@ class DeclAttribute : public AttributeBase {
 
     /// Whether this attribute is only valid when distributed is enabled.
     DistributedOnly = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 17),
+
+    /// Whether this attribute is valid on additional decls in ClangImporter.
+    OnAnyClangDecl = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 18),
   };
 
   LLVM_READNONE
@@ -2224,6 +2227,10 @@ class DeclAttributes {
     return nullptr;
   }
 
+  /// Returns the "winning" \c NonSendableAttr or \c SendableAttr in this
+  /// attribute list, or \c nullptr if there are none.
+  const DeclAttribute *getEffectiveSendableAttr() const;
+
 private:
   /// Predicate used to filter MatchingAttributeRange.
   template <typename ATTR, bool AllowInvalid> struct ToAttributeKind {

lib/AST/Attr.cpp

@@ -131,6 +131,8 @@ DeclAttrKind DeclAttribute::getAttrKindFromString(StringRef Str) {
 
 /// Returns true if this attribute can appear on the specified decl.
 bool DeclAttribute::canAttributeAppearOnDecl(DeclAttrKind DK, const Decl *D) {
+  if ((getOptions(DK) & OnAnyClangDecl) && D->hasClangNode())
+    return true;
   return canAttributeAppearOnDeclKind(DK, D->getKind());
 }
 
@@ -699,6 +701,13 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
     if (Options.excludeAttrKind(DA->getKind()))
       continue;
 
+    // If this attribute is only allowed because this is a Clang decl, don't
+    // print it.
+    if (D && D->hasClangNode()
+        && !DeclAttribute::canAttributeAppearOnDeclKind(
+                               DA->getKind(), D->getKind()))
+      continue;
+
     // Be careful not to coalesce `@available(swift 5)` with other short
     // `available' attributes.
     if (auto *availableAttr = dyn_cast<AvailableAttr>(DA)) {
@@ -2102,6 +2111,23 @@ TypeSequenceAttr *TypeSequenceAttr::create(ASTContext &Ctx, SourceLoc atLoc,
   return new (mem) TypeSequenceAttr(atLoc, range);
 }
 
+const DeclAttribute *
+DeclAttributes::getEffectiveSendableAttr() const {
+  const NonSendableAttr *assumedAttr = nullptr;
+
+  for (auto attr : getAttributes<NonSendableAttr>()) {
+    if (attr->Specificity == NonSendableKind::Specific)
+      return attr;
+    if (!assumedAttr)
+      assumedAttr = attr;
+  }
+
+  if (auto sendableAttr = getAttribute<SendableAttr>())
+    return sendableAttr;
+
+  return assumedAttr;
+}
+
 void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);

lib/ClangImporter/ClangImporter.cpp

@@ -467,6 +467,14 @@ getGlibcModuleMapPath(SearchPathOptions& Opts, llvm::Triple triple,
   return None;
 }
 
+static bool clangSupportsPragmaAttributeWithSwiftAttr() {
+  clang::AttributeCommonInfo swiftAttrInfo(clang::SourceRange(),
+     clang::AttributeCommonInfo::AT_SwiftAttr,
+     clang::AttributeCommonInfo::AS_GNU);
+  auto swiftAttrParsedInfo = clang::ParsedAttrInfo::get(swiftAttrInfo);
+  return swiftAttrParsedInfo.IsSupportedByPragmaAttribute;
+}
+
 void
 importer::getNormalInvocationArguments(
     std::vector<std::string> &invocationArgStrs,
@@ -610,6 +618,12 @@ importer::getNormalInvocationArguments(
       "-DSWIFT_CLASS_EXTRA=",
     });
 
+    // Indicate that using '__attribute__((swift_attr))' with '@Sendable' and
+    // '@_nonSendable' on Clang declarations is fully supported, including the
+    // 'attribute push' pragma.
+    if (clangSupportsPragmaAttributeWithSwiftAttr())
+      invocationArgStrs.push_back( "-D__SWIFT_ATTR_SUPPORTS_SENDABLE_DECLS=1");
+
     // Get the version of this compiler and pass it to C/Objective-C
     // declarations.
     auto V = version::Version::getCurrentCompilerVersion();

lib/ClangImporter/ImportDecl.cpp

@@ -8495,6 +8495,16 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
                swiftAttr->getAttribute());
     }
   }
+
+  // Now that we've collected all @Sendable and @_nonSendable attributes, we
+  // can see if we should synthesize a Sendable conformance.
+  if (auto nominal = dyn_cast<NominalTypeDecl>(MappedDecl)) {
+    auto sendability = nominal->getAttrs().getEffectiveSendableAttr();
+    if (isa_and_nonnull<SendableAttr>(sendability)) {
+      addSynthesizedProtocolAttrs(*this, nominal, {KnownProtocolKind::Sendable},
+                                  /*isUnchecked=*/true);
+    }
+  }
 }
 
 static bool isUsingMacroName(clang::SourceManager &SM,

lib/Sema/TypeCheckConcurrency.cpp

@@ -4035,9 +4035,6 @@ NormalProtocolConformance *GetImplicitSendableRequest::evaluate(
     return conformance;
   };
 
-  if (auto nonSendable = nominal->getAttrs().getAttribute<NonSendableAttr>())
-    return formConformance(nonSendable);
-
   // A non-protocol type with a global actor is implicitly Sendable.
   if (nominal->getGlobalActorAttr()) {
     // If this is a class, check the superclass. We won't infer Sendable
@@ -4058,6 +4055,12 @@ NormalProtocolConformance *GetImplicitSendableRequest::evaluate(
     return formConformance(nullptr);
   }
 
+  if (auto attr = nominal->getAttrs().getEffectiveSendableAttr()) {
+    assert(!isa<SendableAttr>(attr) &&
+           "Conformance should have been added by SynthesizedProtocolAttr!");
+    return formConformance(cast<NonSendableAttr>(attr));
+  }
+
   // Only structs and enums can get implicit Sendable conformances by
   // considering their instance data.
   if (!isa<StructDecl>(nominal) && !isa<EnumDecl>(nominal))

test/ClangImporter/objc_async.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/custom-modules -disable-availability-checking  %s -verify
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/custom-modules -disable-availability-checking  %s -verify -warn-concurrency
 
 // REQUIRES: objc_interop
 // REQUIRES: concurrency
@@ -111,6 +111,18 @@ func testSendableInAsync() async {
   print(x)
 }
 
+func testSendableClasses(sendable: SendableClass, nonSendable: NonSendableClass) async {
+  func takesSendable<T: Sendable>(_: T) {}
+
+  takesSendable(sendable)        // no-error
+  takesSendable(nonSendable)     // expected-FIXME-warning{{something about missing conformance}}
+
+  doSomethingConcurrently {
+    print(sendable)        // no-error
+    print(nonSendable)     // expected-warning{{cannot use parameter 'nonSendable' with a non-sendable type 'NonSendableClass' from concurrently-executed code}}
+  }
+}
+
 // Check import of attributes
 func globalAsync() async { }
 

test/IDE/print_objc_concurrency_interface.swift

@@ -1,6 +1,9 @@
 // RUN: %empty-directory(%t)
 
-// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -print-module -print-interface -source-filename %s -module-to-print=ObjCConcurrency -function-definitions=false  | %FileCheck %s
+// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -print-module -print-interface -source-filename %s -module-to-print=ObjCConcurrency -function-definitions=false > %t/ObjCConcurrency.printed.txt
+// RUN: %FileCheck -input-file %t/ObjCConcurrency.printed.txt %s
+// RUN: %FileCheck -check-prefix NEGATIVE -input-file %t/ObjCConcurrency.printed.txt %s
+
 
 // REQUIRES: objc_interop
 // REQUIRES: concurrency
@@ -12,3 +15,18 @@ import _Concurrency
 // CHECK-NOT: @available
 // CHECK: func doSomethingSlow(_ operation: String, completionHandler handler: @escaping (Int) -> Void)
 // CHECK: func doSomethingSlow(_ operation: String) async -> Int
+
+// NEGATIVE-NOT: @Sendable{{.+}}class
+// NEGATIVE-NOT: @_nonSendable{{.+}}class
+
+// CHECK-LABEL: class SendableClass :
+// CHECK-SAME: @unchecked Sendable
+
+// CHECK-LABEL: class NonSendableClass
+
+// CHECK-LABEL: class AuditedSendable :
+// CHECK-SAME: @unchecked Sendable
+
+// CHECK-LABEL: class AuditedNonSendable
+
+// CHECK-LABEL: class AuditedBoth

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

@@ -6,6 +6,21 @@
 #define MAIN_ACTOR __attribute__((__swift_attr__("@MainActor")))
 #define MAIN_ACTOR_UNSAFE __attribute__((__swift_attr__("@_unsafeMainActor")))
 
+#ifdef __SWIFT_ATTR_SUPPORTS_SENDABLE_DECLS
+  #define SENDABLE __attribute__((__swift_attr__("@Sendable")))
+  #define NONSENDABLE __attribute__((__swift_attr__("@_nonSendable")))
+  #define ASSUME_NONSENDABLE_BEGIN _Pragma("clang attribute ASSUME_NONSENDABLE.push (__attribute__((swift_attr(\"@_nonSendable(_assumed)\"))), apply_to = any(objc_interface, record, enum))")
+  #define ASSUME_NONSENDABLE_END _Pragma("clang attribute ASSUME_NONSENDABLE.pop")
+#else
+  // If we take this #else, we should see minor failures of some subtests,
+  // but not systematic failures of everything that uses this header.
+  #define SENDABLE
+  #define NONSENDABLE
+  #define ASSUME_NONSENDABLE_BEGIN
+  #define ASSUME_NONSENDABLE_END
+#endif
+
+
 #define NS_EXTENSIBLE_STRING_ENUM __attribute__((swift_wrapper(struct)));
 typedef NSString *Flavor NS_EXTENSIBLE_STRING_ENUM;
 
@@ -167,7 +182,7 @@ __attribute__((__swift_attr__("@MainActor(unsafe)")))
 @end
 
 // Do something concurrently, but without escaping.
-void doSomethingConcurrently(__attribute__((noescape)) __attribute__((swift_attr("@Sendable"))) void (^block)(void));
+void doSomethingConcurrently(__attribute__((noescape)) SENDABLE void (^block)(void));
 
 
 
@@ -186,4 +201,16 @@ MAIN_ACTOR MAIN_ACTOR __attribute__((__swift_attr__("@MainActor(unsafe)"))) @pro
 - (void)instanceMethodWithCompletionHandler:(void (^)(void))completionHandler __attribute__((swift_async_name("instanceAsync()")));
 @end
 
+SENDABLE @interface SendableClass : NSObject @end
+
+NONSENDABLE @interface NonSendableClass : NSObject @end
+
+ASSUME_NONSENDABLE_BEGIN
+
+SENDABLE @interface AuditedSendable : NSObject @end
+@interface AuditedNonSendable : NSObject @end
+NONSENDABLE SENDABLE @interface AuditedBoth : NSObject @end
+
+ASSUME_NONSENDABLE_END
+
 #pragma clang assume_nonnull end