Hello 👋 Any suggestions on how one would go around debugging

org.jetbrains.kotlin.util.KotlinFrontEndException: Front-end Internal error: Failed to analyze declaration Variables
File being compiled: (35,3) in <Foo.kt>
The root cause java.lang.AssertionError was thrown at: org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor.getModality(LazyClassDescriptor.java:564)
...
Caused by: java.lang.AssertionError: Recursion detected in a lazy value under LockBasedStorageManager@2f5a443e (TopDownAnalyzer for JVM)

Hi there! Facing troubles with Serialization… Could someone explain me what’s wrong and what I need to do? Using serialization 1.6.10…

sealed interface Convertible {

    fun convertUserInput(value : String): String
}


@Serializable
@SerialName("CustomConvertible")
class CustomConvertible(): Convertible {


    override fun convertUserInput(value : String): String {
       return ""
    }
}


@Serializable
class DTOAttribute(val convertibles         : List<Convertible>   = emptyList())

Later on, I’d like to encode the

DTOAttribute

with

val string = Json.encodeToString(dtoAttr)

Calling this, gives me the following exception:

kotlinx.serialization.SerializationException: Class 'CustomConvertible' is not registered for polymorphic serialization in the scope of 'Convertible'.
Mark the base class as 'sealed' or register the serializer explicitly.

What am I doing wrong?

Hi, could someone explain to me why I'm still getting "kotlinx.serialization.SerializationException: Serializer for class 'Project' is not found. Mark the class as @Serializable or provide the serializer explicitly." even if the class is annoted, literally using the 2 line example from https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/basic-serialization.md#json-decoding

Is it possible to deserialize only a fragment of the Json response?. For example, if I have a Json response like this:

{
  "responseHeader": {
    "a": 0,
    "b": 407,
    "c": {
         ....
    }
  },
  "response": {
    "numFound": 2,
    "start": 0,
    "docs": [
      {
        "foo": "foo",
        "bar": "bar"
      },
      {
        "foo": "foo",
        "bar": "bar"
      }
    ]
  },
  "unimportant": {
    "unimportant": []
  }
}

I'm interested only in the

response

part, so, Instead of deserializing the entire response, I want to just deserialize this part. is this possible with kotlinx.serialization? Of course I can deserialize the whole response & get rid of the irrelevant parts on the client side, but this would be a waste of time. So, it would be nice if there is a built-in way to do this.

I am at a loss trying to configure serialization of generics. I have a pretty simple setup:

import kotlinx.serialization.*
import kotlinx.serialization.json.Json

@Serializable
sealed class ApiResponse<T> {
    @Serializable
    @SerialName("result")
    data class Ok<T>(val result: T) : ApiResponse<T>()

    @Serializable
    @SerialName("error")
    data class Error<T>(val error: ErrorResponse) : ApiResponse<T>()
}

@Serializable
data class VersionResponse(val version: String)

@Serializable
data class ErrorResponse(val description: String)

fun main() {
    val data: ApiResponse<VersionResponse> = ApiResponse.Ok(VersionResponse("v42"))
    println(Json.encodeToString(data)) // prints {"type":"result","result":{"version":"v42"}}
}

The last line mentions the result I want to achieve:

ApiResponse

is discriminated using

type

, and the

result

field is just serialized as it is. However, running this with Kotlin 1.7.10 and kotlinx.serialization 1.3.3 (json jvm) produces this error:

Exception in thread "main" kotlinx.serialization.SerializationException: Class 'VersionResponse' is not registered for polymorphic serialization in the scope of 'Any'.
Mark the base class as 'sealed' or register the serializer explicitly.
	at kotlinx.serialization.internal.AbstractPolymorphicSerializerKt.throwSubtypeNotRegistered(AbstractPolymorphicSerializer.kt:102)

Could you please help figuring this out? I tried in many ways to configure polymorphic serialization, but none of them worked.

bump https://kotlinlang.slack.com/archives/C7A1U5PTM/p1658261294261379?thread_ts=1658261294.261379&cid=C7A1U5PTM

I want to port the custom serializer at https://github.com/Vampire/setup-wsl/blob/master/buildSrc/src/main/kotlin/net/kautler/dao/GitHubAction.kt#L73 that still runs on 0.20.0 to 1.3.x. I there have used

override val descriptor = SerialDescriptor("...", CONTEXTUAL)

for the

KSerializer

. How would I port that to 1.3.x as the function does not expect a kind anymore?

We're currently using Serialization (1.3.2, but trying 1.3.3 and 1.4 now) for serializing some very simple objects into JSON (they're basically Android navigation holders). We use these classes a lot. They're used for all navigation calls in our Android app, and get serialized at each

navigate()

, therefore performance is important. Most of these

Args

classes we have are

@Serializable object MyScreenArgs: ArgsInterface

, and some are data classes if they contain some inner values. We've seen that creating a

serializer()

for the

object

classes is extremely slow:

7,137ns   benchmarkDataClassContentViewArgsToBundle
69,204ns  benchmarkObjectContentViewArgsToBundle
5,301ns   benchmarkDataClassBundleToContentViewArgs
67,981ns  benchmarkObjectBundleToContentViewArgs

(tests using AndroidX Microbenchmark on a Google Pixel 1) It doesn't matter if we use the reflection or non-reflection versions of

serializer()

, they're both very similar in terms of time. In fact, the generated serializer is usually slightly slower to retrieve for some reason. I've profiled our tests, and 90% of the time is spent retrieving the

serializer()

, the conversion to/from JSON is around 3ms for all benchmarks. Anyone know why the object serializer could be so slow?

Hey! Just wonder if someone could help with this issue: https://youtrack.jetbrains.com/issue/KT-53437/External-serializer-does-not-work-properly-with-multiple-modules My friend stuck with it 😢

Hey folks, is it possible to make a custom (de-) serializer (

KSerializer

) configurable? Specifically I'm looking for a way to make a serializer for

BigDecimal

configurable regarding the scale of the

BigDecimal

. Contextual serialization doesn't seem to be a fit because it would only work per class and not per field, right?

Bonjour, please tell me why my bad idea is indeed bad So I am doing lots of SQL and to decouple sql entities from domain classes, I have to write tons of dummy mappers from say

UserProfileEntity

(sql) to

UserProfile

who have the same properties And I'm bored to write those mappers manually In the .Net world, there is http://automapper.org/ for that I wonder I could just leverage

kotlinx.serialization

to transform

UserProfileEntity

to

JsonElement

and back to

UserProfile

Hi there! I am running into a Jackson issue with sealed classes. I have the following code:

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
sealed class Principal
object AnonymousUser : Principal() {
  val _empty: String? = null
}

// other implementations of Principal

fun main() {
  // jacksonObjectMapper() is a function in jackson which creates an object mapper with the Kotlin module
  val input = jacksonObjectMapper().writeValueAsString(AnonymousUser)
  val principal = jacksonObjectMapper().readValue(input, Principal::class.java)
  println(principal)
}

This gives me the following error:

Exception in thread "main" com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "_empty" (class com.example.hellojavabin.graphql.context.Principal$AnonymousUser), not marked as ignorable (0 known properties: ])
 at [Source: (String)"{"@type":"Principal$AnonymousUser","_empty":null}"; line: 1, column: 49] (through reference chain: com.example.hellojavabin.graphql.context.Principal$AnonymousUser["_empty"])

What am I missing here? I also tried casting the input string directly to

AnonymousUser

but that fails with the same issue. Has anyone done something similar?

Hi is there a "default" serializer for

kotlin.Throwable

? and while i am here (Asking fro help) how do i resolved this duplicate name issue ?

Why isn't Nothing Serializable by default? did the serialization team miss a use case for it? or where there ambiguations that led to it being stalled??

Is there a way to create a

JSONTransformingSerializer

to replace all keys with a

snake_case

instead of a

camelCase

that works for any data class ?

How can I make a deserializer for the json shown in the screenshot?

What is the benefit of using the

Serializer

annotation?

I just discovered the kotlinx.serialization library and it seems to work very well and I can use it as a substitute for jackson, I wanted to do a little performance test and if I use it as the documentation says

val foo = Json.decodeFromString<Project>(string)

I see that the performance drops much more than others like jackson and GSON. instead, if I instantiate the serializer and then reuse it, the performance works much better,

val serializer = serializer(typeOf<Project>()) as KSerializer<Project>

val foo = Json.decodeFromString(serializer, string)

Is there a problem with doing it this way? more details in https://github.com/jcaromiq/serde-benchmark

I have a class structure roughly like:

sealed class MessagePayload ...

data class PayloadOne(val foo: String) : MessagePayload ...

class Message(val msgType: MessageType, val payload: MessagePayload) { ... }

and I was hoping to get it to serialize as:

{
  "msgType": "payloadOne",
  "payload": {
    "foo": "..."
  }
}

that is: have the discriminant for the 'payload' field actually be at a layer "above", is that possible via just annotations? or would it require custom serializer/deserializer?

In

JsonContentPolymorphicSerializer

can I skip serializing an element? So if I dont have any serializers I can just skip it and it wont be included in the list

I have a class

data class(val foo: String, ...)

and in one context I need field

foo

to be serialized as

bar

(don’t need deserialization), but in other cases it should be de-/serialized as usual. How is it possible to achieve this?

Ah ok, I see, this is not a member function but an extension function and has to be manually imported:

import kotlinx.serialization.decodeFromString

hey, I feel super stupid as I fail to formulate a proper search 😄 I need to define a type that takes a generic. The issue is that I do get the target Type as argument (I am creating a retrofit converter but its not a retrofit specific question, just to mention some context). This is my generic class I want to serialize:

data class Envelope<T> (
   val response: T
)

this is the method where i need to instance the generic typed method:

override fun responseBodyConverter(
            type: Type,
            annotations: Array<Annotation>,
            retrofit: Retrofit
        ): Converter<ResponseBody, *>? {

I cannot find any way to create a parameterized Class with type as

Type

parameter. I'd need something like this:

val response : Envelope<type> = json.decodeFromString(...)

I keep finding solutions how to do it with moshi using:

val typed = Types.newParameterizedType(Envelope::class.java, type)

however I'd like to avoid pulling moshi in just to be able to work around the reflection definition

Is there a way to force serialization to use

ksp

instead of

kapt

? I have a module that usess

ksp

only and fails after adding

kapt

Hello! Is there a way to serialize properties of a (sealed) superclass without using surrogates?

After a large refactoring I get the following exception when running

compileKotlinJs

task. Any idea how to get more insights?

--debug

does not give more information.

so, if I have a class that I want to serialize with a custom serializer, but don't want to add it in the annotation, and I'm using Spring Boot, so I don't call the framework directly, how can I register my serializer for use in my case?

Hello, I have a custom format and Encoder/Decoder, however, it is just for top-level properties, the more complex (nested) inner values would be converted to json. Is there a way to delegate to

JsonEncoder

? I think I should return

JsonEncoder

instance (

JsonTreeEncoder

?) in my

beginStructure

method, but everything related to Json encoding seems to be internal. Is there a way? Thank you.

Hi, is there a kind of Gson's type adapter in kotlin serialization ?