Kotlin嵌套模板类编译报错：IR lowering后端内部错误排查

我尝试用Kotlin封装域（Field）及域元素的概念用于有限域开发，希望类之间紧密耦合（域元素属于对应域），后续还要实现扩展域，因此搭建了抽象框架并编写了最简单的Fp实现。但在Kotlin 1.9.22版本编译时，出现了IR后端内部错误。

最小复现代码 #

abstract class AbstractField<F: AbstractField<F, E>, E: AbstractField<F, E>.AbstractFieldElement<E>> {
    abstract val zero: E

    abstract inner class AbstractFieldElement<E: AbstractFieldElement<E>> {
        abstract operator fun plus(other: E): E
    }
}

// Implementation
class Fp(val prime: Int): AbstractField<Fp, Fp.EFp>() {
    override val zero = EFp(0)

    inner class EFp(val value: Int): AbstractFieldElement<EFp>() {
        override operator fun plus(other: EFp): EFp =
            EFp((value + other.value) % prime)

        override fun toString(): String =
            "$value (mod $prime)"
    }
}

fun main() {
    val field = Fp(13)
    val e1 = field.EFp(8)
    val e2 = field.EFp(10)
    println("$e1 + $e2 = ${e1 + e2}")
}

核心编译报错 #

org.jetbrains.kotlin.backend.common.BackendException: Backend Internal error: Exception during IR lowering
...
Caused by: java.lang.AssertionError: -2 trailing arguments were found in this type: org.example.AbstractField.AbstractFieldElement<*>

解决建议 #

这个错误源于抽象类泛型参数的循环依赖搭配内部类的泛型绑定，导致Kotlin编译器IR后端无法正确解析类型关系。在不拆分内部类的前提下，可通过以下两种方式修复：

方案1：简化AbstractFieldElement的泛型参数 #

去掉AbstractFieldElement自身的泛型参数，让它直接使用外部类AbstractField绑定的E类型，降低编译器解析复杂度：

abstract class AbstractField<F : AbstractField<F, E>, E : AbstractField<F, E>.AbstractFieldElement> {
    abstract val zero: E

    abstract inner class AbstractFieldElement {
        abstract operator fun plus(other: E): E
    }
}

// Implementation
class Fp(val prime: Int) : AbstractField<Fp, Fp.EFp>() {
    override val zero = EFp(0)

    inner class EFp(val value: Int) : AbstractFieldElement() {
        override operator fun plus(other: EFp): EFp =
            EFp((value + other.value) % prime)

        override fun toString(): String =
            "$value (mod $prime)"
    }
}

方案2：调整泛型参数绑定逻辑 #

如果需要保留AbstractFieldElement的泛型，可修改类型参数约束，让它指向外部类的具体实现，避免循环依赖：

abstract class AbstractField<F : AbstractField<F, E>, E : AbstractFieldElement<F, E>> {
    abstract val zero: E

    abstract inner class AbstractFieldElement<F : AbstractField<F, E>, E : AbstractFieldElement<F, E>> {
        abstract operator fun plus(other: E): E
    }
}

// Implementation
class Fp(val prime: Int) : AbstractField<Fp, Fp.EFp>() {
    override val zero = EFp(0)

    inner class EFp(val value: Int) : AbstractFieldElement<Fp, EFp>() {
        override operator fun plus(other: EFp): EFp =
            EFp((value + other.value) % prime)

        override fun toString(): String =
            "$value (mod $prime)"
    }
}

两种方案都能修复IR后端错误，同时保持域与域元素的紧密耦合，满足后续扩展域的需求。

内容的提问来源于stack exchange，提问作者Sebastian