fix the isolation of the self param in ctors and dtors

The isolation of `self` was missing on its ParamDecl of ctors
of an actor, leading to situations where closures that should
inherit the isolation of the ctor, not actually inheriting it
because they only inspect the ParamDecl.

This patch makes it so that both inits and deinits also
get their `self` isolation by making a query in the
type checker.

resolves rdar://84682865

Author: kavon

lib/AST/ASTContext.cpp

@@ -2936,7 +2936,6 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
   bool isStatic = false;
   SelfAccessKind selfAccess = SelfAccessKind::NonMutating;
   bool isDynamicSelf = false;
-  bool isIsolated = false;
 
   if (auto *FD = dyn_cast<FuncDecl>(AFD)) {
     isStatic = FD->isStatic();
@@ -2954,10 +2953,6 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
     else if (wantDynamicSelf && FD->hasDynamicSelfResult())
       isDynamicSelf = true;
 
-    // If this is a non-static method within an actor, the 'self' parameter
-    // is isolated if this declaration is isolated.
-    isIsolated = evaluateOrDefault(
-        Ctx.evaluator, HasIsolatedSelfRequest{AFD}, false);
   } else if (auto *CD = dyn_cast<ConstructorDecl>(AFD)) {
     if (isInitializingCtor) {
       // initializing constructors of value types always have an implicitly
@@ -3014,6 +3009,10 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
   if (isStatic)
     return AnyFunctionType::Param(MetatypeType::get(selfTy, Ctx));
 
+  // `self` is isolated if typechecker says the function is isolated to it.
+  bool isIsolated =
+      evaluateOrDefault(Ctx.evaluator, HasIsolatedSelfRequest{AFD}, false);
+
   auto flags = ParameterTypeFlags().withIsolated(isIsolated);
   switch (selfAccess) {
   case SelfAccessKind::Consuming:

test/Concurrency/actor_definite_init.swift

@@ -141,8 +141,8 @@ actor MyActor {
 
         Task { // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -175,8 +175,8 @@ actor MyActor {
 
         Task { // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -209,8 +209,8 @@ actor MyActor {
 
         Task { // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -267,8 +267,8 @@ actor MyActor {
         computedProp = 1
 
         Task {
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -315,7 +315,7 @@ actor X {
 
     init(v1 start: Int) {
         self.counter = start
-        Task { await self.setCounter(start + 1) } // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
+        Task { self.setCounter(start + 1) } // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                                                   // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
 
         if self.counter != start {

test/Concurrency/actor_definite_init_swift6.swift

@@ -137,8 +137,8 @@ actor MyActor {
 
         Task { // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -171,8 +171,8 @@ actor MyActor {
 
         Task { // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -205,8 +205,8 @@ actor MyActor {
 
         Task { // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -263,8 +263,8 @@ actor MyActor {
         computedProp = 1
 
         Task {
-            _ = await self.hax
-            await self.helloWorld()
+            _ = self.hax
+            self.helloWorld()
         }
     }
 
@@ -311,7 +311,7 @@ actor X {
 
     init(v1 start: Int) {
         self.counter = start
-        Task { await self.setCounter(start + 1) } // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
+        Task { self.setCounter(start + 1) } // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                                                   // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
 
         if self.counter != start {

test/Concurrency/actor_isolation.swift

@@ -1006,3 +1006,90 @@ actor Butterfly {
     self.init()
   }
 }
+
+// Test the isolation of `self` in constructors and deinits of an actor.
+// We know that Task.init accepts a special closure that inherits the isolation
+// of the context based on the isolation of values captured in the closure,
+// like `self`.
+actor SelfParamIsolationNonMethod {
+  init(s0: Void) {
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  @MainActor init(s1: Void) {
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  init(a1: Void) async {
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  @MainActor init(a2: Void) async {
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  nonisolated init(a3: Void) async {
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  deinit {
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  func f() {}
+}
+
+@MainActor
+final class MainActorInit: Sendable {
+  init() {
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  deinit {
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task { self.f() }
+
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    Task.detached { self.f() }
+  }
+
+  func f() {}
+}