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)

    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) }

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",

    require(lineNumber >= 1) { "Line numbers are 1-based" }
    return fragment(identifier, body, prefix = String(repeat('\n', lineNumber - 1)))
}


private
fun repeat(char: Char, times: Int) =
    CharArray(times).also { fill(it, char) }


internal
fun fragment(identifier: String, body: String, prefix: String = ""): ProgramSourceFragment {

    }

    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

        }
    }

    private
    fun boundOf(wildcard: Char) =
        when (wildcard) {
            '+' -> Variance.COVARIANT
            '-' -> Variance.CONTRAVARIANT
            else -> Variance.INVARIANT
        }
}


private
fun binaryNameOfBaseType(descriptor: Char) =
    Type.getType(descriptor.toString()).className


private

        buffer.takeIf(StringBuilder::isNotEmpty)?.toString()?.let {
            if (it in primitiveKotlinTypeNames) null
            else it
        }

    typeString.forEach { char ->
        when (char) {
            '<' -> {
                nonPrimitiveKotlinType()?.also { all.add(it) }
                buffer = StringBuilder()
            }

            in " ,>" -> {

     * @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.

            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)