Add @_nonSendable decl attribute

This attribute creates an unavailable extension with a `Sendable` conformance so that the type is explicity marked as not being `Sendable`.

We also fully suppress diagnostics about unavailable Sendable conformances in Swift 5 mode code. (This is not fully developed yet—it should return to being a warning in concurrent contexts.)

The behavior when a @_nonSendable and a Sendable conformance are both on the same type is also not right yet.

Author: beccadax

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -376,6 +376,22 @@ override.
 This attribute and the corresponding `-warn-implicit-overrides` flag are
 used when compiling the standard library and overlays.
 
+## `@_nonSendable`
+
+There is no clang attribute to add a Swift conformance to an imported type, but
+there *is* a clang attribute to add a Swift attribute to an imported type. So
+`@Sendable` (which is not normally allowed on types) is used from clang headers
+to indicate that an unconstrained, fully available `Sendable` conformance should
+be added to a given type, while `@_nonSendable` indicates that an unavailable
+`Sendable` conformance should be added to it.
+
+`@_nonSendable` can have no options after it, in which case it "beats"
+`@Sendable` if both are applied to the same declaration, or it can have
+`(_assumed)` after it, in which case `@Sendable` "beats" it.
+`@_nonSendable(_assumed)` is intended to be used when mass-marking whole regions
+of a header as non-`Sendable` so that you can make spot exceptions with
+`@Sendable`.   
+
 ## `@_objc_non_lazy_realization`
 
 Marks a class as being non-lazily (i.e. eagerly) [realized](/docs/Lexicon.md#realization).

include/swift/AST/Attr.def

@@ -665,6 +665,13 @@ SIMPLE_DECL_ATTR(_assemblyVision, EmitAssemblyVisionRemarks,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   120)
 
+DECL_ATTR(_nonSendable, NonSendable,
+  OnNominalType |
+  UserInaccessible | AllowMultipleAttributes |
+  ABIStableToAdd | ABIBreakingToRemove |
+  APIStableToAdd | APIBreakingToRemove,
+  121)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Attr.h

@@ -2030,6 +2030,37 @@ class TransposeAttr final
   }
 };
 
+enum class NonSendableKind : uint8_t {
+  /// A plain '@_nonSendable' attribute. Should be applied directly to
+  /// particular declarations; overrides even an explicit 'Sendable'
+  /// conformance.
+  Specific,
+
+  /// A '@_nonSendable(_assumed)' attribute. Should be applied to large swaths
+  /// of declarations; does not override explicit 'Sendable' conformances.
+  Assumed
+};
+
+/// Marks a declaration as explicitly non-Sendable.
+class NonSendableAttr : public DeclAttribute {
+public:
+  NonSendableAttr(SourceLoc AtLoc, SourceRange Range,
+                  NonSendableKind Specificity, bool Implicit = false)
+    : DeclAttribute(DAK_NonSendable, AtLoc, Range, Implicit),
+      Specificity(Specificity)
+  {}
+
+  NonSendableAttr(NonSendableKind Specificity, bool Implicit = false)
+    : NonSendableAttr(SourceLoc(), SourceRange(), Specificity, Implicit) {}
+
+  /// Was this '@_nonSendable(_assumed)'?
+  const NonSendableKind Specificity;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_NonSendable;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

lib/AST/Attr.cpp

@@ -1226,6 +1226,15 @@ StringRef DeclAttribute::getAttrName() const {
     }
     llvm_unreachable("Invalid inline kind");
   }
+  case DAK_NonSendable: {
+    switch (cast<NonSendableAttr>(this)->Specificity) {
+    case NonSendableKind::Specific:
+      return "_nonSendable";
+    case NonSendableKind::Assumed:
+      return "_nonSendable(_assumed)";
+    }
+    llvm_unreachable("Invalid nonSendable kind");
+  }
   case DAK_Optimize: {
     switch (cast<OptimizeAttr>(this)->getMode()) {
     case OptimizationMode::NoOptimization:

lib/Parse/ParseDecl.cpp

@@ -2014,6 +2014,20 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
     break;
   }
 
+  case DAK_NonSendable: {
+    auto kind = parseSingleAttrOption<NonSendableKind>
+                         (*this, Loc, AttrRange, AttrName, DK)
+                    .when("_assumed", NonSendableKind::Assumed)
+                    .whenOmitted(NonSendableKind::Specific);
+    if (!kind)
+      return false;
+
+    if (!DiscardAttribute)
+      Attributes.add(new (Context) NonSendableAttr(AtLoc, AttrRange, *kind));
+
+    break;
+  }
+
   case DAK_AccessControl: {
 
     // Diagnose using access control in a local scope, which isn't meaningful.

lib/Sema/TypeCheckAttr.cpp

@@ -107,6 +107,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(NoDerivative)
   IGNORED_ATTR(SpecializeExtension)
   IGNORED_ATTR(Sendable)
+  IGNORED_ATTR(NonSendable)
   IGNORED_ATTR(AtRethrows)
   IGNORED_ATTR(AtReasync)
   IGNORED_ATTR(UnsafeSendable)

lib/Sema/TypeCheckAvailability.cpp

@@ -2422,6 +2422,31 @@ bool swift::diagnoseExplicitUnavailability(const ValueDecl *D, SourceRange R,
   });
 }
 
+static DiagnosticBehavior
+behaviorLimitForExplicitUnavailability(const RootProtocolConformance *rootConf) {
+  auto protoDecl = rootConf->getProtocol();
+
+  // Soften errors about unavailable `Sendable` conformances depending on the
+  // concurrency checking mode
+  if (protoDecl->isSpecificProtocol(KnownProtocolKind::Sendable) ||
+      protoDecl->isSpecificProtocol(KnownProtocolKind::UnsafeSendable)) {
+    // TODO: Base this on concurrency checking mode from ExportContext so it
+    //       detects when you're in concurrency code without -warn-concurrency.
+    auto &langOpts = protoDecl->getASTContext().LangOpts;
+    if (langOpts.isSwiftVersionAtLeast(6))
+      /* fall through */;
+    else if (!langOpts.WarnConcurrency)
+      // TODO: Needs more conditions--should only do this if we aren't in a
+      //       concurrent context, and either the import or the declaration is
+      //       @predatesConcurrency.
+      return DiagnosticBehavior::Ignore;
+    else
+      return DiagnosticBehavior::Warning;
+  }
+
+  return DiagnosticBehavior::Unspecified;
+}
+
 /// Emit a diagnostic for references to declarations that have been
 /// marked as unavailable, either through "unavailable" or "obsoleted:".
 bool swift::diagnoseExplicitUnavailability(SourceLoc loc,
@@ -2457,12 +2482,10 @@ bool swift::diagnoseExplicitUnavailability(SourceLoc loc,
       // This was platform-specific; indicate the platform.
       platform = attr->prettyPlatformString();
       break;
-    } else if (rootConf->getProtocol()->isSpecificProtocol(
-                   KnownProtocolKind::Sendable) &&
-               !ctx.LangOpts.isSwiftVersionAtLeast(6)) {
+    } else {
       // Downgrade unavailable Sendable conformances to warnings prior to
       // Swift 6.
-      behavior = DiagnosticBehavior::Warning;
+      behavior = behaviorLimitForExplicitUnavailability(rootConf);
     }
     LLVM_FALLTHROUGH;
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -3933,22 +3933,57 @@ NormalProtocolConformance *GetImplicitSendableRequest::evaluate(
   }
 
   // Local function to form the implicit conformance.
-  auto formConformance = [&]() -> NormalProtocolConformance * {
+  auto formConformance = [&](const DeclAttribute *attrMakingUnavailable)
+        -> NormalProtocolConformance * {
     ASTContext &ctx = nominal->getASTContext();
     auto proto = ctx.getProtocol(KnownProtocolKind::Sendable);
     if (!proto)
       return nullptr;
 
+    DeclContext *conformanceDC = nominal;
+    if (attrMakingUnavailable) {
+      llvm::VersionTuple NoVersion;
+      auto attr = new (ctx) AvailableAttr(attrMakingUnavailable->AtLoc,
+                                          attrMakingUnavailable->Range,
+                                          PlatformKind::none, "", "", nullptr,
+                                          NoVersion, SourceRange(),
+                                          NoVersion, SourceRange(),
+                                          NoVersion, SourceRange(),
+                                          PlatformAgnosticAvailabilityKind::Unavailable,
+                                          false);
+
+      // Conformance availability is currently tied to the declaring extension.
+      // FIXME: This is a hack--we should give conformances real availability.
+      auto extension = ExtensionDecl::create(ctx, attrMakingUnavailable->AtLoc,
+                                             nullptr, {},
+                                             nominal->getModuleScopeContext(),
+                                             nullptr);
+      extension->setImplicit();
+      extension->getAttrs().add(attr);
+
+      ctx.evaluator.cacheOutput(ExtendedTypeRequest{extension},
+                                nominal->getDeclaredType());
+      ctx.evaluator.cacheOutput(ExtendedNominalRequest{extension},
+                                std::move(nominal));
+      nominal->addExtension(extension);
+
+      conformanceDC = extension;
+    }
+
     auto conformance = ctx.getConformance(
         nominal->getDeclaredInterfaceType(), proto, nominal->getLoc(),
-        nominal, ProtocolConformanceState::Complete, false);
+        conformanceDC, ProtocolConformanceState::Complete,
+        /*isUnchecked=*/attrMakingUnavailable != nullptr);
     conformance->setSourceKindAndImplyingConformance(
         ConformanceEntryKind::Synthesized, nullptr);
 
     nominal->registerProtocolConformance(conformance, /*synthesized=*/true);
     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
@@ -3966,7 +4001,7 @@ NormalProtocolConformance *GetImplicitSendableRequest::evaluate(
     }
 
     // Form the implicit conformance to Sendable.
-    return formConformance();
+    return formConformance(nullptr);
   }
 
   // Only structs and enums can get implicit Sendable conformances by
@@ -3991,7 +4026,7 @@ NormalProtocolConformance *GetImplicitSendableRequest::evaluate(
           nominal, nominal, SendableCheck::Implicit))
     return nullptr;
 
-  return formConformance();
+  return formConformance(nullptr);
 }
 
 AnyFunctionType *swift::applyGlobalActorType(

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1545,6 +1545,7 @@ namespace  {
     UNINTERESTING_ATTR(GlobalActor)
     UNINTERESTING_ATTR(Async)
     UNINTERESTING_ATTR(Sendable)
+    UNINTERESTING_ATTR(NonSendable)
 
     UNINTERESTING_ATTR(AtRethrows)
     UNINTERESTING_ATTR(Marker)

lib/Serialization/Deserialization.cpp

@@ -4404,6 +4404,14 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
         break;
       }
 
+      case decls_block::NonSendable_DECL_ATTR: {
+        unsigned kind;
+        serialization::decls_block::NonSendableDeclAttrLayout::readRecord(
+            scratch, kind);
+        Attr = new (ctx) NonSendableAttr((NonSendableKind)kind);
+        break;
+      }
+
       case decls_block::Optimize_DECL_ATTR: {
         unsigned kind;
         serialization::decls_block::OptimizeDeclAttrLayout::readRecord(