Merge pull request #72070 from hborla/nonisolated-unsafe-fixes

[Concurrency] Fix an issue where `nonisolated(unsafe)` did not suppress concurrency warnings.

Author: hborla

lib/Sema/TypeCheckConcurrency.cpp

@@ -2468,6 +2468,15 @@ namespace {
         // If the closure won't execute concurrently with the context in
         // which the declaration occurred, it's okay.
         auto decl = capture.getDecl();
+        auto isolation = getActorIsolation(decl);
+
+        // 'nonisolated' local variables are always okay to capture in
+        // 'Sendable' closures because they can be accessed from anywhere.
+        // Note that only 'nonisolated(unsafe)' can be applied to local
+        // variables.
+        if (isolation.isNonisolated())
+          continue;
+
         auto *context = localFunc.getAsDeclContext();
         auto fnType = localFunc.getType()->getAs<AnyFunctionType>();
         if (!mayExecuteConcurrentlyWith(context, decl->getDeclContext()))
@@ -5490,13 +5499,18 @@ static bool checkSendableInstanceStorage(
 
     /// Handle a stored property.
     bool operator()(VarDecl *property, Type propertyType) override {
+      ActorIsolation isolation = getActorIsolation(property);
+
+      // 'nonisolated' properties are always okay in 'Sendable' types because
+      // they can be accessed from anywhere. Note that 'nonisolated' without
+      // '(unsafe)' can only be applied to immutable, 'Sendable' properties.
+      if (isolation.isNonisolated())
+        return false;
+
       // Classes with mutable properties are Sendable if property is
       // actor-isolated
       if (isa<ClassDecl>(nominal)) {
-        ActorIsolation isolation = getActorIsolation(property);
-
-        if (property->supportsMutation() &&
-            (isolation.isNonisolated() || isolation.isUnspecified())) {
+        if (property->supportsMutation() && isolation.isUnspecified()) {
           auto behavior =
               SendableCheckContext(dc, check).defaultDiagnosticBehavior();
           if (behavior != DiagnosticBehavior::Ignore) {

test/Concurrency/sendable_checking.swift

@@ -361,3 +361,18 @@ enum SynthesizedConformances {
     let x: NotSendable
   }
 }
+
+@available(SwiftStdlib 5.1, *)
+final class UseNonisolatedUnsafe: Sendable {
+  nonisolated(unsafe) var x1: NonSendable = .init()
+  nonisolated(unsafe) let x2: NonSendable = .init()
+  nonisolated(unsafe) var x3: Int = 0
+
+  func captureInTask() {
+    nonisolated(unsafe) var x = NonSendable()
+    Task {
+      print(x)
+      x = NonSendable()
+    }
+  }
+}