Kotlin 2.3

benchmark/src/jmh/kotlin/kotlinx/benchmarks/json/ImplicitNullsBenchmark.kt

@@ -82,37 +82,30 @@ open class ImplicitNullsBenchmark {
     private val serializer = Values.serializer()
 
     @Benchmark
-    fun decodeNoNulls() {
+    fun decodeNoNulls() =
         Json.decodeFromString(serializer, jsonNoNulls)
-    }
 
     @Benchmark
-    fun decodeNoNullsImplicit() {
+    fun decodeNoNullsImplicit() =
         jsonImplicitNulls.decodeFromString(serializer, jsonNoNulls)
-    }
 
     @Benchmark
-    fun decodeNulls() {
+    fun decodeNulls() =
         Json.decodeFromString(serializer, jsonWithNulls)
-    }
 
     @Benchmark
-    fun decodeNullsImplicit() {
+    fun decodeNullsImplicit() =
         jsonImplicitNulls.decodeFromString(serializer, jsonWithNulls)
-    }
 
     @Benchmark
-    fun decodeAbsenceImplicit() {
+    fun decodeAbsenceImplicit() =
         jsonImplicitNulls.decodeFromString(serializer, jsonWithAbsence)
-    }
 
     @Benchmark
-    fun encodeNulls() {
+    fun encodeNulls() =
         Json.encodeToString(serializer, valueWithNulls)
-    }
 
     @Benchmark
-    fun encodeNullsImplicit() {
+    fun encodeNullsImplicit() =
         jsonImplicitNulls.encodeToString(serializer, valueWithNulls)
-    }
 }

buildSrc/src/main/kotlin/global-compiler-options.gradle.kts

@@ -15,6 +15,7 @@ val globalCompilerArgs
         "-P", "plugin:org.jetbrains.kotlinx.serialization:disableIntrinsic=false",
         "-Xreport-all-warnings",
         "-Xrender-internal-diagnostic-names",
+        "-Xreturn-value-checker=full",
     )
 
 val kotlin_Werror_override: String? by project

buildSrc/src/main/kotlin/source-sets-conventions.gradle.kts

@@ -76,6 +76,8 @@ kotlin {
             freeCompilerArgs.add("-Xsuppress-version-warnings")
         }
         freeCompilerArgs.add("-Xexpect-actual-classes")
+        // for some reason, IDE does not enable feature in test source sets without this line:
+        freeCompilerArgs.add("-Xreturn-value-checker=full")
     }
 
     sourceSets {
@@ -87,7 +89,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                api(versionCatalog().findLibrary("kotlin.test").get())
+                implementation(versionCatalog().findLibrary("kotlin.test").get())
             }
         }
 

core/commonMain/src/kotlinx/serialization/internal/Tagged.kt

@@ -158,6 +158,7 @@ public abstract class TaggedEncoder<Tag : Any?> : Encoder, CompositeEncoder {
         tagStack.add(name)
     }
 
+    @IgnorableReturnValue
     protected fun popTag(): Tag =
         if (tagStack.isNotEmpty())
             tagStack.removeAt(tagStack.lastIndex)
@@ -316,6 +317,7 @@ public abstract class TaggedDecoder<Tag : Any?> : Decoder, CompositeDecoder {
 
     private var flag = false
 
+    @IgnorableReturnValue
     protected fun popTag(): Tag {
         val r = tagStack.removeAt(tagStack.lastIndex)
         flag = true

core/commonTest/src/kotlinx/serialization/SerializersLookupEnumTest.kt

@@ -10,8 +10,7 @@ import kotlinx.serialization.internal.EnumSerializer
 import kotlinx.serialization.test.*
 import kotlin.test.*
 
-// This is unimplemented functionality that should be
-@Suppress("RemoveExplicitTypeArguments") // This is exactly what's being tested
+@Suppress("RETURN_VALUE_NOT_USED") // assertIs, KT-82363
 class SerializersLookupEnumTest {
     @Serializable(with = EnumExternalObjectSerializer::class)
     enum class EnumExternalObject

core/commonTest/src/kotlinx/serialization/features/SealedInterfacesSerializationTest.kt

@@ -68,9 +68,9 @@ class SealedInterfacesSerializationTest {
         assertEquals(listOf("ImplA", "ImplB"), subclasses)
     }
 
-    private fun SerialDescriptor.isDummy() = serialName == "Dummy"
+    private fun SerialDescriptor.isDummy() = assertEquals(serialName, "Dummy")
 
-    private fun SerialDescriptor.isPolymorphic() = kind == PolymorphicKind.OPEN
+    private fun SerialDescriptor.isPolymorphic() = assertEquals(kind, PolymorphicKind.OPEN)
 
     operator fun SerialDescriptor.get(i: Int) = getElementDescriptor(i)
 

core/commonTest/src/kotlinx/serialization/internal/ObjectSerializerTest.kt

@@ -10,7 +10,7 @@ import kotlinx.serialization.*
 class ObjectSerializerTest {
     @Test
     fun testSequentialDecoding() {
-        SimpleObject.serializer().deserialize(DummySequentialDecoder())
+        assertSame(SimpleObject, SimpleObject.serializer().deserialize(DummySequentialDecoder()))
     }
 
     @Serializable

core/commonTest/src/kotlinx/serialization/internal/TuplesTest.kt

@@ -12,7 +12,7 @@ class TuplesTest {
     fun testSequentialDecodingKeyValue() {
         val decoder = DummySequentialDecoder()
         val serializer = MapEntrySerializer(Unit.serializer(), Unit.serializer())
-        serializer.deserialize(decoder)
+        assertNotNull(serializer.deserialize(decoder))
         assertEquals(decoder.beginStructureCalled, decoder.endStructureCalled)
     }
 }

core/commonTest/src/kotlinx/serialization/test/TestHelpers.kt

@@ -38,7 +38,7 @@ inline fun jvmOnly(test: () -> Unit) {
     if (isJvm()) test()
 }
 
-inline fun <reified T : Throwable> assertFailsWithMessage(message: String, block: () -> Unit) {
+inline fun <reified T : Throwable> assertFailsWithMessage(message: String, block: () -> Any?) {
     val exception = assertFailsWith(T::class, null, block)
     assertTrue(exception.message!!.contains(message), "Expected message '${exception.message}' to contain substring '$message'")
 }

core/jvmMain/src/kotlinx/serialization/internal/Caching.kt

@@ -18,7 +18,7 @@ import kotlin.reflect.KTypeProjection
  * and fallback to ConcurrentHashMap-based cache.
  */
 private val useClassValue = try {
-    Class.forName("java.lang.ClassValue")
+    val _ = Class.forName("java.lang.ClassValue")
     true
 } catch (_: Throwable) {
     false

core/jvmTest/src/kotlinx/serialization/CachingTest.kt

@@ -21,7 +21,7 @@ class CachingTest {
         }
 
         repeat(10) {
-            cache.get(typeOf<String>().kclass())
+            val _ = cache.get(typeOf<String>().kclass())
         }
 
         assertEquals(1, factoryCalled)
@@ -38,7 +38,7 @@ class CachingTest {
         }
 
         repeat(10) {
-            cache.get(typeOf<Map<*, *>>().kclass(), listOf(typeOf<String>(), typeOf<String>()))
+            val _ = cache.get(typeOf<Map<*, *>>().kclass(), listOf(typeOf<String>(), typeOf<String>()))
         }
 
         assertEquals(1, factoryCalled)

core/jvmTest/src/kotlinx/serialization/SerializationMethodInvocationOrderTest.kt

@@ -23,7 +23,7 @@ class SerializationMethodInvocationOrderTest {
         out.done()
 
         val inp = Inp()
-        inp.decodeSerializableValue(serializer<Container>())
+        assertEquals(Container(Data("s1", 42)), inp.decodeSerializableValue(serializer<Container>()))
         inp.done()
     }
 

formats/cbor/commonMain/src/kotlinx/serialization/cbor/internal/Decoder.kt

@@ -158,6 +158,7 @@ internal class CborParser(private val input: ByteArrayInput, private val verifyO
         readByte()
     }
 
+    @IgnorableReturnValue
     private fun readByte(): Int {
         curByte = input.read()
         return curByte
@@ -268,6 +269,7 @@ internal class CborParser(private val input: ByteArrayInput, private val verifyO
             input.readExactNBytes(strLen)
         }
 
+    @IgnorableReturnValue
     private fun processTags(tags: ULongArray?): ULongArray? {
         var index = 0
         val collectedTags = mutableListOf<ULong>()
@@ -364,7 +366,7 @@ internal class CborParser(private val input: ByteArrayInput, private val verifyO
             error("Unexpected EOF, available $availableBytes bytes, requested: $bytesCount")
         }
         val array = ByteArray(bytesCount)
-        read(array, 0, bytesCount)
+        val _ = read(array, 0, bytesCount)
         return array
     }
 
@@ -445,7 +447,7 @@ internal class CborParser(private val input: ByteArrayInput, private val verifyO
                 val header = curByte and 0b111_00000
                 val length = elementLength()
                 if (header == HEADER_TAG) {
-                    readNumber()
+                    val _ = readNumber()
                 } else if (header == HEADER_ARRAY || header == HEADER_MAP) {
                     if (length > 0) lengthStack.add(length)
                     else prune(lengthStack) // empty map or array automatically completes

formats/cbor/commonMain/src/kotlinx/serialization/cbor/internal/Encoder.kt

@@ -193,7 +193,7 @@ internal class DefiniteLengthCborWriter(cbor: Cbor, output: ByteArrayOutput) : C
 
     override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
         val current = Data(ByteArrayOutput(), 0)
-        structureStack.push(current)
+        val _ = structureStack.push(current)
         return this
     }
 

formats/cbor/commonTest/src/kotlinx/serialization/TestUtilities.kt

@@ -30,7 +30,7 @@ internal inline fun <reified T : Any> assertSerializedToBinaryAndRestored(
     assertEquals(original, restored)
 }
 
-inline fun <reified T : Throwable> assertFailsWithMessage(message: String, block: () -> Unit) {
+inline fun <reified T : Throwable> assertFailsWithMessage(message: String, block: () -> Any?) {
     val exception = assertFailsWith(T::class, null, block)
     assertTrue(exception.message!!.contains(message), "Expected message '${exception.message}' to contain substring '$message'")
 }

formats/cbor/commonTest/src/kotlinx/serialization/cbor/CborDecoderTest.kt

@@ -81,7 +81,7 @@ class CborDecoderTest {
 
     @Test
     fun testNullables() {
-        Cbor.decodeFromHexString<NullableByteStringDefaultNull>("a0")
+        assertEquals(NullableByteStringDefaultNull(), Cbor.decodeFromHexString<NullableByteStringDefaultNull>("a0"))
     }
 
     /**

formats/cbor/commonTest/src/kotlinx/serialization/cbor/SampleClasses.kt

@@ -99,7 +99,7 @@ data class NullableByteStringDefaultNull(
         if (this === other) return true
         if (other == null || this::class != other::class) return false
 
-        other as NullableByteString
+        other as NullableByteStringDefaultNull
 
         if (byteString != null) {
             if (other.byteString == null) return false
@@ -150,4 +150,4 @@ value class ValueClassWithUnlabeledByteString(@ByteString val x: Inner) {
     @JvmInline
     @Serializable
     value class Inner(val x: ByteArray)
-}
+}

formats/cbor/jvmTest/src/kotlinx/serialization/cbor/CborStacktraceRecoveryTest.kt

@@ -15,7 +15,7 @@ class CborStacktraceRecoveryTest {
         Cbor.decodeFromByteArray<String>(byteArrayOf(0xFF.toByte()))
     }
 
-    private inline fun <reified E : Exception> checkRecovered(noinline block: () -> Unit) = runBlocking {
+    private inline fun <reified E : Exception> checkRecovered(noinline block: () -> Any?) = runBlocking {
         val result = runCatching {
             callBlockWithRecovery(block)
         }
@@ -29,7 +29,7 @@ class CborStacktraceRecoveryTest {
     }
 
     // KLUDGE: A separate function with state-machine to ensure coroutine DebugMetadata is generated. See KT-41789
-    private suspend fun callBlockWithRecovery(block: () -> Unit) {
+    private suspend fun callBlockWithRecovery(block: () -> Any?) {
         yield()
         // use withContext to perform switch between coroutines and thus trigger exception recovery machinery
         withContext(NonCancellable) {

formats/json-tests/build.gradle.kts

@@ -33,9 +33,9 @@ kotlin {
         }
         val commonTest by getting {
             dependencies {
-                api(project(":kotlinx-serialization-json"))
-                api(project(":kotlinx-serialization-json-okio"))
-                api(project(":kotlinx-serialization-json-io"))
+                implementation(project(":kotlinx-serialization-json"))
+                implementation(project(":kotlinx-serialization-json-okio"))
+                implementation(project(":kotlinx-serialization-json-io"))
                 implementation(libs.kotlinx.io)
                 implementation(libs.okio)
             }

formats/json-tests/commonTest/src/kotlinx/serialization/JsonPathTest.kt

@@ -106,15 +106,15 @@ class JsonPathTest : JsonTestBase() {
 
         @Serializable
         @SerialName("n")
-        class Nesting(val f: Sealed) : Sealed()
+        data class Nesting(val f: Sealed) : Sealed()
 
         @Serializable
         @SerialName("b")
-        class Box(val s: String) : Sealed()
+        data class Box(val s: String) : Sealed()
 
         @Serializable
         @SerialName("d")
-        class DoubleNesting(val f: Sealed, val f2: Sealed) : Sealed()
+        data class DoubleNesting(val f: Sealed, val f2: Sealed) : Sealed()
     }
 
     // TODO use non-array polymorphism when https://github.com/Kotlin/kotlinx.serialization/issues/1839 is fixed
@@ -126,8 +126,8 @@ class JsonPathTest : JsonTestBase() {
             outer = Sealed.Nesting(outer)
         }
         val str = json.encodeToString(Sealed.serializer(), outer)
-        // throw-away data
-        json.decodeFromString(Sealed.serializer(), str)
+        // check that data is correctly formed
+        assertEquals(outer, json.decodeFromString(Sealed.serializer(), str))
 
         val malformed = str.replace("\"value\"", "42")
         val expectedPath = "$" + ".value.f".repeat(101) + ".value.s"
@@ -147,9 +147,10 @@ class JsonPathTest : JsonTestBase() {
             outer2 = Sealed.Nesting(outer2)
         }
 
-        val str = json.encodeToString(Sealed.serializer(), Sealed.DoubleNesting(outer1, outer2))
-        // throw-away data
-        json.decodeFromString(Sealed.serializer(), str)
+        val value = Sealed.DoubleNesting(outer1, outer2)
+        val str = json.encodeToString(Sealed.serializer(), value)
+        // check that data is correctly formed
+        assertEquals(value, json.decodeFromString(Sealed.serializer(), str))
 
         val malformed = str.replace("\"incorrect\"", "42")
         val expectedPath = "$.value.f2" + ".value.f".repeat(34) + ".value.s"
@@ -169,15 +170,15 @@ class JsonPathTest : JsonTestBase() {
             outer = SimpleNested(n = outer)
         }
         val str = Json.encodeToString(SimpleNested.serializer(), outer)
-        // throw-away data
-        Json.decodeFromString(SimpleNested.serializer(), str)
+        // check that data is correctly formed
+        assertEquals(outer, Json.decodeFromString(SimpleNested.serializer(), str))
 
         val malformed = str.replace("{}", "42")
         val expectedPath = "$" + ".n".repeat(20) + ".t\n"
         expectPath(expectedPath) { Json.decodeFromString(SimpleNested.serializer(), malformed) }
     }
 
-    private inline fun expectPath(path: String, block: () -> Unit) {
+    private inline fun expectPath(path: String, block: () -> Any?) {
         val message = runCatching { block() }
             .exceptionOrNull()!!.message!!
         assertContains(message, path)

formats/json-tests/commonTest/src/kotlinx/serialization/KeepGeneratedSerializerTest.kt

@@ -127,7 +127,7 @@ class KeepGeneratedSerializerTest {
         override val descriptor = PrimitiveSerialDescriptor("MyEnumSerializer", PrimitiveKind.INT)
 
         override fun deserialize(decoder: Decoder): MyEnum {
-            decoder.decodeString()
+            val _ = decoder.decodeString()
             return MyEnum.A
         }
 
@@ -203,7 +203,7 @@ class KeepGeneratedSerializerTest {
         override val descriptor = PrimitiveSerialDescriptor("ObjectSerializer", PrimitiveKind.INT)
 
         override fun deserialize(decoder: Decoder): Object {
-            decoder.decodeInt()
+            val _ = decoder.decodeInt()
             return Object
         }
         override fun serialize(encoder: Encoder, value: Object) {
@@ -244,4 +244,4 @@ class KeepGeneratedSerializerTest {
         assertEquals(value, keepDecoded, "Json.decodeFromString(${T::class.simpleName}.generatedSerializer(), json)")
     }
 
-}
+}

formats/json-tests/commonTest/src/kotlinx/serialization/features/PolymorphicDeserializationErrorMessagesTest.kt

@@ -6,6 +6,7 @@ package kotlinx.serialization.features
 
 import kotlinx.serialization.*
 import kotlinx.serialization.json.*
+import kotlinx.serialization.test.checkSerializationException
 import kotlin.test.*
 
 class PolymorphicDeserializationErrorMessagesTest : JsonTestBase() {
@@ -15,13 +16,6 @@ class PolymorphicDeserializationErrorMessagesTest : JsonTestBase() {
     @Serializable
     class Holder(val d: DummyData)
 
-    // TODO: remove this after #2480 is merged
-    private fun checkSerializationException(action: () -> Unit, assertions: SerializationException.(String) -> Unit) {
-        val e = assertFailsWith(SerializationException::class, action)
-        assertNotNull(e.message)
-        e.assertions(e.message!!)
-    }
-
     @Test
     fun testNotRegisteredMessage() = parametrizedTest { mode ->
         val input = """{"d":{"a":{"type":"my.Class", "value":42}}}"""

formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonConfigurationTest.kt

@@ -23,6 +23,7 @@ class JsonConfigurationTest {
         assertFailsWith<IllegalArgumentException> { json(true, "\tf\n") }
     }
 
+    @IgnorableReturnValue
     private fun json(prettyPrint: Boolean, prettyPrintIndent: String) = Json {
         this.prettyPrint = prettyPrint
         this.prettyPrintIndent = prettyPrintIndent