Support scopes for multibind types

[davidparsson]

Tasks spawned from related discussion in #277 (comment):

1. Respect scopes in when getting items in multibind lists/dicts. Described by the first test case below.
2. Repurpose the scope argument to injector.multibind(), to apply the scope to the element(s) being added instead of the list/dict. Described by the second test case below.

Open question: Should binder.multibind(List[Plugin], to=PluginA, scope=singleton) make injector.get(PluginA) return the same singleton?

Test case idéas:

def test_multibind_types_respect_the_bound_type_scope() -> None:
    def configure(binder: Binder) -> None:
        binder.bind(PluginA, to=PluginA, scope=singleton)
        binder.multibind(List[Plugin], to=PluginA)

    injector = Injector([configure])
    first_list = injector.get(List[Plugin])
    second_list = injector.get(List[Plugin])

    assert first_list[0] is second_list[0]


def test_multibind_scopes_applies_to_the_bound_items() -> None:
    def configure(binder: Binder) -> None:
        binder.multibind(List[Plugin], to=PluginA, scope=singleton)
        binder.multibind(List[Plugin], to=PluginB)
        binder.multibind(List[Plugin], to=PluginC, scope=singleton)

    injector = Injector([configure])
    first_list = injector.get(List[Plugin])
    second_list = injector.get(List[Plugin])

    assert first_list is not second_list
    assert first_list[0] is second_list[0]
    assert first_list[1] is not second_list[1]
    assert first_list[2] is second_list[2]


def test_multibind_scopes_does_not_apply_to_the_type_globally() -> None:
    def configure(binder: Binder) -> None:
        binder.multibind(List[Plugin], to=PluginA, scope=singleton)

    injector = Injector([configure])
    plugins = injector.get(List[Plugin])

    assert plugins[0] is not injector.get(PluginA)
    assert plugins[0] is not injector.get(Plugin)
    assert injector.get(PluginA) is not injector.get(PluginA)

[davidparsson]

I'm not sure if I think multibind scopes should be to the type outside of the multibound container or not, but I'm leaning towards not wanting that. If so, binding binder.multibind(List[Plugin], to=PluginA, scope=singleton) should not make injector.get(PluginA) return a singleton.

Perhaps letting Guice guide us is the way to go here as well, but I have not yet found those details in the documentation.

[eirikur-nc]

I'm not sure if I think multibind scopes should be to the type outside of the multibound container or not, but I'm leaning towards not wanting that. If so, binding binder.multibind(List[Plugin], to=PluginA, scope=singleton) should not make injector.get(PluginA) return a singleton.

I concur.

[eirikur-nc]

I can verify that the behavior described by the tests in the description is consistent with Guice's behavior.
Here are the corresponding Java/Guice tests

public class ParentScopeTest {
    static class DIModule extends AbstractModule {
        @Override
        protected void configure() {
            bind(PluginA.class).in(Singleton.class);
            var pluginBinder = Multibinder.newSetBinder(binder(), Plugin.class);
            pluginBinder.addBinding().to(PluginA.class);
            pluginBinder.addBinding().to(PluginB.class);
            pluginBinder.addBinding().to(PluginC.class).in(Singleton.class);
        }
    }

    static class PluginConsumer {
        public final Set<Plugin> plugins;
        @Inject
        PluginConsumer(Set<Plugin> plugins) {
            this.plugins = plugins;
        }
    }

    @Test
    void ParentScopeIsHonored() {
        var injector = Guice.createInjector(new DIModule());
        var instance1 = injector.getInstance(PluginA.class);
        var instance2 = injector.getInstance(PluginA.class);
        assertEquals(instance1, instance2);

        var consumer1 = injector.getInstance(PluginConsumer.class);
        var consumer2 = injector.getInstance(PluginConsumer.class);
        assertNotEquals(consumer1, consumer2);

        assertNotEquals(consumer1.plugins, consumer2.plugins);
        assertEquals(consumer1.plugins.toArray()[0], consumer2.plugins.toArray()[0]);

        assertNotEquals(consumer1.plugins.toArray()[1], consumer2.plugins.toArray()[1]);
        assertEquals(consumer1.plugins.toArray()[2], consumer2.plugins.toArray()[2]);
    }
}

public class MultiboundScopeTest {
    static class DIModule extends AbstractModule {
        @Override
        protected void configure() {
            var pluginBinder = Multibinder.newSetBinder(binder(), Plugin.class);
            pluginBinder.addBinding().to(PluginA.class).in(Singleton.class);
        }
    }

    static class PluginConsumer {
        public final Set<Plugin> plugins;
        @Inject
        PluginConsumer(Set<Plugin> plugins) {
            this.plugins = plugins;
        }
    }

    @Test
    void MultiboundScopeDoesNotAffectGlobalScope() {
        var injector = Guice.createInjector(new DIModule());
        var consumer1 = injector.getInstance(PluginConsumer.class);
        var consumer2 = injector.getInstance(PluginConsumer.class);
        assertNotEquals(consumer1.plugins.toArray()[0], injector.getInstance(PluginA.class));
        assertEquals(consumer1.plugins.toArray()[0], consumer2.plugins.toArray()[0]);
        assertNotEquals(injector.getInstance(PluginA.class), injector.getInstance(PluginA.class));
    }
}

[eirikur-nc]

FYI - I have started looking into this @davidparsson
I've had partial success. Conceptually, I'm promoting the ListOfProviders class into something more like a Multibinder, so that it becomes capable of storing scope per individual provider. It's all quite hacky at this point but I've managed to get the middle test green (test_multibind_scopes_applies_to_the_bound_items).

[eirikur-nc]

All tests are now green. I've opened up a draft PR.

[eirikur-nc]

I've finalized the PR. I think it's ready for review.