[Concurrency] Don't strip @Sendable when determining the actor isolation

of a closure in a `@preconcurrency` context.

Instead, downgrade any diagnostics about non-`Sendable` captures using the
`.limitBehaviorUntilSwiftVersion` mechanism like other preconcurrency errors
that are suppressed in minimal checking. Stripping `@Sendable` from closure
types actually changes the isolation of the closure, because non-`Sendable`
closures are isolated to the context they're formed in, which leads to bogus
dynamic assertion failures under `-enable-actor-data-race-checks`.

Author: hborla

lib/Sema/TypeCheckConcurrency.cpp

@@ -675,10 +675,6 @@ static bool isSendableClosure(
     if (forActorIsolation && explicitClosure->inheritsActorContext()) {
       return false;
     }
-
-    if (explicitClosure->isIsolatedByPreconcurrency() &&
-        !shouldDiagnoseExistingDataRaces(closure->getParent()))
-      return false;
   }
 
   if (auto type = closure->getType()) {
@@ -3692,13 +3688,16 @@ namespace {
     bool checkLocalCapture(
         ConcreteDeclRef valueRef, SourceLoc loc, DeclRefExpr *declRefExpr) {
       auto value = valueRef.getDecl();
+      auto *dc = getDeclContext();
 
       // Check whether we are in a context that will not execute concurrently
       // with the context of 'self'. If not, it's safe.
-      if (!mayExecuteConcurrentlyWith(
-              getDeclContext(), findCapturedDeclContext(value)))
+      if (!mayExecuteConcurrentlyWith(dc, findCapturedDeclContext(value)))
         return false;
 
+      SendableCheckContext sendableBehavior(dc);
+      auto limit = sendableBehavior.defaultDiagnosticBehavior();
+
       // Check whether this is a local variable, in which case we can
       // determine whether it was safe to access concurrently.
       if (auto var = dyn_cast<VarDecl>(value)) {
@@ -3738,7 +3737,7 @@ namespace {
             loc, diag::concurrent_access_of_local_capture,
             parent.dyn_cast<LoadExpr *>(),
             var)
-          .warnUntilSwiftVersion(6);
+          .limitBehaviorUntilSwiftVersion(limit, 6);
         return true;
       }
 
@@ -3748,7 +3747,7 @@ namespace {
 
         func->diagnose(diag::local_function_executed_concurrently, func)
           .fixItInsert(func->getAttributeInsertionLoc(false), "@Sendable ")
-          .warnUntilSwiftVersion(6);
+          .limitBehaviorUntilSwiftVersion(limit, 6);
 
         // Add the @Sendable attribute implicitly, so we don't diagnose
         // again.

test/Concurrency/actor_data_race_checks_minimal.swift

@@ -0,0 +1,35 @@
+// RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking -enable-actor-data-race-checks -swift-version 5 -strict-concurrency=minimal) | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: concurrency_runtime
+
+@preconcurrency @MainActor
+protocol P {
+  func requirement()
+}
+
+class C: P {
+  func requirement() {
+    call {
+      print("don't crash!")
+    }
+  }
+
+  var task: Task<Void, Never>?
+
+  @preconcurrency func call(closure: @escaping @Sendable () -> Void) {
+    task = Task.detached {
+      closure()
+    }
+  }
+
+  func wait() async {
+    await task?.value
+  }
+}
+
+// CHECK: don't crash!
+let c = C()
+c.requirement()
+await c.wait()