static final $constantType STATIC_FINAL_FIELD = Constant4.CONSTANT4 $addition;
    static final $constantType STATIC_FINAL_FIELD_2;
    private final $constantType finalField = Constant5.CONSTANT5 $addition;
    private $constantType fieldDecleration = Constant6.CONSTANT6 $addition;
    static {

        BooleanDataType::class,
    ])
    sealed interface ConstantType<JvmType> : DataType {
        val constantType: Class<*>
    }

    interface IntDataType : ConstantType<Int>
    interface LongDataType : ConstantType<Long>
    interface StringDataType : ConstantType<String>
    interface BooleanDataType : ConstantType<Boolean>

    // TODO: implement nulls?
    interface NullType : DataType

        override val constantType: Class<Int> = Int::class.java
        override fun toString(): String = "Int"
        private
        fun readResolve(): Any = DefaultIntDataType
    }

    @Serializable
    @SerialName("long")
    data object DefaultLongDataType : DataType.LongDataType {
        override val constantType: Class<Long> = Long::class.java

        source api: ["class A {}", "class B { final static $constantType x = $constantValue; }"], impl: ["class X { $constantType foo() { return B.x; }}", "class Y {int foo() { return -2; }}"]
        impl.snapshot { run language.compileTaskName }

        when:
        source api: ["class B { final static $constantType x = $newValue; }"]

        val customAccessorObjects: List<ObjectReflection>,
        val lambdaAccessedObjects: List<ObjectReflection>
    ) : ObjectReflection

    data class ConstantValue(
        override val type: DataType.ConstantType<*>,
        override val objectOrigin: ObjectOrigin.ConstantOrigin,
        val value: Any
    ) : ObjectReflection

    data class External(
        override val type: DataType,

    override val token: KaLifetimeToken,
) : KaLifetimeOwner {
    public enum class KaContractConstantType {
        NULL, TRUE, FALSE;
    }

    public val constantType: KaContractConstantType get() = withValidityAssertion { backingConstantType }

    override fun equals(other: Any?): Boolean {

data class LocalValue(val name: String, val rhs: Expr, override val sourceData: SourceData) : DataStatement


sealed interface Literal<T : Any> : Expr {
    val value: T
    val type: DataType.ConstantType<T>

    data class StringLiteral(
        override val value: String,
        override val sourceData: SourceData
    ) : Literal<String> {
        override val type: DataType.StringDataType

        }
    }

private fun Context.renderKaContractConstantValue(value: KaContractConstantValue, endWithNewLine: Boolean = true): Unit =
    printer.appendHeader(value::class) {
        appendSimpleProperty(value::constantType, endWithNewLine)
    }

private fun Context.renderKaContractParameterValue(value: KaContractParameterValue, endWithNewLine: Boolean = true): Unit =
    printer.appendHeader(value::class) {

    analysisContext: Fe10AnalysisContext,
): List<KaAnnotationValue> = flatMap { constantValue: ConstantValue<*> ->
    val constantType = constantValue.getType(analysisContext.resolveSession.moduleDescriptor)
    if (analysisContext.builtIns.areSameArrayTypeIgnoringProjections(containingArrayType, constantType)) {
        // If an element in the array has the same type as the containing array, it's a spread component that needs