Non-static providers inside abstract modules cause runtime crashes

If you forget to add static to an abstract module your app will crash at runtime. This should be prevented at compile time.

Example: Suppose you have a nice abstract module such as the following example:

class SomeOuterClass {
  @dagger.Module
  public abstract static class Module {
      @NonNull
      @OnlineScope
      @Provides
      static A a() {
          return new A();
      }
  }

  @OnlineScope
  @dagger.Component(modules = Module.class, dependencies = ParentComponent.class)
  interface Component {
      @dagger.Component.Builder
      interface Builder {
          @BindsInstance
          Builder interactor(OnlineInteractor interactor);

          @BindsInstance
          Builder view(Observable<Optional<OnlineView>> view);

          Builder parentComponent(ParentComponent component);
          Component build();
      }
  }
}

Next, lets add a new provider to the Module.

@dagger.Module
public abstract static class Module {
    @NonNull
    @OnlineScope
    @Provides
    static A a() {
        return new A();
       }
   }

    @NonNull
    @OnlineScope
    @Provides
    B b() {
        return new B();
    }
}

Oops! We forgot to add static to the second provider. This example now crashes at runtime.

[pyricau]

We’ve been running into the same issue. Technically, this is actually not a Dagger bug. However this behavior leads to incorrect usage.

There are 3 kind of modules:

• Modules for which Dagger needs instances, and can create on its own:

@Module
class MyModule {
  @Provides Thing foo() { return new Thing(); }
}

• Modules for which Dagger does not need instances:

@Module
abstract class MyModule {
  @Provides static Thing foo() { return new Thing(); }
}

• Modules for which Dagger needs instances, but cannot create on its own:

@Module
class MyModule {
  Thing thing;

  MyModule(Thing thing) { this.thing = thing; }

  @Provides Thing foo() { return thing; }
}

For the latter modules, the build() method of Builders will throw an exception if a module instance has not been set manually on the component builder.

The problem appears with this type of module:

@Module
abstract class MyModule {
  @Provides static Thing foo() { return new Thing(); }

  @Provides OtherThing bar() { return new OtherThing(); }
}

This latter module has a second method that isn’t static. So Dagger needs a module instance. However that module is abstract and therefore Dagger cannot create instances. So the generated code expects the module instance to be provided.

This case could maybe be a compiler error instead. However, there might be legitimate cases for abstract modules with real implementations that aren’t known to Dagger.

[ronshapiro]

I talked this over with @netdpb and we think the best path forward is to not allow abstract modules that have instance @Provides methods. The error will say to either make the methods static, or use a subclass of the module (where it’s clear whether or not an instance is required). How does that sound?