Add support of WASM target to mainline (#2410)

* Implement wasm target

* Slightly fix test data to suite wasm fp parser

Wasm fp parser has a different algorithm, so fix the tests to have similar results for all platforms

* Update okio version to 3.5.0

* Kotlin 1.9.30+ support

Author: igoriakovlev

buildSrc/src/main/kotlin/KotlinVersion.kt

@@ -0,0 +1,14 @@
+@file:JvmName("KotlinVersion")
+
+fun isKotlinVersionAtLeast(kotlinVersion: String, atLeastMajor: Int, atLeastMinor: Int, atLeastPatch: Int): Boolean {
+    val (major, minor) = kotlinVersion
+        .split('.')
+        .take(2)
+        .map { it.toInt() }
+    val patch = kotlinVersion.substringAfterLast('.').substringBefore('-').toInt()
+    return when {
+        major > atLeastMajor -> true
+        major < atLeastMajor -> false
+        else -> (minor == atLeastMinor && patch >= atLeastPatch) || minor > atLeastMinor
+    }
+}

core/build.gradle

@@ -66,3 +66,7 @@ tasks.withType(Jar).named(kotlin.jvm().artifactsTaskName) {
 }
 
 Java9Modularity.configureJava9ModuleInfo(project)
+
+tasks.withType(org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrLink.class).configureEach {
+    kotlinOptions.freeCompilerArgs += "-Xwasm-enable-array-range-checks"
+}

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

@@ -10,6 +10,7 @@ import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.encoding.*
 import kotlinx.serialization.encoding.CompositeDecoder.Companion.UNKNOWN_NAME
 import kotlinx.serialization.modules.*
+import kotlinx.serialization.test.*
 import kotlin.test.*
 import kotlin.time.Duration
 

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

@@ -34,7 +34,7 @@ class SerializersLookupInterfaceTest {
     @Test
     fun testInterfaceLookup() {
         // Native does not have KClass.isInterface
-        if (isNative()) return
+        if (isNative() || isWasm()) return
 
         val serializer1 = serializer<I>()
         assertTrue(serializer1 is PolymorphicSerializer)

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

@@ -64,25 +64,25 @@ class SerializersLookupNamedCompanionTest {
     fun test() {
         assertSame<KSerializer<*>>(Plain.serializer(), serializer(typeOf<Plain>()))
 
-        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false) {
+        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false, onWasm = false) {
             assertSame<KSerializer<*>>(PlainSerializer, serializer(typeOf<PlainWithCustom>()))
         }
 
-        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false) {
+        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false, onWasm = false) {
             assertEquals(
                 Parametrized.serializer(Int.serializer()).descriptor.toString(),
                 serializer(typeOf<Parametrized<Int>>()).descriptor.toString()
             )
         }
 
-        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false) {
+        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false, onWasm = false) {
             assertEquals(
                 ParametrizedWithCustom.serializer(Int.serializer()).descriptor.toString(),
                 serializer(typeOf<ParametrizedWithCustom<Int>>()).descriptor.toString()
             )
         }
 
-        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false) {
+        shouldFail<SerializationException>(beforeKotlin = "1.9.20", onJs = false, onNative = false, onWasm = false) {
             assertEquals(
                 SealedInterface.serializer().descriptor.toString(),
                 serializer(typeOf<SealedInterface>()).descriptor.toString()
@@ -91,7 +91,7 @@ class SerializersLookupNamedCompanionTest {
 
         // should fail because annotation @NamedCompanion will be placed again by the compilation plugin
         // and they both will be placed into @Container annotation - thus they will be invisible to the runtime
-        shouldFail<SerializationException>(sinceKotlin = "1.9.20", onJs = false, onNative = false) {
+        shouldFail<SerializationException>(sinceKotlin = "1.9.20", onJs = false, onNative = false, onWasm = false) {
             serializer(typeOf<SealedInterfaceWithExplicitAnnotation>())
         }
     }

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

@@ -86,4 +86,4 @@ val umbrellaInstance = TypesUmbrella(
         arrayOf(null, -1, -2),
         arrayOf(IntData(1), IntData(2))
     )
-)
+)

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

@@ -29,14 +29,16 @@ internal inline fun <reified T : Throwable> shouldFail(
     onJvm: Boolean = true,
     onJs: Boolean = true,
     onNative: Boolean = true,
+    onWasm: Boolean = true,
     test: () -> Unit
 ) {
     val args = mapOf(
         "since" to sinceKotlin,
         "before" to beforeKotlin,
         "onJvm" to onJvm,
         "onJs" to onJs,
-        "onNative" to onNative
+        "onNative" to onNative,
+        "onWasm" to onWasm
     )
 
     val sinceVersion = sinceKotlin?.toKotlinVersion()
@@ -45,7 +47,7 @@ internal inline fun <reified T : Throwable> shouldFail(
     val version = (sinceVersion != null && currentKotlinVersion >= sinceVersion)
         || (beforeVersion != null && currentKotlinVersion < beforeVersion)
 
-    val platform = (isJvm() && onJvm) || (isJs() && onJs) || (isNative() && onNative)
+    val platform = (isJvm() && onJvm) || (isJs() && onJs) || (isNative() && onNative) || (isWasm() && onWasm)
 
     var error: Throwable? = null
     try {
@@ -164,6 +166,16 @@ internal class CompilerVersionTest {
             shouldFail<IllegalArgumentException>(sinceKotlin = "0.0.0", beforeKotlin = "255.255.255", onJs = false) {
                 // no-op
             }
+        } else if (isWasm()) {
+            shouldFail<IllegalArgumentException>(beforeKotlin = "255.255.255", onWasm = false) {
+                // no-op
+            }
+            shouldFail<IllegalArgumentException>(sinceKotlin = "0.0.0", onWasm = false) {
+                // no-op
+            }
+            shouldFail<IllegalArgumentException>(sinceKotlin = "0.0.0", beforeKotlin = "255.255.255", onWasm = false) {
+                // no-op
+            }
         } else if (isNative()) {
             shouldFail<IllegalArgumentException>(beforeKotlin = "255.255.255", onNative = false) {
                 // no-op

core/commonTest/src/kotlinx/serialization/test/CurrentPlatform.common.kt

@@ -5,11 +5,12 @@
 package kotlinx.serialization.test
 
 enum class Platform {
-    JVM, JS, NATIVE
+    JVM, JS, NATIVE, WASM
 }
 
 public expect val currentPlatform: Platform
 
 public fun isJs(): Boolean = currentPlatform == Platform.JS
 public fun isJvm(): Boolean = currentPlatform == Platform.JVM
 public fun isNative(): Boolean = currentPlatform == Platform.NATIVE
+public fun isWasm(): Boolean = currentPlatform == Platform.WASM

core/wasmMain/src/kotlinx/serialization/Serializers.kt

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2017-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.serialization
+
+import kotlin.reflect.*
+
+@OptIn(ExperimentalAssociatedObjects::class)
+@AssociatedObjectKey
+@Retention(AnnotationRetention.BINARY)
+@PublishedApi
+internal annotation class SerializableWith(public val serializer: KClass<out KSerializer<*>>)

core/wasmMain/src/kotlinx/serialization/internal/Platform.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2017-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.serialization.internal
+
+import kotlinx.serialization.*
+import kotlin.reflect.*
+
+@Suppress("NOTHING_TO_INLINE")
+internal actual inline fun <T> Array<T>.getChecked(index: Int): T {
+    return get(index)
+}
+
+@Suppress("NOTHING_TO_INLINE")
+internal actual inline fun BooleanArray.getChecked(index: Int): Boolean {
+    return get(index)
+}
+
+internal actual fun KClass<*>.platformSpecificSerializerNotRegistered(): Nothing {
+    throw SerializationException(
+        "${notRegisteredMessage()}\n" +
+                "On Kotlin/Wasm explicitly declared serializer should be used for interfaces and enums without @Serializable annotation"
+    )
+}
+
+@Suppress(
+    "UNCHECKED_CAST",
+    "DEPRECATION_ERROR"
+)
+@OptIn(ExperimentalAssociatedObjects::class)
+internal actual fun <T : Any> KClass<T>.constructSerializerForGivenTypeArgs(vararg args: KSerializer<Any?>): KSerializer<T>? =
+    when (val assocObject = findAssociatedObject<SerializableWith>()) {
+        is KSerializer<*> -> assocObject as KSerializer<T>
+        is SerializerFactory -> assocObject.serializer(*args) as KSerializer<T>
+        else -> null
+    }
+
+@Suppress("DEPRECATION_ERROR")
+internal actual fun <T : Any> KClass<T>.compiledSerializerImpl(): KSerializer<T>? =
+    this.constructSerializerForGivenTypeArgs()
+
+
+internal actual fun <T> createCache(factory: (KClass<*>) -> KSerializer<T>?): SerializerCache<T> {
+    return object: SerializerCache<T> {
+        override fun get(key: KClass<Any>): KSerializer<T>? {
+            return factory(key)
+        }
+    }
+}
+
+internal actual fun <T> createParametrizedCache(factory: (KClass<Any>, List<KType>) -> KSerializer<T>?): ParametrizedSerializerCache<T> {
+    return object: ParametrizedSerializerCache<T> {
+        override fun get(key: KClass<Any>, types: List<KType>): Result<KSerializer<T>?> {
+            return kotlin.runCatching { factory(key, types) }
+        }
+    }
+}
+
+internal actual fun <T : Any, E : T?> ArrayList<E>.toNativeArrayImpl(eClass: KClass<T>): Array<E> = toTypedArray()
+
+internal actual fun isReferenceArray(rootClass: KClass<Any>): Boolean = rootClass == Array::class