swift: Incorrect actor isolation assumption across Swift 5/6 module boundary leads to `dispatch_assert_queue` crashes
Reproduction
Consider the following code, split in 2 modules:
// Module 1, compiled with Swift 5 and no strict concurrency checking:
public class A {
public init() {}
public func f(_ value: @escaping () -> Void) {
DispatchQueue.global().async { value() }
}
}
// Module 2, compiled with Swift 6:
import Module1
@MainActor
func g() {
A().f {
// This is assumed to be @MainActor isolated by default, leading to `dispatch_assert_queue` failed assertion
}
}
Expected behavior
The code compiles with no warnings (because the closure passed to f is valid based on the definition), but it crashes at runtime due to it being inferred as @MainActor, and executing outside of it.
The closure shouldn’t become @MainActor isolated implicitly just because it’s called from a @MainActor method.
Environment
swift-driver version: 1.112.3 Apple Swift version 6.0 (swiftlang-6.0.0.6.8 clang-1600.0.23.1)
Target: arm64-apple-macosx14.0
Additional information
No response
About this issue
- Original URL
- State: open
- Created 2 years ago
- Reactions: 2
- Comments: 42 (31 by maintainers)
We’re coming up on a year since I filed this… any update? Does Apple not consider this a breaking bug? 🤔
I added documentation for this behavior in the migration guide here: https://www.swift.org/migration/documentation/swift-6-concurrency-migration-guide/dataracesafety#Function-Types
I think the text here can still be improved, but the philosophy is that the compiler shouldn’t consider code to be concurrent until you explicitly opt into using concurrency (e.g. using annotations like
@Sendable). By default, code is synchronous, and closures that are formed cannot be run concurrently. The problem in this GitHub issue is purely an incremental migration problem. The Swift 6 language mode will prevent you from passing a closure over an isolation boundary unless that closure is@Sendable. To catch actor isolation violations in code you don’t own and that the compiler cannot see (i.e. because the implementation is across a module boundary), that’s when the dynamic actor isolation checking from SE-0423 kicks in.I also filed these two enhancements for the dynamic actor isolation checking to provide more actionable guidance when you hit one of these assertions, and to eliminate false-positives when the closure does not touch any actor-isolated state or methods in its body:
If it’s known that it will cause a runtime crash (which it seems to be) then it really should be an error that can be resolved by marking the closure as @Sendable as the migration doc says. Without an error it’s going to be very hard to find where this occurs in any app other than sample or toy apps.
it makes incremental adoption difficult because this will introduce crashes in code that hasn’t changed. So there would be no way to incrementally adopt and test an app. The whole app will need to be tested when just one module is updated to Swift 6. That’s quite a big ask for commercial apps.
Perhaps my comment was misunderstood. The compiler does not and cannot know the code will crash at runtime, because it cannot see across module boundaries into the implementation of the function that contains the violation. My comment here:
Means that the design choice to assume that non-
Sendableclosures don’t leave the isolation domain they’re formed in is deliberate, and it’s valuable for eliminating the annotation burden in the long run. I want to elaborate on why, but that’ll take me some time to articulate.There is no need to pile onto this issue. I understand that people are struggling with runtime crashes that they can’t predict, and I’m listening to the feedback. I’m not saying that no improvement is possible, but the solution is not as obvious as you all are making it out to be.
I greatly appreciate your constructive feedback and your informative bug reports, but this sort of response isn’t helpful. Please at least give me a chance to write up why the design decision was made.
No, I do not have any updates on this issue. As always, I will post here when I have an update to share.
I assume you specifically mean with Swift 6 language mode adoption, right? Note that this issue does not impact projects built with the Swift 6.0 compiler in the Swift 5 language mode, even if you are building with
-strict-concurrency=complete. This issue only impacts projects built with theDynamicActorIsolationupcoming feature or the-enable-actor-data-race-checksdebugging flag enabled, and neither of these flags are automatically enabled under complete concurrency checking.FYI, to make matters worse, this is affecting apps on iOS 18 even without compiling with Swift 6, we see production crashes from system frameworks being affected by the same thing:
You can disable the dynamic actor isolation checking with
-disable-dynamic-actor-isolation.Apologies, I had understood that this was by design and was very confused about this decision.
Per https://www.swift.org/migration/documentation/swift-6-concurrency-migration-guide/incrementaladoption/#Unmarked-Sendable-Closures, adding
@Sendable inwould fix this, but it’s not feasible to go through the entire codebase and find instances where this is needed to prevent crashes if the compiler can’t at last warn us about it.IMO, considering that Swift still doesn’t have a way to silence individual warnings (and I’d like to continue compiling with warnings as errors), I would love for this behavior to not crash and also not produce a warning.
I’m running into this crash when switching my project to Swift 6. My code is like this:
I just want to make absolutely sure that everyone reading here understands that by disabling this runtime check you are explicitly opting into isolation violations. Stuff is going to get accessed on the the wrong thread.
To my knowledge, this would disallow the package from being used as a versioned dependency in other packages. It could be used as a
revisiondependency though: https://forums.swift.org/t/swift-package-manager-doesnt-check-for-unsafe-flags-when-the-dependency-uses-revision/73281For what it’s worth, this exact situation is covered here in the migration guide:
https://www.swift.org/migration/documentation/swift-6-concurrency-migration-guide/incrementaladoption#Unmarked-Sendable-Closures
I’m now seeing users crash on iOS 19 even though the app is compiled with Swift 5 (because of this). This is becoming pretty difficult to navigate.
Good news, I figured out why we were running into this despite compiling with Swift 5. I filed
FB15274506with a sample project reproducing this. Despite the project and app target havingSWIFT_VERSION=5, the SPM target dependencies were being compiled with Swift 6, leading to this bug.With this figured out, we’re at least unblocked to use Xcode 16 + Swift 5 👍🏻
No, the only upcoming features that are implicitly enabled under
StrictConcurrencyareIsolatedDefaultValues,GlobalConcurrency, andRegionBasedIsolation.Just ran into another example of this that wasn’t caught at compile time, but crashed at runtime:
If I hadn’t noticed this, we could have shipped an instant crash-loop to our users, due to an issue that should have been detected at compile time, but instead it’s a runtime
dispatch_assert_queuecrash.This is completely unacceptable and I truly hope Swift 6 does not ship in this state.
@mattmassicotte do you mind linking where the implicit behavior is documented, for future reference? (it’s not easy to navigate Swift Concurrency rules)
I think something like this would possibly work?
So you know that this would lead to a runtime crash and still decide to not produce a warning or error? 🫣