Add the @exclusivity attribute.

The `@exclusivity(unchecked)` attribute can be used on variables to selectively disable exclusivity checking.
For completeness, also the `@exclusivity(checked)` variant is supported: it turns on exclusivity checking for specific variables if exclusivity enforcement is disabled by the command line option.

This new attribute is a missing implementation part of SE-0176 (https://github.com/apple/swift-evolution/blob/main/proposals/0176-enforce-exclusive-access-to-memory.md).

rdar://31121356

Author: eeckstein

include/swift/AST/Attr.def

@@ -705,6 +705,11 @@ DECL_ATTR(_unavailableFromAsync, UnavailableFromAsync,
   APIBreakingToAdd | APIStableToRemove,
   127)
 
+DECL_ATTR(exclusivity, Exclusivity,
+  OnVar |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  128)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Attr.h

@@ -1199,6 +1199,32 @@ class OptimizeAttr : public DeclAttribute {
   }
 };
 
+/// Represents the exclusivity attribute.
+class ExclusivityAttr : public DeclAttribute {
+public:
+  enum Mode {
+    Checked,
+    Unchecked
+  };
+
+private:
+  Mode mode;
+
+public:
+  ExclusivityAttr(SourceLoc atLoc, SourceRange range, Mode mode)
+     : DeclAttribute(DAK_Exclusivity, atLoc, range, /*Implicit=*/false),
+       mode(mode) {}
+
+  ExclusivityAttr(Mode mode)
+    : ExclusivityAttr(SourceLoc(), SourceRange(), mode) {}
+
+  Mode getMode() const { return mode; }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_Exclusivity;
+  }
+};
+
 /// Represents the side effects attribute.
 class EffectsAttr : public DeclAttribute {
 public:

include/swift/AST/DiagnosticsSema.def

@@ -5314,6 +5314,17 @@ ERROR(nonobjc_not_allowed,none,
 #undef OBJC_DIAG_SELECT
 #undef OBJC_ATTR_SELECT
 
+//------------------------------------------------------------------------------
+// MARK: @exclusivity
+//------------------------------------------------------------------------------
+ERROR(exclusivity_on_wrong_decl,none,
+      "@exclusivity can only be used on class properties, static properties and global variables",
+      ())
+
+ERROR(exclusivity_on_computed_property,none,
+      "@exclusivity can only be used on stored properties",
+      ())
+
 //------------------------------------------------------------------------------
 // MARK: @_borrowed
 //------------------------------------------------------------------------------

lib/AST/Attr.cpp

@@ -883,6 +883,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
   case DAK_ReferenceOwnership:
   case DAK_Effects:
   case DAK_Optimize:
+  case DAK_Exclusivity:
   case DAK_NonSendable:
     if (DeclAttribute::isDeclModifier(getKind())) {
       Printer.printKeyword(getAttrName(), Options);
@@ -1289,6 +1290,16 @@ StringRef DeclAttribute::getAttrName() const {
       llvm_unreachable("Invalid optimization kind");
     }
   }
+  case DAK_Exclusivity: {
+    switch (cast<ExclusivityAttr>(this)->getMode()) {
+    case ExclusivityAttr::Checked:
+      return "exclusivity(checked)";
+    case ExclusivityAttr::Unchecked:
+      return "exclusivity(unchecked)";
+    default:
+      llvm_unreachable("Invalid optimization kind");
+    }
+  }
   case DAK_Effects:
     switch (cast<EffectsAttr>(this)->getKind()) {
       case EffectsKind::ReadNone:

lib/Parse/ParseDecl.cpp

@@ -1996,6 +1996,21 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
     break;
   }
 
+  case DAK_Exclusivity: {
+    auto mode = parseSingleAttrOption<ExclusivityAttr::Mode>
+                            (*this, Loc, AttrRange, AttrName, DK)
+                       .when("checked", ExclusivityAttr::Mode::Checked)
+                       .when("unchecked", ExclusivityAttr::Mode::Unchecked)
+                       .diagnoseWhenOmitted();
+    if (!mode)
+      return false;
+
+    if (!DiscardAttribute)
+      Attributes.add(new (Context) ExclusivityAttr(AtLoc, AttrRange, *mode));
+
+    break;
+  }
+
   case DAK_ReferenceOwnership: {
     // Handle weak/unowned/unowned(unsafe).
     auto Kind = AttrName == "weak" ? ReferenceOwnership::Weak

lib/SILGen/SILGenLValue.cpp

@@ -240,10 +240,16 @@ static bool shouldUseUnsafeEnforcement(VarDecl *var) {
   if (var->isDebuggerVar())
     return true;
 
-  // TODO: Check for the explicit "unsafe" attribute.
   return false;
 }
 
+static bool hasExclusivityAttr(VarDecl *var, ExclusivityAttr::Mode mode) {
+  if (!var)
+    return false;
+  auto *exclAttr = var->getAttrs().getAttribute<ExclusivityAttr>();
+  return exclAttr && exclAttr->getMode() == mode;
+}
+
 Optional<SILAccessEnforcement>
 SILGenFunction::getStaticEnforcement(VarDecl *var) {
   if (var && shouldUseUnsafeEnforcement(var))
@@ -257,6 +263,10 @@ SILGenFunction::getDynamicEnforcement(VarDecl *var) {
   if (getOptions().EnforceExclusivityDynamic) {
     if (var && shouldUseUnsafeEnforcement(var))
       return SILAccessEnforcement::Unsafe;
+    if (hasExclusivityAttr(var, ExclusivityAttr::Unchecked))
+      return SILAccessEnforcement::Unsafe;
+    return SILAccessEnforcement::Dynamic;
+  } else if (hasExclusivityAttr(var, ExclusivityAttr::Checked)) {
     return SILAccessEnforcement::Dynamic;
   }
   return None;

lib/Sema/TypeCheckAttr.cpp

@@ -239,6 +239,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitUsableFromInlineAttr(UsableFromInlineAttr *attr);
   void visitInlinableAttr(InlinableAttr *attr);
   void visitOptimizeAttr(OptimizeAttr *attr);
+  void visitExclusivityAttr(ExclusivityAttr *attr);
 
   void visitDiscardableResultAttr(DiscardableResultAttr *attr);
   void visitDynamicReplacementAttr(DynamicReplacementAttr *attr);
@@ -2471,6 +2472,27 @@ void AttributeChecker::visitOptimizeAttr(OptimizeAttr *attr) {
   }
 }
 
+void AttributeChecker::visitExclusivityAttr(ExclusivityAttr *attr) {
+  if (auto *varDecl = dyn_cast<VarDecl>(D)) {
+    if (!varDecl->hasStorage()) {
+      diagnose(attr->getLocation(), diag::exclusivity_on_computed_property);
+      attr->setInvalid();
+      return;
+    }
+  
+    if (isa<ClassDecl>(varDecl->getDeclContext()))
+      return;
+    
+    if (varDecl->getDeclContext()->isTypeContext() && !varDecl->isInstanceMember())
+      return;
+    
+    if (varDecl->getDeclContext()->isModuleScopeContext())
+      return;
+  }
+  diagnose(attr->getLocation(), diag::exclusivity_on_wrong_decl);
+  attr->setInvalid();
+}
+
 void AttributeChecker::visitDiscardableResultAttr(DiscardableResultAttr *attr) {
   if (auto *FD = dyn_cast<FuncDecl>(D)) {
     if (auto result = FD->getResultInterfaceType()) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1466,6 +1466,7 @@ namespace  {
     UNINTERESTING_ATTR(InheritsConvenienceInitializers)
     UNINTERESTING_ATTR(Inline)
     UNINTERESTING_ATTR(Optimize)
+    UNINTERESTING_ATTR(Exclusivity)
     UNINTERESTING_ATTR(NoLocks)
     UNINTERESTING_ATTR(NoAllocation)
     UNINTERESTING_ATTR(Inlinable)

lib/Serialization/Deserialization.cpp

@@ -4416,6 +4416,14 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
         break;
       }
 
+      case decls_block::Exclusivity_DECL_ATTR: {
+        unsigned kind;
+        serialization::decls_block::ExclusivityDeclAttrLayout::readRecord(
+            scratch, kind);
+        Attr = new (ctx) ExclusivityAttr((ExclusivityAttr::Mode)kind);
+        break;
+      }
+
       case decls_block::Effects_DECL_ATTR: {
         unsigned kind;
         serialization::decls_block::EffectsDeclAttrLayout::readRecord(scratch,

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 660; // remove nested archetypes
+const uint16_t SWIFTMODULE_VERSION_MINOR = 661; // @exclusivity attribute
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1923,6 +1923,11 @@ namespace decls_block {
     BCFixed<2>  // optimize value
   >;
 
+  using ExclusivityDeclAttrLayout = BCRecordLayout<
+    Optimize_DECL_ATTR,
+    BCFixed<2>  // exclusivity mode
+  >;
+
   using AvailableDeclAttrLayout = BCRecordLayout<
     Available_DECL_ATTR,
     BCFixed<1>, // implicit flag