Suggestion for #128: Add escape hatch for old environments

IntegrationTests/Makefile

@@ -1,11 +1,13 @@
 CONFIGURATION ?= debug
+SWIFT_BUILD_FLAGS ?=
 
 FORCE:
 TestSuites/.build/$(CONFIGURATION)/%.wasm: FORCE
  swift build --package-path TestSuites \
  --product $(basename $(notdir $@)) \
  --triple wasm32-unknown-wasi \
- --configuration $(CONFIGURATION)
+ --configuration $(CONFIGURATION) \
+ $(SWIFT_BUILD_FLAGS)
 
 dist/%.wasm: TestSuites/.build/$(CONFIGURATION)/%.wasm
  mkdir -p dist

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,21 +398,31 @@ 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
 }
 
+#if JAVASCRIPTKIT_WITHOUT_WEAKREFS
 func closureScope() -> ObjectIdentifier {
- ObjectIdentifier(JSClosure { _ in .undefined })
+ let closure = JSClosure { _ in .undefined }
+ let result = ObjectIdentifier(closure)
+ closure.release()
+ return result
 }
 
 try test("Closure Identifiers") {
  let oid1 = closureScope()
  let oid2 = closureScope()
  try expectEqual(oid1, oid2)
 }
+#endif
 
 func checkArray<T>(_ array: [T]) throws where T: TypedArrayElement {
  try expectEqual(toString(JSTypedArray(array).jsValue().object!), jsStringify(array))

Makefile

@@ -14,7 +14,9 @@ build:
 test:
  cd IntegrationTests && \
  CONFIGURATION=debug make test && \
- CONFIGURATION=release make test
+ CONFIGURATION=debug SWIFT_BUILD_FLAGS="-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS" make test && \
+ CONFIGURATION=release make test && \
+ CONFIGURATION=release SWIFT_BUILD_FLAGS="-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS" make test
 
 .PHONY: benchmark_setup
 benchmark_setup:

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,31 @@ class SwiftRuntimeHeap {
  }
 }
 
+/// Memory lifetime of closures in Swift are managed by Swift side
+class SwiftClosureHeap {
+ private functionRegistry: FinalizationRegistry<number>;
+
+ constructor(exports: SwiftRuntimeExportedFunctions) {
+ this.functionRegistry = new FinalizationRegistry((id) => {
+ 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 version: number = 701;
+ private _closureHeap: SwiftClosureHeap | null;
+ private version: number = 702;
 
  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) {
@@ -146,6 +157,28 @@ export class SwiftRuntime {
  throw new Error("The versions of JavaScriptKit are incompatible.");
  }
  }
+ get closureHeap(): SwiftClosureHeap | null {
+ if (this._closureHeap) return this._closureHeap;
+ if (!this.instance)
+ throw new Error("WebAssembly instance is not set yet");
+
+ const exports = (this.instance
+ .exports as any) as SwiftRuntimeExportedFunctions;
+ const features = exports.swjs_library_features();
+ const librarySupportsWeakRef =
+ (features & LibraryFeatures.WeakRefs) != 0;
+ if (librarySupportsWeakRef) {
+ if (typeof FinalizationRegistry !== "undefined") {
+ this._closureHeap = new SwiftClosureHeap(exports);
+ return this._closureHeap;
+ } else {
+ throw new Error(
+ "The Swift part of JavaScriptKit was configured to require the availability of JavaScript WeakRefs. Please build with `-Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS` to disable features that use WeakRefs."
+ );
+ }
+ }
+ return null;
+ }
 
  importObjects() {
  const memory = () => {
@@ -472,7 +505,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: (

Sources/JavaScriptKit/Features.swift

@@ -0,0 +1,12 @@
+enum LibraryFeatures {
+ static let weakRefs: Int32 = 1 << 0
+}
+
+@_cdecl("_library_features")
+func _library_features() -> Int32 {
+ var features: Int32 = 0
+#if !JAVASCRIPTKIT_WITHOUT_WEAKREFS
+ features |= LibraryFeatures.weakRefs
+#endif
+ return features
+}