[AST/ASTGen] Introduce @concurrent attribute to replace @execution(concurrent) spelling

Author: xedin

include/swift/AST/DeclAttr.def

@@ -884,7 +884,13 @@ SIMPLE_DECL_ATTR(extensible, Extensible,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove | ForbiddenInABIAttr,
   169)
 
-LAST_DECL_ATTR(Extensible)
+SIMPLE_DECL_ATTR(concurrent, Concurrent,
+  OnFunc | OnConstructor | OnSubscript | OnVar,
+  ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove | UnconstrainedInABIAttr,
+  170)
+DECL_ATTR_FEATURE_REQUIREMENT(Concurrent, ExecutionAttribute)
+
+LAST_DECL_ATTR(Concurrent)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

lib/AST/ASTDumper.cpp

@@ -4926,6 +4926,7 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   TRIVIAL_ATTR_PRINTER(WarnUnqualifiedAccess, warn_unqualified_access)
   TRIVIAL_ATTR_PRINTER(WeakLinked, weak_linked)
   TRIVIAL_ATTR_PRINTER(Extensible, extensible)
+  TRIVIAL_ATTR_PRINTER(Concurrent, concurrent)
 
 #undef TRIVIAL_ATTR_PRINTER
 

lib/AST/Decl.cpp

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

lib/AST/FeatureSet.cpp

@@ -510,6 +510,9 @@ static bool usesFeatureExecutionAttribute(Decl *decl) {
   if (decl->getAttrs().hasAttribute<ExecutionAttr>())
     return true;
 
+  if (decl->getAttrs().hasAttribute<ConcurrentAttr>())
+    return true;
+
   auto hasExecutionAttr = [](TypeRepr *R) {
     if (!R)
       return false;

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -197,6 +197,8 @@ extension ASTGenVisitor {
         return handle(self.generateSimpleDeclAttr(attribute: node, kind: .atReasync))
       case .rethrows:
         return handle(self.generateSimpleDeclAttr(attribute: node, kind: .atRethrows))
+      case .concurrent:
+        return handle(self.generateSimpleDeclAttr(attribute: node, kind: .concurrent))
       case .none where attrName == "_unavailableInEmbedded":
         return handle(self.generateUnavailableInEmbeddedAttr(attribute: node)?.asDeclAttribute)
 

lib/Sema/ConstraintSystem.cpp

@@ -1414,8 +1414,10 @@ FunctionType::ExtInfo ClosureEffectsRequest::evaluate(
   bool async = expr->getAsyncLoc().isValid();
   bool sendable = expr->getAttrs().hasAttribute<SendableAttr>();
 
-  // `@execution(...)` attribute is only valid on asynchronous function types.
-  if (expr->getAttrs().hasAttribute<ExecutionAttr>()) {
+  // `@execution(...)` and `@concurrent` attributes are only
+  // valid on asynchronous function types.
+  if (expr->getAttrs().hasAttribute<ExecutionAttr>() ||
+      expr->getAttrs().hasAttribute<ConcurrentAttr>()) {
     async = true;
   }
 

lib/Sema/TypeCheckAttr.cpp

@@ -198,7 +198,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     TypeChecker::checkDeclABIAttribute(D, attr);
   }
 
-  void visitExecutionAttr(ExecutionAttr *attr) {
+  void checkExecutionBehaviorAttribute(DeclAttribute *attr) {
     auto *const decl = cast<ValueDecl>(D);
 
     auto *const storage = dyn_cast<AbstractStorageDecl>(decl);
@@ -258,6 +258,22 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     }
   }
 
+  void visitExecutionAttr(ExecutionAttr *attr) {
+    checkExecutionBehaviorAttribute(attr);
+
+    if (auto *concurrentAttr = D->getAttrs().getAttribute<ConcurrentAttr>())
+    diagnoseAndRemoveAttr(attr, diag::actor_isolation_multiple_attr_2, D,
+                          attr, concurrentAttr);
+  }
+
+  void visitConcurrentAttr(ConcurrentAttr *attr) {
+    checkExecutionBehaviorAttribute(attr);
+
+    if (auto *executionAttr = D->getAttrs().getAttribute<ExecutionAttr>())
+      diagnoseAndRemoveAttr(attr, diag::actor_isolation_multiple_attr_2, D,
+                            attr, executionAttr);
+  }
+
   void visitAlignmentAttr(AlignmentAttr *attr) {
     // Alignment must be a power of two.
     auto value = attr->getValue();
@@ -4316,6 +4332,7 @@ static void checkGlobalActorAttr(
   auto isolatedAttr = decl->getAttrs().getAttribute<IsolatedAttr>();
   auto nonisolatedAttr = decl->getAttrs().getAttribute<NonisolatedAttr>();
   auto executionAttr = decl->getAttrs().getAttribute<ExecutionAttr>();
+  auto concurrentAttr = decl->getAttrs().getAttribute<ConcurrentAttr>();
 
   llvm::SmallVector<const DeclAttribute *, 2> attributes;
 
@@ -4330,7 +4347,9 @@ static void checkGlobalActorAttr(
   if (executionAttr) {
     attributes.push_back(executionAttr);
   }
-
+  if (concurrentAttr) {
+    attributes.push_back(concurrentAttr);
+  }
   if (attributes.size() == 1)
     return;
 
@@ -8145,13 +8164,13 @@ class ClosureAttributeChecker
     // Nothing else to check.
   }
 
-  void visitExecutionAttr(ExecutionAttr *attr) {
+  void checkExecutionBehaviorAttribute(DeclAttribute *attr) {
     if (!ctx.LangOpts.hasFeature(Feature::ExecutionAttribute)) {
       visitDeclAttribute(attr);
       return;
     }
 
-    // `@execution(...)` implies `async`.
+    // execution behavior attribute implies `async`.
     if (closure->hasExplicitResultType() &&
         closure->getAsyncLoc().isInvalid()) {
       ctx.Diags
@@ -8184,6 +8203,14 @@ class ClosureAttributeChecker
     }
   }
 
+  void visitExecutionAttr(ExecutionAttr *attr) {
+    checkExecutionBehaviorAttribute(attr);
+  }
+
+  void visitConcurrentAttr(ConcurrentAttr *attr) {
+    checkExecutionBehaviorAttribute(attr);
+  }
+
   void visitNonisolatedAttr(NonisolatedAttr *attr) {
     if (attr->isUnsafe() ||
         !ctx.LangOpts.hasFeature(Feature::ClosureIsolation)) {

lib/Sema/TypeCheckConcurrency.cpp

@@ -4890,6 +4890,7 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
   auto nonisolatedAttr = decl->getAttrs().getAttribute<NonisolatedAttr>();
   auto globalActorAttr = decl->getGlobalActorAttr();
   auto concurrentExecutionAttr = decl->getAttrs().getAttribute<ExecutionAttr>();
+  auto concurrentAttr = decl->getAttrs().getAttribute<ConcurrentAttr>();
 
   // Remove implicit attributes if we only care about explicit ones.
   if (onlyExplicit) {
@@ -4901,11 +4902,14 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
       globalActorAttr = std::nullopt;
     if (concurrentExecutionAttr && concurrentExecutionAttr->isImplicit())
       concurrentExecutionAttr = nullptr;
+    if (concurrentAttr && concurrentAttr->isImplicit())
+      concurrentAttr = nullptr;
   }
 
   unsigned numIsolationAttrs =
       (isolatedAttr ? 1 : 0) + (nonisolatedAttr ? 1 : 0) +
-      (globalActorAttr ? 1 : 0) + (concurrentExecutionAttr ? 1 : 0);
+      (globalActorAttr ? 1 : 0) + (concurrentExecutionAttr ? 1 : 0) +
+      (concurrentAttr ? 1 : 0);
   if (numIsolationAttrs == 0) {
     if (isa<DestructorDecl>(decl) && !decl->isImplicit()) {
       return ActorIsolation::forNonisolated(false);
@@ -4930,6 +4934,9 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
     }
   }
 
+  if (concurrentAttr)
+    return ActorIsolation::forNonisolated(/*is unsafe*/ false);
+
   // If the declaration is explicitly marked 'nonisolated', report it as
   // independent.
   if (nonisolatedAttr) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1588,6 +1588,7 @@ namespace  {
     UNINTERESTING_ATTR(Borrowed)
     UNINTERESTING_ATTR(Borrowing)
     UNINTERESTING_ATTR(CDecl)
+    UNINTERESTING_ATTR(Concurrent)
     UNINTERESTING_ATTR(Consuming)
     UNINTERESTING_ATTR(Documentation)
     UNINTERESTING_ATTR(Dynamic)

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,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 = 938; // custom AvailabilityDomains
+const uint16_t SWIFTMODULE_VERSION_MINOR = 939; // @concurrent attribute
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///