Support JavaScript function invocation

Author: kateinoigakukun

src/swift/Sources/JavaScriptKit/JSFunction.swift

@@ -0,0 +1,30 @@
+import _CJavaScriptKit
+
+@dynamicCallable
+public class JSFunctionRef: Equatable {
+    let id: UInt32
+
+    init(id: UInt32) {
+        self.id = id
+    }
+
+    public static func == (lhs: JSFunctionRef, rhs: JSFunctionRef) -> Bool {
+        return lhs.id == rhs.id
+    }
+
+    public func dynamicallyCall(withArguments arguments: [JSValue]) -> JSValue {
+        let result = arguments.withRawJSValues { rawValues in
+            rawValues.withUnsafeBufferPointer { bufferPointer -> RawJSValue in
+                let argv = bufferPointer.baseAddress
+                let argc = bufferPointer.count
+                var result = RawJSValue()
+                _call_function(
+                    self.id, argv, Int32(argc),
+                    &result.kind, &result.payload1, &result.payload2
+                )
+                return result
+            }
+        }
+        return result.jsValue()
+    }
+}

src/swift/Sources/JavaScriptKit/JSValue.swift

@@ -18,17 +18,6 @@ public class JSObjectRef: Equatable {
     }
 }
 
-public class JSFunctionRef: Equatable {
-    let id: UInt32
-
-    init(id: UInt32) {
-        self.id = id
-    }
-
-    public static func == (lhs: JSFunctionRef, rhs: JSFunctionRef) -> Bool {
-        return lhs.id == rhs.id
-    }
-}
 
 public enum JSValue: Equatable {
     case boolean(Bool)

src/swift/Sources/JavaScriptKit/JSValueConvertible.swift

@@ -10,12 +10,6 @@ extension Bool: JSValueConvertible {
     }
 }
 
-struct RawJSValue {
-    var kind: JavaScriptValueKind = JavaScriptValueKind_Invalid
-    var payload1: JavaScriptPayload = 0
-    var payload2: JavaScriptPayload = 0
-}
-
 extension RawJSValue: JSValueConvertible {
     func jsValue() -> JSValue {
         switch kind {
@@ -89,3 +83,19 @@ extension JSValue {
         return body(rawValue)
     }
 }
+
+extension Array where Element == JSValue {
+    func withRawJSValues<T>(_ body: ([RawJSValue]) -> T) -> T {
+        func _withCollectedRawJSValue<T>(
+            _ values: [JSValue], _ index: Int,
+            _ results: inout [RawJSValue], _ body: ([RawJSValue]) -> T) -> T {
+            if index == values.count { return body(results) }
+            return values[index].withRawJSValue { (rawValue) -> T in
+                results.append(rawValue)
+                return _withCollectedRawJSValue(values, index + 1, &results, body)
+            }
+        }
+        var _results = [RawJSValue]()
+        return _withCollectedRawJSValue(self, 0, &_results, body)
+    }
+}

src/swift/Sources/JavaScriptKit/XcodeSupport.swift

@@ -33,4 +33,10 @@ func _get_subscript(
 func _load_string(
     _ ref: JavaScriptValueId,
     _ buffer: UnsafeMutablePointer<UInt8>!) { fatalError() }
+func _call_function(
+    _ ref: JavaScriptValueId,
+    _ args: UnsafePointer<RawJSValue>!, _ length: Int32,
+    _ result_kind: UnsafeMutablePointer<JavaScriptValueKind>!,
+    _ result_payload1: UnsafeMutablePointer<JavaScriptPayload>!,
+    _ result_payload2: UnsafeMutablePointer<JavaScriptPayload>!) { fatalError() }
 #endif

src/swift/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -18,6 +18,12 @@ typedef enum {
 
 typedef unsigned JavaScriptPayload;
 
+typedef struct {
+    JavaScriptValueKind kind;
+    JavaScriptPayload payload1;
+    JavaScriptPayload payload2;
+} RawJSValue;
+
 
 const unsigned int _JS_Predef_Value_Global = 0;
 
@@ -80,4 +86,16 @@ extern void _load_string(
     unsigned char *buffer
 );
 
+__attribute__((
+    __import_module__("javascript_kit"),
+    __import_name__("swjs_call_function")
+))
+extern void _call_function(
+    const JavaScriptValueId ref,
+    const RawJSValue *args, const int length,
+    JavaScriptValueKind *result_kind,
+    JavaScriptPayload *result_payload1,
+    JavaScriptPayload *result_payload2
+);
+
 #endif /* _CJavaScriptKit_h */

src/web/src/index.ts

@@ -73,6 +73,14 @@ export class SwiftRuntime {
             uint8Memory[ptr]
         }
 
+        const readUInt32 = (ptr: pointer) => {
+            const uint8Memory = new Uint8Array(memory().buffer);
+            return uint8Memory[ptr + 0]
+                 + (uint8Memory[ptr + 1] << 8)
+                 + (uint8Memory[ptr + 2] << 16)
+                 + (uint8Memory[ptr + 3] << 24)
+        }
+
         const writeUint32 = (ptr: pointer, value: number) => {
             const uint8Memory = new Uint8Array(memory().buffer);
             uint8Memory[ptr + 0] = (value & 0x000000ff) >> 0
@@ -171,6 +179,21 @@ export class SwiftRuntime {
             }
         }
 
+        // Note:
+        // `decodeValues` assumes that the size of RawJSValue is 12
+        // and the alignment of it is 4
+        const decodeValues = (ptr: pointer, length: number) => {
+            let result = []
+            for (let index = 0; index < length; index++) {
+                const base = ptr + 12 * index
+                const kind = readUInt32(base)
+                const payload1 = readUInt32(base + 4)
+                const payload2 = readUInt32(base + 8)
+                result.push(decodeValue(kind, payload1, payload2))
+            }
+            return result
+        }
+
         return {
             swjs_set_prop: (
                 ref: ref, name: pointer, length: number,
@@ -215,6 +238,18 @@ export class SwiftRuntime {
             swjs_load_string: (ref: ref, buffer: pointer) => {
                 const string = this._heapValues[ref];
                 writeString(buffer, string);
+            },
+            swjs_call_function: (
+                ref: ref, argv: pointer, argc: number,
+                kind_ptr: pointer,
+                payload1_ptr: pointer, payload2_ptr: pointer
+            ) => {
+                const func = this._heapValues[ref]
+                const result = Reflect.apply(func, undefined, decodeValues(argv, argc))
+                const { kind, payload1, payload2 } = encodeValue(result);
+                writeUint32(kind_ptr, kind);
+                writeUint32(payload1_ptr, payload1);
+                writeUint32(payload2_ptr, payload2);
             }
         }
     }

test/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift

@@ -35,7 +35,7 @@ Object_Conversion: do {
     //   "prop_4": [
     //     3, 4, "str_elm_1", 5,
     //   ],
-    //   "prop_5": function () {},
+    //   ...
     // }
     // ```
     //
@@ -60,8 +60,51 @@ Object_Conversion: do {
         try expectEqual(actualElement, expectedElement)
     }
 
+} catch {
+    print(error)
+}
+
+Function_Call: do {
+    // Notes: globalObject1 is defined in JavaScript environment
+    //
+    // ```js
+    // global.globalObject1 = {
+    //   ...
+    //   "prop_5": {
+    //     "func1": function () { return },
+    //     "func2": function () { return 1 },
+    //     "func3": function (n) { return n * 2 },
+    //     "func4": function (a, b, c) { return a + b + c },
+    //     "func5": function (x) { return "Hello, " + x },
+    //     "func6": function (c, a, b) {
+    //       if (c) { return a } else { return b }
+    //     },
+    //   }
+    // }
+    // ```
+    //
+
+    // Notes: If the size of `RawJSValue` is updated, these test suites will fail.
+    let globalObject1 = getJSValue(this: .global(), name: "globalObject1")
+    let globalObject1Ref = try expectObject(globalObject1)
     let prop_5 = getJSValue(this: globalObject1Ref, name: "prop_5")
-    _ = try expectFunction(prop_5)
+    let prop_5Ref = try expectObject(prop_5)
+
+    let func1 = try expectFunction(getJSValue(this: prop_5Ref, name: "func1"))
+    try expectEqual(func1(), .undefined)
+    let func2 = try expectFunction(getJSValue(this: prop_5Ref, name: "func2"))
+    try expectEqual(func2(), .number(1))
+    let func3 = try expectFunction(getJSValue(this: prop_5Ref, name: "func3"))
+    try expectEqual(func3(.number(2)), .number(4))
+    let func4 = try expectFunction(getJSValue(this: prop_5Ref, name: "func4"))
+    try expectEqual(func4(.number(2), .number(3), .number(4)), .number(9))
+    try expectEqual(func4(.number(2), .number(3), .number(4), .number(5)), .number(9))
+    let func5 = try expectFunction(getJSValue(this: prop_5Ref, name: "func5"))
+    try expectEqual(func5(.string("World!")), .string("Hello, World!"))
+    let func6 = try expectFunction(getJSValue(this: prop_5Ref, name: "func6"))
+    try expectEqual(func6(.boolean(true), .number(1), .number(2)), .number(1))
+    try expectEqual(func6(.boolean(false), .number(1), .number(2)), .number(2))
+    try expectEqual(func6(.boolean(true), .string("OK"), .number(2)), .string("OK"))
 
 } catch {
     print(error)

test/index.js

@@ -27,7 +27,16 @@ global.globalObject1 = {
   "prop_4": [
     3, 4, "str_elm_1", 5,
   ],
-  "prop_5": function () {},
+  "prop_5": {
+    "func1": function () { return },
+    "func2": function () { return 1 },
+    "func3": function (n) { return n * 2},
+    "func4": function (a, b, c) { return a + b + c },
+    "func5": function (x) { return "Hello, " + x },
+    "func6": function (c, a, b) {
+      if (c) { return a } else { return b }
+    },
+  }
 }
 
 const startWasiTask = async () => {