New error @MainActor "Call to main actor-isolated initializer 'init()' in a synchronous nonisolated context"

[DmitryKhristenko]

Factory version: 2.5.3
Xcode version: 26.0 beta 3 (17A5276g)
Swift version: 6.2
Swift Concurrency checking: Complete
Default actor isolation: MainActor
Approachable concurrency: Yes

This post is related to post number 274, but the solution proposed in it does not help in my case. I found another solution, but I'm not sure if it's thread-safe.

ERROR: "Converting function value of type '@mainactor @sendable () -> Foo' to '@sendable () -> Foo' loses global actor 'MainActor'"

This code will be compiled in my case:

[buresdv]

Can confirm I'm getting the same error for an Observable when following the documentation:

extension Container
{
    @MainActor
    var appState: Factory<AppState>
    {
        self
        { @MainActor in // <- Converting function value of type '@MainActor @Sendable () -> AppState' to '@Sendable () -> AppState' loses global actor 'MainActor'
            AppState()
        }
    }
}

@Observable @MainActor
final class AppState 

Without the @MainActor in closure annotation:

extension Container
{
    @MainActor
    var appState: Factory<AppState>
    {
        self
        {
            AppState() // <- Call to main actor-isolated initializer 'init()' in a synchronous nonisolated context
        }
    }
}

@Observable @MainActor
final class AppState 

[hmlongco]

In Swift 6.2 you no longer need the internal @mainactor in

[buresdv]

The project is still using Swift 6.0 though

[DmitryKhristenko]

Are there any updates that fix this bug and allow you to get rid of the MainActor.Assumed workaround?

[hmlongco]

Checkout the develop branch.

[tfsgmbh]

Does this really work, though?

Let's say I have a really simple service, that is isolated to the MainActor.

@MainActor protocol TestService {}

class DefaultTestService: TestService {
    init() {
        MainActor.assertIsolated()
    }
}

This service is then registered with the Factory container.

extension Container {
    @MainActor
    var testService: Factory<TestService> {
        Factory(self) { DefaultTestService() }
    }
}

Now, I try to resolve the service at runtime from a background thread. Of course, I have to use await here, because the service is isolated to the MainActor.

Task.detached {
    let service = await Container.shared.testService()
}

While the compiler is happy, the app crashes at runtime because the assertion in the DefaultTestService's init method is triggered. Even though the initializer is isolated to the MainActor, it doesn't actually run on the MainActor. This can lead to all kinds of problems.

Of course, actor isolation does work as expected when the service is initialized without using Factory.

Task.detached {
   let service = await DefaultTestService()
}

[KrzysztofLema]

For me similar. Im trying to register the mock service in the #Preview but the
Call to main actor-isolated initializer 'init(services:)' in a synchronous nonisolated context
let _ = Container.shared.PostManager.register {
PostManager(services: MockPostServices(), configuration: .mockDefault())
}

Swift Version: 6.2
Xcode: Version 26.2 (17C52)

[ertembiyik]

hi, @hmlongco, sorry for ping but it is still an error in version 2.5.3, what is the recommended fix?

[TizianoCoroneo]

I've pinned the library to this commit: a46ce210c1535064beffd1f00caf9835507b656f, but I also would prefer a regular release

[m13v]

this is one of the most painful parts of Swift 6 strict concurrency. the issue is that with default MainActor isolation + complete checking, any Factory container init that doesn't explicitly specify an actor gets inferred as @mainactor, and then calling it from a nonisolated context is an error.

we hit this across our entire codebase when we turned on strict concurrency. the workaround that worked for us was marking the container properties as nonisolated(unsafe) where we know the initialization is thread-safe (which Factory containers generally are since they're just closures). not ideal but it unblocks the migration while keeping the rest of the concurrency checking strict.

[m13v]

we dealt with Swift 6 actor isolation across our macOS desktop app. the concurrency patterns in our SwiftUI views and services: https://github.com/m13v/fazm/blob/main/Desktop/Sources/FloatingControlBar/FloatingControlBarView.swift

and the transcription service that bridges between actor-isolated and nonisolated contexts: https://github.com/m13v/fazm/blob/main/Desktop/Sources/TranscriptionService.swift