Add escape hatch for old environments

Author: kateinoigakukun

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 = exports.swjs_library_features();
+        const librarySupportsWeakRef = features & LibraryFeatures.WeakRefs;
+        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
+}

Diff for: Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift

@@ -1,9 +1,6 @@
 import _CJavaScriptKit
 
-fileprivate var closureRef: JavaScriptHostFuncRef = 0
-fileprivate var sharedClosures: [JavaScriptHostFuncRef: ([JSValue]) -> JSValue] = [:]
-
-/// JSClosureProtocol abstracts closure object in JavaScript, whose lifetime is manualy managed
+/// JSClosureProtocol abstracts closure object in JavaScript, whose lifetime might be manualy managed
 public protocol JSClosureProtocol: JSValueCompatible {
 
     /// Release this function resource.
@@ -28,8 +25,15 @@ public protocol JSClosureProtocol: JSValueCompatible {
 /// ```
 ///
 public class JSClosure: JSObject, JSClosureProtocol {
+
+    fileprivate static var sharedClosures: [JavaScriptHostFuncRef: ([JSValue]) -> JSValue] = [:]
+
     private var hostFuncRef: JavaScriptHostFuncRef = 0
 
+    #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    private var isReleased: Bool = false
+    #endif
+
     @available(*, deprecated, message: "This initializer will be removed in the next minor version update. Please use `init(_ body: @escaping ([JSValue]) -> JSValue)` and add `return .undefined` to the end of your closure")
     @_disfavoredOverload
     public convenience init(_ body: @escaping ([JSValue]) -> ()) {
@@ -40,26 +44,27 @@ public class JSClosure: JSObject, JSClosureProtocol {
     }
 
     public init(_ body: @escaping ([JSValue]) -> JSValue) {
-        self.hostFuncRef = closureRef
-        closureRef += 1
-
-        // Retain the given body in static storage by `closureRef`.
-        sharedClosures[self.hostFuncRef] = body
-
-        // Create a new JavaScript function which calls the given Swift function.
+        // 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] = body
+        // 3. Create a new JavaScript function which calls the given Swift function.
         var objectRef: JavaScriptObjectRef = 0
-        _create_function(self.hostFuncRef, &objectRef)
+        _create_function(funcRef, &objectRef)
 
-        super.init(id: objectRef)
+        hostFuncRef = funcRef
+        id = objectRef
     }
 
-    @available(*, deprecated, message: "JSClosure.release() is no longer necessary")
-    public func release() {}
-}
-
-@_cdecl("_free_host_function_impl")
-func _free_host_function_impl(_ hostFuncRef: JavaScriptHostFuncRef) {
-    sharedClosures[hostFuncRef] = nil
+    #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+    deinit {
+        guard isReleased else {
+            fatalError("release() must be called on JSClosure objects manually before they are deallocated")
+        }
+    }
+    #endif
 }
 
 
@@ -103,7 +108,7 @@ func _call_host_function_impl(
     _ argv: UnsafePointer<RawJSValue>, _ argc: Int32,
     _ callbackFuncRef: JavaScriptObjectRef
 ) {
-    guard let hostFunc = sharedClosures[hostFuncRef] else {
+    guard let hostFunc = JSClosure.sharedClosures[hostFuncRef] else {
         fatalError("The function was already released")
     }
     let arguments = UnsafeBufferPointer(start: argv, count: Int(argc)).map {
@@ -114,10 +119,16 @@ func _call_host_function_impl(
     _ = callbackFuncRef(result)
 }
 
+
+
+// [WeakRefs](https://github.com/tc39/proposal-weakrefs) is already Stage 4, but it's still newish API,
+// so provide a escape hatch.
+// Please build with `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS` by SwiftPM build system
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+
 // MARK: - Legacy Closure Types
 
 /// `JSOneshotClosure` is a JavaScript function that can be called only once.
-/// It is recommended to use `JSClosure` instead if your target runtimes support `FinalizationRegistry`.
 public class JSOneshotClosure: JSObject, JSClosureProtocol {
     private var hostFuncRef: JavaScriptHostFuncRef = 0
 
@@ -127,7 +138,7 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
         let objectId = ObjectIdentifier(self)
         let funcRef = JavaScriptHostFuncRef(bitPattern: Int32(objectId.hashValue))
         // 2. Retain the given body in static storage by `funcRef`.
-        sharedClosures[funcRef] = {
+        JSClosure.sharedClosures[funcRef] = {
             defer { self.release() }
             return body($0)
         }
@@ -142,38 +153,31 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
     /// Release this function resource.
     /// After calling `release`, calling this function from JavaScript will fail.
     public func release() {
-        sharedClosures[hostFuncRef] = nil
+        JSClosure.sharedClosures[hostFuncRef] = nil
     }
 }
 
-public class JSUnretainedClosure: JSObject, JSClosureProtocol {
-    private var hostFuncRef: JavaScriptHostFuncRef = 0
-    var isReleased: Bool = false
-
-    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`.
-        sharedClosures[funcRef] = 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
-    }
-
+extension JSClosure {
     public func release() {
         isReleased = true
-        sharedClosures[hostFuncRef] = nil
+        Self.sharedClosures[hostFuncRef] = nil
     }
+}
 
-    deinit {
-        guard isReleased else {
-            // Safari doesn't support `FinalizationRegistry`, so we cannot automatically manage the lifetime of Swift objects
-            fatalError("release() must be called on JSClosure objects manually before they are deallocated")
-        }
-    }
+#else
+
+@available(*, deprecated, renamed: "JSClosure", message: "JSClosure supports automatic memory management")
+public typealias JSOneshotClosure = JSClosure
+
+extension JSClosure {
+
+    @available(*, deprecated, message: "JSClosure.release() is no longer necessary if the target environment supports WeakRefs")
+    public func release() {}
+
+}
+
+@_cdecl("_free_host_function_impl")
+func _free_host_function_impl(_ hostFuncRef: JavaScriptHostFuncRef) {
+    JSClosure.sharedClosures[hostFuncRef] = nil
 }
+#endif

Diff for: Sources/_CJavaScriptKit/_CJavaScriptKit.c

@@ -35,8 +35,15 @@ void swjs_cleanup_host_function_call(void *argv_buffer) {
 /// Notes: If you change any interface of runtime library, please increment
 /// this and `SwiftRuntime.version` in `./Runtime/src/index.ts`.
 __attribute__((export_name("swjs_library_version")))
-int swjs_library_version() {
+int swjs_library_version(void) {
     return 701;
 }
 
+int _library_features(void);
+
+__attribute__((export_name("swjs_library_features")))
+int swjs_library_features(void) {
+    return _library_features();
+}
+
 #endif