Update to Kotlin 1.9.0: (#2364)

- Apply @ExperimentalNativeApi on WeakReference usages
- Drop Legacy JS compiler as it is deprecated
- Update API Dump with .entries enum properties
- Update yarn.lock

Author: sandwwraith

core/api/kotlinx-serialization-core.api

@@ -26,6 +26,7 @@ public abstract interface annotation class kotlinx/serialization/EncodeDefault :
 public final class kotlinx/serialization/EncodeDefault$Mode : java/lang/Enum {
 	public static final field ALWAYS Lkotlinx/serialization/EncodeDefault$Mode;
 	public static final field NEVER Lkotlinx/serialization/EncodeDefault$Mode;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
 	public static fun valueOf (Ljava/lang/String;)Lkotlinx/serialization/EncodeDefault$Mode;
 	public static fun values ()[Lkotlinx/serialization/EncodeDefault$Mode;
 }

core/build.gradle

@@ -65,10 +65,4 @@ tasks.withType(Jar).named(kotlin.jvm().artifactsTaskName) {
     }
 }
 
-tasks.withType(Kotlin2JsCompile.class).configureEach {
-    if (it.name == "compileTestKotlinJsLegacy") {
-        it.exclude("**/SerializersModuleTest.kt")
-    }
-}
-
 Java9Modularity.configureJava9ModuleInfo(project)

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

@@ -38,27 +38,27 @@ class CachedSerializersTest {
     }
 
     @Test
-    fun testObjectSerializersAreSame() = noJsLegacy {
+    fun testObjectSerializersAreSame() {
         assertSame(Object.serializer(), Object.serializer())
     }
 
     @Test
-    fun testSerializableEnumSerializersAreSame() = noJsLegacy {
+    fun testSerializableEnumSerializersAreSame() {
         assertSame(SerializableEnum.serializer(), SerializableEnum.serializer())
     }
 
     @Test
-    fun testSerializableMarkedEnumSerializersAreSame() = noJsLegacy {
+    fun testSerializableMarkedEnumSerializersAreSame() {
         assertSame(SerializableMarkedEnum.serializer(), SerializableMarkedEnum.serializer())
     }
 
     @Test
-    fun testSealedSerializersAreSame() = noJsLegacy {
+    fun testSealedSerializersAreSame() {
         assertSame(SealedParent.serializer(), SealedParent.serializer())
     }
 
     @Test
-    fun testAbstractSerializersAreSame() = noJsLegacy {
+    fun testAbstractSerializersAreSame() {
         assertSame(Abstract.serializer(), Abstract.serializer())
     }
 

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

@@ -1,7 +1,6 @@
 package kotlinx.serialization
 
 import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.test.isJsLegacy
 import kotlin.test.*
 
 
@@ -33,7 +32,6 @@ class InheritableSerialInfoTest {
     class E3: A, B
 
     private fun doTest(descriptor: SerialDescriptor) {
-        if (isJsLegacy()) return // Unsupported
         val list = descriptor.annotations.filterIsInstance<InheritableDiscriminator>()
         assertEquals(1, list.size)
         assertEquals("a", list.first().discriminator)

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

@@ -34,20 +34,20 @@ class MetaSerializableTest {
     )
 
     @Test
-    fun testMetaSerializable() = noJsLegacy {
+    fun testMetaSerializable() {
         val serializer = serializer<Project1>()
         assertNotNull(serializer)
     }
 
     @Test
-    fun testMetaSerializableWithInfo() = noJsLegacy {
+    fun testMetaSerializableWithInfo() {
         val info = serializer<Project2>().descriptor.annotations.filterIsInstance<MySerializableWithInfo>().first()
         assertEquals(123, info.value)
         assertEquals(String::class, info.kclass)
     }
 
     @Test
-    fun testMetaSerializableOnProperty() = noJsLegacy {
+    fun testMetaSerializableOnProperty() {
         val info = serializer<Wrapper>().descriptor
             .getElementAnnotations(0).filterIsInstance<MySerializableWithInfo>().first()
         assertEquals(234, info.value)

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

@@ -5,7 +5,6 @@
 package kotlinx.serialization
 
 import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.test.isJsLegacy
 import kotlin.test.*
 
 class SerialDescriptorAnnotationsTest {
@@ -103,7 +102,6 @@ class SerialDescriptorAnnotationsTest {
     class Holder(val r: Result, val a: AbstractResult, val o: ObjectResult, @Contextual val names: WithNames)
 
     private fun doTest(position: Int, expected: String) {
-        if (isJsLegacy()) return // Unsupported
         val desc = Holder.serializer().descriptor.getElementDescriptor(position)
         assertEquals(expected, desc.annotations.getCustom())
     }

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

@@ -54,11 +54,7 @@ class SerializersLookupEnumTest {
 
     @Test
     fun testPlainEnum() {
-        if (isJsLegacy()) {
-            assertSame(PlainEnum.serializer()::class, serializer<PlainEnum>()::class)
-        } else {
-            assertSame(PlainEnum.serializer(), serializer<PlainEnum>())
-        }
+        assertSame(PlainEnum.serializer(), serializer<PlainEnum>())
 
         if (!isJs()) {
             assertIs<EnumSerializer<PlainEnum>>(serializer<PlainEnum>())
@@ -69,22 +65,14 @@ class SerializersLookupEnumTest {
     fun testSerializableEnumSerializer() {
         assertIs<EnumSerializer<SerializableEnum>>(SerializableEnum.serializer())
 
-        if (isJsLegacy()) {
-            assertSame(SerializableEnum.serializer()::class, serializer<SerializableEnum>()::class)
-        } else {
-            assertSame(SerializableEnum.serializer(), serializer<SerializableEnum>())
-        }
+        assertSame(SerializableEnum.serializer(), serializer<SerializableEnum>())
     }
 
     @Test
     fun testSerializableMarkedEnumSerializer() {
         assertIs<EnumSerializer<SerializableMarkedEnum>>(SerializableMarkedEnum.serializer())
 
-        if (isJsLegacy()) {
-            assertSame(SerializableMarkedEnum.serializer()::class, serializer<SerializableMarkedEnum>()::class)
-        } else {
-            assertSame(SerializableMarkedEnum.serializer(), serializer<SerializableMarkedEnum>())
-        }
+        assertSame(SerializableMarkedEnum.serializer(), serializer<SerializableMarkedEnum>())
     }
 
     @Test

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

@@ -26,7 +26,6 @@ class SerializersLookupInterfaceTest {
 
     @Test
     fun testSealedInterfaceLookup() {
-        if (currentPlatform == Platform.JS_LEGACY) return
         val serializer = serializer<S>()
         assertTrue(serializer is SealedClassSerializer)
         assertEquals("S", serializer.descriptor.serialName)
@@ -35,7 +34,7 @@ class SerializersLookupInterfaceTest {
     @Test
     fun testInterfaceLookup() {
         // Native does not have KClass.isInterface
-        if (currentPlatform == Platform.NATIVE || currentPlatform == Platform.JS_LEGACY) return
+        if (isNative()) return
 
         val serializer1 = serializer<I>()
         assertTrue(serializer1 is PolymorphicSerializer)

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

@@ -46,26 +46,19 @@ class SerializersLookupObjectTest {
 
     @Test
     fun testPlainObject() {
-        if (!isJsLegacy()) {
-            assertSame(PlainObject.serializer(), serializer<PlainObject>())
-        }
+        assertSame(PlainObject.serializer(), serializer<PlainObject>())
     }
 
 
     @Test
     fun testObjectExternalObject() {
         assertSame(ObjectCustomObjectSerializer, ObjectExternalObject.serializer())
-        if (!isJsLegacy()) {
-            assertSame(ObjectCustomObjectSerializer, serializer<ObjectExternalObject>())
-        }
+        assertSame(ObjectCustomObjectSerializer, serializer<ObjectExternalObject>())
     }
 
     @Test
     fun testObjectExternalClass() {
         assertIs<ObjectCustomClassSerializer>(ObjectExternalClass.serializer())
-
-        if (!isJsLegacy()) {
-            assertIs<ObjectCustomClassSerializer>(serializer<ObjectExternalClass>())
-        }
+        assertIs<ObjectCustomClassSerializer>(serializer<ObjectExternalClass>())
     }
 }

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

@@ -49,7 +49,7 @@ class SerializersModuleTest {
     class ContextualHolder(@Contextual val contextual: ContextualType)
 
     @Test
-    fun testCompiled() = noJsLegacy {
+    fun testCompiled() {
         assertSame<KSerializer<*>>(Object.serializer(), serializer(Object::class, emptyList(), false))
         assertSame<KSerializer<*>>(SealedParent.serializer(), serializer(SealedParent::class, emptyList(), false))
         assertSame<KSerializer<*>>(