R8 and Moshi-sealed crash

[georgi-mirchev]

Hello,
Moshi-sealed is great and we love using it but recently, we experienced an issue that is hard to tackle and I decided to ping you if you have any idea in mind. We have the following hierarchy of classes:

@Keep
@JsonClass(generateAdapter = true)
data class A(val b: B)

@Keep
@JsonClass(generateAdapter = true)
data class B(val c: C)

@Keep
@JsonClass(generateAdapter = true, generator = "sealed:type")
sealed interface C {
    @Keep
    @TypeLabel("C1")
    @JsonClass(generateAdapter = true)
    data class C1(
        @Json(name = "coordinates") override val coordinates: List<List<Double>>,
    ) : C

    @Keep
    @TypeLabel("C2")
    @JsonClass(generateAdapter = true)
    data class C2(
        @Json(name = "coordinates") val jsonCoordinates: List<List<List<Double>>>,
    ) : C
}

As you can see, moshi-sealed is used inside normal moshi json adapters. When running the app version with r8 I get this error:

Caused by: java.lang.ClassCastException: $Proxy7 cannot be cast to kotlin.metadata.jvm.b
                                                                                                    	at dev.zacsweers.moshix.sealed.reflect.MetadataMoshiSealedJsonAdapterFactoryKt.b(MetadataMoshiSealedJsonAdapterFactory.kt:13)
                                                                                                    	at dev.zacsweers.moshix.sealed.reflect.MetadataMoshiSealedJsonAdapterFactoryKt.access$header(MetadataMoshiSealedJsonAdapterFactory.kt)
                                                                                                    	at dev.zacsweers.moshix.sealed.reflect.MetadataMoshiSealedJsonAdapterFactory.create(MetadataMoshiSealedJsonAdapterFactory.java)
                                                                                                    	at com.squareup.moshi.Moshi.adapter(Moshi.java)

We use the MetadataMoshiSealedJsonAdapterFactory. In build.gradle we have:

 api libs.square.moshi.kotlin
api libs.square.moshi.adapters
api(libs.zacsweers.moshi.sealed.runtime) {
    exclude group: 'com.squareup.moshi'
}
api(libs.zacsweers.moshi.sealed.metadata.reflect) {
    exclude group: 'com.squareup.moshi'
}
api libs.square.converter.moshi
ksp libs.square.moshi.codegen
ksp libs.zacsweers.moshi.sealed.codegen

In proguard, I have added:

# Region Moshi
# JSR 305 annotations are for embedding nullability information.
-keep class kotlin.Metadata { *; }

# Keep default constructor marker name for lookup in signatures.
-keepnames class kotlin.jvm.internal.DefaultConstructorMarker

# Keep implementations of service loaded interfaces
-keep interface kotlinx.metadata.impl.extensions.MetadataExtensions
-keep class * implements kotlinx.metadata.impl.extensions.MetadataExtensions { public protected *; }

# Keep generic signatures and annotations at runtime.
-keepattributes Signature,RuntimeVisible*Annotations
-dontwarn javax.annotation.**

-keepattributes InnerClasses
-keepclasseswithmembers class * {
    @com.squareup.moshi.* <methods>;
    *;
}

-keep @com.squareup.moshi.JsonQualifier @interface *

# Enum field names are used by the integrated EnumJsonAdapter.
# values() is synthesized by the Kotlin compiler and is used by EnumJsonAdapter indirectly
# Annotate enums with @JsonClass(generateAdapter = false) to use them with Moshi.
-keepclassmembers @com.squareup.moshi.JsonClass class * extends java.lang.Enum {
    <fields>;
    **[] values();
    *;
}

# Keep helper method to avoid R8 optimisation that would keep all Kotlin Metadata when unwanted
-keepclassmembers class com.squareup.moshi.internal.Util {
    private static java.lang.String getKotlinMetadataClassName();
}

# Keep ToJson/FromJson-annotated methods
-keepclassmembers class * {
  @com.squareup.moshi.FromJson <methods>;
  @com.squareup.moshi.ToJson <methods>;
}

-keep,allowobfuscation,allowshrinking class com.squareup.moshi.JsonAdapter

And we still have the error happening. I was wondering what am I missing in the proguard configuration. Any help is appreciated, thank you!

[georgi-mirchev]

Reproducible sample app https://drive.google.com/file/d/1diXfz14LWNIR7F_DbEFqHb3fm9M94_Dx/view?usp=sharing

I managed to fix the issue by manually adding the PolymorphicJsonAdapter to the moshi instance:

PolymorphicJsonAdapterFactory.of(GeoJson.Feature.Geometry::class.java, "type")
                    .withSubtype(GeoJson.Feature.Geometry.LineString::class.java, "LineString")
                    .withSubtype(GeoJson.Feature.Geometry.Polygon::class.java, "Polygon")

[georgi-mirchev]

Got it working by using the following pro-guard configuration:

-keep class kotlin.Metadata { *; }
-keepclassmembers class * {
    @kotlin.Metadata *;
}
-keep @kotlin.Metadata class * { *; }

[ZacSweers]

Those rules are bundled with kotlin-reflect's jar. Please file an issue with the kotlin issue tracker if those are not being properly bundled?

[georgi-mirchev]

Will do that, thank you 👍

[georgi-mirchev]

I am still struggling to understand where the issue lies exactly. The guys from R8 are telling me that I have practically disabled R8 optimisation for all kotlin files by using the above 😄 I have raised a YouTrack issue and one in the IssueTracker but just wanted to confirm, why is MetadataJsonFactory executed if I have already annotated my sealed class (as per the example from the project above) with the generator property and have added type labels. Doesn't that mean that they are not recognized and MetadataJsonFactory now uses reflection to recognize the classes while I shouldn't reach reflection at all?

[ZacSweers]

Sorry are you saying you are trying to use code gen? All of your information up to this point seemed to imply you were intentionally trying to configure reflective use. Converting this to a discussion now as this appears to be more of a usage question than anything

[georgi-mirchev]

A bit above, I have a sample small repo (https://drive.google.com/file/d/1diXfz14LWNIR7F_DbEFqHb3fm9M94_Dx/view?usp=sharing). In there I am using code generation:

ksp libs.square.moshi.codegen
ksp libs.zacsweers.moshi.sealed.codegen

from Moshi and Moshi Sealed for the appropriate classes ("Geometry") to be serialised to either Polygon or Line. I use the:

@JsonClass(generateAdapter = true, generator = "sealed:type")

annotation with the generator option and I can see the code generation running fine. I can see the generated adapters. Where Moshi Sealed fails and throws an exception is in one of the generated adapters where I expect to receiv the sealed class implementation.

Meaning there is something fishy there as Moshi Sealed tries to use reflection to serialise correctly to the expected instance of the sealed class. While I can see the PolymorphicJsonAdapter being correctly generated:

And if I manually add it to my Moshi instance, everything works magically well. But the moment I remove it from there, it seems the generated JsonAdapter is not called at all and Moshi Sealed tries to do reflection to recognize the sealed class instance. And I don't know why.

[georgi-mirchev]

Here I add the MetadataMoshiSealedFactory by simply calling add. If I use addLast the app continues to crash with the same error that the MetadataFactory fails to read the metadata of the class (which is probably an r8 issue).

If I remove it from the Moshi instance and not add it at all, then the code generation works totally fine and the generated adapter is picked up correctly.

[sgjesse]

After looking further, this looks like an R8 issue. It is tracked here: https://issuetracker.google.com/378473616.

[sgjesse]

R8 fix is in, see https://issuetracker.google.com/378473616#comment17 for which versions to use.