Violating @Singleton definition and bypassing "depends on more than one scoped component" error

[guliash]

Hi. I found example where we can create two singletons in hierarchy:

package com.guliash.dagger;

import dagger.Component;
import dagger.Module;
import dagger.Provides;

import javax.inject.Inject;
import javax.inject.Scope;
import javax.inject.Singleton;

public class Main {

    public static void main(String[] args) {
        ComponentC componentC = DaggerComponentC.builder()
                .markerA(DaggerComponentA.create())
                .markerB(DaggerComponentB.create())
                .build();

        System.out.println(componentC.myClassA().myClass);
        System.out.println(componentC.myClassB().myClass);
    }

}

@Singleton
class MyClass {

    @Inject
    public MyClass() {

    }
}

class MyClassA {
    MyClass myClass;

    @Inject
    public MyClassA(MyClass myClass) {
        this.myClass = myClass;
    }
}

interface MarkerA {
    MyClassA myClassA();
}

@Singleton
@Component
interface ComponentA extends MarkerA {

}

class MyClassB {
    MyClass myClass;

    @Inject
    public MyClassB(MyClass myClass) {
        this.myClass = myClass;
    }
}

interface MarkerB {
    MyClassB myClassB();
}

@Singleton
@Component
interface ComponentB extends MarkerB {

}

@Scope
@interface ScopeC {}

@ScopeC
@Component(dependencies = { MarkerA.class, MarkerB.class })
interface ComponentC {
    MyClassA myClassA();

    MyClassB myClassB();
}

Why does Dagger2 allow passing interfaces not annotated with Component annotation to dependencies attribute?

[ronshapiro]

This is either Working As Intended and/or something that we could not reasonably detect.

At runtime, there's no way to detect that a component dependency instance is one that was generated by Dagger. Even if we could, there wouldn't be much meaning to that - a Dagger-generated component is just like any other implementation of that interface/abstract class. Restricting the exact implementation allowed could even cause issues with repackaging/shading. And if there's no reason the runtime type must be a component, why must the compile-time type be a component?

Often when we see "non-components" as dependencies, they are base types of what will eventually be a component. Something like this:

interface AppComponent {
  App app();
}

@Component(dependencies = AppComponent.class)
interface RequestComponent { ... }

@Component
interface EnglishAppComponent extends AppComponent {}

@Component
interface SpanishAppComponent extends AppComponent {}

[guliash]

I got it. Thank you for the quick response.

[guliash]

@ronshapiro, could you please explain one more thing?
Why do we have "depends on more than one scoped component" error? At first I thought it is needed to prevent creation of multiple instances of classes marked with Singleton annotation. But after your answer I can't find a reason for the error.