ConstantValueKind.Boolean -> KaConstantValue.KaBooleanConstantValue(value as Boolean, psi)
            ConstantValueKind.Char -> KaConstantValue.KaCharConstantValue(value as Char, psi)
            ConstantValueKind.String -> KaConstantValue.KaStringConstantValue(value as String, psi)
            ConstantValueKind.Null -> KaConstantValue.KaNullConstantValue(psi)

    override val float: KaType by cachedBuiltin(builtinTypes.floatType)
    override val double: KaType by cachedBuiltin(builtinTypes.doubleType)

    override val char: KaType by cachedBuiltin(builtinTypes.charType)
    override val boolean: KaType by cachedBuiltin(builtinTypes.booleanType)
    override val string: KaType by cachedBuiltin(builtinTypes.stringType)

    }

    private fun String.sanitizeName(): String =
        lowercase()
            .split('_')
            .joinToString(separator = "") {
                it.replaceFirstChar(Char::uppercaseChar)
            }

}

internal object FirToKtConversionCreator {
    fun createConversion(type: KType): HLParameterConversion {
        val nullable = type.isMarkedNullable

- [`KT-64867`](https://youtrack.jetbrains.com/issue/KT-64867) K2 JS: Name clash between constructors with same JsName but in different classes
- [`KT-64463`](https://youtrack.jetbrains.com/issue/KT-64463) KJS / K2: "Name contains illegal chars that cannot appear in JavaScript identifier" caused by non-ASCII character
- [`KT-64451`](https://youtrack.jetbrains.com/issue/KT-64451) K2: Implement MultiModuleOrderTestGenerated for K2

    }.associateWith { it.correspondingArrayOfCallFqName() }

    private fun ClassId.correspondingArrayOfCallFqName(): Name =
        Name.identifier("${shortClassName.identifier.replaceFirstChar(Char::lowercaseChar)}Of")

            // In most cases, we can get the callee name from the callee's candidate symbols. However, there is at least one case where we
            // cannot do so:
            // ```
            // fun x(c: Char) {}
            // fun call(x: kotlin.Int) {
            //   operator fun Int.invoke(a: Int) {}
            //   operator fun Int.invoke(b: Boolean) {}
            //   <expr>x()</expr>
            // }

            type.isBoolean -> KaConstantValue.KaBooleanConstantValue(value as Boolean, expression)
            type.isChar -> KaConstantValue.KaCharConstantValue((value as? Char) ?: (value as Number).toInt().toChar(), expression)
            type.isByte -> KaConstantValue.KaByteConstantValue((value as Number).toByte(), expression)

    override val boolean: KaType
        get() = withValidityAssertion { analysisContext.builtIns.booleanType.toKtType(analysisContext) }

    override val char: KaType
        get() = withValidityAssertion { analysisContext.builtIns.charType.toKtType(analysisContext) }

    override val string: KaType