Add escape hatch for old environments

Author: kateinoigakukun

Diff for: IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -197,18 +197,26 @@ try test("Closure Lifetime") {
             return arguments[0]
         }
         try expectEqual(evalClosure(c1, JSValue.number(1.0)), .number(1.0))
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+        c1.release()
+#endif
     }
 
     do {
         let c1 = JSClosure { _ in .undefined }
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
         c1.release()
-        c1.release()
+#endif
     }
 
     do {
         let array = JSObject.global.Array.function!.new()
-        _ = array.push!(JSClosure { _ in .number(3) })
+        let c1 = JSClosure { _ in .number(3) }
+        _ = array.push!(c1)
         try expectEqual(array[0].function!().number, 3.0)
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+        c1.release()
+#endif
     }
 
 //    do {
@@ -221,6 +229,7 @@ try test("Closure Lifetime") {
 //        try expectEqual(weakRef.deref!(), .undefined)
 //    }
 
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
     do {
         let c1 = JSOneshotClosure { _ in
             return .boolean(true)
@@ -230,6 +239,7 @@ try test("Closure Lifetime") {
         try expectCrashByCall(ofClosure: c1)
         // OneshotClosure won't call fatalError even if it's deallocated before `release`
     }
+#endif
 }
 
 try test("Host Function Registration") {
@@ -261,6 +271,10 @@ try test("Host Function Registration") {
     try expectEqual(call_host_1Func(), .number(1))
     try expectEqual(isHostFunc1Called, true)
 
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    hostFunc1.release()
+#endif
+
     let hostFunc2 = JSClosure { (arguments) -> JSValue in
         do {
             let input = try expectNumber(arguments[0])
@@ -272,6 +286,10 @@ try test("Host Function Registration") {
 
     try expectEqual(evalClosure(hostFunc2, 3), .number(6))
     _ = try expectString(evalClosure(hostFunc2, true))
+
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    hostFunc2.release()
+#endif
 }
 
 try test("New Object Construction") {
@@ -380,14 +398,24 @@ try test("ObjectRef Lifetime") {
     // }
     // ```
 
+    let identity = JSClosure { $0[0] }
     let ref1 = getJSValue(this: .global, name: "globalObject1").object!
-    let ref2 = evalClosure(JSClosure { $0[0] }, ref1).object!
+    let ref2 = evalClosure(identity, ref1).object!
     try expectEqual(ref1.prop_2, .number(2))
     try expectEqual(ref2.prop_2, .number(2))
+
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    identity.release()
+#endif
 }
 
 func closureScope() -> ObjectIdentifier {
-    ObjectIdentifier(JSClosure { _ in .undefined })
+    let closure = JSClosure { _ in .undefined }
+    let result = ObjectIdentifier(closure)
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    closure.release()
+#endif
+    return result
 }
 
 try test("Closure Identifiers") {

Diff for: Runtime/src/index.ts

@@ -21,6 +21,7 @@ if (typeof globalThis !== "undefined") {
 
 interface SwiftRuntimeExportedFunctions {
     swjs_library_version(): number;
+    swjs_library_features(): number;
     swjs_prepare_host_function_call(size: number): pointer;
     swjs_cleanup_host_function_call(argv: pointer): void;
     swjs_call_host_function(
@@ -44,6 +45,10 @@ enum JavaScriptValueKind {
     Function = 6,
 }
 
+enum LibraryFeatures {
+    WeakRefs = 1 << 0,
+}
+
 type TypedArray =
     | Int8ArrayConstructor
     | Uint8ArrayConstructor
@@ -117,25 +122,33 @@ class SwiftRuntimeHeap {
     }
 }
 
+/// Memory lifetime of closures in Swift are managed by Swift side
+class SwiftClosureHeap {
+    private functionRegistry: FinalizationRegistry<number>;
+    private exports: SwiftRuntimeExportedFunctions
+
+    constructor(exports: SwiftRuntimeExportedFunctions) {
+        this.exports = exports
+        this.functionRegistry = new FinalizationRegistry((id) => {
+            this.exports.swjs_free_host_function(id);
+        });
+    }
+
+    alloc(func: any, func_ref: number) {
+        this.functionRegistry.register(func, func_ref);
+    }
+}
+
 export class SwiftRuntime {
     private instance: WebAssembly.Instance | null;
     private heap: SwiftRuntimeHeap;
-    private functionRegistry: FinalizationRegistry<unknown>;
+    private closureHeap: SwiftClosureHeap | null;
     private version: number = 701;
 
     constructor() {
         this.instance = null;
         this.heap = new SwiftRuntimeHeap();
-        this.functionRegistry = new FinalizationRegistry(
-            this.handleFree.bind(this)
-        );
-    }
-
-    handleFree(id: unknown) {
-        if (!this.instance || typeof id !== "number") return;
-        const exports = (this.instance
-            .exports as any) as SwiftRuntimeExportedFunctions;
-        exports.swjs_free_host_function(id);
+        this.closureHeap = null;
     }
 
     setInstance(instance: WebAssembly.Instance) {
@@ -145,6 +158,15 @@ export class SwiftRuntime {
         if (exports.swjs_library_version() != this.version) {
             throw new Error("The versions of JavaScriptKit are incompatible.");
         }
+        const features = 1 // exports.swjs_library_features();
+        const librarySupportsWeakRef = (features & LibraryFeatures.WeakRefs) != 0;
+        if (librarySupportsWeakRef) {
+            if (typeof FinalizationRegistry !== "undefined") {
+                this.closureHeap = new SwiftClosureHeap(exports);
+            } else {
+                throw new Error("The JavaScriptKit in Swift expects the target environment supports WeakRefs. Please build with `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS` to disable features using WeakRefs.");
+            }
+        }
     }
 
     importObjects() {
@@ -472,7 +494,7 @@ export class SwiftRuntime {
                     );
                 };
                 const func_ref = this.heap.retain(func);
-                this.functionRegistry.register(func, func_ref);
+                this.closureHeap?.alloc(func, func_ref);
                 writeUint32(func_ref_ptr, func_ref);
             },
             swjs_call_throwing_new: (

Diff for: Sources/JavaScriptKit/Features.swift

@@ -0,0 +1,14 @@
+struct LibraryFeatures: OptionSet {
+    let rawValue: Int32
+
+    static let weakRefs = LibraryFeatures(rawValue: 1 << 0)
+}
+
+@_cdecl("_library_features")
+func _library_features() -> Int32 {
+    var features: LibraryFeatures = []
+#if !JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    features.insert(.weakRefs)
+#endif
+    return features.rawValue
+}