Support for inline classes

[jnizet]

Kotlin 1.3 has experimental inline classes.

When wrapping a primitive type, an inline class instance is just compiled to the primitive type, making the code very efficient, whie still keeping it typesafe and preventing for example to sum Watts with Volts.

When the inline class instance is nullable, a wrapper class is used (just like java.lang.Integer is used to represent a nullable Int).

Unfortunately, inline classes don't follow the same rules as standard wrapper classes. Example:

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

inline class Watt(val value: Long)

data class Foo(val nonNullable: Watt, val nullable: Watt?, val otherNullable: Watt?)
data class Bar(val nonNullable: Long, val nullable: Long?, val otherNullable: Long?)

fun main() {
    val foo = Foo(Watt(1000), Watt(2000), null)
    val bar = Bar(1000, 2000, null)

    val objectMapper = ObjectMapper().registerModule(KotlinModule())

    println("With Watt: ${objectMapper.writeValueAsString(foo)}")
    println("With Long: ${objectMapper.writeValueAsString(bar)}")
}

The output of this program is:

With Watt: {"nonNullable":1000,"nullable":{"value":2000},"otherNullable":null}
With Long: {"nonNullable":1000,"nullable":2000,"otherNullable":null}

It would be really nice if the first output was identical to the second one, and of course if unmarshalling worked too.

[TjeuKayim]

I use this workaround to read and write inline classes.
The box-impl method boxes the value, so it can be used as JsonCreator.
https://github.com/Kotlin/KEEP/blob/master/proposals/inline-classes.md#inline-classes-abi-jvm

inline class Watt(@JsonValue val value: Long)

@Test
fun `Read and write inline classes with Jackson`() {
  val mapper = ObjectMapper().registerModule(KotlinModule()).registerModule(InlineModule)
  val watt = Watt(1234)
  val json = mapper.writeValueAsString(watt)
  assertEquals("1234", json)
  val result = mapper.readValue<Watt>(json)
  assertEquals(watt, result)
}

object InlineModule : SimpleModule("Inline") {
  override fun setupModule(context: SetupContext) {
    super.setupModule(context)
    context.appendAnnotationIntrospector(KotlinNamesAnnotationIntrospector)
  }

  object InlineAnnotationIntrospector : NopAnnotationIntrospector() {
    override fun findCreatorAnnotation(config: MapperConfig<*>, a: Annotated): JsonCreator.Mode? {
      if (a is AnnotatedMethod && a.name == "box-impl") {
        return JsonCreator.Mode.DEFAULT
      }
      return null
    }
  }
}

[kostya05983]

@TjeuKayim, is serialization working with inline classes now?

[TjeuKayim]

I tried building the latest master branch, however the build fails.

Instead I used 7bfb771.
I ran these unit-tests, and they all failed.

So inline classes are still not working in the latest release.

[cowtowncoder]

Please do not use master as that is for 3.0.0 (and still has couple of issues) -- code for 2.10 is in 2.10 branch (for patches to 2.10), and 2.11 is for developing next 2.x minor version.

[apatrida]

This would have to be studied to see how an inline class would be detected safely and without fail, I'm not sure if just the naming convention of the static constructor is clear enough. Maybe if detecting is Kotlin class, plus that naming convention, and a pattern of other methods maybe.

[apatrida]

I think this would be a pretty messy fix, but is worth looking into. @TjeuKayim did you abandon that PR completely?

[TjeuKayim]

Unfortunately, I can't spend more time on this, and currently I'm not using Kotlin for any project.
There has to be changed a lot: TjeuKayim/jackson-module-kotlin@master...TjeuKayim:class-descriptor-reflection.
I just found out that reflection functionality has improved since Kotlin 1.3.20 (https://github.com/Kotlin/KEEP/blob/master/proposals/inline-classes.md#reflection).

[TjeuKayim]

This would have to be studied to see how an inline class would be detected safely @apatrida

I used kotlin.reflect.jvm.internal.impl.descriptorsClassDescriptor.isInline, but this is an internal API.

[StephenOTT]

Has there been any updates to this? Or workaround code samples?
@TjeuKayim, do you have any compartmentalized samples?

[TjeuKayim]

No, I don't have any updates. The last few months I have not used Kotlin. For a workaround I refer to my comment above #199 (comment).

[StephenOTT]

@TjeuKayim thanks. The greater issue i have found is: #187. Once using the inline within a class, then it seems to fall apart on deserialization.

[efenderbosch]

Found a decent workaround today. Use @JsonDeserialize(builder = BuilderForYourRealClass::class)

Where BuilderForYourRealClass has "with" functions, one for each argument. The key is that you need a "with" method for the wrapped class. For example if I have an inline class MyInlineClass that simply wraps a String then the builder needs a function that accepts a String and creates an instance of MyInlineClass in the build function. Like this:

@JsonDeserialize(builder = MyClassThatUsesAnInlineClassBuilder::class)
data class MyClassThatUsesAnInlineClass(val foo: String, val bar: MyInlineClass)

class MyClassThatUsesAnInlineClassBuilder {
    lateinit var foo: String
    lateinit var bar: String
    fun withFoo(foo: String) = apply { this.foo = foo }
    fun withBar(bar: String) = apply { this.bar = bar }
    fun build() = MyClassThatUsesAnInlineClass(foo, MyInlineClass(bar))
}