Reduce memory store for returned value kind

Author: kateinoigakukun

Runtime/src/index.ts

@@ -237,35 +237,24 @@ export class SwiftRuntime {
             ref: ref,
             argv: pointer,
             argc: number,
-            kind_ptr: pointer,
             payload1_ptr: pointer,
             payload2_ptr: pointer
         ) => {
             const func = this.memory.getObject(ref);
+            let result = undefined;
             let isException = true;
             try {
                 const args = JSValue.decodeArray(argv, argc, this.memory);
-                const result = func(...args);
-                JSValue.write(
+                result = func(...args);
+                isException = false;
+            } finally {
+                return JSValue.writeV2(
                     result,
-                    kind_ptr,
                     payload1_ptr,
                     payload2_ptr,
-                    false,
+                    isException,
                     this.memory
                 );
-                isException = false;
-            } finally {
-                if (isException) {
-                    JSValue.write(
-                        undefined,
-                        kind_ptr,
-                        payload1_ptr,
-                        payload2_ptr,
-                        true,
-                        this.memory
-                    );
-                }
             }
         },
 

Runtime/src/js-value.ts

@@ -1,5 +1,5 @@
 import { Memory } from "./memory.js";
-import { assertNever, pointer } from "./types.js";
+import { assertNever, JavaScriptValueKindAndFlags, pointer } from "./types.js";
 
 export const enum Kind {
     Boolean = 0,
@@ -121,3 +121,59 @@ export const write = (
             assertNever(type, `Type "${type}" is not supported yet`);
     }
 };
+
+
+export const writeV2 = (
+    value: any,
+    payload1_ptr: pointer,
+    payload2_ptr: pointer,
+    is_exception: boolean,
+    memory: Memory
+): JavaScriptValueKindAndFlags => {
+    if (value === undefined) {
+        return Kind.Undefined;
+    }
+
+    const exceptionBit = (is_exception ? 1 : 0) << 31;
+    if (value === null) {
+        return exceptionBit | Kind.Null;
+    }
+
+    const writeRef = (kind: Kind) => {
+        memory.writeUint32(payload1_ptr, memory.retain(value));
+        return exceptionBit | kind
+    };
+
+    const type = typeof value;
+    switch (type) {
+        case "boolean": {
+            memory.writeUint32(payload1_ptr, value ? 1 : 0);
+            return exceptionBit | Kind.Boolean;
+        }
+        case "number": {
+            memory.writeFloat64(payload2_ptr, value);
+            return exceptionBit | Kind.Number;
+        }
+        case "string": {
+            return writeRef(Kind.String);
+        }
+        case "undefined": {
+            return exceptionBit | Kind.Undefined;
+        }
+        case "object": {
+            return writeRef(Kind.Object);
+        }
+        case "function": {
+            return writeRef(Kind.Function);
+        }
+        case "symbol": {
+            return writeRef(Kind.Symbol);
+        }
+        case "bigint": {
+            return writeRef(Kind.BigInt);
+        }
+        default:
+            assertNever(type, `Type "${type}" is not supported yet`);
+    }
+    throw new Error("Unreachable");
+};

Runtime/src/types.ts

@@ -3,6 +3,7 @@ import * as JSValue from "./js-value.js";
 export type ref = number;
 export type pointer = number;
 export type bool = number;
+export type JavaScriptValueKindAndFlags = number;
 
 export interface ExportedFunctions {
     swjs_library_version(): number;
@@ -63,10 +64,9 @@ export interface ImportedFunctions {
         ref: number,
         argv: pointer,
         argc: number,
-        kind_ptr: pointer,
         payload1_ptr: pointer,
         payload2_ptr: pointer
-    ): void;
+    ): JavaScriptValueKindAndFlags;
     swjs_call_function_with_this(
         obj_ref: ref,
         func_ref: ref,

Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift

@@ -96,10 +96,11 @@ func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleTo
                                                   jsFunc.id, argv, Int32(argc),
                                                   &kindAndFlags, &payload1, &payload2)
             } else {
-                _call_function_no_catch(
+                let result = _call_function_no_catch(
                     jsFunc.id, argv, Int32(argc),
-                    &kindAndFlags, &payload1, &payload2
+                    &payload1, &payload2
                 )
+                kindAndFlags = unsafeBitCast(result, to: JavaScriptValueKindAndFlags.self)
             }
             assert(!kindAndFlags.isException)
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)

Sources/JavaScriptKit/XcodeSupport.swift

@@ -59,10 +59,9 @@ import _CJavaScriptKit
     func _call_function_no_catch(
         _: JavaScriptObjectRef,
         _: UnsafePointer<RawJSValue>!, _: Int32,
-        _: UnsafeMutablePointer<JavaScriptValueKindAndFlags>!,
         _: UnsafeMutablePointer<JavaScriptPayload1>!,
         _: UnsafeMutablePointer<JavaScriptPayload2>!
-    ) { fatalError() }
+    ) -> UInt32 { fatalError() }
     func _call_function_with_this(
         _: JavaScriptObjectRef,
         _: JavaScriptObjectRef,

Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -3,6 +3,7 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 /// `JavaScriptObjectRef` represents JavaScript object reference that is referenced by Swift side.
 /// This value is an address of `SwiftRuntimeHeap`.
@@ -193,12 +194,15 @@ extern void _call_function(const JavaScriptObjectRef ref, const RawJSValue *argv
 /// @param result_kind A result pointer of JavaScript value kind of returned result or thrown exception.
 /// @param result_payload1 A result pointer of first payload of JavaScript value of returned result or thrown exception.
 /// @param result_payload2 A result pointer of second payload of JavaScript value of returned result or thrown exception.
+/// @return A JavaScriptValueKindAndFlags bits represented as 32bit integer for the returned value.
 __attribute__((__import_module__("javascript_kit"),
                __import_name__("swjs_call_function_no_catch")))
-extern void _call_function_no_catch(const JavaScriptObjectRef ref, const RawJSValue *argv,
-                           const int argc, JavaScriptValueKindAndFlags *result_kind,
-                           JavaScriptPayload1 *result_payload1,
-                           JavaScriptPayload2 *result_payload2);
+extern uint32_t _call_function_no_catch(
+  const JavaScriptObjectRef ref, const RawJSValue *argv,
+  const int argc,
+  JavaScriptPayload1 *result_payload1,
+  JavaScriptPayload2 *result_payload2
+);
 
 /// `_call_function_with_this` calls JavaScript function with given arguments list and given `_this`.
 ///