Add support for BigInts and BigInt-based TypedArrays

.github/workflows/compatibility.yml

@@ -22,3 +22,6 @@ jobs:
           make bootstrap
           cd Example/JavaScriptKitExample
           swift build --triple wasm32-unknown-wasi
+          swift build --triple wasm32-unknown-wasi -Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS
+          swift build --triple wasm32-unknown-wasi -Xswiftc -DJAVASCRIPTKIT_WITHOUT_BIGINTS
+          swift build --triple wasm32-unknown-wasi -Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS -Xswiftc -DJAVASCRIPTKIT_WITHOUT_BIGINTS

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -853,4 +853,35 @@ try test("JSValueDecoder") {
 }
 
 
+try test("BigInt") {
+    func expectPassesThrough(signed value: Int64) throws {
+        let bigInt = JSBigInt(value)
+        try expectEqual(bigInt.description, value.description)
+    }
+
+    func expectPassesThrough(unsigned value: UInt64) throws {
+        let bigInt = JSBigInt(unsigned: value)
+        try expectEqual(bigInt.description, value.description)
+    }
+
+    try expectPassesThrough(signed: 0)
+    try expectPassesThrough(signed: 1 << 62)
+    try expectPassesThrough(signed: -2305)
+    for _ in 0 ..< 100 {
+        try expectPassesThrough(signed: .random(in: .min ... .max))
+    }
+    try expectPassesThrough(signed: .min)
+    try expectPassesThrough(signed: .max)
+
+    try expectPassesThrough(unsigned: 0)
+    try expectPassesThrough(unsigned: 1 << 62)
+    try expectPassesThrough(unsigned: 1 << 63)
+    try expectPassesThrough(unsigned: .min)
+    try expectPassesThrough(unsigned: .max)
+    try expectPassesThrough(unsigned: ~0)
+    for _ in 0 ..< 100 {
+        try expectPassesThrough(unsigned: .random(in: .min ... .max))
+    }
+}
+
 Expectation.wait(expectations)

IntegrationTests/lib.js

@@ -6,6 +6,8 @@ const promisify = require("util").promisify;
 const fs = require("fs");
 const readFile = promisify(fs.readFile);
 
+Error.stackTraceLimit = Infinity;
+
 const startWasiTask = async (wasmPath) => {
     // Instantiate a new WASI Instance
     const wasmFs = new WasmFs();

README.md

@@ -149,7 +149,7 @@ JavaScript features should work, which currently includes:
 - Mobile Safari 14.8+
 
 If you need to support older browser versions, you'll have to build with
-`JAVASCRIPTKIT_WITHOUT_WEAKREFS` flag, passing `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS` flags
+`JAVASCRIPTKIT_WITHOUT_WEAKREFS` and `JAVASCRIPTKIT_WITHOUT_BIGINTS` flags, passing `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS -Xswiftc -DJAVASCRIPTKIT_WITHOUT_BIGINTS` flags
 when compiling. This should lower browser requirements to these versions:
 
 - Edge 16+

Runtime/src/index.ts

@@ -14,7 +14,7 @@ export class SwiftRuntime {
     private _instance: WebAssembly.Instance | null;
     private _memory: Memory | null;
     private _closureDeallocator: SwiftClosureDeallocator | null;
-    private version: number = 706;
+    private version: number = 707;
 
     private textDecoder = new TextDecoder("utf-8");
     private textEncoder = new TextEncoder(); // Only support utf-8
@@ -35,6 +35,17 @@ export class SwiftRuntime {
                 }`
             );
         }
+
+        if (this.exports.swjs_library_features() & LibraryFeatures.BigInts) {
+            if (typeof BigInt === "undefined") {
+                throw new Error(
+                    "The Swift part of JavaScriptKit was configured to require " +
+                        "the availability of JavaScript BigInts. Please build " +
+                        "with `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_BIGINTS` to " +
+                        "disable features that use BigInts."
+                );
+            }
+        }
     }
 
     private get instance() {
@@ -114,7 +125,6 @@ export class SwiftRuntime {
             const value = JSValue.decode(kind, payload1, payload2, this.memory);
             obj[key] = value;
         },
-
         swjs_get_prop: (
             ref: ref,
             name: ref,
@@ -146,7 +156,6 @@ export class SwiftRuntime {
             const value = JSValue.decode(kind, payload1, payload2, this.memory);
             obj[index] = value;
         },
-
         swjs_get_subscript: (
             ref: ref,
             index: number,
@@ -172,15 +181,13 @@ export class SwiftRuntime {
             this.memory.writeUint32(bytes_ptr_result, bytes_ptr);
             return bytes.length;
         },
-
         swjs_decode_string: (bytes_ptr: pointer, length: number) => {
             const bytes = this.memory
                 .bytes()
                 .subarray(bytes_ptr, bytes_ptr + length);
             const string = this.textDecoder.decode(bytes);
             return this.memory.retain(string);
         },
-
         swjs_load_string: (ref: ref, buffer: pointer) => {
             const bytes = this.memory.getObject(ref);
             this.memory.writeBytes(buffer, bytes);
@@ -290,7 +297,6 @@ export class SwiftRuntime {
                 this.memory
             );
         },
-
         swjs_call_function_with_this_no_catch: (
             obj_ref: ref,
             func_ref: ref,
@@ -328,13 +334,13 @@ export class SwiftRuntime {
                 }
             }
         },
+
         swjs_call_new: (ref: ref, argv: pointer, argc: number) => {
             const constructor = this.memory.getObject(ref);
             const args = JSValue.decodeArray(argv, argc, this.memory);
             const instance = new constructor(...args);
             return this.memory.retain(instance);
         },
-
         swjs_call_throwing_new: (
             ref: ref,
             argv: pointer,
@@ -409,5 +415,25 @@ export class SwiftRuntime {
         swjs_release: (ref: ref) => {
             this.memory.release(ref);
         },
+
+        swjs_i64_to_bigint: (value: bigint, signed: number) => {
+            return this.memory.retain(
+                signed ? value : BigInt.asUintN(64, value)
+            );
+        },
+        swjs_bigint_to_i64: (ref: ref, signed: number) => {
+            const object = this.memory.getObject(ref);
+            if (typeof object !== "bigint") {
+                throw new Error(`Expected a BigInt, but got ${typeof object}`);
+            }
+            if (signed) {
+                return object;
+            } else {
+                if (object < BigInt(0)) {
+                    return BigInt(0);
+                }
+                return BigInt.asIntN(64, object);
+            }
+        },
     };
 }

Runtime/src/js-value.ts

@@ -1,8 +1,7 @@
 import { Memory } from "./memory";
-import { pointer } from "./types";
+import { assertNever, pointer } from "./types";
 
-export enum Kind {
-    Invalid = -1,
+export const enum Kind {
     Boolean = 0,
     String = 1,
     Number = 2,
@@ -11,6 +10,7 @@ export enum Kind {
     Undefined = 5,
     Function = 6,
     Symbol = 7,
+    BigInt = 8,
 }
 
 export const decode = (
@@ -33,6 +33,8 @@ export const decode = (
         case Kind.String:
         case Kind.Object:
         case Kind.Function:
+        case Kind.Symbol:
+        case Kind.BigInt:
             return memory.getObject(payload1);
 
         case Kind.Null:
@@ -42,7 +44,7 @@ export const decode = (
             return undefined;
 
         default:
-            throw new Error(`JSValue Type kind "${kind}" is not supported`);
+            assertNever(kind, `JSValue Type kind "${kind}" is not supported`);
     }
 };
 
@@ -73,7 +75,14 @@ export const write = (
         memory.writeUint32(kind_ptr, exceptionBit | Kind.Null);
         return;
     }
-    switch (typeof value) {
+
+    const writeRef = (kind: Kind) => {
+        memory.writeUint32(kind_ptr, exceptionBit | kind);
+        memory.writeUint32(payload1_ptr, memory.retain(value));
+    };
+
+    const type = typeof value;
+    switch (type) {
         case "boolean": {
             memory.writeUint32(kind_ptr, exceptionBit | Kind.Boolean);
             memory.writeUint32(payload1_ptr, value ? 1 : 0);
@@ -85,30 +94,30 @@ export const write = (
             break;
         }
         case "string": {
-            memory.writeUint32(kind_ptr, exceptionBit | Kind.String);
-            memory.writeUint32(payload1_ptr, memory.retain(value));
+            writeRef(Kind.String);
             break;
         }
         case "undefined": {
             memory.writeUint32(kind_ptr, exceptionBit | Kind.Undefined);
             break;
         }
         case "object": {
-            memory.writeUint32(kind_ptr, exceptionBit | Kind.Object);
-            memory.writeUint32(payload1_ptr, memory.retain(value));
+            writeRef(Kind.Object);
             break;
         }
         case "function": {
-            memory.writeUint32(kind_ptr, exceptionBit | Kind.Function);
-            memory.writeUint32(payload1_ptr, memory.retain(value));
+            writeRef(Kind.Function);
             break;
         }
         case "symbol": {
-            memory.writeUint32(kind_ptr, exceptionBit | Kind.Symbol);
-            memory.writeUint32(payload1_ptr, memory.retain(value));
+            writeRef(Kind.Symbol);
+            break;
+        }
+        case "bigint": {
+            writeRef(Kind.BigInt);
             break;
         }
         default:
-            throw new Error(`Type "${typeof value}" is not supported yet`);
+            assertNever(type, `Type "${type}" is not supported yet`);
     }
 };

Runtime/src/memory.ts

@@ -17,13 +17,20 @@ export class Memory {
     bytes = () => new Uint8Array(this.rawMemory.buffer);
     dataView = () => new DataView(this.rawMemory.buffer);
 
-    writeBytes = (ptr: pointer, bytes: Uint8Array) => this.bytes().set(bytes, ptr);
+    writeBytes = (ptr: pointer, bytes: Uint8Array) =>
+        this.bytes().set(bytes, ptr);
 
     readUint32 = (ptr: pointer) => this.dataView().getUint32(ptr, true);
+    readUint64 = (ptr: pointer) => this.dataView().getBigUint64(ptr, true);
+    readInt64 = (ptr: pointer) => this.dataView().getBigInt64(ptr, true);
     readFloat64 = (ptr: pointer) => this.dataView().getFloat64(ptr, true);
 
     writeUint32 = (ptr: pointer, value: number) =>
         this.dataView().setUint32(ptr, value, true);
+    writeUint64 = (ptr: pointer, value: bigint) =>
+        this.dataView().setBigUint64(ptr, value, true);
+    writeInt64 = (ptr: pointer, value: bigint) =>
+        this.dataView().setBigInt64(ptr, value, true);
     writeFloat64 = (ptr: pointer, value: number) =>
         this.dataView().setFloat64(ptr, value, true);
 }

Runtime/src/types.ts

@@ -2,6 +2,7 @@ import * as JSValue from "./js-value";
 
 export type ref = number;
 export type pointer = number;
+export type bool = number;
 
 export interface ExportedFunctions {
     swjs_library_version(): number;
@@ -102,10 +103,13 @@ export interface ImportedFunctions {
     ): number;
     swjs_load_typed_array(ref: ref, buffer: pointer): void;
     swjs_release(ref: number): void;
+    swjs_i64_to_bigint(value: bigint, signed: bool): ref;
+    swjs_bigint_to_i64(ref: ref, signed: bool): bigint;
 }
 
-export enum LibraryFeatures {
+export const enum LibraryFeatures {
     WeakRefs = 1 << 0,
+    BigInts = 1 << 1,
 }
 
 export type TypedArray =
@@ -120,3 +124,7 @@ export type TypedArray =
     // | BigUint64ArrayConstructor
     | Float32ArrayConstructor
     | Float64ArrayConstructor;
+
+export function assertNever(x: never, message: string) {
+    throw new Error(message);
+}

Runtime/tsconfig.json

@@ -8,7 +8,7 @@
         "rootDir": "src",
         "strict": true,
         "target": "es2017",
-        "lib": ["es2017", "DOM", "ESNext.WeakRef"],
+        "lib": ["es2020", "DOM", "ESNext.WeakRef"],
         "skipLibCheck": true
     },
     "include": ["src/**/*"],

Sources/JavaScriptEventLoop/JavaScriptEventLoop.swift

@@ -12,15 +12,15 @@ public final class JavaScriptEventLoop: SerialExecutor, @unchecked Sendable {
     /// See also: https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide
     let queueMicrotask: @Sendable (@escaping () -> Void) -> Void
     /// A function that invokes a given closure after a specified number of milliseconds.
-    let setTimeout: @Sendable (UInt64, @escaping () -> Void) -> Void
+    let setTimeout: @Sendable (Double, @escaping () -> Void) -> Void
 
     /// A mutable state to manage internal job queue
     /// Note that this should be guarded atomically when supporting multi-threaded environment.
     var queueState = QueueState()
 
     private init(
         queueTask: @Sendable @escaping (@escaping () -> Void) -> Void,
-        setTimeout: @Sendable @escaping (UInt64, @escaping () -> Void) -> Void
+        setTimeout: @Sendable @escaping (Double, @escaping () -> Void) -> Void
     ) {
         self.queueMicrotask = queueTask
         self.setTimeout = setTimeout
@@ -83,7 +83,7 @@ public final class JavaScriptEventLoop: SerialExecutor, @unchecked Sendable {
 
     private func enqueue(_ job: UnownedJob, withDelay nanoseconds: UInt64) {
         let milliseconds = nanoseconds / 1_000_000
-        setTimeout(milliseconds, {
+        setTimeout(Double(milliseconds), {
             job._runSynchronously(on: self.asUnownedSerialExecutor())
         })
     }

Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift

@@ -135,14 +135,14 @@ extension UInt32: TypedArrayElement {
     public static var typedArrayClass = JSObject.global.Uint32Array.function!
 }
 
-// FIXME: Support passing BigInts across the bridge
-// See https://github.com/swiftwasm/JavaScriptKit/issues/56
-//extension Int64: TypedArrayElement {
-//    public static var typedArrayClass = JSObject.global.BigInt64Array.function!
-//}
-//extension UInt64: TypedArrayElement {
-//    public static var typedArrayClass = JSObject.global.BigUint64Array.function!
-//}
+#if !JAVASCRIPTKIT_WITHOUT_BIGINTS
+extension Int64: TypedArrayElement {
+    public static var typedArrayClass = JSObject.global.BigInt64Array.function!
+}
+extension UInt64: TypedArrayElement {
+    public static var typedArrayClass = JSObject.global.BigUint64Array.function!
+}
+#endif
 
 extension Float32: TypedArrayElement {
     public static var typedArrayClass = JSObject.global.Float32Array.function!