Adding wasm target to wire runtime.

Author: mpawliszyn

.github/workflows/build.yml

@@ -29,13 +29,13 @@ jobs:
           ./gradlew generateTests -Pswift=false --stacktrace --warning-mode all
           if [ ! -z "$(git status --porcelain)" ]; then git diff; echo -e "\nTest files changed. Did you run ./gradlew generateTests?"; exit 1; fi
 
-      - name: Test Native and JS
+      - name: Test Native, JS and Wasm
         run: |
-          ./gradlew -Dkjs=true -Dknative=true -Pswift=false samples:native:build samples:js:build samples:multi-target:build --stacktrace --warning-mode all
+          ./gradlew -Dkjs=true -Dknative=true -Dkwasm=true -Pswift=false samples:native:build samples:js:build samples:multi-target:build --stacktrace --warning-mode all
 
       - name: Test
         run: |
-          ./gradlew -Dkjs=false -Dknative=false -Pswift=false build --stacktrace --warning-mode all -x samples:native:build -x samples:js:build -x samples:multi-target:build
+          ./gradlew -Dkjs=false -Dknative=false -Dkwasm=false -Pswift=false build --stacktrace --warning-mode all -x samples:native:build -x samples:js:build -x samples:multi-target:build
 
   multiplatform:
     runs-on: macos-latest

wire-runtime/build.gradle.kts

@@ -1,4 +1,5 @@
 import com.diffplug.gradle.spotless.SpotlessExtension
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 
 plugins {
   kotlin("multiplatform")
@@ -39,6 +40,14 @@ kotlin {
     tvosArm64()
     tvosSimulatorArm64()
   }
+
+  if (System.getProperty("kwasm", "true").toBoolean()) {
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmWasi {
+      nodejs()
+    }
+  }
+
   sourceSets {
     val commonMain by getting {
       dependencies {
@@ -69,6 +78,13 @@ kotlin {
         }
       }
     }
+    if (System.getProperty("kwasm", "true").toBoolean()) {
+      val wasmWasiTest by getting {
+        dependencies {
+          implementation(libs.kotlin.test)
+        }
+      }
+    }
   }
 }
 

wire-runtime/src/wasmWasiMain/kotlin/com/squareup/wire/Duration.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2020 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.wire
+
+import com.squareup.wire.internal.NANOS_PER_SECOND
+import com.squareup.wire.internal.addExactLong
+import com.squareup.wire.internal.commonEquals
+import com.squareup.wire.internal.commonHashCode
+import com.squareup.wire.internal.floorDivLong
+import com.squareup.wire.internal.floorModLong
+
+actual class Duration internal constructor(
+  private val seconds: Long,
+  private val nanos: Int,
+) {
+  actual fun getSeconds(): Long = seconds
+  actual fun getNano(): Int = nanos
+
+  override fun equals(other: Any?): Boolean = commonEquals(other)
+
+  override fun hashCode(): Int = commonHashCode()
+}
+
+actual fun durationOfSeconds(
+  seconds: Long,
+  nano: Long,
+): Duration {
+  val secs = addExactLong(seconds, floorDivLong(nano, NANOS_PER_SECOND))
+  val nos = floorModLong(nano, NANOS_PER_SECOND).toInt()
+  return Duration(secs, nos)
+}

wire-runtime/src/wasmWasiMain/kotlin/com/squareup/wire/EnumAdapter.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.wire
+
+import kotlin.reflect.KClass
+
+/**
+ * An abstract [ProtoAdapter] that converts values of an enum to and from integers.
+ */
+actual abstract class EnumAdapter<E : WireEnum> protected actual constructor(
+  type: KClass<E>,
+  syntax: Syntax,
+  identity: E?,
+) : ProtoAdapter<E>(FieldEncoding.VARINT, type, null, syntax, identity) {
+  actual override fun encodedSize(value: E): Int = commonEncodedSize(value)
+
+  actual override fun encode(writer: ProtoWriter, value: E) {
+    commonEncode(writer, value)
+  }
+
+  actual override fun encode(writer: ReverseProtoWriter, value: E) {
+    commonEncode(writer, value)
+  }
+
+  actual override fun decode(reader: ProtoReader): E = commonDecode(reader, this::fromValue)
+
+  actual override fun decode(reader: ProtoReader32): E = commonDecode(reader, this::fromValue)
+
+  actual override fun redact(value: E): E = commonRedact(value)
+
+  /**
+   * Converts an integer to an enum.
+   * Returns null if there is no corresponding enum.
+   */
+  protected actual abstract fun fromValue(value: Int): E?
+}

wire-runtime/src/wasmWasiMain/kotlin/com/squareup/wire/Instant.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.wire
+
+import com.squareup.wire.internal.NANOS_PER_SECOND
+import com.squareup.wire.internal.addExactLong
+import com.squareup.wire.internal.commonEquals
+import com.squareup.wire.internal.commonHashCode
+import com.squareup.wire.internal.floorDivLong
+import com.squareup.wire.internal.floorModLong
+
+actual class Instant internal constructor(
+  private val epochSeconds: Long,
+  private val nanos: Int,
+) {
+  actual fun getEpochSecond(): Long = epochSeconds
+  actual fun getNano(): Int = nanos
+
+  override fun equals(other: Any?): Boolean = commonEquals(other)
+
+  override fun hashCode(): Int = commonHashCode()
+}
+
+actual fun ofEpochSecond(epochSecond: Long, nano: Long): Instant {
+  val secs = addExactLong(epochSecond, floorDivLong(nano, NANOS_PER_SECOND))
+  val nos = floorModLong(nano, NANOS_PER_SECOND).toInt()
+  return Instant(secs, nos)
+}

wire-runtime/src/wasmWasiMain/kotlin/com/squareup/wire/Message.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2013 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.wire
+
+import okio.Buffer
+import okio.BufferedSink
+import okio.ByteString
+
+/** A protocol buffer message. */
+actual abstract class Message<M : Message<M, B>, B : Message.Builder<M, B>>
+protected actual constructor(
+  /** The [ProtoAdapter] for encoding and decoding messages of this type. */
+  actual val adapter: ProtoAdapter<M>,
+  /**
+   * Returns a byte string containing the proto encoding of this message's unknown fields. Returns
+   * an empty byte string if this message has no unknown fields.
+   */
+  actual open val unknownFields: ByteString,
+) {
+  /** If non-zero, the hash code of this message. Accessed by generated code. */
+  protected actual var hashCode = 0
+
+  /**
+   * Returns a new builder initialized with the data in this message.
+   */
+  actual abstract fun newBuilder(): B
+
+  /** Encode this message and write it to `stream`. */
+  actual fun encode(sink: BufferedSink) {
+    @Suppress("UNCHECKED_CAST")
+    adapter.encode(sink, this as M)
+  }
+
+  /** Encode this message as a `byte[]`. */
+  actual fun encode(): ByteArray {
+    @Suppress("UNCHECKED_CAST")
+    return adapter.encode(this as M)
+  }
+
+  /** Encode this message as a `ByteString`. */
+  actual fun encodeByteString(): ByteString {
+    @Suppress("UNCHECKED_CAST")
+    return adapter.encodeByteString(this as M)
+  }
+
+  /**
+   * Superclass for protocol buffer message builders.
+   */
+  actual abstract class Builder<M : Message<M, B>, B : Builder<M, B>> protected actual constructor() {
+    internal actual var unknownFieldsByteString = ByteString.EMPTY
+    internal actual var unknownFieldsBuffer: Buffer? = null
+    internal actual var unknownFieldsWriter: ProtoWriter? = null
+
+    actual fun addUnknownFields(unknownFields: ByteString): Builder<M, B> = apply {
+      if (unknownFields.size > 0) {
+        prepareForNewUnknownFields()
+        unknownFieldsWriter!!.writeBytes(unknownFields)
+      }
+    }
+
+    actual fun addUnknownField(
+      tag: Int,
+      fieldEncoding: FieldEncoding,
+      value: Any?,
+    ): Builder<M, B> = apply {
+      prepareForNewUnknownFields()
+      @Suppress("UNCHECKED_CAST")
+      val protoAdapter = fieldEncoding.rawProtoAdapter() as ProtoAdapter<Any>
+      protoAdapter.encodeWithTag(unknownFieldsWriter!!, tag, value)
+    }
+
+    actual fun clearUnknownFields(): Builder<M, B> = apply {
+      unknownFieldsByteString = ByteString.EMPTY
+      if (unknownFieldsBuffer != null) {
+        unknownFieldsBuffer!!.clear()
+        unknownFieldsBuffer = null
+      }
+      unknownFieldsWriter = null
+    }
+
+    actual fun buildUnknownFields(): ByteString {
+      if (unknownFieldsBuffer != null) {
+        // Reads and caches the unknown fields from the buffer.
+        unknownFieldsByteString = unknownFieldsBuffer!!.readByteString()
+        unknownFieldsBuffer = null
+        unknownFieldsWriter = null
+      }
+      return unknownFieldsByteString
+    }
+
+    actual abstract fun build(): M
+
+    private fun prepareForNewUnknownFields() {
+      if (unknownFieldsBuffer == null) {
+        unknownFieldsBuffer = Buffer()
+        unknownFieldsWriter = ProtoWriter(unknownFieldsBuffer!!)
+        // Writes the cached unknown fields to the buffer.
+        unknownFieldsWriter!!.writeBytes(unknownFieldsByteString)
+        unknownFieldsByteString = ByteString.EMPTY
+      }
+    }
+  }
+}

wire-runtime/src/wasmWasiMain/kotlin/com/squareup/wire/MessageSink.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2019 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.wire
+
+actual interface MessageSink<in T : Any> {
+  actual fun write(message: T)
+
+  actual fun cancel()
+
+  actual fun close()
+}

wire-runtime/src/wasmWasiMain/kotlin/com/squareup/wire/MessageSource.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.wire
+
+actual interface MessageSource<out T : Any> {
+  actual fun read(): T?
+
+  actual fun close()
+}