shouldn't inject parameters when qualifier is present

[luozejiaqun]

example:

module {
    single(named("echo")) { "Hello," + it.get<String>() }
}

koin.get<String>(named("echo")) { parametersOf("World!") } // this should be "Hello,World!", but we get "World!"

PS. this issue will effect multibinding with parameters:

module {
    declareSetMultibinding<String> {
        intoSet { it.get<String>() + "1" }
        intoSet { it.get<String>() + "2" }
    }
}
koin.getSetMultibinding<String> { parametersOf("set element prefix") }

multibinding #1951

[luozejiaqun]

i also think it's kind of weird that we can't do this:

module {
    single { "Hello," + it.get<String>() }
}

koin.get<String> { parametersOf("World!") } // never get "Hello,World!", always "World!"

when the declared type is same to the parameter and no qualifier presents, the parameter always win.

[arnaudgiuliani]

I don't understand your point here 🤔 Let avoid mixing topic 👍

[luozejiaqun]

The key point is the inject order:

// code from Scope
private fun <T> resolveFromContext(
  instanceContext: ResolutionContext
): T {
  return resolveFromInjectedParameters(instanceContext)
      ?: resolveFromRegistry(instanceContext)
      ?: resolveFromStackedParameters(instanceContext)
      ?: resolveFromScopeSource(instanceContext)
      ?: resolveFromParentScopes(instanceContext)
      ?: throwNoDefinitionFound(instanceContext)
}

If we want to resolve an instance of class T, and we provide an parameter which is also class T, then we will always get the parameter:

module {
    single<String> { parameters -> "Hello," + parameters.get<String>() }
}

koin.get<String> { parametersOf("World!") } == "World!"

This it the current implement, becase we can't tell which instance is wanted.
But, if we resolve an instance with qualifier, there is no way the parameter wins, since parameter has nothing to do with qualifier.

module {
    single<String>(named("echo")) { parameters -> "Hello," + parameters.get<String>() }
}

koin.get<String>(named("echo")) { parametersOf("World!") } // expected "Hello,World!", but currently we get "World!"

All in all, I just find a situation where we should skip the parameter injection and continue the rest.

[arnaudgiuliani]

it's about how you shadow your definition instances. The latest additions in your context show be found first. If you try to pass an instance T in the parameters, you will solve this param first as it's the most recent additions.

If you use qualifier, it won't find it in the parameters as it doesn't have been tagged with qualifier.

[luozejiaqun]

@arnaudgiuliani exactly, but the parameter injection doesn't check the qualifier, only the type:

    private inline fun <T> resolveFromInjectedParameters(ctx: ResolutionContext): T? {
        return if (ctx.parameters == null) null
            else {
            _koin.logger.debug("|- ? ${ctx.debugTag} look in injected parameters")
            ctx.parameters.getOrNull(clazz = ctx.clazz)
        }
    }

[arnaudgiuliani]

I see your point, we could skip parameter stage if we have qualifier 👍