Generic casting in Kotlin

Question

I have the following classes and interfaces:

public interface ActivityComponent<T extends Activity> {
    void inject(T activity);
}

public interface MyActivityComponent extends ActivityComponent<MyActivity> {
}

public abstract class DaggerActivity extends Activity {
    abstract ActivityComponent getComponent(Context context);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityComponent component = getComponent(this);
    }
}

public class MyActivity extends DaggerActivity {
    @Override
    ActivityComponent getComponent(Context context) {
        MyActivityComponent component = buildComponent();
        return component;
    }

And this analogous (I think?) Kotlin code:

public trait ActivityComponent<T : Activity> {
    public fun inject(activity: T)
}

public abstract class DaggerActivity : Activity {
    protected abstract fun getComponent(context: Context): ActivityComponent<Activity> // Type required

    override fun onCreate(savedInstanceState: Bundle?) {
        var component = getComponent(this)
    }
}

public class MyActivity extends DaggerActivity {
    override fun getComponent(context: Context): ActivityComponent<Activity> {
        val component: MyActivityComponent = buildComponent()
        return component as ActivityComponent<Activity>
    }
}

Note: MyActivityComponent implementation is always in Java so that Dagger can process it.

The "problem" is that MyActivity.getComponent() in Kotlin requires a cast to the return type even though MyActivityComponent subclasses ActivityComponent.

My understanding of Kotlin's generics is admittedly weak, and I'm having trouble translating from Java's generics. Can someone explain why this cast is necessary or, preferably, the correct implementation which removes the need for casting?

I've also tried things like:

protected abstract fun <E : Activity> getComponent(context: Context): ActivityComponent<E>

and

protected abstract fun <A: Activity, E : ActivityComponent<A> getComponent(context: Context): E

With the same result (casting required).

Answer 1

The difference is that in Java you are using a raw type ActivityComponent as a return type for getComponent(). Raw types are Java's legacy mechanism introduced in Java 5, mainly for backward compatibility with Java 4 collections.

Kotlin does not have raw types. Instead, you can use a "star-projection", i.e. ActivityComponent<*>, which is vaguely analogous to Java's ActivityComponent<?>, which I would recommend to use instead of a raw type anyways.

So, the solution would be:

fun getComponent(context: Context): ActivityComponent<*>