Merge pull request #75325 from xedin/rdar-131855678-6.0

[6.0][Concurrency] Downgrade mutable captures of `inout` parameters into a…

Author: xedin

lib/Sema/TypeCheckConcurrency.cpp

@@ -4111,10 +4111,13 @@ namespace {
           return false;
         }
 
-        if (auto param =  dyn_cast<ParamDecl>(value)){
-          if(param->isInOut()){
-              ctx.Diags.diagnose(loc, diag::concurrent_access_of_inout_param, param->getName());
-              return true;
+        if (auto param = dyn_cast<ParamDecl>(value)) {
+          if (param->isInOut()) {
+            ctx.Diags
+                .diagnose(loc, diag::concurrent_access_of_inout_param,
+                          param->getName())
+                .limitBehaviorUntilSwiftVersion(limit, 6);
+            return true;
           }
         }
 

test/Concurrency/sendable_checking_captures.swift

@@ -0,0 +1,53 @@
+// RUN: %target-typecheck-verify-swift -swift-version 5
+// RUN: %target-typecheck-verify-swift -swift-version 5 -strict-concurrency=complete -verify-additional-prefix complete-
+
+class NonSendable {} // expected-complete-note 3{{class 'NonSendable' does not conform to the 'Sendable' protocol}}
+
+func callee(_: @Sendable () -> NonSendable) {}
+
+var testLocalCaptures: Int {
+  let ns = NonSendable()
+
+  @Sendable func localFunc() -> NonSendable {
+    return ns // expected-complete-warning {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` local function}}
+  }
+
+  callee { return ns } // expected-complete-warning {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` closure}}
+
+  return 3
+}
+
+struct Bad {
+  var c: Int = {
+    let ns = NonSendable()
+    callee { return ns } // expected-complete-warning {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` closure}}
+    return 3
+  }()
+}
+
+do {
+  class Test { // expected-complete-note 2 {{class 'Test' does not conform to the 'Sendable' protocol}}
+    func update() {}
+  }
+
+  func sendable(_: @Sendable () -> Void) {}
+
+  @preconcurrency
+  func sendable_preconcurrency(_: @Sendable () -> Void) {}
+  
+  func withMutable(_: (inout Test) -> Void) {}
+
+  withMutable { test in
+    sendable {
+      test.update()
+      // expected-complete-warning@-1 {{capture of 'test' with non-sendable type 'Test' in a `@Sendable` closure}}
+      // expected-warning@-2 {{mutable capture of 'inout' parameter 'test' is not allowed in concurrently-executing code}}
+    }
+
+    sendable_preconcurrency {
+      test.update()
+      // expected-complete-warning@-1 {{capture of 'test' with non-sendable type 'Test' in a `@Sendable` closure}}
+      // expected-complete-warning@-2 {{mutable capture of 'inout' parameter 'test' is not allowed in concurrently-executing code}}
+    }
+  }
+}

test/Concurrency/sendable_checking_captures_swift5.swift

@@ -0,0 +1,52 @@
+// RUN: %target-typecheck-verify-swift -swift-version 6
+
+class NonSendable {} // expected-note 3{{class 'NonSendable' does not conform to the 'Sendable' protocol}}
+
+func callee(_: @Sendable () -> NonSendable) {}
+
+var testLocalCaptures: Int {
+  let ns = NonSendable()
+
+  @Sendable func localFunc() -> NonSendable {
+    return ns // expected-error {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` local function}}
+  }
+
+  callee { return ns } // expected-error {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` closure}}
+
+  return 3
+}
+
+struct Bad {
+  var c: Int = {
+    let ns = NonSendable()
+    callee { return ns } // expected-error {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` closure}}
+    return 3
+  }()
+}
+
+do {
+  class Test { // expected-note 2 {{class 'Test' does not conform to the 'Sendable' protocol}}
+    func update() {}
+  }
+
+  func sendable(_: @Sendable () -> Void) {}
+
+  @preconcurrency
+  func sendable_preconcurrency(_: @Sendable () -> Void) {}
+
+  func withMutable(_: (inout Test) -> Void) {}
+
+  withMutable { test in
+    sendable {
+      test.update()
+      // expected-error@-1 {{capture of 'test' with non-sendable type 'Test' in a `@Sendable` closure}}
+      // expected-error@-2 {{mutable capture of 'inout' parameter 'test' is not allowed in concurrently-executing code}}
+    }
+
+    sendable_preconcurrency {
+      test.update()
+      // expected-error@-1 {{capture of 'test' with non-sendable type 'Test' in a `@Sendable` closure}}
+      // expected-error@-2 {{mutable capture of 'inout' parameter 'test' is not allowed in concurrently-executing code}}
+    }
+  }
+}

test/Concurrency/sendable_checking_captures_swift6.swift

@@ -8,17 +8,18 @@
 
 @available(SwiftStdlib 5.1, *)
 func test_taskGroup_cancelAll() async {
-    await withTaskGroup(of: Int.self, returning: Void.self) { group in
+    await withTaskGroup(of: Int.self, returning: Void.self) { group in // expected-note {{parameter 'group' is declared 'inout'}}
         group.spawn {
             await Task.sleep(3_000_000_000)
             let c = Task.isCancelled
             print("group task isCancelled: \(c)")
             return 0
        }
 
-       group.spawn {
+       group.spawn { // expected-error {{escaping closure captures 'inout' parameter 'group'}}
          group.cancelAll() //expected-warning{{capture of 'group' with non-sendable type 'TaskGroup<Int>' in a `@Sendable` closure}}
-                           //expected-error@-1{{mutable capture of 'inout' parameter 'group' is not allowed in concurrently-executing code}}
+         //expected-warning@-1{{mutable capture of 'inout' parameter 'group' is not allowed in concurrently-executing code; this is an error in the Swift 6 language mode}}
+         // expected-note@-2 {{captured here}}
 
          return 0
        }