Ktor泛型路由触发编译器IR降低内部错误，求动态路由创建方案

我尝试基于开发者定义的数据类模型创建动态服务，通过registerDataModels()方法调用appDataModule()，实现自动在路由服务中生成所有基础方法。但使用泛型实现该逻辑时，触发了编译器错误。请问是否有更优方案，可通过定义数据类自动创建路由服务？

错误信息 #

org.jetbrains.kotlin.backend.common.BackendException: Backend Internal error: Exception during IR lowering
File being compiled: */api/AppConfigService.kt
The root cause java.lang.RuntimeException was thrown at: org.jetbrains.kotlin.backend.jvm.codegen.FunctionCodegen.generate(FunctionCodegen.kt:47)

File is unknown
The root cause java.lang.AssertionError was thrown at: org.jetbrains.kotlin.codegen.coroutines.CoroutineTransformerMethodVisitor.spillVariables(CoroutineTransformerMethodVisitor.kt:636)

相关代码 #

fun Application.registerDataModels() {
  appDataModule<M1>()
  appDataModule<M2>()
  appDataModule<M3>()
}

inline fun <reified T: DBModel> Application.appDataModule() {
  routing {
    createAppData<T>()
    updateAppData<T>()
    deleteAppData<T>()
  }
}

inline fun <reified T: DBModel> Route.createAppData() {
  put("/api/data/${getName<T>()}/create") {
    authenticated {
      create<T>{}
    }
  }
}

inline fun <reified T: DBModel> Route.updateAppData() {
  put("/api/data/${getName<T>()}/update") {
    authenticated {
      update<T>{}
    }
  }
}

inline fun <reified T: DBModel> Route.deleteAppData() {
  put("/api/data/${getName<T>()}/delete") {
    authenticated {
      delete<T>{}
    }
  }
}

方案1：移除嵌套inline函数，改用类实现路由注册 #

编译器错误核心原因是嵌套inline函数与Ktor协程路由的IR编译逻辑冲突，改用类封装路由注册逻辑可彻底规避：

// 基础路由注册抽象类
abstract class DataRouteRegistrar<T : DBModel>(private val modelName: String) {
    fun register(route: Route) {
        route.apply {
            put("/api/data/$modelName/create") {
                authenticated {
                    create<T>{}
                }
            }
            put("/api/data/$modelName/update") {
                authenticated {
                    update<T>{}
                }
            }
            put("/api/data/$modelName/delete") {
                authenticated {
                    delete<T>{}
                }
            }
        }
    }
}

// 为每个数据类实现具体注册器
class M1RouteRegistrar : DataRouteRegistrar<M1>(getName<M1>())
class M2RouteRegistrar : DataRouteRegistrar<M2>(getName<M2>())
class M3RouteRegistrar : DataRouteRegistrar<M3>(getName<M3>())

// 统一注册入口
fun Application.registerDataModels() {
    routing {
        M1RouteRegistrar().register(this)
        M2RouteRegistrar().register(this)
        M3RouteRegistrar().register(this)
    }
}

方案2：用反射替代inline reified，简化注册逻辑 #

如果想保留简洁的调用方式，可通过反射获取数据类信息，避免过度依赖inline泛型：

// 反射获取模型名称
fun <T : DBModel> getModelName(clazz: Class<T>): String {
    return clazz.simpleName.lowercase()
}

// 单个模型路由注册方法
fun <T : DBModel> Application.registerDataModel(clazz: Class<T>) {
    val modelName = getModelName(clazz)
    routing {
        put("/api/data/$modelName/create") {
            authenticated {
                createByClass(clazz) // 需封装基于Class的create实现
            }
        }
        put("/api/data/$modelName/update") {
            authenticated {
                updateByClass(clazz) // 同理封装update
            }
        }
        put("/api/data/$modelName/delete") {
            authenticated {
                deleteByClass(clazz) // 同理封装delete
            }
        }
    }
}

// 批量注册
fun Application.registerDataModels() {
    registerDataModel(M1::class.java)
    registerDataModel(M2::class.java)
    registerDataModel(M3::class.java)
}

方案3：编译时注解处理器（APT）生成路由代码 #

这是性能最优的方案，通过编译时自动生成路由代码，完全避免运行时泛型/反射开销：

1. 定义注解：

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class GenerateDataRoute

2. 给数据类添加注解：

@GenerateDataRoute
data class M1(/* 字段定义 */) : DBModel

@GenerateDataRoute
data class M2(/* 字段定义 */) : DBModel

3. 编写APT处理器，编译时为每个带注解的类生成路由代码，例如生成M1Route.kt：

fun Route.registerM1Routes() {
    put("/api/data/m1/create") {
        authenticated {
            create<M1>{}
        }
    }
    put("/api/data/m1/update") {
        authenticated {
            update<M1>{}
        }
    }
    put("/api/data/m1/delete") {
        authenticated {
            delete<M1>{}
        }
    }
}

4. 统一注册：

fun Application.registerDataModels() {
    routing {
        registerM1Routes()
        registerM2Routes()
        // 其他模型路由
    }
}

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