Migrate existing dagger tree in multi module with deep Subcomponent Tree

[mateherber]

Hi!

I wanted to ask for help because I'm a bit stuck migrating our anvil tree to metro:

We have the following structure:

• Level 0: :app with AppScope and AppComponent
• Level 1: :activity1, :activity2, etc with ActivityScope and ActivitySubComponent1, ActivitySubComponent2, etc.
• Level 2: :fragment1, :fragment2, etc. with FragmentScope and FragmentSubComponent1, FragmentSubComponent2, etc.

We'd like to have AppComponent-ActivitySubComponent1-FragmentSubComponent1, etc chains. So far we could achieve this by not using ContributesSubcomponent that would lead to adding all fragment components to all activity components, but we made ActivitySubComponent1 to implement FragmentSubComponent1.Parent (factory), and same for all pairs.

Now with Graph extensions the direction changes. We cannot reference :activity1 from :fragment1 or :app from :activity1 to do proper graph extension, so our only option seems to be @ContributesGraphExtension the problem with this is that we can't control which ActivityScope graph will be extended with which FragmentScope one, all of them will have all the extensions, that we would like to avoid.

Is there a way to solve this structure?

Bonus question:

In @ContributesTo replaces I read "List of interface types that this interface replaces in the scope". Does it mean the following is not going to work:

// In code

class MySuperClass @Inject constructor() {
   ...
}

// In test

@ContributesTo(scope = AppScope::class, replaces = [MySuperClass::class]
interface MySuperClassMockProvider {

  @Provides
  fun provideMockMySuperClass(): MySuperClass = mockk()
}

[ZacSweers]

Is there a way to solve this structure?

It should be possible to use ContributesGraphExtension on the contributed graph and then manually make the target graph implement its factory (rather than contributing its factory to a general scope)

@ContributesGraphExtension(...)
interface FragmentSubComponent1 {
  interface Parent {
    ...
  }
}

interface ActivitySubComponent1 : FragmentSubComponent1.Parent

The parent graph processing should recognize that Parent's inherited creator function returns a contributed graph and thus create the graph still. Somewhat similar to how Dagger will special-case accessors that return subcomponents or subcomponent creators.

This isn't a case with a test currently though so let me know if you have any issues where we need to maybe relax some constraints or make this easier.

[mateherber]

Thank you! I'll try without contributing the factory but adding it manually and report back if something doesn't work.

[mateherber]

@ZacSweers Sorry for the late reply, I found time today to try but I hit a wall:

@ContributesGraphExtension declarations must have a nested class annotated with @ContributesGraphExtension.Factory

I'll try with creating a fake factory with nonexistent parent scope

[ZacSweers]

@mateherber sorry that's not really enough context to help

[mateherber]

I'm sorry, I did what you suggested using the @ContributesGraphExtension without annotating the factory with ContributesGraphExtension.Factory. The plugin fails with the error above. So far it seems if I add another fake (contributed to a non existing scope) factory method annotated, I can pass this check.

[mateherber-jt]

With the changes in 0.6.0 this is no longer an issue that needs workarounds

[ZacSweers]

Bonus question:
In @ContributesTo replaces I read "List of interface types that this interface replaces in the scope". Does it mean the following is not going to work:

Yes and no!

Replacements are only for excluding other contributions and injected classes are not inherently contributions.

That said, this case will actually still work the way you want because you are adding an explicit provider of that class, which will short-circuit the lookup of the class's injectable constructor.

[mateherber]

So if I modify my sample to:

// In code

interface MySuperClass

@ContributesBinding(AppScope::class)
class MySuperClassImpl @Inject constructor(): MySuperClass {
   ...
}

// In test

@ContributesTo(scope = AppScope::class, replaces = [MySuperClassImpl::class]
interface MySuperClassMockProvider {

  @Provides
  fun provideMockMySuperClass(): MySuperClass = mockk()
}

Is that going to work?

[ZacSweers]

That should work, contributions may replace other contributions