How can I use region-based isolation?

[Michael_Gottesman]

@gwendal.roue

I suppose you're right, but the language does not provide such a feature.

Another point of view on the same problem is the interaction of Sendable with pre-concurrency constructs such as DispatchQueue and Thread:

class NonSendable { }

func run(on queue: DispatchQueue) {
    let ns = NonSendable()
    queue.async {
        // ⚠️ Capture of 'ns' with non-sendable type 'NonSendable'
        // in a `@Sendable` closure.
        _ = ns
    }
}

func spawn() {
    let ns = NonSendable()
    Thread {
        // ⚠️ Capture of 'ns' with non-sendable type 'NonSendable'
        // in a `@Sendable` closure.
        _ = ns
    }.start()
}

I should note that a simple way to remove the warning is nonisolated(unsafe):

class NonSendable { }

// no warning
func run(on queue: DispatchQueue) {
    nonisolated(unsafe) let ns = NonSendable()
    queue.async {
        _ = ns
    }
}

func spawn() {
    nonisolated(unsafe) let ns = NonSendable()
    Thread {
        _ = ns
    }.start()
}

protocol Scheduler: Sendable {
    func schedule(_ action: @escaping @Sendable () -> Void)
}

func run(scheduler: some Scheduler) {
    nonisolated(unsafe) let ns = NonSendable()
    scheduler.schedule {
        _ = ns
    }
}

What you have shown here is a result of us not having changed apis yet to take a transferring non-Sendable closure since transferring has not finished going through evolution. As a quick example of this in action, consider the following:

class NonSendable { }

extension Task where Failure == Never {
  // Modified Task.init() converting it to a non-Sendable transferring implementation.
  init(x: (), @_inheritActorContext @_implicitSelfCapture operation: transferring @escaping () async -> Success) {
    /* ... */
  }
}

func spawn() {
    let ns = NonSendable()
    Task.init(x: ()) {
        _ = ns
    }
}