Parameters with default values

[evant]

Parameters with default values

[saket]

I also noticed that the error message produced by kotlin-inject doesn't use the correct type. For the above example, it would print this error message:

e: [ksp] Cannot find an @Inject constructor or provider for: String

[evant]

Can look into it. My biggest concern is how confusing it is to know which params get injected and which ones don't. You can use a secondary constructor for now.

class Foo(val generator: () -> String) {
  @Inject constructor() : this({ "bar" })
}

[evant]

Note, that message is correct, if you have a @Provides of type String you can also inject it as () -> String or Lazy<String>.

[evant]

Put up a pr to make params with default values optional. For example:

@Inject class Foo(bar: Bar = Bar("default"))

@Component abstract class WithDefaultComponent {
   abstract val foo: Foo // returns Foo(Bar("default"))
}

@Component abstract class WithoutDefaultComponent {
   abstract val foo: Foo // returns Foo(Bar("override"))
   
   @Provides fun bar(): Bar = Bar("override")
}

This actually works similarly to dagger's optional binding.

[saket]

Awesome!

Note, that message is correct, if you have a @provides of type String you can also inject it as () -> String or Lazy.

Gotcha.

[swankjesse]

Optional injection has really ugly consequences when paired with constructor injection.

class ConnectivityService @Inject constructor(
  val client: OkHttpClient,
  val metrics: Metrics = Metrics(NoOpLogger)
)

class Metrics @Inject constructor(
  val logger: Logger
)

interface Logger

What happens when I ask for a ConnectivityService if Logger is not bound? Does it fail because it can't satisfy Metrics’ constructor? Or does it succeed by using the default Metrics instance?

Guice’s implementation of optional injection does backtracking here and the consequences are completely awful, that design was a big mistake.

[evant]

With the proposed impl, this would fail, there is no backtracking.

[evant]

Added a test to validate this behavior. @swankjesse Mind elaborating on what the issue is with how guice does it?

[swankjesse]

Guice does backtracking and that's a mess. If you're not doing that you're good!

[saket]

This doesn't seem to work with lambda parameters. Was that an intentional choice?

@Inject
class App(foo: () -> String = { "bar" })

[evant]

What exactly do you mean by 'doesn't work'?

[saket]

kotlin-inject throws the same error:

e: [ksp] Cannot find an @Inject constructor or provider for: String

I can send a reproducible sample if you want, but this can be easily reproduced by converting the type of any parameter with a lambda:

 @Inject
 class App(
-  foo: String = "bar"
+  foo: () -> String = { "bar" }
 )

[evant]

Sounds like a bug, will take a look

[evant]

Yep, found the issue. Pr up.