Add a helper method to copy an array of numbers to a JS TypedArray (#31)

j-f1 · kateinoigakukun · web-flow · commit 171c39165572 · 2020-09-11T06:37:10.000+09:00
* Add a helper method to copy an array of numbers to a JS TypedArray

* _copy_typed_array_content → _create_typed_array

* Add globalVariable

* Remove broken test target

* Create JSTypedArray

* Reduce to just a single class

* Clean up types

* Fix tests

* Formatting

* Test all the array types

* Fix test error

* Add a test("name") { ... } helper that makes it easy to find out which test errors on the JS side happen in

* Rename allocHeap and freeHeap to retain/release

This matches the Objective-C names and better corresponds with their tasks (freeHeap just decreases ref count so it doesn’t always free). I’m not as sure about allocHeap → retain because it adds to the heap in addition to increasing the refcount.

* Propagate names through to the Swift side

* Add an explicit retain() function and fix a ref counting bug

* Add error when reading invalid reference

Previously it would just return undefined which would throw an error when attempting to use the object later on. Now you’re able to demangle the stack trace to find exactly where you’re misusing a ref.

* Actually fix the tests

* Explain why _retain is necessary

* Update _CJavaScriptKit.h

* Remove manual reference counting

* Fix test cases

* Expose failable initializer

Co-authored-by: Yuta Saito &lt;kateinoigakukun@gmail.com&gt;
diff --git a/IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift b/IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift
@@ -341,3 +341,56 @@ try test("Closure Identifiers") {
     let oid2 = closureScope()
     try expectEqual(oid1, oid2)
 }
+
+func checkArray<T>(_ array: [T]) throws where T: TypedArrayElement {
+    try expectEqual(toString(JSTypedArray(array).jsValue().object!), jsStringify(array))
+}
+
+func toString<T: JSObject>(_ object: T) -> String {
+    return object.toString!().string!
+}
+
+func jsStringify(_ array: [Any]) -> String {
+    array.map({ String(describing: $0) }).joined(separator: ",")
+}
+
+try test("TypedArray") {
+    let numbers = [UInt8](0 ... 255)
+    let typedArray = JSTypedArray(numbers)
+    try expectEqual(typedArray[12], 12)
+
+    try checkArray([0, .max, 127, 1] as [UInt8])
+    try checkArray([0, 1, .max, .min, -1] as [Int8])
+
+    try checkArray([0, .max, 255, 1] as [UInt16])
+    try checkArray([0, 1, .max, .min, -1] as [Int16])
+
+    try checkArray([0, .max, 255, 1] as [UInt32])
+    try checkArray([0, 1, .max, .min, -1] as [Int32])
+
+    try checkArray([0, .max, 255, 1] as [UInt])
+    try checkArray([0, 1, .max, .min, -1] as [Int])
+
+    let float32Array: [Float32] = [0, 1, .pi, .greatestFiniteMagnitude, .infinity, .leastNonzeroMagnitude, .leastNormalMagnitude, 42]
+    let jsFloat32Array = JSTypedArray(float32Array)
+    for (i, num) in float32Array.enumerated() {
+        try expectEqual(num, jsFloat32Array[i])
+    }
+
+    let float64Array: [Float64] = [0, 1, .pi, .greatestFiniteMagnitude, .infinity, .leastNonzeroMagnitude, .leastNormalMagnitude, 42]
+    let jsFloat64Array = JSTypedArray(float64Array)
+    for (i, num) in float64Array.enumerated() {
+        try expectEqual(num, jsFloat64Array[i])
+    }
+}
+
+try test("TypedArray_Mutation") {
+    let array = JSTypedArray<Int>(length: 100)
+    for i in 0..<100 {
+        array[i] = i
+    }
+    for i in 0..<100 {
+        try expectEqual(i, array[i])
+    }
+    try expectEqual(toString(array.jsValue().object!), jsStringify(Array(0..<100)))
+}
diff --git a/Runtime/src/index.ts b/Runtime/src/index.ts
@@ -8,6 +8,17 @@ type pointer = number;
 interface GlobalVariable { }
 declare const window: GlobalVariable;
 declare const global: GlobalVariable;
+let globalVariable: any;
+if (typeof globalThis !== "undefined") {
+    globalVariable = globalThis
+} else if (typeof window !== "undefined") {
+    globalVariable = window
+} else if (typeof global !== "undefined") {
+    globalVariable = global
+} else if (typeof self !== "undefined") {
+    globalVariable = self
+}
+
 
 interface SwiftRuntimeExportedFunctions {
     swjs_library_version(): number;
@@ -31,6 +42,32 @@ enum JavaScriptValueKind {
     Function = 6,
 }
 
+enum JavaScriptTypedArrayKind {
+    Int8 = 0,
+    Uint8 = 1,
+    Int16 = 2,
+    Uint16 = 3,
+    Int32 = 4,
+    Uint32 = 5,
+    BigInt64 = 6,
+    BigUint64 = 7,
+    Float32 = 8,
+    Float64 = 9,
+}
+
+type TypedArray =
+    | Int8ArrayConstructor
+    | Uint8ArrayConstructor
+    | Int16ArrayConstructor
+    | Uint16ArrayConstructor
+    | Int32ArrayConstructor
+    | Uint32ArrayConstructor
+    // | BigInt64ArrayConstructor
+    // | BigUint64ArrayConstructor
+    | Float32ArrayConstructor
+    | Float64ArrayConstructor
+
+
 type SwiftRuntimeHeapEntry = {
     id: number,
     rc: number,
@@ -41,23 +78,17 @@ class SwiftRuntimeHeap {
     private _heapNextKey: number;
 
     constructor() {
-        let _global: any;
-        if (typeof window !== "undefined") {
-            _global = window
-        } else if (typeof global !== "undefined") {
-            _global = global
-        }
         this._heapValueById = new Map();
-        this._heapValueById.set(0, _global);
+        this._heapValueById.set(0, globalVariable);
 
         this._heapEntryByValue = new Map();
-        this._heapEntryByValue.set(_global, { id: 0, rc: 1 });
+        this._heapEntryByValue.set(globalVariable, { id: 0, rc: 1 });
 
         // Note: 0 is preserved for global
         this._heapNextKey = 1;
     }
 
-    allocHeap(value: any) {
+    retain(value: any) {
         const isObject = typeof value == "object";
         const entry = this._heapEntryByValue.get(value);
         if (isObject && entry) {
@@ -72,7 +103,7 @@ class SwiftRuntimeHeap {
         return id
     }
 
-    freeHeap(ref: ref) {
+    release(ref: ref) {
         const value = this._heapValueById.get(ref);
         const isObject = typeof value == "object"
         if (isObject) {
@@ -88,7 +119,11 @@ class SwiftRuntimeHeap {
     }
 
     referenceHeap(ref: ref) {
-        return this._heapValueById.get(ref)
+        const value = this._heapValueById.get(ref)
+        if (value === undefined) {
+            throw new ReferenceError("Attempted to read invalid reference " + ref)
+        }
+        return value
     }
 }
 
@@ -130,7 +165,7 @@ export class SwiftRuntime {
                 writeValue(argument, base, base + 4, base + 8, base + 16)
             }
             let output: any;
-            const callback_func_ref = this.heap.allocHeap(function (result: any) {
+            const callback_func_ref = this.heap.retain(function (result: any) {
                 output = result
             })
             exports.swjs_call_host_function(host_func_id, argv, argc, callback_func_ref)
@@ -241,7 +276,7 @@ export class SwiftRuntime {
                 case "string": {
                     const bytes = textEncoder.encode(value);
                     writeUint32(kind_ptr, JavaScriptValueKind.String);
-                    writeUint32(payload1_ptr, this.heap.allocHeap(bytes));
+                    writeUint32(payload1_ptr, this.heap.retain(bytes));
                     writeUint32(payload2_ptr, bytes.length);
                     break;
                 }
@@ -253,13 +288,13 @@ export class SwiftRuntime {
                 }
                 case "object": {
                     writeUint32(kind_ptr, JavaScriptValueKind.Object);
-                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
+                    writeUint32(payload1_ptr, this.heap.retain(value));
                     writeUint32(payload2_ptr, 0);
                     break;
                 }
                 case "function": {
                     writeUint32(kind_ptr, JavaScriptValueKind.Function);
-                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
+                    writeUint32(payload1_ptr, this.heap.retain(value));
                     writeUint32(payload2_ptr, 0);
                     break;
                 }
@@ -347,7 +382,7 @@ export class SwiftRuntime {
                 host_func_id: number,
                 func_ref_ptr: pointer,
             ) => {
-                const func_ref = this.heap.allocHeap(function () {
+                const func_ref = this.heap.retain(function () {
                     return callHostFunction(host_func_id, Array.prototype.slice.call(arguments))
                 })
                 writeUint32(func_ref_ptr, func_ref)
@@ -360,7 +395,7 @@ export class SwiftRuntime {
                 const result = Reflect.construct(obj, decodeValues(argv, argc))
                 if (typeof result != "object")
                     throw Error(`Invalid result type of object constructor of "${obj}": "${result}"`)
-                writeUint32(result_obj, this.heap.allocHeap(result));
+                writeUint32(result_obj, this.heap.retain(result));
             },
             swjs_instanceof: (
                 obj_ref: ref, constructor_ref: ref,
@@ -370,8 +405,21 @@ export class SwiftRuntime {
               const constructor = this.heap.referenceHeap(constructor_ref)
               return obj instanceof constructor
             },
-            swjs_destroy_ref: (ref: ref) => {
-                this.heap.freeHeap(ref)
+            swjs_create_typed_array: (
+                kind: JavaScriptTypedArrayKind,
+                elementsPtr: pointer, length: number,
+                result_obj: pointer
+            ) => {
+                const ArrayType: TypedArray = globalVariable[JavaScriptTypedArrayKind[kind] + 'Array']
+                const array = new ArrayType(memory().buffer, elementsPtr, length);
+                // Call `.slice()` to copy the memory
+                writeUint32(result_obj, this.heap.retain(array.slice()));
+            },
+            swjs_retain: (ref: ref) => {
+                this.heap.retain(this.heap.referenceHeap(ref))
+            },
+            swjs_release: (ref: ref) => {
+                this.heap.release(ref)
             }
         }
     }
diff --git a/Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift b/Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift
@@ -0,0 +1,136 @@
+//
+//  Created by Manuel Burghard. Licensed unter MIT.
+//
+
+import _CJavaScriptKit
+
+public protocol TypedArrayElement: JSValueConvertible, JSValueConstructible {
+    static var typedArrayKind: JavaScriptTypedArrayKind { get }
+    static var typedArrayClass: JSFunctionRef { get }
+}
+
+public class JSTypedArray<Element>: JSValueConvertible, ExpressibleByArrayLiteral where Element: TypedArrayElement {
+    let ref: JSObject
+    public func jsValue() -> JSValue {
+        .object(ref)
+    }
+
+    public subscript(_ index: Int) -> Element {
+        get {
+            return Element.construct(from: getJSValue(this: ref, index: Int32(index)))!
+        }
+        set {
+            setJSValue(this: ref, index: Int32(index), value: newValue.jsValue())
+        }
+    }
+    
+    // This private initializer assumes that the passed object is TypedArray
+    private init(unsafe object: JSObject) {
+        self.ref = object
+    }
+
+    public init?(_ object: JSObject) {
+        guard object.isInstanceOf(Element.typedArrayClass) else { return nil }
+        self.ref = object
+    }
+
+    public convenience init(length: Int) {
+        let jsObject = Element.typedArrayClass.new(length)
+        self.init(unsafe: jsObject)
+    }
+
+    required public convenience init(arrayLiteral elements: Element...) {
+        self.init(elements)
+    }
+
+    public convenience init(_ array: [Element]) {
+        var resultObj = JavaScriptObjectRef()
+        array.withUnsafeBufferPointer { ptr in
+            _create_typed_array(Element.typedArrayKind, ptr.baseAddress!, Int32(array.count), &resultObj)
+        }
+        self.init(unsafe: JSObject(id: resultObj))
+    }
+
+    public convenience init(_ stride: StrideTo<Element>) where Element: Strideable {
+        self.init(stride.map({ $0 }))
+    }
+}
+
+// MARK: - Int and UInt support
+
+// FIXME: Should be updated to support wasm64 when that becomes available.
+func valueForBitWidth<T>(typeName: String, bitWidth: Int, when32: T) -> T {
+    if bitWidth == 32 {
+        return when32
+    } else if bitWidth == 64 {
+        fatalError("64-bit \(typeName)s are not yet supported in JSTypedArray")
+    } else {
+        fatalError("Unsupported bit width for type \(typeName): \(bitWidth) (hint: stick to fixed-size \(typeName)s to avoid this issue)")
+    }
+}
+
+extension Int: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef {
+        valueForBitWidth(typeName: "Int", bitWidth: Int.bitWidth, when32: JSObjectRef.global.Int32Array).function!
+    }
+    public static var typedArrayKind: JavaScriptTypedArrayKind {
+        valueForBitWidth(typeName: "Int", bitWidth: Int.bitWidth, when32: .int32)
+    }
+}
+extension UInt: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef {
+        valueForBitWidth(typeName: "UInt", bitWidth: Int.bitWidth, when32: JSObjectRef.global.Uint32Array).function!
+    }
+    public static var typedArrayKind: JavaScriptTypedArrayKind {
+        valueForBitWidth(typeName: "UInt", bitWidth: UInt.bitWidth, when32: .uint32)
+    }
+}
+
+// MARK: - Concrete TypedArray classes
+
+extension Int8: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Int8Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .int8 }
+}
+extension UInt8: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Uint8Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .uint8 }
+}
+// TODO: Support Uint8ClampedArray?
+
+extension Int16: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Int16Array.function! }
+   public static var typedArrayKind: JavaScriptTypedArrayKind { .int16 }
+}
+extension UInt16: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Uint16Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .uint16 }
+}
+
+extension Int32: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Int32Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .int32 }
+}
+extension UInt32: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Uint32Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .uint32 }
+}
+
+// FIXME: Support passing BigInts across the bridge
+//extension Int64: TypedArrayElement {
+//    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.BigInt64Array.function! }
+//    public static var type: JavaScriptTypedArrayKind { .bigInt64 }
+//}
+//extension UInt64: TypedArrayElement {
+//    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.BigUint64Array.function! }
+//    public static var type: JavaScriptTypedArrayKind { .bigUint64 }
+//}
+
+extension Float32: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Float32Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .float32 }
+}
+extension Float64: TypedArrayElement {
+    public static var typedArrayClass: JSFunctionRef { JSObjectRef.global.Float64Array.function! }
+    public static var typedArrayKind: JavaScriptTypedArrayKind { .float64 }
+}
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift b/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift
@@ -34,10 +34,10 @@ public class JSObject: Equatable {
         _instanceof(id, constructor.id)
     }
 
-    static let _JS_Predef_Value_Global: UInt32 = 0
+    static let _JS_Predef_Value_Global: JavaScriptObjectRef = 0
     public static let global = JSObject(id: _JS_Predef_Value_Global)
 
-    deinit { _destroy_ref(id) }
+    deinit { _release(id) }
 
     public static func == (lhs: JSObject, rhs: JSObject) -> Bool {
         return lhs.id == rhs.id
@@ -47,3 +47,4 @@ public class JSObject: Equatable {
         .object(self)
     }
 }
+
diff --git a/Sources/JavaScriptKit/JSValueConvertible.swift b/Sources/JavaScriptKit/JSValueConvertible.swift
@@ -40,6 +40,10 @@ extension UInt16: JSValueConvertible {
     public func jsValue() -> JSValue { .number(Double(self)) }
 }
 
+extension UInt32: JSValueConvertible {
+  public func jsValue() -> JSValue { .number(Double(self)) }
+}
+
 extension Float: JSValueConvertible {
     public func jsValue() -> JSValue { .number(Double(self)) }
 }
diff --git a/Sources/JavaScriptKit/XcodeSupport.swift b/Sources/JavaScriptKit/XcodeSupport.swift
diff --git a/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h b/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

Original file line number	Diff line number	Diff line change
`@@ -34,10 +34,10 @@ public class JSObject: Equatable {`
`34`	`34`	`_instanceof(id, constructor.id)`
`35`	`35`	`}`
`36`	`36`
`37`		`- static let _JS_Predef_Value_Global: UInt32 = 0`
	`37`	`+ static let _JS_Predef_Value_Global: JavaScriptObjectRef = 0`
`38`	`38`	`public static let global = JSObject(id: _JS_Predef_Value_Global)`
`39`	`39`
`40`		`- deinit { _destroy_ref(id) }`
	`40`	`+ deinit { _release(id) }`
`41`	`41`
`42`	`42`	`public static func == (lhs: JSObject, rhs: JSObject) -> Bool {`
`43`	`43`	`return lhs.id == rhs.id`
`@@ -47,3 +47,4 @@ public class JSObject: Equatable {`
`47`	`47`	`.object(self)`
`48`	`48`	`}`
`49`	`49`	`}`
	`50`	`+`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,10 @@ extension UInt16: JSValueConvertible {`
`40`	`40`	`public func jsValue() -> JSValue { .number(Double(self)) }`
`41`	`41`	`}`
`42`	`42`
	`43`	`+extension UInt32: JSValueConvertible {`
	`44`	`+ public func jsValue() -> JSValue { .number(Double(self)) }`
	`45`	`+}`
	`46`	`+`
`43`	`47`	`extension Float: JSValueConvertible {`
`44`	`48`	`public func jsValue() -> JSValue { .number(Double(self)) }`
`45`	`49`	`}`