Merge pull request #60688 from theblixguy/defer-isolation-closures

[Concurrency] Handle actor isolation for defers in closures

Author: swift-ci

lib/AST/Decl.cpp

@@ -9212,14 +9212,20 @@ ActorIsolation swift::getActorIsolation(ValueDecl *value) {
 }
 
 ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
-  if (auto *vd = dyn_cast_or_null<ValueDecl>(dc->getAsDecl()))
+  auto dcToUse = dc;
+  // Defer bodies share actor isolation of their enclosing context.
+  if (auto FD = dyn_cast<FuncDecl>(dcToUse)) {
+    if (FD->isDeferBody()) {
+      dcToUse = FD->getDeclContext();
+    }
+  }
+  if (auto *vd = dyn_cast_or_null<ValueDecl>(dcToUse->getAsDecl()))
     return getActorIsolation(vd);
 
-  if (auto *var = dc->getNonLocalVarDecl())
-     return getActorIsolation(var);
-
+  if (auto *var = dcToUse->getNonLocalVarDecl())
+    return getActorIsolation(var);
 
-  if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
+  if (auto *closure = dyn_cast<AbstractClosureExpr>(dcToUse)) {
     switch (auto isolation = closure->getActorIsolation()) {
     case ClosureActorIsolation::Independent:
       return ActorIsolation::forIndependent()
@@ -9243,14 +9249,14 @@ ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
     }
   }
 
-  if (auto *tld = dyn_cast<TopLevelCodeDecl>(dc)) {
-    if (dc->isAsyncContext() ||
-        dc->getASTContext().LangOpts.StrictConcurrencyLevel
-            >= StrictConcurrency::Complete) {
-      if (Type mainActor = dc->getASTContext().getMainActorType())
+  if (auto *tld = dyn_cast<TopLevelCodeDecl>(dcToUse)) {
+    if (dcToUse->isAsyncContext() ||
+        dcToUse->getASTContext().LangOpts.StrictConcurrencyLevel >=
+            StrictConcurrency::Complete) {
+      if (Type mainActor = dcToUse->getASTContext().getMainActorType())
         return ActorIsolation::forGlobalActor(
             mainActor,
-            /*unsafe=*/!dc->getASTContext().isSwiftVersionAtLeast(6));
+            /*unsafe=*/!dcToUse->getASTContext().isSwiftVersionAtLeast(6));
     }
   }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -1522,6 +1522,7 @@ static FuncDecl *findAnnotatableFunction(DeclContext *dc) {
 }
 
 /// Note when the enclosing context could be put on a global actor.
+// FIXME: This should handle closures too.
 static void noteGlobalActorOnContext(DeclContext *dc, Type globalActor) {
   // If we are in a synchronous function on the global actor,
   // suggest annotating with the global actor itself.
@@ -3832,14 +3833,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // If this is a local function, inherit the actor isolation from its
   // context if it global or was captured.
   if (auto func = dyn_cast<FuncDecl>(value)) {
-    // If this is a defer body, inherit unconditionally; we don't
-    // care if the enclosing function captures the isolated parameter.
-    if (func->isDeferBody()) {
-      auto enclosingIsolation =
-                        getActorIsolationOfContext(func->getDeclContext());
-      return inferredIsolation(enclosingIsolation);
-    }
-
     if (func->isLocalCapture() && !func->isSendable()) {
       switch (auto enclosingIsolation =
                   getActorIsolationOfContext(func->getDeclContext())) {

test/Concurrency/actor_defer.swift

@@ -5,7 +5,7 @@
 
 func doSomething() {}
 
-// expected-note @+1 4 {{calls to global function 'requiresMainActor()' from outside of its actor context are implicitly asynchronous}}
+// expected-note @+1 6 {{calls to global function 'requiresMainActor()' from outside of its actor context are implicitly asynchronous}}
 @MainActor func requiresMainActor() {}
 
 @MainActor func testNonDefer_positive() {
@@ -66,7 +66,7 @@ func testGlobalActorAsync_negative() async {
 
 @available(SwiftStdlib 5.1, *)
 actor Actor {
-  // expected-note @+1 3 {{mutation of this property is only permitted within the actor}}
+  // expected-note @+1 6 {{mutation of this property is only permitted within the actor}}
   var actorProperty = 0
 
   func testActor_positive() {
@@ -76,6 +76,13 @@ actor Actor {
     doSomething()
   }
 
+  func testActor_task_positive() {
+    Task {
+      defer { actorProperty += 1 }
+      doSomething()
+    }
+  }
+
 #if NEGATIVES
   nonisolated func testActor_negative() {
     defer {
@@ -84,13 +91,30 @@ actor Actor {
     }
     doSomething()
   }
+
+  nonisolated func testActor_task_negative() {
+    Task {
+      // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from a non-isolated context}}
+      defer { actorProperty += 1 }
+      doSomething()
+    }
+  }
+
   @MainActor func testActor_negative_globalActor() {
     defer {
       // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from the main actor}}
       actorProperty += 1
     }
     doSomething()
   }
+
+  func testActor_task_negative_globalActor() {
+    Task { @MainActor in
+      // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from the main actor}}
+      defer { actorProperty += 1 }
+      doSomething()
+    }
+  }
 #endif
 
   @MainActor func testGlobalActor_positive() {
@@ -99,6 +123,13 @@ actor Actor {
     }
     doSomething()
   }
+  
+  func testGlobalActor_task_positive() {
+    Task { @MainActor in
+      defer { requiresMainActor() }
+      doSomething()
+    }
+  }
 
 #if NEGATIVES
   func testGlobalActor_negative() {
@@ -108,6 +139,14 @@ actor Actor {
     }
     doSomething()
   }
+
+  func testGlobalActor_task_negative() {
+    Task {
+      // expected-error @+1 {{call to main actor-isolated global function 'requiresMainActor()' in a synchronous nonisolated context}}
+      defer { requiresMainActor() }
+      doSomething()
+    }
+  }
 #endif
 }
 
@@ -130,3 +169,48 @@ func testIsolatedActor_negative(actor: Actor) {
   doSomething()
 }
 #endif
+
+@available(SwiftStdlib 5.1, *)
+func testGlobalActor_inTask_positive() {
+  Task { @MainActor in
+    defer { requiresMainActor() }
+    doSomething()
+  }
+}
+
+#if NEGATIVES
+@available(SwiftStdlib 5.1, *)
+func testGlobalActor_inTask_negative() {
+  Task {
+    // expected-error @+1 {{call to main actor-isolated global function 'requiresMainActor()' in a synchronous nonisolated context}}
+    defer { requiresMainActor() }
+    doSomething()
+  }
+}
+#endif
+
+@available(SwiftStdlib 5.1, *)
+func takeClosureWithIsolatedParam(body: (isolated Actor) -> Void) {}
+
+@available(SwiftStdlib 5.1, *)
+func takeClosureWithNotIsolatedParam(body: (Actor) -> Void) {}
+
+@available(SwiftStdlib 5.1, *)
+func testIsolatedActor_closure_positive() {
+  takeClosureWithIsolatedParam { actor in
+    actor.actorProperty += 1
+    defer { actor.actorProperty += 1 }
+    doSomething()
+  }
+}
+
+#if NEGATIVES
+@available(SwiftStdlib 5.1, *)
+func testIsolatedActor_closure_negative() {
+  takeClosureWithNotIsolatedParam { actor in
+    // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from a non-isolated context}}
+    defer { actor.actorProperty += 1 }
+    doSomething()
+  }
+}
+#endif