`kotlin.Lazy` support

It would be nice to use kotlin.Lazy for lazily instantiated dependencies instead of dagger.Lazy in Kotlin code and omit som .get() method calls.

Then instead of:

class AccountManager @Inject constructor(
    service: dagger.Lazy<AccountService>
) {
  service.get().getAccount()
}

it would be possible to write:

class AccountManager @Inject constructor(
    service: kotlin.Lazy<AccountService>
) {
  service.getAccount()
}

[ZacSweers]

I think orienting this discussion around use of dagger.Lazy as delegate buried the lede a bit. It would be nice, but the biggest value prop IMO would be avoiding the constant papercut that is Kotlin’s implicit import of its own Lazy.

i.e. this code looks correct until dagger fails at runtime with a long trace about not providing a Lazy, something I’ve seen multiple colleagues (and myself) get burned by.

class TestClass @Inject constructor(val dependency: Lazy<Dependency>)

this looks right but fails to compile, and kotlin users reflexively will try to write it this way. This costs cycles and cognitive overhead

+import dagger.Lazy
+
class TestClass @Inject constructor(val dependency: Lazy<Dependency>)

I think the combination of this and the free delegate support make this a pretty compelling addition. If not, I’d want to probably sent a PR to add a lint check for this case instead since it comes up regularly.

[JakeWharton]

The Kotlin compiler does not special case kotlin.Lazy. It’s entirely a library feature that neither the compiler nor language are aware of.

In general I don’t see much advantage to adding support for Kotlin’s lazy in Dagger, but there’s also very little disadvantage I suppose. Dagger already has too many things that have more than one way of doing it. What’s one more.

I would rather see time spent on parsing Kotlin metadata to avoid generic variance mismatches that require @JvmSuppressWildcard or wiring up @Provide suspend fun and injectable Deferred<T> if we’re going to focus on Kotlin-specific features of Dagger.