Merge pull request #78704 from xedin/rdar-142920095

Implement experimental`@execution(concurrent | caller)` attribute

Author: xedin

include/swift/AST/ASTBridging.h

@@ -601,6 +601,16 @@ BridgedABIAttr BridgedABIAttr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc atLoc,
     BridgedSourceRange range, BridgedNullableDecl abiDecl);
 
+enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedExecutionKind {
+  BridgedExecutionKindConcurrent,
+  BridgedExecutionKindCaller,
+};
+
+SWIFT_NAME("BridgedExecutionAttr.createParsed(_:atLoc:range:behavior:)")
+BridgedExecutionAttr BridgedExecutionAttr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc atLoc,
+    BridgedSourceRange range, BridgedExecutionKind behavior);
+
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedAccessLevel {
   BridgedAccessLevelPrivate,
   BridgedAccessLevelFilePrivate,

include/swift/AST/Attr.h

@@ -217,6 +217,10 @@ class DeclAttribute : public AttributeBase {
 
       NumFeatures : 31
     );
+
+    SWIFT_INLINE_BITFIELD(ExecutionAttr, DeclAttribute, NumExecutionKindBits,
+      Behavior : NumExecutionKindBits
+    );
   } Bits;
   // clang-format on
 
@@ -2916,6 +2920,30 @@ class ABIAttr : public DeclAttribute {
   UNIMPLEMENTED_CLONE(ABIAttr)
 };
 
+class ExecutionAttr : public DeclAttribute {
+public:
+  ExecutionAttr(SourceLoc AtLoc, SourceRange Range,
+                ExecutionKind behavior,
+                bool Implicit)
+      : DeclAttribute(DeclAttrKind::Execution, AtLoc, Range, Implicit) {
+    Bits.ExecutionAttr.Behavior = static_cast<uint8_t>(behavior);
+  }
+
+  ExecutionAttr(ExecutionKind behavior, bool Implicit)
+      : ExecutionAttr(/*AtLoc=*/SourceLoc(), /*Range=*/SourceRange(), behavior,
+                      Implicit) {}
+
+  ExecutionKind getBehavior() const {
+    return static_cast<ExecutionKind>(Bits.ExecutionAttr.Behavior);
+  }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::Execution;
+  }
+
+  UNIMPLEMENTED_CLONE(ExecutionAttr)
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/AttrKind.h

@@ -130,6 +130,15 @@ enum class ExternKind: uint8_t {
 enum : unsigned { NumExternKindBits =
   countBitsUsed(static_cast<unsigned>(ExternKind::Last_ExternKind)) };
 
+enum class ExecutionKind : uint8_t {
+  Concurrent = 0,
+  Caller,
+  Last_ExecutionKind = Caller
+};
+
+enum : unsigned { NumExecutionKindBits =
+  countBitsUsed(static_cast<unsigned>(ExecutionKind::Last_ExecutionKind)) };
+
 enum class DeclAttrKind : unsigned {
 #define DECL_ATTR(_, CLASS, ...) CLASS,
 #define LAST_DECL_ATTR(CLASS) Last_DeclAttr = CLASS,

include/swift/AST/DeclAttr.def

@@ -538,7 +538,12 @@ DECL_ATTR(abi, ABI,
   165)
 DECL_ATTR_FEATURE_REQUIREMENT(ABI, ABIAttribute)
 
-LAST_DECL_ATTR(ABI)
+DECL_ATTR(execution, Execution,
+  OnFunc | ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  166)
+DECL_ATTR_FEATURE_REQUIREMENT(Execution, NonIsolatedAsyncInheritsIsolationFromContext)
+
+LAST_DECL_ATTR(Execution)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -8211,5 +8211,32 @@ ERROR(attr_abi_incompatible_with_silgen_name,none,
       "the same purpose",
       (DescriptiveDeclKind))
 
+//===----------------------------------------------------------------------===//
+// MARK: @execution Attribute
+//===----------------------------------------------------------------------===//
+ERROR(attr_execution_concurrent_only_on_async,none,
+      "cannot use '@execution(concurrent)' on non-async %kind0",
+      (ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_with_global_actor,none,
+      "cannot use '@execution(concurrent)' on %kind0 isolated to global actor %1",
+      (ValueDecl *, Type))
+
+ERROR(attr_execution_concurrent_incompatible_isolated_parameter,none,
+      "cannot use '@execution(concurrent)' on %kind0 because it has "
+      "an isolated parameter: %1",
+      (ValueDecl *, ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_dynamically_isolated_parameter,none,
+      "cannot use '@execution(concurrent)' on %kind0 because it has "
+      "a dynamically isolated parameter: %1",
+      (ValueDecl *, ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_with_nonisolated,none,
+      "cannot use '@execution(concurrent)' and 'nonisolated' on the same %0 "
+      "because they serve the same purpose",
+      (ValueDecl *))
+
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/KnownIdentifiers.def

@@ -332,6 +332,8 @@ IDENTIFIER(size)
 IDENTIFIER(speed)
 IDENTIFIER(unchecked)
 IDENTIFIER(unsafe)
+IDENTIFIER(concurrent)
+IDENTIFIER(caller)
 
 // The singleton instance of TupleTypeDecl in the Builtin module
 IDENTIFIER(TheTupleType)

lib/AST/ASTDumper.cpp

@@ -526,6 +526,14 @@ static StringRef getDumpString(NonSendableKind kind) {
     return "Specific";
   }
 }
+static StringRef getDumpString(ExecutionKind kind) {
+  switch (kind) {
+  case ExecutionKind::Concurrent:
+    return "concurrent";
+  case ExecutionKind::Caller:
+    return "caller";
+  }
+}
 static StringRef getDumpString(StringRef s) {
   return s;
 }
@@ -3871,6 +3879,11 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, StringRef>,
 
 #undef TRIVIAL_ATTR_PRINTER
 
+  void visitExecutionAttr(ExecutionAttr *Attr, StringRef label) {
+    printCommon(Attr, "execution_attr", label);
+    printField(Attr->getBehavior(), "behavior");
+    printFoot();
+  }
   void visitABIAttr(ABIAttr *Attr, StringRef label) {
     printCommon(Attr, "abi_attr", label);
     printRec(Attr->abiDecl, "decl");

lib/AST/Attr.cpp

@@ -1650,6 +1650,19 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DeclAttrKind::Execution: {
+    auto *attr = cast<ExecutionAttr>(this);
+    switch (attr->getBehavior()) {
+    case ExecutionKind::Concurrent:
+      Printer << "@execution(concurrent)";
+      break;
+    case ExecutionKind::Caller:
+      Printer << "@execution(caller)";
+      break;
+    }
+    break;
+  }
+
 #define SIMPLE_DECL_ATTR(X, CLASS, ...) case DeclAttrKind::CLASS:
 #include "swift/AST/DeclAttr.def"
     llvm_unreachable("handled above");
@@ -1861,6 +1874,15 @@ StringRef DeclAttribute::getAttrName() const {
     }
   case DeclAttrKind::Lifetime:
     return "lifetime";
+  case DeclAttrKind::Execution: {
+    switch (cast<ExecutionAttr>(this)->getBehavior()) {
+    case ExecutionKind::Concurrent:
+      return "execution(concurrent)";
+    case ExecutionKind::Caller:
+      return "execution(caller)";
+    }
+    llvm_unreachable("Invalid execution kind");
+  }
   }
   llvm_unreachable("bad DeclAttrKind");
 }

lib/AST/Bridging/DeclAttributeBridging.cpp

@@ -585,3 +585,21 @@ BridgedUnavailableFromAsyncAttr BridgedUnavailableFromAsyncAttr_createParsed(
       UnavailableFromAsyncAttr(cMessage.unbridged(), cAtLoc.unbridged(),
                                cRange.unbridged(), /*implicit=*/false);
 }
+
+static ExecutionKind unbridged(BridgedExecutionKind kind) {
+  switch (kind) {
+  case BridgedExecutionKindConcurrent:
+    return ExecutionKind::Concurrent;
+  case BridgedExecutionKindCaller:
+    return ExecutionKind::Caller;
+  }
+  llvm_unreachable("unhandled enum value");
+}
+
+BridgedExecutionAttr BridgedExecutionAttr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc atLoc,
+    BridgedSourceRange range, BridgedExecutionKind behavior) {
+  return new (cContext.unbridged())
+      ExecutionAttr(atLoc.unbridged(), range.unbridged(),
+                    unbridged(behavior), /*implicit=*/false);
+}

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -111,6 +111,8 @@ extension ASTGenVisitor {
       let attrName = identTy.name.rawText
       let attrKind = BridgedDeclAttrKind(from: attrName.bridged)
       switch attrKind {
+      case .execution:
+        return handle(self.generateExecutionAttr(attribute: node)?.asDeclAttribute)
       case .ABI:
         return handle(self.generateABIAttr(attribute: node)?.asDeclAttribute)
       case .alignment:
@@ -329,6 +331,33 @@ extension ASTGenVisitor {
     return handle(self.generateCustomAttr(attribute: node)?.asDeclAttribute)
   }
 
+  /// E.g.:
+  ///   ```
+  ///   @execution(concurrent)
+  ///   @execution(caller)
+  ///   ```
+  func generateExecutionAttr(attribute node: AttributeSyntax) -> BridgedExecutionAttr? {
+    let behavior: BridgedExecutionKind? = self.generateSingleAttrOption(
+      attribute: node,
+      {
+        switch $0.rawText {
+        case "concurrent": return .concurrent
+        case "caller": return .caller
+        default: return nil
+        }
+      }
+    )
+    guard let behavior else {
+      return nil
+    }
+    return .createParsed(
+      self.ctx,
+      atLoc: self.generateSourceLoc(node.atSign),
+      range: self.generateAttrSourceRange(node),
+      behavior: behavior
+    )
+  }
+
   /// E.g.:
   ///   ```
   ///   @abi(func fn())