IssueTracker

hmm room should've filtered out the overridden method, maybe the extends check is failing w/o kotlin.

Kotlin has an interesting approach in this scenario and I am afraid it's designed into the language so I can only see Room adapting to it.

@Dao
interface FooDao: BaseDao<Long, Foo> {

    @Query("select * from foo where id=:id")
    override fun getItem(id: Long): Foo?

}

When a concrete class extends BaseDao Kotlin actually creates 2 methods, one for the Java primitive and one for the boxed version of it. Opening the generated version FooDao_Impl.java you see just the primitive version implemented and an error because there is no boxed version. (from what I see, but I may be mistaking, when an abstract or interface extends BaseDao the boxed version is not there and Room generates the class only for the primitive one).

Room should be able to detect this particular case and generate the boxed version of the method and delegate to the primitive version.

The fix doesn't work for a case where the generic type parameter is only used as a parameter to another generic type. I'm using the roomerror.zip from the opening post, with only these two modifications:

interface BaseDao<Key, Value> {
    fun getItem(id: Key): Value?
    fun delete(id: Collection<Key>)  // Previously: fun delete(id: Key)
}

@Dao
interface FooDao: BaseDao<Long, Foo> {
    @Query("select * from foo where id=:id")
    override fun getItem(id: Long): Foo?

    @Query("delete from foo where id IN (:id)")   // Previously: @Query("delete from foo where id=:id")
    override fun delete(id: Collection<Long>)     // Previously:   override fun delete(id: Long)
}

Note that if it weren't for the super interface, the delete function accepting Collection<Long> would be treated perfectly fine by Room. But now it complains:

roomerror/app/build/tmp/kapt3/stubs/debug/com/roomerror/BaseDao.java:11: error: An abstract DAO method must be annotated with one and only one of the following annotations: Insert,Delete,Query,Update,RawQuery
    public abstract void delete(@org.jetbrains.annotations.NotNull()
                         ^

I imagine this happens because of some type erasure. For the same reason, it's incredibly difficult for me to work around this issue. If I use a signature with vararg id: Key instead, Room is happy, but I can't call the function anymore. That's because my call site looks sth like this:

class Manager<Key, Value> {
  private val dao: BaseDao<Key, Value>
  private val stuff: List<Key>
  fun clear() { dao.delete(*stuff.toTypedArray()) }  // It seems impossible to convert stuff to vararg when Key is not reified.
}

Just realized it might be cleaner to file this as a new bug, as it's not specific to primitives and rather it's specific to type erasure.

I believe this test case for room/room-compiler-processing/src/test/java/androidx/room/compiler/processing/XTypeElementTest.kt might reproduce the underlying problem:

    @Test
    fun overrideMethodWithGenericTypeArgument() {
        val src = Source.kotlin(
            "ParentWithGenericTypeArgument.kt",
            """
            interface ParentWithGenericTypeArgument: GenericInterface<String> {
                override fun child(arg: Collection<String>)
            }

            interface GenericInterface<T> {
                fun child(arg: Collection<T>)
            }
            """.trimIndent()
        )

        runProcessorTest(sources = listOf(src)) { invocation ->
            val objectMethodNames = invocation.processingEnv.requireTypeElement(Any::class)
                .getAllMethods().jvmNames()
            fun XMethodElement.signature(
                owner: XType
            ): String {
                val methodType = this.asMemberOf(owner)
                val params = methodType.parameterTypes.joinToString(",") {
                    it.typeName.toString()
                }
                return "$jvmName($params):${returnType.typeName}"
            }

            fun XTypeElement.allMethodSignatures(): List<String> = getAllMethods().filterNot {
                it.jvmName in objectMethodNames
            }.map { it.signature(this.type) }.toList()

            invocation.processingEnv.requireTypeElement(
                "ParentWithGenericTypeArgument"
            ).let { parent ->
                assertWithMessage(parent.qualifiedName).that(
                    parent.allMethodSignatures()
                ).containsExactly(
                    "child(java.util.Collection<java.lang.String>):void"
                )
            }
        }
    }

In particular, room-compiler fails to recognize that child(arg: Collection<String>) overrides child(arg: Collection<T>). Kotlin clearly thinks that it does override, as it doesn't complain about the override keyword.

This problem happens because fun child(arg: Collection<T>) is converted to void child(@NonNull Collection<? extends T>) in Java, because Kotlin declares a covariant type parameter Collection<out T>. This isn't the case for MutableCollection, so using that instead make things work, though I consider that an ugly workaround.