Kotlin 2.2.0 regression: Creating a fun interface `CoroutineContext.Element` with SAM lamda results in a AbstractMethodError

[matejdro]

Describe the bug

Creating a CoroutineContext.Element with the SAM lambda (ACoroutineContextElement { ... }) results in a `AbstractMethodError˙ crash:

Exception in thread "main" java.lang.AbstractMethodError: Receiver class FileKt$$Lambda$14/0x00007f153c0195e8 does not define or inherit an implementation of the resolved method 'abstract java.lang.Object fold(java.lang.Object, kotlin.jvm.functions.Function2)' of interface kotlin.coroutines.CoroutineContext.
 at kotlinx.coroutines.CoroutineContextKt.hasCopyableElements (CoroutineContext.kt:40) 
 at kotlinx.coroutines.CoroutineContextKt.newCoroutineContext (CoroutineContext.kt:35) 

Provide a Reproducer

Run the following playground: https://pl.kotl.in/K7_VMaqK2, with Kotlin 2.2.0 selected. 2.1.21 works fine.

Alternatively, run the following code locally:

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import kotlin.coroutines.CoroutineContext

fun main() = runBlocking {
    val aCoroutineContextElement = createACoroutineContextElement(10)
    withContext(aCoroutineContextElement) {
        println("Hello World")
    }
}

fun createACoroutineContextElement(number: Int): ACoroutineContextElement {
   return ACoroutineContextElement { number }
}

fun interface ACoroutineContextElement : CoroutineContext.Element {
   override val key: CoroutineContext.Key<*>
      get() = ACoroutineContextElement

   fun number(): Int

   companion object : CoroutineContext.Key<ACoroutineContextElement>
}

I can reproduce it with the Kotlin 2.2.0 & coroutines 1.10.2. Downgrading to 2.1.21 or creating the ACoroutineContextElement with the object : syntax fixes the issue.

[murfel]

Thank you for bringing in it!

Minimizer attempt 1

import kotlin.coroutines.CoroutineContext

fun interface ElementChild : CoroutineContext.Element {
    override val key: CoroutineContext.Key<*>
        get() = ElementChild

    fun number(): Int

    companion object : CoroutineContext.Key<ElementChild>
}

fun main() {
    val e1 = object : ElementChild {
        override fun number(): Int = 1
    }
    println(e1.number())
    println(e1.key)

    val e2 = ElementChild { 2 }
    println(e2.number())
    println(e2.key)

    // ok
    e1.fold(0) { _, _ -> 0 }
    // java.lang.AbstractMethodError: Receiver class does not define or inherit fold
    e2.fold(0) { _, _ -> 0 }
}

Moreover, raises AbstractMethodError for all the methods of Element (get, fold, minusKey) and CoroutineContext (those + plus)

(Still working on minimizing, potentially to get rid of kotlinx.coroutines completely.)

NB: Somehow doesn't reproduce if ran as a test in kotlinx.coroutines, both in master (Kotlin 2.0.0) or develop (Kotlin 2.2.0). Does reproduce as a separate project, though.

[murfel]

Does not reproduce with a self-sufficient exerpt from kotlinx.coroutines.

// NB: No imports, no kotlinx.coroutines dependency. Self-sufficient example.

// Copy of kotlinx.coroutines.CoroutineContext with silly implementations
// for plus and Element.minusKey, to keep it independent of other imports
public interface CoroutineContext {
    public operator fun <E : Element> get(key: Key<E>): E?
    public fun <R> fold(initial: R, operation: (R, Element) -> R): R
    public operator fun plus(context: CoroutineContext): CoroutineContext = this
    public fun minusKey(key: Key<*>): CoroutineContext

    public interface Key<E : Element>

    public interface Element : CoroutineContext {
        public val key: Key<*>

        public override operator fun <E : Element> get(key: Key<E>): E? =
            @Suppress("UNCHECKED_CAST")
            if (this.key == key) this as E else null

        public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =
            operation(initial, this)

        public override fun minusKey(key: Key<*>): CoroutineContext = this
    }
}


fun interface ElementChild : CoroutineContext.Element {
    override val key: CoroutineContext.Key<*>
        get() = ElementChild

    fun number(): Int

    companion object : CoroutineContext.Key<ElementChild>
}

fun main() {
    val e1 = object : ElementChild {
        override fun number(): Int = 1
    }
    println(e1.number())
    println(e1.key)

    val e2 = ElementChild { 2 }
    println(e2.number())
    println(e2.key)

    // ok
    e1.fold(0) { _, _ -> 0 }
    // ok, does NOT reproduce: java.lang.AbstractMethodError: Receiver class does not define or inherit fold
    e2.fold(0) { _, _ -> 0 }
}

[murfel]

So it must be something that import kotlin.coroutines.CoroutineContext brings into the mix.

[udalov]

I've reported this issue to the Kotlin compiler issue tracker: https://youtrack.jetbrains.com/issue/KT-80400/AbstractMethodError-on-fun-interface-implementation-inheriting-from-an-interface-compiled-with-jvm-defaultdisable