public val BOOLEAN: KaType
        get() = boolean

    public abstract val char: KaType

    @Deprecated("Use 'char' instead.", replaceWith = ReplaceWith("char"))
    public val CHAR: KaType
        get() = char

    public abstract val string: KaType

    @Deprecated("Use 'string' instead.", replaceWith = ReplaceWith("string"))

            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)

private
val primitiveTypeStrings =
    mapOf(
        "java.lang.Object" to "Any",
        "java.lang.String" to "String",
        "java.lang.Character" to "Char",
        "char" to "Char",
        "java.lang.Boolean" to "Boolean",
        "boolean" to "Boolean",
        "java.lang.Byte" to "Byte",
        "byte" to "Byte",
        "java.lang.Short" to "Short",

        override fun renderAsKotlinConstant(): String = value.toString()
    }

    public class KaCharConstantValue(
        override val value: Char,
        override val sourcePsi: KtElement?
    ) : KaConstantValue(ConstantValueKind.Char) {
        override fun renderAsKotlinConstant(): String = "`$value`"
    }

    public class KaByteConstantValue(
        override val value: Byte,

        null -> KaConstantValue.KaNullConstantValue(expression)
        is Boolean -> KaConstantValue.KaBooleanConstantValue(value, expression)
        is Char -> KaConstantValue.KaCharConstantValue(value, expression)
        is Byte -> KaConstantValue.KaByteConstantValue(value, expression)
        is UByte -> KaConstantValue.KaUnsignedByteConstantValue(value, expression)

    public val KaType.isDouble: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.DOUBLE) }
    public val KaType.isChar: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.CHAR) }
    public val KaType.isBoolean: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.BOOLEAN) }

    }.associateWith { it.correspondingArrayOfCallFqName() }

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

    }

    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

     * @throws XMLStreamException XMLStreamException if
     * any.
     * @return char
     */
    private char getCharacterValue(String s, String attribute, XMLStreamReader parser)
        throws XMLStreamException {
        if (s != null) {
            return s.charAt(0);
        }
        return 0;
    } //-- char getCharacterValue(String, String, XMLStreamReader)

    /**
     * Method getDateValue.

    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)