Tengo una arquitectura compleja de varios niveles en mi proyecto de Android.

Actualmente quiero usar la siguiente estructura de los componentes y módulos DI:

[Data Layer]
    @DataScope //scope is used for caching (Singleton) some Data Layer entities for whole application
    - DataComponent //exposes just interfaces which should be used on the BL Layer
        //Modules exposes entities for internal (Data Layer) injections and entities which exposed by DataComponent for BL Layer
        * DataModule1
        * DataModule2
        * DataModule3

[Business Logic Layer] (also has component dependency on DataComponent)
    @BlScope //scope is used for caching (Singleton) some BL Layer entities for whole application
    - BlComponent //exposes just interfaces which should be used on the Service Layer & Presentation Layer
        //Modules exposes entities for internal (BL Layer) injections and entities which exposed by BLComponent for the Service Layer & Presentation Layer
        * BlModule1
        * BlModule2

[Service Layer] (also has component dependency on BlComponent) - this layer has Android specific entities (Android Service, ContentProvider) not related to the Presentation Layer
    @ServiceScope //scope is used for caching (Singleton) some Service Layer entities for whole application
    - ServiceComponent //exposes just interfaces which should be used on the Presentation Layer
        * ServiceModule //Module exposes entities for internal (Service Layer) injections and entities which exposed by ServiceComponent for the Presentation Layer

[Presentation Layer] (also has component dependency on: ServiceComponent, BlComponent)
    @PresentationScope //scope is used for caching (Singleton) some Presentation Layer entities for whole application
    - PresentationComponent //exposes just interfaces which should be used on the current layer
        * PresentationModule //Module exposes entities injections on the current layer

ServiceComponent y BlComponent no exponen las interfaces similares.

Para construir el gráfico principal, uso el siguiente código:

DataComponent dataComponent = DaggerDataComponent.builder().<addModules>.build();
BlComponent dataComponent = DaggerBlComponent.builder().<addModules>.dataComponent(dataComponent).build();
ServiceComponent serviceComponent = DaggerServiceComponent.builder().<addModule>.blComponent(blComponent).build();
PresentationComponent presentationComponent = DaggerPresentationComponent.builder().<addModule>.blComponent(blComponent).serviceComponent(serviceComponent).build();

En PresentationLayer utilizo solo "presentationComponent" para proporcionar las dependencias requeridas de ServiceComponent / Layer y BLComponent / Layer.

Actualmente, el escenario anterior no funciona, porque PresentationComponent depende de los 2 componentes del alcance con el error

"... depende de más de un componente de ámbito: ..."

Aunque permite utilizar un componente con ámbito con muchos componentes sin ámbito. Esta arquitectura está dirigida a restringir el uso de entidades de capa interna en las capas superiores y al mismo tiempo tener pruebas independientes (unidad e instrumentación) en cada capa / módulo.

¿Alguien podría ayudarme a entender si es un error o un comportamiento deseable del procesador Dagger? (¿y por qué?) Problema en el repositorio Dagger2:https://github.com/google/dagger/issues/747#issuecomment-303526785