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()
}