Return from runtime functions instead of taking a pointer where possible (#147)

j-f1 · web-flow · commit 10349408e88c · 2022-01-04T04:01:25.000+09:00
* Explicitly write false into the exception bit in swjs_call_throwing_new

* Update Prettier

* Return from runtime functions instead of taking a pointer where possible

* Reorder functions to match each other

* );

* bump versions
diff --git a/Runtime/src/index.ts b/Runtime/src/index.ts
@@ -141,7 +141,7 @@ export class SwiftRuntime {
     private instance: WebAssembly.Instance | null;
     private heap: SwiftRuntimeHeap;
     private _closureHeap: SwiftClosureHeap | null;
-    private version: number = 702;
+    private version: number = 703;
 
     constructor() {
         this.instance = null;
@@ -154,7 +154,11 @@ export class SwiftRuntime {
         const exports = (this.instance
             .exports as any) as SwiftRuntimeExportedFunctions;
         if (exports.swjs_library_version() != this.version) {
-            throw new Error(`The versions of JavaScriptKit are incompatible. ${exports.swjs_library_version()} != ${this.version}`);
+            throw new Error(
+                `The versions of JavaScriptKit are incompatible. ${exports.swjs_library_version()} != ${
+                    this.version
+                }`
+            );
         }
     }
     get closureHeap(): SwiftClosureHeap | null {
@@ -386,6 +390,7 @@ export class SwiftRuntime {
                     decodeValue(kind, payload1, payload2)
                 );
             },
+
             swjs_get_prop: (
                 ref: ref,
                 name: ref,
@@ -397,6 +402,7 @@ export class SwiftRuntime {
                 const result = Reflect.get(obj, readString(name));
                 writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, false);
             },
+
             swjs_set_subscript: (
                 ref: ref,
                 index: number,
@@ -407,6 +413,7 @@ export class SwiftRuntime {
                 const obj = this.heap.referenceHeap(ref);
                 Reflect.set(obj, index, decodeValue(kind, payload1, payload2));
             },
+
             swjs_get_subscript: (
                 ref: ref,
                 index: number,
@@ -418,12 +425,14 @@ export class SwiftRuntime {
                 const result = Reflect.get(obj, index);
                 writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, false);
             },
+
             swjs_encode_string: (ref: ref, bytes_ptr_result: pointer) => {
                 const bytes = textEncoder.encode(this.heap.referenceHeap(ref));
                 const bytes_ptr = this.heap.retain(bytes);
                 writeUint32(bytes_ptr_result, bytes_ptr);
                 return bytes.length;
             },
+
             swjs_decode_string: (bytes_ptr: pointer, length: number) => {
                 const uint8Memory = new Uint8Array(memory().buffer);
                 const bytes = uint8Memory.subarray(
@@ -433,10 +442,12 @@ export class SwiftRuntime {
                 const string = textDecoder.decode(bytes);
                 return this.heap.retain(string);
             },
+
             swjs_load_string: (ref: ref, buffer: pointer) => {
                 const bytes = this.heap.referenceHeap(ref);
                 writeString(buffer, bytes);
             },
+
             swjs_call_function: (
                 ref: ref,
                 argv: pointer,
@@ -465,6 +476,7 @@ export class SwiftRuntime {
                 }
                 writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, false);
             },
+
             swjs_call_function_with_this: (
                 obj_ref: ref,
                 func_ref: ref,
@@ -491,33 +503,30 @@ export class SwiftRuntime {
                 }
                 writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, false);
             },
-            swjs_create_function: (
-                host_func_id: number,
-                func_ref_ptr: pointer
-            ) => {
-                const func = function () {
-                    return callHostFunction(
-                        host_func_id,
-                        Array.prototype.slice.call(arguments)
-                    );
-                };
-                const func_ref = this.heap.retain(func);
-                this.closureHeap?.alloc(func, func_ref);
-                writeUint32(func_ref_ptr, func_ref);
+            swjs_call_new: (ref: ref, argv: pointer, argc: number) => {
+                const constructor = this.heap.referenceHeap(ref);
+                const instance = Reflect.construct(
+                    constructor,
+                    decodeValues(argv, argc)
+                );
+                return this.heap.retain(instance);
             },
+
             swjs_call_throwing_new: (
                 ref: ref,
                 argv: pointer,
                 argc: number,
-                result_obj: pointer,
                 exception_kind_ptr: pointer,
                 exception_payload1_ptr: pointer,
                 exception_payload2_ptr: pointer
             ) => {
-                const obj = this.heap.referenceHeap(ref);
+                const constructor = this.heap.referenceHeap(ref);
                 let result: any;
                 try {
-                    result = Reflect.construct(obj, decodeValues(argv, argc));
+                    result = Reflect.construct(
+                        constructor,
+                        decodeValues(argv, argc)
+                    );
                 } catch (error) {
                     writeValue(
                         error,
@@ -526,30 +535,40 @@ export class SwiftRuntime {
                         exception_payload2_ptr,
                         true
                     );
-                    return;
+                    return -1;
                 }
-                writeUint32(result_obj, this.heap.retain(result));
-            },
-            swjs_call_new: (
-                ref: ref,
-                argv: pointer,
-                argc: number,
-                result_obj: pointer
-            ) => {
-                const obj = this.heap.referenceHeap(ref);
-                const result = Reflect.construct(obj, decodeValues(argv, argc));
-                writeUint32(result_obj, this.heap.retain(result));
+                writeValue(
+                    null,
+                    exception_kind_ptr,
+                    exception_payload1_ptr,
+                    exception_payload2_ptr,
+                    false
+                );
+                return this.heap.retain(result);
             },
+
             swjs_instanceof: (obj_ref: ref, constructor_ref: ref) => {
                 const obj = this.heap.referenceHeap(obj_ref);
                 const constructor = this.heap.referenceHeap(constructor_ref);
                 return obj instanceof constructor;
             },
+
+            swjs_create_function: (host_func_id: number) => {
+                const func = function () {
+                    return callHostFunction(
+                        host_func_id,
+                        Array.prototype.slice.call(arguments)
+                    );
+                };
+                const func_ref = this.heap.retain(func);
+                this.closureHeap?.alloc(func, func_ref);
+                return func_ref;
+            },
+
             swjs_create_typed_array: (
                 constructor_ref: ref,
                 elementsPtr: pointer,
-                length: number,
-                result_obj: pointer
+                length: number
             ) => {
                 const ArrayType: TypedArray = this.heap.referenceHeap(
                     constructor_ref
@@ -560,8 +579,9 @@ export class SwiftRuntime {
                     length
                 );
                 // Call `.slice()` to copy the memory
-                writeUint32(result_obj, this.heap.retain(array.slice()));
+                return this.heap.retain(array.slice());
             },
+
             swjs_release: (ref: ref) => {
                 this.heap.release(ref);
             },
diff --git a/Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift b/Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift
@@ -44,11 +44,10 @@ public class JSTypedArray<Element>: JSBridgedClass, ExpressibleByArrayLiteral wh
     ///
     /// - Parameter array: The array that will be copied to create a new instance of TypedArray
     public convenience init(_ array: [Element]) {
-        var resultObj = JavaScriptObjectRef()
-        array.withUnsafeBufferPointer { ptr in
-            _create_typed_array(Element.typedArrayClass.id, ptr.baseAddress!, Int32(array.count), &resultObj)
+        let jsArrayRef = array.withUnsafeBufferPointer { ptr in
+            _create_typed_array(Element.typedArrayClass.id, ptr.baseAddress!, Int32(array.count))
         }
-        self.init(unsafelyWrapping: JSObject(id: resultObj))
+        self.init(unsafelyWrapping: JSObject(id: jsArrayRef))
     }
 
     /// Convenience initializer for `Sequence`.
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift b/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift
@@ -18,19 +18,16 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
     public init(_ body: @escaping ([JSValue]) -> JSValue) {
         // 1. Fill `id` as zero at first to access `self` to get `ObjectIdentifier`.
         super.init(id: 0)
-        let objectId = ObjectIdentifier(self)
-        let funcRef = JavaScriptHostFuncRef(bitPattern: Int32(objectId.hashValue))
-        // 2. Retain the given body in static storage by `funcRef`.
-        JSClosure.sharedClosures[funcRef] = (self, {
+
+        // 2. Create a new JavaScript function which calls the given Swift function.
+        hostFuncRef = JavaScriptHostFuncRef(bitPattern: Int32(ObjectIdentifier(self).hashValue))
+        id = _create_function(hostFuncRef)
+
+        // 3. Retain the given body in static storage by `funcRef`.
+        JSClosure.sharedClosures[hostFuncRef] = (self, {
             defer { self.release() }
             return body($0)
         })
-        // 3. Create a new JavaScript function which calls the given Swift function.
-        var objectRef: JavaScriptObjectRef = 0
-        _create_function(funcRef, &objectRef)
-
-        hostFuncRef = funcRef
-        id = objectRef
     }
 
     /// Release this function resource.
@@ -78,16 +75,13 @@ public class JSClosure: JSObject, JSClosureProtocol {
     public init(_ body: @escaping ([JSValue]) -> JSValue) {
         // 1. Fill `id` as zero at first to access `self` to get `ObjectIdentifier`.
         super.init(id: 0)
-        let objectId = ObjectIdentifier(self)
-        let funcRef = JavaScriptHostFuncRef(bitPattern: Int32(objectId.hashValue))
-        // 2. Retain the given body in static storage by `funcRef`.
-        Self.sharedClosures[funcRef] = (self, body)
-        // 3. Create a new JavaScript function which calls the given Swift function.
-        var objectRef: JavaScriptObjectRef = 0
-        _create_function(funcRef, &objectRef)
-
-        hostFuncRef = funcRef
-        id = objectRef
+
+        // 2. Create a new JavaScript function which calls the given Swift function.
+        hostFuncRef = JavaScriptHostFuncRef(bitPattern: Int32(ObjectIdentifier(self).hashValue))
+        id = _create_function(hostFuncRef)
+
+        // 3. Retain the given body in static storage by `funcRef`.
+        Self.sharedClosures[hostFuncRef] = (self, body)
     }
 
     #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift
@@ -41,11 +41,7 @@ public class JSFunction: JSObject {
     public func new(arguments: [ConvertibleToJSValue]) -> JSObject {
         arguments.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer in
-                let argv = bufferPointer.baseAddress
-                let argc = bufferPointer.count
-                var resultObj = JavaScriptObjectRef()
-                _call_new(self.id, argv, Int32(argc), &resultObj)
-                return JSObject(id: resultObj)
+                return JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))
             }
         }
     }
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift
@@ -44,10 +44,9 @@ public class JSThrowingFunction {
                 var exceptionKind = JavaScriptValueKindAndFlags()
                 var exceptionPayload1 = JavaScriptPayload1()
                 var exceptionPayload2 = JavaScriptPayload2()
-                var resultObj = JavaScriptObjectRef()
-                _call_throwing_new(
+                let resultObj = _call_throwing_new(
                     self.base.id, argv, Int32(argc),
-                    &resultObj, &exceptionKind, &exceptionPayload1, &exceptionPayload2
+                    &exceptionKind, &exceptionPayload1, &exceptionPayload2
                 )
                 if exceptionKind.isException {
                     let exception = RawJSValue(kind: exceptionKind.kind, payload1: exceptionPayload1, payload2: exceptionPayload2)
diff --git a/Sources/JavaScriptKit/XcodeSupport.swift b/Sources/JavaScriptKit/XcodeSupport.swift
@@ -63,31 +63,25 @@ import _CJavaScriptKit
     ) { fatalError() }
     func _call_new(
         _: JavaScriptObjectRef,
-        _: UnsafePointer<RawJSValue>!, _: Int32,
-        _: UnsafeMutablePointer<JavaScriptObjectRef>!
-    ) { fatalError() }
+        _: UnsafePointer<RawJSValue>!, _: Int32
+    ) -> JavaScriptObjectRef { fatalError() }
     func _call_throwing_new(
         _: JavaScriptObjectRef,
         _: UnsafePointer<RawJSValue>!, _: Int32,
-        _: UnsafeMutablePointer<JavaScriptObjectRef>!,
         _: UnsafeMutablePointer<JavaScriptValueKindAndFlags>!,
         _: UnsafeMutablePointer<JavaScriptPayload1>!,
         _: UnsafeMutablePointer<JavaScriptPayload2>!
-    ) { fatalError() }
+    ) -> JavaScriptObjectRef { fatalError() }
     func _instanceof(
         _: JavaScriptObjectRef,
         _: JavaScriptObjectRef
     ) -> Bool { fatalError() }
-    func _create_function(
-        _: JavaScriptHostFuncRef,
-        _: UnsafePointer<JavaScriptObjectRef>!
-    ) { fatalError() }
-    func _release(_: JavaScriptObjectRef) { fatalError() }
+    func _create_function(_: JavaScriptHostFuncRef) -> JavaScriptObjectRef { fatalError() }
     func _create_typed_array<T: TypedArrayElement>(
         _: JavaScriptObjectRef,
         _: UnsafePointer<T>,
-        _: Int32,
-        _: UnsafeMutablePointer<JavaScriptObjectRef>!
-    ) { fatalError() }
+        _: Int32
+    ) -> JavaScriptObjectRef { fatalError() }
+    func _release(_: JavaScriptObjectRef) { fatalError() }
 
 #endif
diff --git a/Sources/_CJavaScriptKit/_CJavaScriptKit.c b/Sources/_CJavaScriptKit/_CJavaScriptKit.c
@@ -36,7 +36,7 @@ void swjs_cleanup_host_function_call(void *argv_buffer) {
 /// this and `SwiftRuntime.version` in `./Runtime/src/index.ts`.
 __attribute__((export_name("swjs_library_version")))
 int swjs_library_version(void) {
-    return 702;
+    return 703;
 }
 
 int _library_features(void);
diff --git a/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h b/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json

Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,10 @@ public class JSTypedArray<Element>: JSBridgedClass, ExpressibleByArrayLiteral wh`
`44`	`44`	`///`
`45`	`45`	`/// - Parameter array: The array that will be copied to create a new instance of TypedArray`
`46`	`46`	`public convenience init(_ array: [Element]) {`
`47`		`- var resultObj = JavaScriptObjectRef()`
`48`		`- array.withUnsafeBufferPointer { ptr in`
`49`		`- _create_typed_array(Element.typedArrayClass.id, ptr.baseAddress!, Int32(array.count), &resultObj)`
	`47`	`+ let jsArrayRef = array.withUnsafeBufferPointer { ptr in`
	`48`	`+ _create_typed_array(Element.typedArrayClass.id, ptr.baseAddress!, Int32(array.count))`
`50`	`49`	`}`
`51`		`- self.init(unsafelyWrapping: JSObject(id: resultObj))`
	`50`	`+ self.init(unsafelyWrapping: JSObject(id: jsArrayRef))`
`52`	`51`	`}`
`53`	`52`
`54`	`53`	/// Convenience initializer for `Sequence`.
Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,7 @@ public class JSFunction: JSObject {`
`41`	`41`	`public func new(arguments: [ConvertibleToJSValue]) -> JSObject {`
`42`	`42`	`arguments.withRawJSValues { rawValues in`
`43`	`43`	`rawValues.withUnsafeBufferPointer { bufferPointer in`
`44`		`- let argv = bufferPointer.baseAddress`
`45`		`- let argc = bufferPointer.count`
`46`		`- var resultObj = JavaScriptObjectRef()`
`47`		`- _call_new(self.id, argv, Int32(argc), &resultObj)`
`48`		`- return JSObject(id: resultObj)`
	`44`	`+ return JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))`
`49`	`45`	`}`
`50`	`46`	`}`
`51`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ void swjs_cleanup_host_function_call(void *argv_buffer) {`
`36`	`36`	/// this and `SwiftRuntime.version` in `./Runtime/src/index.ts`.
`37`	`37`	`__attribute__((export_name("swjs_library_version")))`
`38`	`38`	`int swjs_library_version(void) {`
`39`		`- return 702;`
	`39`	`+ return 703;`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`int _library_features(void);`