Sema: Allow @execution on storage declarations

AnthonyLatsis · AnthonyLatsis · commit 8ad2e0259613 · 2025-03-25T02:07:04.000Z
diff --git a/include/swift/AST/DeclAttr.def b/include/swift/AST/DeclAttr.def
@@ -862,7 +862,7 @@ DECL_ATTR(abi, ABI,
 DECL_ATTR_FEATURE_REQUIREMENT(ABI, ABIAttribute)
 
 DECL_ATTR(execution, Execution,
-  OnFunc | OnConstructor,
+  OnFunc | OnConstructor | OnSubscript | OnVar,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   166)
 DECL_ATTR_FEATURE_REQUIREMENT(Execution, ExecutionAttribute)
diff --git a/lib/AST/FeatureSet.cpp b/lib/AST/FeatureSet.cpp
@@ -466,13 +466,13 @@ static bool usesFeatureBuiltinEmplaceTypedThrows(Decl *decl) {
 }
 
 static bool usesFeatureExecutionAttribute(Decl *decl) {
+  if (!DeclAttribute::canAttributeAppearOnDecl(DeclAttrKind::Execution, decl)) {
+    return false;
+  }
+
   if (decl->getAttrs().hasAttribute<ExecutionAttr>())
     return true;
 
-  auto VD = dyn_cast<ValueDecl>(decl);
-  if (!VD)
-    return false;
-
   auto hasExecutionAttr = [](TypeRepr *R) {
     if (!R)
       return false;
@@ -490,6 +490,8 @@ static bool usesFeatureExecutionAttribute(Decl *decl) {
     });
   };
 
+  auto *VD = cast<ValueDecl>(decl);
+
   // Check if any parameters that have `@execution` attribute.
   if (auto *PL = VD->getParameterList()) {
     for (auto *P : *PL) {
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -257,16 +257,20 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
 public:
   void visitExecutionAttr(ExecutionAttr *attr) {
-    auto *F = dyn_cast<AbstractFunctionDecl>(D);
-    if (!F)
+    auto *const decl = cast<ValueDecl>(D);
+
+    auto *const storage = dyn_cast<AbstractStorageDecl>(decl);
+    if (storage && storage->hasStorage()) {
+      diagnoseAndRemoveAttr(attr, diag::attr_not_on_stored_properties, attr);
       return;
+    }
 
-    if (!F->hasAsync()) {
-      diagnoseAndRemoveAttr(attr, diag::attr_execution_only_on_async, F);
+    if (!decl->isAsync()) {
+      diagnoseAndRemoveAttr(attr, diag::attr_execution_only_on_async, decl);
       return;
     }
 
-    auto parameters = F->getParameters();
+    auto *parameters = decl->getParameterList();
     if (!parameters)
       return;
 
@@ -278,7 +282,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
       // isolated parameters affect isolation of the function itself
       if (isa<IsolatedTypeRepr>(repr)) {
         diagnoseAndRemoveAttr(
-            attr, diag::attr_execution_incompatible_isolated_parameter, F, P);
+            attr, diag::attr_execution_incompatible_isolated_parameter, decl,
+            P);
         return;
       }
 
@@ -287,7 +292,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
           diagnoseAndRemoveAttr(
               attr,
               diag::attr_execution_incompatible_dynamically_isolated_parameter,
-              F, P);
+              decl, P);
           return;
         }
       }
diff --git a/test/IDE/complete_decl_attribute_feature_requirement.swift b/test/IDE/complete_decl_attribute_feature_requirement.swift
@@ -54,7 +54,7 @@
 @#^ON_GLOBALVAR^# var globalVar
 // ON_GLOBALVAR:              Begin completions
 // ON_GLOBALVAR_ENABLED-DAG:  Keyword/None:              abi[#Var Attribute#]; name=abi
-// ON_GLOBALVAR_ENABLED-NOT:  Keyword/None:              execution[#{{.*}} Attribute#]; name=execution
+// ON_GLOBALVAR_ENABLED-DAG:  Keyword/None:              execution[#Var Attribute#]; name=execution
 // ON_GLOBALVAR_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
 // ON_GLOBALVAR_DISABLED-NOT: Keyword/None:              execution[#{{.*}} Attribute#]; name=execution
 // ON_GLOBALVAR:              End completions
@@ -71,11 +71,19 @@ struct _S {
   @#^ON_PROPERTY^# var foo
 // ON_PROPERTY:              Begin completions
 // ON_PROPERTY_ENABLED-DAG:  Keyword/None:              abi[#Var Attribute#]; name=abi
-// ON_PROPERTY_ENABLED-NOT:  Keyword/None:              execution[#{{.*}} Attribute#]; name=execution
+// ON_PROPERTY_ENABLED-DAG:  Keyword/None:              execution[#Var Attribute#]; name=execution
 // ON_PROPERTY_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
 // ON_PROPERTY_DISABLED-NOT: Keyword/None:              execution[#{{.*}} Attribute#]; name=execution
 // ON_PROPERTY:              End completions
 
+  @#^ON_SUBSCR^# subscript
+// ON_SUBSCR:              Begin completions
+// ON_SUBSCR_ENABLED-DAG:  Keyword/None:              abi[#Declaration Attribute#]; name=abi
+// ON_SUBSCR_ENABLED-DAG:  Keyword/None:              execution[#Declaration Attribute#]; name=execution
+// ON_SUBSCR_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_SUBSCR_DISABLED-NOT: Keyword/None:              execution[#{{.*}} Attribute#]; name=execution
+// ON_SUBSCR:              End completions
+
   @#^ON_METHOD^# private
   func foo()
 // ON_METHOD:              Begin completions
diff --git a/test/ModuleInterface/execution_attr.swift b/test/ModuleInterface/execution_attr.swift
@@ -30,5 +30,37 @@ public struct Test {
   // CHECK-NEXT:  public func other(_: () async -> Swift.Void)
   // CHECK-NEXT:  #endif
   public func other(_: @execution(caller) () async -> Void) {}
+
+  // CHECK: #if compiler(>=5.3) && $ExecutionAttribute
+  // CHECK-NEXT: @execution(caller) public var testOnVar: Swift.Int {
+  // CHECK-NEXT:   get async
+  // CHECK-NEXT: }
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: public var testOnVar: Swift.Int {
+  // CHECK-NEXT:   get async
+  // CHECK-NEXT: }
+  // CHECK-NEXT: #endif
+  @execution(caller)
+  public var testOnVar: Int {
+    get async {
+      42
+    }
+  }
+
+  // CHECK: #if compiler(>=5.3) && $ExecutionAttribute
+  // CHECK-NEXT: @execution(caller) public subscript(onSubscript _: Swift.Int) -> Swift.Bool {
+  // CHECK-NEXT:   get async
+  // CHECK-NEXT: }
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: public subscript(onSubscript _: Swift.Int) -> Swift.Bool {
+  // CHECK-NEXT:   get async
+  // CHECK-NEXT: }
+  // CHECK-NEXT: #endif
+  @execution(caller)
+  public subscript(onSubscript _: Int) -> Bool {
+    get async {
+      false
+    }
+  }
 }
 
diff --git a/test/attr/attr_execution.swift b/test/attr/attr_execution.swift
@@ -8,6 +8,14 @@
 @execution(concurrent) @execution(caller) func mutipleAttrs() async {}
 // expected-error@-1 {{duplicate attribute}} expected-note@-1 {{attribute already specified here}}
 
+do {
+  @execution(caller) struct S {}
+  // expected-error@-1 {{'@execution(caller)' attribute cannot be applied to this declaration}}
+
+  func f(@execution(caller) param: Int) {}
+  // expected-error@-1 {{'@execution(caller)' attribute cannot be applied to this declaration}}
+}
+
 @execution(concurrent) func nonAsync1() {}
 // expected-error@-1 {{cannot use '@execution' on non-async global function 'nonAsync1()'}}
 
@@ -27,16 +35,29 @@ struct Test {
 
   @execution(concurrent) func member() async {} // Ok
 
-  // expected-error@+1 {{'@execution(caller)' attribute cannot be applied to this declaration}}
-  @execution(caller) subscript(a: Int) -> Bool {
+  @execution(concurrent) var syncP: Int {
+  // expected-error@-1 {{cannot use '@execution' on non-async property 'syncP'}}
+    get {}
+  }
+  @execution(concurrent) var asyncP: Int {
+    get async {}
+  }
+
+  // expected-error@+1 {{cannot use '@execution' on non-async subscript 'subscript(sync:)'}}
+  @execution(caller) subscript(sync _: Int) -> Bool {
     @execution(concurrent) get { false }
     // expected-error@-1 {{@execution(concurrent)' attribute cannot be applied to this declaration}}
     @execution(concurrent) set { }
     // expected-error@-1 {{@execution(concurrent)' attribute cannot be applied to this declaration}}
   }
+  @execution(caller) subscript(async _: Int) -> Bool {
+    get async {}
+  }
 
-  @execution(caller) var x: Int
-  // expected-error@-1 {{'@execution(caller)' attribute cannot be applied to this declaration}}
+  @execution(caller) var storedVar: Int
+  // expected-error@-1 {{'@execution(caller)' must not be used on stored properties}}
+  @execution(caller) let storedLet: Int
+  // expected-error@-1 {{'@execution(caller)' must not be used on stored properties}}
 }
 
 do {
@@ -48,16 +69,31 @@ do {
 
 do {
   @execution(caller) func local() async {} // Ok
+
+  protocol P {
+    @execution(caller) var syncP: Int { get }
+    // expected-error@-1 {{cannot use '@execution' on non-async property 'syncP'}}
+
+    @execution(caller) var asyncP: Int { get async }
+  }
 }
 
 struct TestAttributeCollisions {
   @execution(concurrent) nonisolated func testNonIsolated() async {}
 
   @execution(concurrent) func test(arg: isolated MainActor) async {}
   // expected-error@-1 {{cannot use '@execution' on instance method 'test(arg:)' because it has an isolated parameter: 'arg'}}
+  @execution(concurrent) subscript(test arg: isolated MainActor) -> Int {
+  // expected-error@-1 {{cannot use '@execution' on subscript 'subscript(test:)' because it has an isolated parameter: 'arg'}}
+    get async {}
+  }
 
   @execution(concurrent) func testIsolationAny(arg: @isolated(any) () -> Void) async {}
   // expected-error@-1 {{cannot use '@execution' on instance method 'testIsolationAny(arg:)' because it has a dynamically isolated parameter: 'arg'}}
+  @execution(concurrent) subscript(testIsolationAny arg: @isolated(any) () -> Void) -> Int {
+  // expected-error@-1 {{cannot use '@execution' on subscript 'subscript(testIsolationAny:)' because it has a dynamically isolated parameter: 'arg'}}
+    get async {}
+  }
 
   @MainActor @execution(concurrent) func testGlobalActor() async {}
   // expected-warning @-1 {{instance method 'testGlobalActor()' has multiple actor-isolation attributes ('MainActor' and 'execution(concurrent)')}}
