Replace typeOf<T?>() with typeOf<T>().withNullability(true)

For platform types (i.e. String!), typeOf<T?>() still returns the platform type (i.e. String!). However, the nullable type is desired here, which withNullability(true) returns.

Author: NichtStudioCode

cosmic-binary-format/src/main/kotlin/xyz/xenondevs/cbf/Compound.kt

@@ -305,7 +305,7 @@ class Compound private constructor(
     @OptIn(UncheckedApi::class)
     @JvmName("entry1")
     inline fun <reified T : Any> entry(key: String, noinline defaultValue: () -> T? = { null }): MutableProvider<T?> =
-        entry(typeOf<T?>(), key, defaultValue)
+        entry(typeOf<T>().withNullability(true), key, defaultValue)
 
     /**
      * Creates a [MutableProvider] of [type] that is linked to the value of this compound under [key].
@@ -355,7 +355,7 @@ class Compound private constructor(
      */
     @OptIn(UncheckedApi::class)
     inline operator fun <reified T : Any> get(key: String): T? {
-        return get(typeOf<T?>(), key)
+        return get(typeOf<T>().withNullability(true), key)
     }
 
     /**

cosmic-binary-format/src/main/kotlin/xyz/xenondevs/cbf/CosmicBinaryFormat.kt

@@ -110,7 +110,7 @@ object Cbf {
      * Registers a [BinarySerializer] that serializes, deserializes, and copies the exact type [T?][T].
      */
     inline fun <reified T : Any> registerSerializer(serializer: BinarySerializer<T>) {
-        val serializerType = typeOf<T?>()
+        val serializerType = typeOf<T>().withNullability(true)
         val factory = object : BinarySerializerFactory {
             override fun create(type: KType): BinarySerializer<*>? =
                 if (type.withNullability(true).equalsIgnorePlatformTypes(serializerType)) serializer else null

cosmic-binary-format/src/test/kotlin/xyz/xenondevs/cbf/PlatformTypesSerializerSelectionTest.kt

@@ -0,0 +1,57 @@
+package xyz.xenondevs.cbf
+
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import xyz.xenondevs.cbf.io.ByteReader
+import xyz.xenondevs.cbf.io.ByteWriter
+import xyz.xenondevs.cbf.serializer.BinarySerializer
+import java.util.concurrent.atomic.AtomicReference
+
+class PlatformTypesSerializerSelectionTest {
+    
+    private class Foo1
+    private class Foo2
+    private class Foo3
+    
+    @Test
+    fun `test retrieving non-platform type serializer after registering as platform type`() {
+        val serializer = platformTypeSerializer(AtomicReference(Foo1())) // BinarySerializer<Foo1!>
+        Cbf.registerSerializer(serializer)
+        
+        assertDoesNotThrow { Cbf.getSerializer<Foo1>() }
+    }
+    
+    @Test
+    fun `test retrieving platform type serializer after registering as platform type`() {
+        val ref = AtomicReference(Foo2())
+        val serializer = platformTypeSerializer(ref) // BinarySerializer<Foo2!>
+        Cbf.registerSerializer(serializer)
+        
+        assertDoesNotThrow { Cbf.getSerializerLike(ref) }
+    }
+    
+    @Test
+    fun `test retrieving platform type serializer after registering as non-platform type`() {
+        val serializer = object : BinarySerializer<Foo3> {
+            override fun read(reader: ByteReader) = throw UnsupportedOperationException()
+            override fun write(obj: Foo3?, writer: ByteWriter) = throw UnsupportedOperationException()
+            override fun copy(obj: Foo3?) = throw UnsupportedOperationException()
+        }
+        Cbf.registerSerializer(serializer)
+        
+        assertDoesNotThrow { Cbf.getSerializerLike(AtomicReference(Foo3())) }
+    }
+    
+    private fun <T : Any> platformTypeSerializer(atomicRef: AtomicReference<T>): BinarySerializer<T> {
+        return object : BinarySerializer<T> {
+            override fun read(reader: ByteReader) = throw UnsupportedOperationException()
+            override fun write(obj: T?, writer: ByteWriter) = throw UnsupportedOperationException()
+            override fun copy(obj: T?) = throw UnsupportedOperationException()
+        }
+    }
+    
+    private inline fun <reified T : Any> Cbf.getSerializerLike(atomicRef: AtomicReference<T>): BinarySerializer<T> {
+        return Cbf.getSerializer<T>()
+    }
+    
+}