[Feature Request] Conditionally providing `@BindsOptionalOf` at runtime

[gabrielhuff]

TLDR: This is a feature request for allowing @BindsOptionalOf bindings to be conditionally provided at runtime, akin to how @ElementsIntoSet works for mulltibindings

---

Background: Conditionally providing multibindings

Say we have 1) a multibinding of Foos; and 2) an injectable implentation of Foo (i.e. FooImpl) :

@Multibinds fun foos(): Set<Foo>

@Provides fun fooImpl(): FooImpl { ... } // where FooImpl : Foo

Say we'd like to conditionally include FooImpl on Set<Foo> at compile time (e.g. include on beta builds, but not release ones). In this case we can:

// Include this on *beta* builds only
@Binds
@IntoSet
fun intoFoos(impl: FooImpl): Foo

It is also possible to conditionally include FooImpl on Set<Foo> at runtime (e.g. depending on a runtime feature flag):

@Provides
@ElementsIntoSet
fun intoFoos(impl: FooImpl): Set<Foo> = if (featureEnabled) setOf(impl) else emptySet()

---

Problem: Conditionally providing optional bindings

Let's change the example above slightly so that we have an optional Foo rather than a set of Foos:

@BindsOptionalOf fun optionalFoo(): Foo // ← change this

@Provides fun fooImpl(): FooImpl { ... } // where FooImpl : Foo

We can still conditionally provide an Optional<Foo> at compile-time as follows:

// Include this on *beta* builds only
@Binds fun foo(impl: FooImpl): Foo

The problem: there's no easy way to conditionally provide an Optional<Foo> at runtime. This is because there's no equivalent to @ElementsIntoSet for optional bindings.

Workaround

Fortunatelly there's a way to overcome the problem above. We need to replace @BindsOptionalOf fun optionalFoo(): Foo with:

@Provides
fun optionalFoo(@Bar foo: Optional<Optional<Foo>>): Optional<Foo> // ← change this
  = if (foo.isPresent() && foo.get().isPresent()) foo.get().get() else Optional.empty

@Qualifier annotation class Bar // ← needed for disambiguating `Optional<Foo>` bindings

@BindsOptionalOf
@Bar
fun optionalOptionalFoo(): Optional<Foo> // ← add this

Then, we can conditionally provide an Optional<Foo> at runtime as follows:

@Provides
@Bar
fun foo(impl: FooImpl): Optional<Foo> = if (featureEnabled) Optional.of(impl) else Optional.empty()

Potential solution (feature request)

The workaround above works, but it's far from ideal (e.g. having to use a qualifier, nested optionals, intermediate binding). Ideally I'd like to be able to write something like this:

@BindsOptionalOf fun optionalFoo(): Foo

@ProvidesOptionalOf // ← this doesn't exist
fun foo(impl: FooImpl): Optional<Foo> = if (featureEnabled) Optional.of(impl) else Optional.empty()

Would it be possible to implement this feature?

[bcorso]

It sounds like FooImpl isn't actually optional -- i.e. it always exists but you want to control whether it binds to Optional<Foo> via a flag. In that case you don't need @BindsOptionalOf, you can just define a normal @Provides, e.g.

@Provides
fun provideOptionalFoo(
    isFooFeatureEnabled: Boolean
    implProvider: Provider<FooImpl>
): Optional<Foo> = if (isFooFeatureEnabled) Optional.of(implProvider.get()) else Optional.empty()

or return Foo? as a more kotlin friendly approach:

@Provides
fun provideOptionalFoo(
    isFooFeatureEnabled: Boolean
    implProvider: Provider<FooImpl>
): Foo? = if (isFooFeatureEnabled) implProvider.get() else null

[gabrielhuff]

Thanks. This solution works when we only want to conditionally provide Foo at runtime. It takes away the flexibility of doing so at compile time (removing this @Provides binding will cause compilation to fail if anything depends on Optional<Foo>).

In other words: switching between runtime and compile-time strategies requires making some changes to the dependency graph. In contrast, the @ElementsIntoSet example my previous message is flexible enough to support both runtime and compile-time gating strategies:

// To disable at runtime: flip `featureEnabled`
// To disable at compile time: do not include this method in the binary
@Provides
@ElementsIntoSet
fun intoFoos(impl: FooImpl): Set<Foo> = if (featureEnabled) setOf(impl) else emptySet()

It would be nice if @BindsOptionalOf had this flexibility.

[bcorso]

Hmm, I get what you're asking for but @BindsOptionalOf requires the compile-time guarantees to satisfy the feature requirements. For example, although Dagger always allows users to request Optional<Foo> everywhere, it also allows users to request Foo directly when you know the binding exists -- without the compile-time guarantees Dagger can't figure this out at compile time.

Taking a step back, we can probably simplify the workaround in your example above. Would something like this work for you:

@Qualifier annotation class Custom

@BindsOptionalOf @Custom fun optionalCustomFoo(): Foo

@Provides
fun optionalFoo(@Custom impl: Optional<Foo>): Optional<Foo> = if (featureEnabled) impl else Optional.empty();

Then in some other module:

// To control at runtime: use `featureEnabled`
// To control at compile time: include/exclude this method in the binary
@Binds @Custom fun bind(impl: FooImpl): Foo;

[gabrielhuff]

Taking a step back, we can probably simplify the workaround in your example above. Would something like this work for you:

Yes, this is definitely an improvement, thanks for sharing!

Dagger always allows users to request Optional<Foo> everywhere, it also allows users to request Foo directly when you know the binding exists -- without the compile-time guarantees Dagger can't figure this out at compile time.

Interesting. I would have assumed that the compile-time guarantee of injecting Foo directly would come from a @Provides / @Binds / @Inject binding, therefore being orthogonal to @BindsOptionalOf. I know very little about the Dagger codegen though.

Nevertheless, I understand that this is a niche feature (nobody asked for it after all these years) and there's a workaround available. So feel free to close if the implementation is infeasible / impractical.

Thanks for looking into it!