#SendingRisksDataRace errors when turning on NonisolatedNonsendingByDefault

Using Swift
, ,
1

I am using Swift 6.2.3 on Linux with // swift-tools-version:6.2. When I turn on NonisolatedNonsendingByDefault then the following code:

private extension HTML {
	consuming func render(into buffer: UnsafeMutablePointer<ByteBuffer>, chunkSize: Int) async throws {
		try await render(into: ByteBufferWriter(buffer: buffer), chunkSize: chunkSize)
	}
}

Produces 2 errors. One about sending self (Both this method and the method I'm calling are consuming), this one makes zero sense.
Another about passing in the ByteBufferWriter that is getting initialized here, which might make sense if the initializer escaped self (which is not the case here, also using final class or struct makes no difference) but I haven't found any ways of marking the initializer's return value sending Self

And then this one:

extension ResponseBodyWriter {
	mutating func writeSSE(event: String? = nil, html: (any HTML)?) async throws {
		try await write(ByteBuffer.sse(event: event, html: html))
	}
}

Also produces an error about sending self. This one I can understand.

All of the errors get resolved by adding some @concurrent annotations. Is this the intended way for migrating to NonisolatedNonsendingByDefault or am I missing something?

As for the first 2 errors, can someone enlighten me?

2

Wanted to test enabling this feature flag on the dependency where I am getting the errors.

Which resulted in finding out that this upcoming feature flag doesn't make local functions nonisolated(nonsending), so this code:

    @_unavailableInEmbedded
    static func _render<Renderer: _AsyncHTMLRendering>(
        _ html: consuming Self,
        into renderer: inout Renderer,
        with context: consuming _RenderingContext
    ) async throws {
        func render<H: HTML>(
            _ html: H,
            into renderer: inout some _AsyncHTMLRendering,
            with context: consuming _RenderingContext
        ) async throws {
            try await H._render(html, into: &renderer, with: context)
        }

        try await render(html.__body, into: &renderer, with: context)
    }

will fail because our nonisolated(nonsending) render is trying to call into the @concurrent local render function. I assume this is a bug and not intentional?

3

Just a few quick comments (I'm not familiar with the API in your example code).

A consuming method doens't invalidate self. It's ok to continue accessing the instance using the same variable after calling it, because an implicity copy is made in this case. To invalidate a binding, you need to use consume operator. But even that won't work in your example because there might be multiple variable holding the same reference to a HTML instance.

In general I think ownership and concurrency were designed as two orthogonal features in Swift (though I didn't see discussion about it).

EDIT: I later realized that my above description was inaccurate. In my new understanding consuming modifer is more about value than binding. In practice, however, my experiment showed that after running a consuming method, a class instance is still shared. So my conclusion still holds.

Are you trying to create an instance in isolation A and pass it to isolation B? If so, I think the idiomatic approach is to define its init as a nonisolated method (I haven't used it myself though).

Since all issues are introduced by NonisolatedNonsendingByDefault setting, they can be resolved by adding @concurrent annotations manually. I suppose what you really asked about was why the change caused the issues. Without understanding of your code, I suspect one possible reason is that nonisolated function's parameters are task isolated, they can be passed to global executors but not to actors (that's the difference caused by the setting).