DataType.IntDataType::class,
    DataType.LongDataType::class,
    DataType.StringDataType::class,
    DataType.BooleanDataType::class,
    DataClass::class
])
sealed interface DataType : Serializable {

    @ToolingModelContract(subTypes = [
        IntDataType::class,
        LongDataType::class,
        StringDataType::class,
        BooleanDataType::class,
    ])

    is DataType.BooleanDataType -> right is DataType.BooleanDataType
    is DataType.IntDataType -> right is DataType.IntDataType
    is DataType.LongDataType -> right is DataType.LongDataType
    is DataType.StringDataType -> right is DataType.StringDataType
    is DataType.NullType -> right is DataType.NullType
    is DataType.UnitType -> right is DataType.UnitType
}


internal

    val type: DataType.ConstantType<T>

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

    data class IntLiteral(
        override val value: Int,
        override val sourceData: SourceData
    ) : Literal<Int> {

        )
        val error = result.errors.singleOrNull()
        assertNotNull(error)
        val reason = error.errorReason
        assertIs<ErrorReason.AssignmentTypeMismatch>(reason)
        assertIs<DataType.StringDataType>(reason.expected)
        assertIs<DataType.IntDataType>(reason.actual)
    }

        private
        fun readResolve(): Any = DefaultLongDataType
    }

    @Serializable
    @SerialName("string")
    data object DefaultStringDataType : DataType.StringDataType {
        override val constantType: Class<String> = String::class.java
        override fun toString(): String = "String"
        private
        fun readResolve(): Any = DefaultStringDataType
    }

        fun indent() = "    ".repeat(depth)
        fun nextIndent() = "    ".repeat(depth + 1)
        when (current) {
            is ObjectReflection.ConstantValue -> append(
                if (current.type is DataType.StringDataType)
                    "\"${current.value}\""
                else current.value.toString()
            )
            is ObjectReflection.DataObjectReflection -> {