Sema: Extend adoption mode for AsyncCallerExecution to storage declarations

Author: AnthonyLatsis

lib/Sema/AsyncCallerExecutionMigration.cpp

@@ -62,21 +62,29 @@ void AsyncCallerExecutionMigrationTarget::diagnose() const {
   ASSERT(node);
   ASSERT(ctx.LangOpts.getFeatureState(feature).isEnabledForAdoption());
 
-  AbstractFunctionDecl *functionDecl = nullptr;
+  ValueDecl *decl = nullptr;
   ClosureExpr *closure = nullptr;
   FunctionTypeRepr *functionRepr = nullptr;
 
-  if (auto *decl = node.dyn_cast<ValueDecl *>()) {
+  if ((decl = node.dyn_cast<ValueDecl *>())) {
     // Diagnose only explicit nodes.
     if (decl->isImplicit()) {
       return;
     }
 
-    // Diagnose only functions.
-    functionDecl = dyn_cast<AbstractFunctionDecl>(decl);
-    if (!functionDecl) {
+    // If the attribute cannot appear on this kind of declaration, we can't
+    // diagnose it.
+    if (!DeclAttribute::canAttributeAppearOnDecl(DeclAttrKind::Execution,
+                                                 decl)) {
       return;
     }
+
+    // For storage, make sure we have an explicit getter to diagnose.
+    if (auto *storageDecl = dyn_cast<AbstractStorageDecl>(decl)) {
+      if (!storageDecl->getParsedAccessor(AccessorKind::Get)) {
+        return;
+      }
+    }
   } else if (auto *anyClosure = node.dyn_cast<AbstractClosureExpr *>()) {
     // Diagnose only explicit nodes.
     if (anyClosure->isImplicit()) {
@@ -107,8 +115,8 @@ void AsyncCallerExecutionMigrationTarget::diagnose() const {
   // If the intended behavior is specified explicitly, don't diagnose.
   {
     const DeclAttributes *attrs = nullptr;
-    if (functionDecl) {
-      attrs = &functionDecl->getAttrs();
+    if (decl) {
+      attrs = &decl->getAttrs();
     } else if (closure) {
       attrs = &closure->getAttrs();
     }
@@ -121,8 +129,8 @@ void AsyncCallerExecutionMigrationTarget::diagnose() const {
   // The execution behavior changes only for async functions.
   {
     bool isAsync = false;
-    if (functionDecl) {
-      isAsync = functionDecl->hasAsync();
+    if (decl) {
+      isAsync = decl->isAsync();
     } else if (closure) {
       isAsync = closure->isBodyAsync();
     } else {
@@ -137,14 +145,26 @@ void AsyncCallerExecutionMigrationTarget::diagnose() const {
   const ExecutionAttr attr(ExecutionKind::Concurrent, /*implicit=*/true);
 
   const auto featureName = getFeatureName(feature);
-  if (functionDecl) {
+  if (decl) {
+    // Diagnose the function, but slap the attribute on the storage declaration
+    // instead if the function is an accessor.
+    auto *functionDecl = dyn_cast<AbstractFunctionDecl>(decl);
+    if (!functionDecl) {
+      auto *storageDecl = cast<AbstractStorageDecl>(decl);
+
+      // This whole logic assumes that an 'async' storage declaration only has
+      // a getter. Yell for an update if this ever changes.
+      ASSERT(!storageDecl->getAccessor(AccessorKind::Set));
+
+      functionDecl = storageDecl->getParsedAccessor(AccessorKind::Get);
+    }
+
     ctx.Diags
         .diagnose(functionDecl->getLoc(),
                   diag::attr_execution_nonisolated_behavior_will_change_decl,
                   featureName, functionDecl, &attr)
         .fixItInsertAttribute(
-            functionDecl->getAttributeInsertionLoc(/*forModifier=*/false),
-            &attr);
+            decl->getAttributeInsertionLoc(/*forModifier=*/false), &attr);
   } else if (closure) {
     ctx.Diags
         .diagnose(closure->getLoc(),

test/Concurrency/attr_execution/adoption_mode.swift

@@ -1,4 +1,5 @@
-// RUN: %target-typecheck-verify-swift -target %target-swift-5.1-abi-triple -enable-experimental-feature ExecutionAttribute -enable-experimental-feature AsyncCallerExecution:adoption
+// RUN: %target-typecheck-verify-swift -target %target-swift-5.1-abi-triple -swift-version 5 -enable-experimental-feature ExecutionAttribute -enable-experimental-feature AsyncCallerExecution:adoption
+// RUN: %target-typecheck-verify-swift -target %target-swift-5.1-abi-triple -swift-version 6 -enable-experimental-feature ExecutionAttribute -enable-experimental-feature AsyncCallerExecution:adoption
 
 // REQUIRES: swift_feature_ExecutionAttribute
 // REQUIRES: swift_feature_AsyncCallerExecution
@@ -19,8 +20,8 @@ do {
     isolation: isolated (any Actor)? = #isolation
   ) async {}
 
-  // expected-warning@+1:8 {{feature 'AsyncCallerExecution' will cause nonisolated async local function 'asyncF' to run on the caller's actor; use @execution(concurrent) to preserve behavior}}{{3-3=@execution(concurrent) }}{{none}}
-  func asyncF() async {}
+  // expected-warning@+1:20 {{feature 'AsyncCallerExecution' will cause nonisolated async local function 'asyncF' to run on the caller's actor; use @execution(concurrent) to preserve behavior}}{{3-3=@execution(concurrent) }}{{none}}
+  nonisolated func asyncF() async {}
 
   struct S {
     init(sync: ()) {}
@@ -36,6 +37,53 @@ do {
     nonisolated
     public func asyncF() async {}
   }
+
+  protocol P {
+    // FIXME: Not diagnosed
+    func asyncF() async
+  }
+}
+
+// MARK: Storage
+do {
+  struct S {
+    var storedVar: Int
+    let storedLet: Int
+
+    var syncS: Int { get {} set {} }
+    subscript(syncS _: Int) -> Int { get {} }
+
+    @execution(concurrent) var executionAsyncS: Int { get async {} }
+    @execution(concurrent) subscript(executionAsyncS _: Int) -> Int { get async {} }
+
+    @MainActor var mainActorAsyncS: Int { get async {} }
+    @MainActor subscript(mainActorAsyncS _: Int) -> Int { get async {} }
+
+    // expected-warning@+2:7 {{feature 'AsyncCallerExecution' will cause nonisolated async getter for property 'asyncS' to run on the caller's actor; use @execution(concurrent) to preserve behavior}}{{-1:5-5=@execution(concurrent) }}{{none}}
+    var asyncS: Int {
+      get async {}
+    }
+    // expected-warning@+2:7 {{feature 'AsyncCallerExecution' will cause nonisolated async getter for subscript 'subscript' to run on the caller's actor; use @execution(concurrent) to preserve behavior}}{{-1:5-5=@execution(concurrent) }}{{none}}
+    subscript(asyncS _: Int) -> Int {
+      get async throws {}
+    }
+  }
+
+  protocol P {
+    var syncS: Int { get }
+    subscript(syncS _: Int) -> Int { get }
+
+    @execution(concurrent) var executionAsyncS: Int { get async }
+    @execution(concurrent) subscript(executionAsyncS _: Int) -> Int { get async }
+
+    @MainActor var mainActorAsyncS: Int { get async }
+    @MainActor subscript(mainActorAsyncS _: Int) -> Int { get async }
+
+    // expected-warning@+1:23 {{feature 'AsyncCallerExecution' will cause nonisolated async getter for property 'asyncS' to run on the caller's actor; use @execution(concurrent) to preserve behavior}}{{5-5=@execution(concurrent) }}{{none}}
+    var asyncS: Int { get async }
+    // FIXME: Not diagnosed
+    subscript(asyncS _: Int) -> Int { get async }
+  }
 }
 
 // MARK: Parameters