[AST/Sema] Intoduce nonisolated(nonsending) as a replacement for @execution(caller)

Author: xedin

include/swift/AST/ASTBridging.h

@@ -1234,11 +1234,18 @@ BridgedNonSendableAttr BridgedNonSendableAttr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
     BridgedSourceRange cRange, BridgedNonSendableKind cKind);
 
-SWIFT_NAME("BridgedNonisolatedAttr.createParsed(_:atLoc:range:isUnsafe:)")
+enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedNonIsolatedModifier {
+  BridgedNonIsolatedModifierNone,
+  BridgedNonIsolatedModifierUnsafe,
+  BridgedNonIsolatedModifierNonSending
+};
+
+SWIFT_NAME("BridgedNonisolatedAttr.createParsed(_:atLoc:range:modifier:)")
 BridgedNonisolatedAttr
 BridgedNonisolatedAttr_createParsed(BridgedASTContext cContext,
                                     BridgedSourceLoc cAtLoc,
-                                    BridgedSourceRange cRange, bool isUnsafe);
+                                    BridgedSourceRange cRange,
+                                    BridgedNonIsolatedModifier modifier);
 
 SWIFT_NAME("BridgedObjCAttr.createParsedUnnamed(_:atLoc:attrNameLoc:)")
 BridgedObjCAttr

include/swift/AST/Attr.h

@@ -226,8 +226,8 @@ class DeclAttribute : public AttributeBase {
       isEarlyAdopter : 1
     );
 
-    SWIFT_INLINE_BITFIELD(NonisolatedAttr, DeclAttribute, 1,
-      isUnsafe : 1
+    SWIFT_INLINE_BITFIELD(NonisolatedAttr, DeclAttribute, NumNonIsolatedModifierBits,
+      Modifier : NumNonIsolatedModifierBits
     );
 
     SWIFT_INLINE_BITFIELD_FULL(AllowFeatureSuppressionAttr, DeclAttribute, 1+31,
@@ -2978,29 +2978,38 @@ class ObjCImplementationAttr final : public DeclAttribute {
 /// Represents nonisolated modifier.
 class NonisolatedAttr final : public DeclAttribute {
 public:
-  NonisolatedAttr(SourceLoc atLoc, SourceRange range, bool unsafe,
-                  bool implicit)
+  NonisolatedAttr(SourceLoc atLoc, SourceRange range,
+                  NonIsolatedModifier modifier, bool implicit)
       : DeclAttribute(DeclAttrKind::Nonisolated, atLoc, range, implicit) {
-    Bits.NonisolatedAttr.isUnsafe = unsafe;
-    assert((isUnsafe() == unsafe) && "not enough bits for unsafe state");
+    Bits.NonisolatedAttr.Modifier = static_cast<unsigned>(modifier);
   }
 
   NonisolatedAttr(bool unsafe, bool implicit)
-      : NonisolatedAttr({}, {}, unsafe, implicit) {}
+      : NonisolatedAttr({}, {},
+                        unsafe ? NonIsolatedModifier::Unsafe
+                               : NonIsolatedModifier::None,
+                        implicit) {}
 
-  bool isUnsafe() const { return Bits.NonisolatedAttr.isUnsafe; }
+  NonIsolatedModifier getModifier() const {
+    return static_cast<NonIsolatedModifier>(Bits.NonisolatedAttr.Modifier);
+  }
+
+  bool isUnsafe() const { return getModifier() == NonIsolatedModifier::Unsafe; }
+  bool isNonSending() const {
+    return getModifier() == NonIsolatedModifier::NonSending;
+  }
 
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DeclAttrKind::Nonisolated;
   }
 
   /// Create a copy of this attribute.
   NonisolatedAttr *clone(ASTContext &ctx) const {
-    return new (ctx) NonisolatedAttr(AtLoc, Range, isUnsafe(), isImplicit());
+    return new (ctx) NonisolatedAttr(AtLoc, Range, getModifier(), isImplicit());
   }
 
   bool isEquivalent(const NonisolatedAttr *other, Decl *attachedTo) const {
-    return isUnsafe() == other->isUnsafe();
+    return getModifier() == other->getModifier();
   }
 };
 

include/swift/AST/AttrKind.h

@@ -138,6 +138,18 @@ enum class ExecutionKind : uint8_t {
 enum : unsigned { NumExecutionKindBits =
   countBitsUsed(static_cast<unsigned>(ExecutionKind::Last_ExecutionKind)) };
 
+enum class NonIsolatedModifier : uint8_t {
+  None = 0,
+  Unsafe,
+  NonSending,
+  Last_NonIsolatedModifier = NonSending
+};
+
+enum : unsigned {
+  NumNonIsolatedModifierBits = countBitsUsed(
+      static_cast<unsigned>(NonIsolatedModifier::Last_NonIsolatedModifier))
+};
+
 enum class DeclAttrKind : unsigned {
 #define DECL_ATTR(_, CLASS, ...) CLASS,
 #define LAST_DECL_ATTR(CLASS) Last_DeclAttr = CLASS,

include/swift/AST/DiagnosticsSema.def

@@ -8554,33 +8554,38 @@ GROUPED_ERROR(isolated_conformance_wrong_domain,IsolatedConformances,none,
 //===----------------------------------------------------------------------===//
 
 ERROR(execution_behavior_only_on_async,none,
-      "cannot use '%0' on non-async %kind1",
+      "cannot use %0 on non-async %kind1",
       (DeclAttribute, ValueDecl *))
 
+ERROR(cannot_specify_execution_behavior_for_decl,none,
+      "%0 is only applicable to asynchronous functions, "
+      "initializers, subscripts and computed properties",
+      (DeclAttribute))
+
 ERROR(execution_behavior_only_on_async_closure,none,
-      "cannot use '%0' on non-async closure",
+      "cannot use %0 on non-async closure",
       (DeclAttribute))
 
 ERROR(execution_behavior_type_attr_only_on_async,none,
       "cannot use '@%0' on non-async function type",
       (StringRef))
 
 ERROR(execution_behavior_incompatible_isolated_parameter,none,
-      "cannot use '%0' on %kind1 because it has "
+      "cannot use %0 on %kind1 because it has "
       "an isolated parameter: %2",
       (DeclAttribute, ValueDecl *, ValueDecl *))
 
 ERROR(execution_behavior_incompatible_dynamically_isolated_parameter,none,
-      "cannot use '%0' on %kind1 because it has "
+      "cannot use %0 on %kind1 because it has "
       "a dynamically isolated parameter: %2",
       (DeclAttribute, ValueDecl *, ValueDecl *))
 
 ERROR(execution_behavior_attr_incompatible_with_global_isolation,none,
-      "cannot use '%0' because function type is isolated to a global actor %1",
+      "cannot use %0 because function type is isolated to a global actor %1",
       (DeclAttribute, Type))
 
 ERROR(execution_behavior_attr_incompatible_with_isolated_param,none,
-      "cannot use '%0' together with an isolated parameter",
+      "cannot use %0 together with an isolated parameter",
       (DeclAttribute))
 
 ERROR(execution_behavior_type_attr_incompatible_with_global_isolation,none,

include/swift/AST/KnownIdentifiers.def

@@ -127,6 +127,7 @@ IDENTIFIER(main)
 IDENTIFIER_WITH_NAME(MainEntryPoint, "$main")
 IDENTIFIER(message)
 IDENTIFIER(next)
+IDENTIFIER(nonsending)
 IDENTIFIER_(nsErrorDomain)
 IDENTIFIER(objectAtIndexedSubscript)
 IDENTIFIER(objectForKeyedSubscript)

lib/AST/ASTDumper.cpp

@@ -2389,6 +2389,8 @@ namespace {
               VD->getAttrs().getAttribute<NonisolatedAttr>()) {
         if (nonisolatedAttr->isUnsafe()) {
           printFlag(true, "nonisolated(unsafe)", DeclModifierColor);
+        } else if (nonisolatedAttr->isNonSending()) {
+          printFlag(true, "nonisolated(nonsending)", DeclModifierColor);
         } else {
           printFlag(true, "nonisolated", DeclModifierColor);
         }
@@ -5183,6 +5185,7 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   void visitNonisolatedAttr(NonisolatedAttr *Attr, Label label) {
     printCommon(Attr, "nonisolated_attr", label);
     printFlag(Attr->isUnsafe(), "unsafe");
+    printFlag(Attr->isNonSending(), "nonsending");
     printFoot();
   }
   void visitObjCAttr(ObjCAttr *Attr, Label label) {

lib/AST/Attr.cpp

@@ -1535,8 +1535,15 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
 
   case DeclAttrKind::Nonisolated: {
     Printer.printAttrName("nonisolated");
-    if (cast<NonisolatedAttr>(this)->isUnsafe()) {
+    switch (cast<NonisolatedAttr>(this)->getModifier()) {
+    case NonIsolatedModifier::None:
+      break;
+    case NonIsolatedModifier::Unsafe:
       Printer << "(unsafe)";
+      break;
+    case NonIsolatedModifier::NonSending:
+      Printer << "(nonsending)";
+      break;
     }
     break;
   }
@@ -1925,10 +1932,13 @@ StringRef DeclAttribute::getAttrName() const {
   case DeclAttrKind::Documentation:
     return "_documentation";
   case DeclAttrKind::Nonisolated:
-    if (cast<NonisolatedAttr>(this)->isUnsafe()) {
-        return "nonisolated(unsafe)";
-    } else {
-        return "nonisolated";
+    switch (cast<NonisolatedAttr>(this)->getModifier()) {
+    case NonIsolatedModifier::None:
+      return "nonisolated";
+    case NonIsolatedModifier::Unsafe:
+      return "nonisolated(unsafe)";
+    case NonIsolatedModifier::NonSending:
+      return "nonisolated(nonsending)";
     }
   case DeclAttrKind::MacroRole:
     switch (cast<MacroRoleAttr>(this)->getMacroSyntax()) {

lib/AST/Bridging/DeclAttributeBridging.cpp

@@ -627,12 +627,26 @@ BridgedNonSendableAttr BridgedNonSendableAttr_createParsed(
       NonSendableAttr(cAtLoc.unbridged(), cRange.unbridged(), unbridged(cKind));
 }
 
+static NonIsolatedModifier unbridged(BridgedNonIsolatedModifier modifier) {
+  switch (modifier) {
+  case BridgedNonIsolatedModifierNone:
+    return NonIsolatedModifier::None;
+  case BridgedNonIsolatedModifierUnsafe:
+    return NonIsolatedModifier::Unsafe;
+  case BridgedNonIsolatedModifierNonSending:
+    return NonIsolatedModifier::NonSending;
+  }
+  llvm_unreachable("unhandled enum value");
+}
+
 BridgedNonisolatedAttr
 BridgedNonisolatedAttr_createParsed(BridgedASTContext cContext,
                                     BridgedSourceLoc cAtLoc,
-                                    BridgedSourceRange cRange, bool isUnsafe) {
+                                    BridgedSourceRange cRange,
+                                    BridgedNonIsolatedModifier modifier) {
   return new (cContext.unbridged()) NonisolatedAttr(
-      cAtLoc.unbridged(), cRange.unbridged(), isUnsafe, /*implicit=*/false);
+      cAtLoc.unbridged(), cRange.unbridged(), unbridged(modifier),
+      /*implicit=*/false);
 }
 
 BridgedObjCAttr

lib/AST/Decl.cpp

@@ -8758,6 +8758,11 @@ void VarDecl::emitLetToVarNoteIfSimple(DeclContext *UseDC) const {
 
 std::optional<ExecutionKind>
 AbstractFunctionDecl::getExecutionBehavior() const {
+  if (auto *nonisolatedAttr = getAttrs().getAttribute<NonisolatedAttr>()) {
+    if (nonisolatedAttr->isNonSending())
+      return ExecutionKind::Caller;
+  }
+
   auto *attr = getAttrs().getAttribute<ExecutionAttr>();
   if (!attr)
     return {};

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -1416,27 +1416,25 @@ extension ASTGenVisitor {
 
   // FIXME: This is a decl modifier
   func generateNonisolatedAttr(attribute node: AttributeSyntax) -> BridgedNonisolatedAttr? {
-    let isUnsafe = self.generateSingleAttrOption(
+    let modifier: BridgedNonIsolatedModifier? = self.generateSingleAttrOption(
       attribute: node,
       {
         switch $0.rawText {
-        case "unsafe":
-          return true
-        default:
-          // FIXME: Diagnose.
-          return nil
+        case "unsafe": return .unsafe
+        case "nonsending": return .nonSending
+        default: return nil
         }
       },
-      valueIfOmitted: false
+      valueIfOmitted: BridgedNonIsolatedModifier.none
     )
-    guard let isUnsafe else {
+    guard let modifier else {
       return nil
     }
     return .createParsed(
       self.ctx,
       atLoc: self.generateSourceLoc(node.atSign),
       range: self.generateAttrSourceRange(node),
-      isUnsafe: isUnsafe
+      modifier: modifier
     )
   }
 
@@ -2410,12 +2408,14 @@ extension ASTGenVisitor {
   }
 
   func generateNonisolatedAttr(declModifier node: DeclModifierSyntax) -> BridgedNonisolatedAttr? {
-    let isUnsafe: Bool
+    let modifier: BridgedNonIsolatedModifier
     switch node.detail?.detail.rawText {
     case "unsafe":
-      isUnsafe = true
+      modifier = .unsafe
+    case "nonsending":
+      modifier = .nonSending
     case nil:
-      isUnsafe = false
+      modifier = .none
     case let text?:
       // TODO: Diagnose
       _ = text
@@ -2426,7 +2426,7 @@ extension ASTGenVisitor {
       self.ctx,
       atLoc: nil,
       range: self.generateSourceRange(node),
-      isUnsafe: isUnsafe
+      modifier: modifier
     )
   }