Add KEEP for sealed inline classes

[ilmirus]

No description provided.

[fvasco]

typo: decraled

[fvasco]

typo: identitiless

[fvasco]

typo: selaed

[fvasco]

typo: Integet

[fvasco]

typo: rulues

[fvasco]

typo: decrared

[fvasco]

synthetic has been used inconsistently in the examples.
See the following lines or the definition of the $value property.

[fvasco]

Is this a Kotlin property?

We should expect on JVM?

private Object $value
public Object get$value()

[elizarov]

Please, create an issue for discussion.

[udalov]

#318

[elizarov]

We should have a separate design discussion on whether we shall deprecate Result.success and Result.failure in favor or Result.Success and Result.Failure constructors. Please, add it to open issues.

[elizarov]

It is better to replace "we can use Number" with "we could have used Number" to let a reader understand what's the actual design we are going with and what is just a digression on other potential alternatives we have considered in the design.

[udalov]

This example does not compile because sealed inline class child cannot be distinguished from another one

[udalov]

The proposal doesn't explain what a "value object" is and when it's allowed

[grechkovlad]

is case of - typo?

[grechkovlad]

Shouldn't be value object instead of sealed object here?

[MairwunNx]

The proposed design solves the Result case (and it's probably the only case) but there are some caveats:

• amongst classes with the same underlying type, only one can be inline,
• primitive wrappers or any control over the underlying value type are absolutely destroyed.

Consider the following example with different design:

@JvmInline
sealed value class Color protected constructor(val value: Long) {
    @JvmInline
    value class Fixed(color: Int) : Color(color.toLong() and 0xFFFFFFFFL) {
        val color: Int get() = value.toInt()
        override fun toString(): String = "Color.Fixed(#%08X)".format(color)
    }

    @JvmInline
    value class Resource(@ColorRes colorRes: Int) : Color((1L shl 32) or (colorRes.toLong() and 0xFFFFFFFFL)) {
        val resId: Int @ColorRes get() = value.toInt()
        override fun toString(): String = "Color.Resource(0x${resId.toString(16)})"
    }

    operator fun getClass(): KClass<out Color> = when (value ushr 32) {
        0L -> Fixed::class
        1L -> Resource::class
        else -> throw AssertionError()
    }
}

Probable desugaring:

@JvmInline
sealed value class Color {
    static fun constructor-impl(value: Long): Long = value

    @JvmInline
    value class Fixed {
        static fun constructor-impl(color: Int): Long {
            val expressionPassedToSuper = color.toLong() and 0xFFFFFFFFL
            val value = Color.constructor-impl(expressionPassedToSuper)
            Intrinsics.requireConsistentInlineCtor(Fixed::class, Color.getClass(value))
            return value
        }
        // val color ...
        // fun toString() ...
    }

    @JvmInline
    value class Resource { /* contents identical */ }

    // static fun getClass() ...

    // proxies for 'overridden' functions
    static fun toString-impl(value: Long) = when (getClass(value)) {
        Fixed::class -> Fixed.toString-impl(value)
        Resource::class -> Resource.toString-impl(value)
        else -> throw NoWhenBranchMatchedException()
    }
    static fun hashCode-impl(value: Long) { /* either `when (getClass()) {}` or default value.hashCode() */ }
    static fun equals-impl(value: Long, other: Long) { /* either `when (getClass()) {}` or default value.equals(other) */ }
}

Probable emulation on top of current Kotlin:

@JvmInline
value class Color(val value: Long) {
    @JvmInline
    value class Fixed @PublishedApi internal constructor(val value: Long) {
        constructor(color: Int) : this(color.toLong() and 0xFFFFFFFFL)
        val color: Int get() = value.toInt()
        override fun toString(): String = "Color.Fixed(#%08X)".format(color)
        fun upcast() = Color(value)
    }

    @JvmInline
    value class Resource @PublishedApi internal constructor(val value: Long) {
        constructor(@ColorRes colorRes: Int) : this((1L shl 32) or (colorRes.toLong() and 0xFFFFFFFFL))
        val resId: Int @ColorRes get() = value.toInt()
        override fun toString(): String = "Color.Resource(0x${resId.toString(16)})"
        fun upcast() = Color(value)
    }

    inline fun <R> switch(
        fixed: (Fixed) -> R,
        resource: (Resource) -> R,
    ): R = when (value ushr 32) {
        0L -> fixed(Fixed(value))
        1L -> resource(Resource(value))
        else -> throw AssertionError()
    }

    fun asFixed(): Fixed =
        if ((value ushr 32) == 0L) Fixed(value) else throw TypeCastException()

    fun safeAsFixed(): Fixed? =
        if ((value ushr 32) == 0L) Fixed(value) else null

    fun asResource(): Resource =
        if ((value ushr 32) == 1L) Resource(value) else throw TypeCastException()

    fun safeAsResource(): Resource? =
        if ((value ushr 32) == 1L) Resource(value) else null
}