Deserializing object declarations does not preserve identity

When serializing and unserializing an object declaration, the resulting instance has a different identity than the original one, resulting in the objects being considered non-equal. For example:

import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.registerKotlinModule

fun main(vararg args: String) {
    val mapper = ObjectMapper().registerKotlinModule()

    val successPre = Success(42)
    val successJson = mapper.writeValueAsString(successPre)
    val successPost = mapper.readValue(successJson, Success::class.java)

    println(successPre == successPost) // Prints true

    val failurePre = Failure
    val json = mapper.writeValueAsString(failurePre)
    val failurePost = mapper.readValue(json, Failure::class.java)

    println(failurePre == failurePost) // Prints false
}

object Failure

data class Success(val foo: Int)

I would expect Jackson to return the one and only singleton instance that Kotlin created for the object and have behaviour similar to data classes.

---

You might wonder why I’d try to JSON serialize an object declaration. My use case is dealing with polymorphism having a sealed class with 2 implementation; one is a data class and the other is an object, like this:

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes(
    JsonSubTypes.Type(value = Purpose.StockOnHand::class, name = "stockOnHand"),
    JsonSubTypes.Type(value = Purpose.Fulfillment::class, name = "fulfillment")
)
sealed class Purpose {
    object StockOnHand : Purpose()
    data class Fulfillment(val channel: String) : Purpose()
}

which translates to JSON like

{"type": "stockOnHand"}

or

{"type": "fulfillment", "channel": "foo"}

[Gama11]

It looks like this has actually been fixed in the meantime (see #225). Apparently there were some issues with it though (see #281) which led to it being an opt-in:

.registerModule(KotlinModule(singletonSupport = SingletonSupport.CANONICALIZE))

[MikeRippon]

I also have this problem.

@EdeMeijer I think provided you don’t mind having Jackson annotations in your code, this is a little cleaner/safer as it maintains the contract of there only ever being a single instance, rather than allowing Jackson to create multiple instances and hacking around equals.

sealed class Purpose {
    object StockOnHand : Purpose() {
        @JvmStatic @JsonCreator fun deserialize() = StockOnHand
    }
    data class Fulfillment(val channel: String) : Purpose()
}