Add support for BigInts and BigInt-based TypedArrays

.github/workflows/compatibility.yml

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

IntegrationTests/TestSuites/Package.swift

@@ -8,7 +8,7 @@ let package = Package(
         // This package doesn't work on macOS host, but should be able to be built for it
         // for developing on Xcode. This minimum version requirement is to prevent availability
         // errors for Concurrency API, whose runtime support is shipped from macOS 12.0
-        .macOS("12.0")
+        .macOS("12.0"),
     ],
     products: [
         .executable(
@@ -25,6 +25,7 @@ let package = Package(
     targets: [
         .target(name: "CHelpers"),
         .target(name: "PrimaryTests", dependencies: [
+            .product(name: "JavaScriptBigIntSupport", package: "JavaScriptKit"),
             "JavaScriptKit",
             "CHelpers",
         ]),

IntegrationTests/TestSuites/Sources/PrimaryTests/I64.swift

@@ -0,0 +1,35 @@
+import JavaScriptBigIntSupport
+import JavaScriptKit
+
+func testI64() throws {
+    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))
+        }
+    }
+}

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -852,5 +852,5 @@ try test("JSValueDecoder") {
     try expectEqual(decodedTama.isCat, true)
 }
 
-
+try testI64()
 Expectation.wait(expectations)

IntegrationTests/bin/concurrency-tests.js

@@ -1,5 +1,7 @@
 const { startWasiTask } = require("../lib");
 
+Error.stackTraceLimit = Infinity;
+
 startWasiTask("./dist/ConcurrencyTests.wasm").catch((err) => {
     console.log(err);
     process.exit(1);

IntegrationTests/bin/primary-tests.js

@@ -1,3 +1,5 @@
+Error.stackTraceLimit = Infinity;
+
 global.globalObject1 = {
     prop_1: {
         nested_prop: 1,
@@ -44,23 +46,26 @@ global.globalObject1 = {
             throw "String Error";
         },
         func3: function () {
-            throw 3.0
+            throw 3.0;
         },
     },
     eval_closure: function (fn) {
-        return fn(arguments[1])
+        return fn(arguments[1]);
     },
     observable_obj: {
         set_called: false,
-        target: new Proxy({
-            nested: {}
-        }, {
-            set(target, key, value) {
-                global.globalObject1.observable_obj.set_called = true;
-                target[key] = value;
-                return true;
+        target: new Proxy(
+            {
+                nested: {},
+            },
+            {
+                set(target, key, value) {
+                    global.globalObject1.observable_obj.set_called = true;
+                    target[key] = value;
+                    return true;
+                },
             }
-        })
+        ),
     },
 };
 
@@ -79,16 +84,16 @@ global.Animal = function (name, age, isCat) {
     };
     this.setName = function (name) {
         this.name = name;
-    }
+    };
 };
 
-global.callThrowingClosure = (c) => { 
+global.callThrowingClosure = (c) => {
     try {
-        c() 
+        c();
     } catch (error) {
-        return error
+        return error;
     }
-}
+};
 
 const { startWasiTask } = require("../lib");
 

Package.swift

@@ -7,13 +7,19 @@ let package = Package(
     products: [
         .library(name: "JavaScriptKit", targets: ["JavaScriptKit"]),
         .library(name: "JavaScriptEventLoop", targets: ["JavaScriptEventLoop"]),
+        .library(name: "JavaScriptBigIntSupport", targets: ["JavaScriptBigIntSupport"]),
     ],
     targets: [
         .target(
             name: "JavaScriptKit",
             dependencies: ["_CJavaScriptKit"]
         ),
         .target(name: "_CJavaScriptKit"),
+        .target(
+            name: "JavaScriptBigIntSupport",
+            dependencies: ["_CJavaScriptBigIntSupport", "JavaScriptKit"]
+        ),
+        .target(name: "_CJavaScriptBigIntSupport", dependencies: ["_CJavaScriptKit"]),
         .target(
             name: "JavaScriptEventLoop",
             dependencies: ["JavaScriptKit", "_CJavaScriptEventLoop"]

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
+the `JAVASCRIPTKIT_WITHOUT_WEAKREFS` flag, passing `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS` 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
@@ -114,7 +114,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 +145,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 +170,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 +286,6 @@ export class SwiftRuntime {
                 this.memory
             );
         },
-
         swjs_call_function_with_this_no_catch: (
             obj_ref: ref,
             func_ref: ref,
@@ -328,13 +323,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 +404,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);
 }