Calling scoped suspending provider should create singleton instance about kotlin-inject HOT 6 CLOSED

As a work-around you can return a Deferred object

@Component
@NetworkScope
internal abstract class NetworkComponent(
    @get:Provides protected val apiInstanceCounter: AtomicInteger,
    @get:Provides val scope: CoroutineScope,
) {
    @NetworkScope
    abstract fun api(): Deferred<Api>

    @Provides
    @NetworkScope
    protected fun api(service: Service, scope: CoroutineScope): Deferred<Api> =
        scope.async(start = CoroutineStart.LAZY) { service.connect() }

    protected val DummyNetworkService.bind: Service
        @Provides get() = this
}

interface Api

interface Service {
    suspend fun connect(): Api
}

@Inject
class DummyNetworkService(private val apiInstanceCounter: AtomicInteger) : Service {
    override suspend fun connect(): Api {
        apiInstanceCounter.incrementAndGet()

        return object : Api {}
    }
}

internal class KotlinInjectTest {
    @Test
    fun `calling scoped suspending provider should create singleton instance`() {
        val apiInstanceCounter = AtomicInteger(0)


        runBlocking {
            val networkComponent = NetworkComponent::class.create(apiInstanceCounter, this)
            val apiInstance0 = networkComponent.api().await()
            val apiInstance1 = networkComponent.api().await()

            assertEquals(apiInstance0, apiInstance1)
        }
    }
}

from kotlin-inject.

Marking as a bug because at the very least it should have a good error message. Will look into if this can be supported

from kotlin-inject.

Thanks for looking into it. It'll be great if this can be supported.
My project currently uses Dagger(kotlin jvm) with Deferred as you have suggested. Using Deferred causes all the dependent objects to also return Deferred, which requires boiler plate code for launching the async, awaiting deferred value in deferred provider methods & passing the coroutineScope to the component.
Even with Deferred "kotlin-inject" is better option than Dagger as it will only require Deferred at the point of "suspending provider" call & dependent object relationship can be expressed without Deferred by adding a suspend mapping from Deferred value to value using await().

    @Provides
    protected suspend fun api(deferredApi: Deferred<Api>): Api = deferredApi.await()

And then api can be returned/injected directly instead of Deferred:

    @NetworkScope
    abstract suspend fun api(): Api

Since it's technically possible with hand written code, it probably should be possible with code generation.

On seeing the location of the error, the problem seems to be in the init block of the get method of LazyMap:

    actual fun <T> get(key: String, init: () -> T): T

Maybe a suspending variant could help:

    actual suspend fun <T> get(key: String, init: suspend () -> T): T

from kotlin-inject.

yeah, though it looks like kotlinx.coroutines is required to implement the suspend version, which isn't currently a dependency. Will have to figure out how to make that optional or if we can live with the extra dependency.

from kotlin-inject.

note: looked into this more and you really need a coroutine-aware lock for this to work correctly, this means that either coroutines would have to be a hard-dependency or we'd need actually do different code gen based on a flag or something. both options feel kinda gross 😞

from kotlin-inject.

This is not blocking for my usecase, and is a good to have feature.
The delta utility vs amount of effort required to implement/maintain it doesn't seems worth it.
Providing an error message with the workaround steps should be good enough.

from kotlin-inject.