[Concurrency] Don't check for data races in an actor's deinit.

An actor's deinit can be invoked from any thread, and does not
(cannot!) synchronize to the actor. However, because "self" is
by definition unique and cannot escape, don't perform data race
checking in it or any local functions/closures within the initializer.

This is an imperfect approximation, because one could introduce a data
race by invoking a concurrent algorithm on "self" that does not
escape the closure but subverts @sendable checking and concurrently
accesses actor state. However, for the moment we accept this false
negative because the false positives from performing this checking are
much more prevalent.

Author: DougGregor

lib/SILGen/SILGenProlog.cpp

@@ -461,7 +461,35 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       }
     }
   }
-  
+
+  // Whether the given declaration context is nested within an actor's
+  // destructor.
+  auto isInActorDestructor = [](DeclContext *dc) {
+    while (!dc->isModuleScopeContext() && !dc->isTypeContext()) {
+      if (auto destructor = dyn_cast<DestructorDecl>(dc)) {
+        switch (getActorIsolation(destructor)) {
+        case ActorIsolation::ActorInstance:
+          return true;
+
+        case ActorIsolation::GlobalActor:
+        case ActorIsolation::GlobalActorUnsafe:
+          // Global-actor-isolated types should likely have deinits that
+          // are not themselves actor-isolated, yet still have access to
+          // the instance properties of the class.
+          return false;
+
+        case ActorIsolation::Independent:
+        case ActorIsolation::Unspecified:
+          return false;
+        }
+      }
+
+      dc = dc->getParent();
+    }
+
+    return false;
+  };
+
   // Initialize ExpectedExecutor if the function is an actor-isolated
   // function or closure.
   if (auto *funcDecl =
@@ -479,7 +507,8 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       // or are local functions. The former require a hop, while the latter
       // are prone to dynamic data races in code that does not enforce Sendable
       // completely.
-      if (F.isAsync() || funcDecl->isLocalCapture()) {
+      if (F.isAsync() ||
+          (funcDecl->isLocalCapture() && !isInActorDestructor(funcDecl))) {
         auto loc = RegularLocation::getAutoGeneratedLocation(F.getLocation());
         ManagedValue selfArg = ManagedValue::forUnmanaged(F.getSelfArgument());
         ExpectedExecutor = emitLoadActorExecutor(loc, selfArg);
@@ -488,31 +517,39 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
     }
 
     case ActorIsolation::GlobalActor:
-      ExpectedExecutor =
-        emitLoadGlobalActorExecutor(actorIsolation.getGlobalActor());
+      if (F.isAsync() || !isInActorDestructor(funcDecl)) {
+        ExpectedExecutor =
+          emitLoadGlobalActorExecutor(actorIsolation.getGlobalActor());
+      }
       break;
     }
   } else if (auto *closureExpr = dyn_cast<AbstractClosureExpr>(FunctionDC)) {
+    bool wantExecutor = F.isAsync() || !isInActorDestructor(closureExpr);
     auto actorIsolation = closureExpr->getActorIsolation();
     switch (actorIsolation.getKind()) {
     case ClosureActorIsolation::Independent:
       break;
 
     case ClosureActorIsolation::ActorInstance: {
-      auto loc = RegularLocation::getAutoGeneratedLocation(F.getLocation());
-      auto actorDecl = actorIsolation.getActorInstance();
-      Type actorType = actorDecl->getType();
-      RValue actorInstanceRV = emitRValueForDecl(loc,
-        actorDecl, actorType, AccessSemantics::Ordinary);
-      ManagedValue actorInstance = std::move(actorInstanceRV).getScalarValue();
-      ExpectedExecutor = emitLoadActorExecutor(loc, actorInstance);
+      if (wantExecutor) {
+        auto loc = RegularLocation::getAutoGeneratedLocation(F.getLocation());
+        auto actorDecl = actorIsolation.getActorInstance();
+        Type actorType = actorDecl->getType();
+        RValue actorInstanceRV = emitRValueForDecl(loc,
+          actorDecl, actorType, AccessSemantics::Ordinary);
+        ManagedValue actorInstance =
+            std::move(actorInstanceRV).getScalarValue();
+        ExpectedExecutor = emitLoadActorExecutor(loc, actorInstance);
+      }
       break;
     }
 
     case ClosureActorIsolation::GlobalActor:
-      ExpectedExecutor =
-        emitLoadGlobalActorExecutor(actorIsolation.getGlobalActor());
-      break;
+      if (wantExecutor) {
+        ExpectedExecutor =
+          emitLoadGlobalActorExecutor(actorIsolation.getGlobalActor());
+        break;
+      }
     }
   }
 

test/SILGen/check_executor.swift

@@ -13,6 +13,8 @@ import _Concurrency
 // CHECK-CANONICAL: function_ref @$ss22_checkExpectedExecutor7Builtin15_filenameLength01_E7IsASCII5_line9_executoryBp_BwBi1_BwBetF
 @MainActor public func onMainActor() { }
 
+func takeClosure(_ fn: @escaping () -> Int) { }
+
 public actor MyActor {
   var counter = 0
 
@@ -27,4 +29,11 @@ public actor MyActor {
       return self.counter
     }
   }
+
+  // CHECK-RAW: sil private [ossa] @$s4test7MyActorCfdSiycfU_
+  // CHECK-RAW-NOT: extract_executor
+  // CHECK-RAW: return [[VALUE:%.*]] : $Int
+  deinit {
+    takeClosure { self.counter }
+  }
 }