Support `@MainActor`-isolated initializers in factory/singleton registrations

[redne-w]

Support @MainActor-isolated initializers in factory/singleton registrations

Problem

WhoopDIKit's factory closures are stored and called with no actor context, so Swift 6 strict concurrency rejects registering any type with a @MainActor-isolated init.

This comes up with patterns like:

@MainActor
public protocol AsyncViewModel { ... }

@MainActor
final class MyViewModel: AsyncViewModel {
    init(service: MyService) { ... } // implicitly @MainActor
}

Registering this fails to compile:

final class MyModule: DependencyModule {
    override func defineDependencies() {
        factory {
            // ❌ Main actor-isolated initializer cannot be referenced from a non-isolated context
            MyViewModel(service: try self.get())
        }
    }
}

---

Workarounds

nonisolated init — Swift 6

If the init only sets stored properties, nonisolated is safe. @MainActor isolation applies to methods on self after init, not to setting stored properties.

@MainActor
final class MyViewModel: AsyncViewModel {
    nonisolated init(service: MyService) {
        self.service = service
    }
}

Inject a factory closure — Swift 6

Register a @MainActor () -> MyViewModel instead of the type directly.
WhoopDI resolves dependencies; you construct on the main actor at the call
site.

// Module
factory {
    let service: MyService = try self.get()
    return { @MainActor in MyViewModel(service: service) } as (@MainActor ()
-> MyViewModel)
}

// @MainActor call site
let makeVM: @MainActor () -> MyViewModel = WhoopDI.inject()
let vm = makeVM()

Swift 5 language mode

Without strict concurrency enabled, this compiles and works fine at runtime as long as inject is always called from the main thread

[jrosen081]

Some off the cuff thoughts:
We could consider making an async initializer, but then we probably need to make the whole machinery internally async (so basically two separate things) ... probably not great
Same concept in terms of MainActor, since we would need the whole machinery main actor ... also not really ideal

I wonder if we can take some inspiration as to what other dependency frameworks do. Like how does swift-dependencies or swinject handle this? Overall I don't have a lot of answers without thinking through this a bit more, but I would be interested to see how others have solved this problem ... if they have