[AST] Define @execution(concurrent | caller) attribute on function declarations

Author: xedin

include/swift/AST/Attr.h

@@ -220,6 +220,10 @@ class DeclAttribute : public AttributeBase {
 
       NumFeatures : 31
     );
+
+    SWIFT_INLINE_BITFIELD(ExecutionAttr, DeclAttribute, NumExecutionKindBits,
+      Behavior : NumExecutionKindBits
+    );
   } Bits;
   // clang-format on
 
@@ -2922,6 +2926,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

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");
 }