BridgeJS: Add tests for memory management of SwiftHeapObject

Author: kateinoigakukun

Tests/BridgeJSRuntimeTests/Generated/BridgeJS.swift

@@ -9190,6 +9190,45 @@ fileprivate func _bjs_Container_wrap_extern(_ pointer: UnsafeMutableRawPointer)
     return _bjs_Container_wrap_extern(pointer)
 }
 
+@_expose(wasm, "bjs_LeakCheck_init")
+@_cdecl("bjs_LeakCheck_init")
+public func _bjs_LeakCheck_init() -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    let ret = LeakCheck()
+    return ret.bridgeJSLowerReturn()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_LeakCheck_deinit")
+@_cdecl("bjs_LeakCheck_deinit")
+public func _bjs_LeakCheck_deinit(_ pointer: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    Unmanaged<LeakCheck>.fromOpaque(pointer).release()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+extension LeakCheck: ConvertibleToJSValue, _BridgedSwiftHeapObject {
+    public var jsValue: JSValue {
+        return .object(JSObject(id: UInt32(bitPattern: _bjs_LeakCheck_wrap(Unmanaged.passRetained(self).toOpaque()))))
+    }
+}
+
+#if arch(wasm32)
+@_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_LeakCheck_wrap")
+fileprivate func _bjs_LeakCheck_wrap_extern(_ pointer: UnsafeMutableRawPointer) -> Int32
+#else
+fileprivate func _bjs_LeakCheck_wrap_extern(_ pointer: UnsafeMutableRawPointer) -> Int32 {
+    fatalError("Only available on WebAssembly")
+}
+#endif
+@inline(never) fileprivate func _bjs_LeakCheck_wrap(_ pointer: UnsafeMutableRawPointer) -> Int32 {
+    return _bjs_LeakCheck_wrap_extern(pointer)
+}
+
 #if arch(wasm32)
 @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_ClosureSupportImports_jsApplyVoid_static")
 fileprivate func bjs_ClosureSupportImports_jsApplyVoid_static_extern(_ callback: Int32) -> Void
@@ -11252,6 +11291,30 @@ fileprivate func bjs_SwiftClassSupportImports_jsRoundTripOptionalGreeter_static_
     return bjs_SwiftClassSupportImports_jsRoundTripOptionalGreeter_static_extern(greeterIsSome, greeterPointer)
 }
 
+#if arch(wasm32)
+@_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_SwiftClassSupportImports_jsConsumeLeakCheck_static")
+fileprivate func bjs_SwiftClassSupportImports_jsConsumeLeakCheck_static_extern(_ value: UnsafeMutableRawPointer) -> Void
+#else
+fileprivate func bjs_SwiftClassSupportImports_jsConsumeLeakCheck_static_extern(_ value: UnsafeMutableRawPointer) -> Void {
+    fatalError("Only available on WebAssembly")
+}
+#endif
+@inline(never) fileprivate func bjs_SwiftClassSupportImports_jsConsumeLeakCheck_static(_ value: UnsafeMutableRawPointer) -> Void {
+    return bjs_SwiftClassSupportImports_jsConsumeLeakCheck_static_extern(value)
+}
+
+#if arch(wasm32)
+@_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_SwiftClassSupportImports_jsConsumeOptionalLeakCheck_static")
+fileprivate func bjs_SwiftClassSupportImports_jsConsumeOptionalLeakCheck_static_extern(_ valueIsSome: Int32, _ valuePointer: UnsafeMutableRawPointer) -> Void
+#else
+fileprivate func bjs_SwiftClassSupportImports_jsConsumeOptionalLeakCheck_static_extern(_ valueIsSome: Int32, _ valuePointer: UnsafeMutableRawPointer) -> Void {
+    fatalError("Only available on WebAssembly")
+}
+#endif
+@inline(never) fileprivate func bjs_SwiftClassSupportImports_jsConsumeOptionalLeakCheck_static(_ valueIsSome: Int32, _ valuePointer: UnsafeMutableRawPointer) -> Void {
+    return bjs_SwiftClassSupportImports_jsConsumeOptionalLeakCheck_static_extern(valueIsSome, valuePointer)
+}
+
 func _$SwiftClassSupportImports_jsRoundTripGreeter(_ greeter: Greeter) throws(JSException) -> Greeter {
     let greeterPointer = greeter.bridgeJSLowerParameter()
     let ret = bjs_SwiftClassSupportImports_jsRoundTripGreeter_static(greeterPointer)
@@ -11268,4 +11331,20 @@ func _$SwiftClassSupportImports_jsRoundTripOptionalGreeter(_ greeter: Optional<G
         throw error
     }
     return Optional<Greeter>.bridgeJSLiftReturn(ret)
+}
+
+func _$SwiftClassSupportImports_jsConsumeLeakCheck(_ value: LeakCheck) throws(JSException) -> Void {
+    let valuePointer = value.bridgeJSLowerParameter()
+    bjs_SwiftClassSupportImports_jsConsumeLeakCheck_static(valuePointer)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+}
+
+func _$SwiftClassSupportImports_jsConsumeOptionalLeakCheck(_ value: Optional<LeakCheck>) throws(JSException) -> Void {
+    let (valueIsSome, valuePointer) = value.bridgeJSLowerParameter()
+    bjs_SwiftClassSupportImports_jsConsumeOptionalLeakCheck_static(valueIsSome, valuePointer)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }

Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.json

@@ -3626,6 +3626,28 @@
           }
         ],
         "swiftCallName" : "Container"
+      },
+      {
+        "constructor" : {
+          "abiName" : "bjs_LeakCheck_init",
+          "effects" : {
+            "isAsync" : false,
+            "isStatic" : false,
+            "isThrows" : false
+          },
+          "parameters" : [
+
+          ]
+        },
+        "explicitAccessControl" : "public",
+        "methods" : [
+
+        ],
+        "name" : "LeakCheck",
+        "properties" : [
+
+        ],
+        "swiftCallName" : "LeakCheck"
       }
     ],
     "enums" : [
@@ -15643,6 +15665,47 @@
                     "_1" : "null"
                   }
                 }
+              },
+              {
+                "name" : "jsConsumeLeakCheck",
+                "parameters" : [
+                  {
+                    "name" : "value",
+                    "type" : {
+                      "swiftHeapObject" : {
+                        "_0" : "LeakCheck"
+                      }
+                    }
+                  }
+                ],
+                "returnType" : {
+                  "void" : {
+
+                  }
+                }
+              },
+              {
+                "name" : "jsConsumeOptionalLeakCheck",
+                "parameters" : [
+                  {
+                    "name" : "value",
+                    "type" : {
+                      "nullable" : {
+                        "_0" : {
+                          "swiftHeapObject" : {
+                            "_0" : "LeakCheck"
+                          }
+                        },
+                        "_1" : "null"
+                      }
+                    }
+                  }
+                ],
+                "returnType" : {
+                  "void" : {
+
+                  }
+                }
               }
             ]
           }

Tests/BridgeJSRuntimeTests/JavaScript/SwiftClassSupportTests.mjs

@@ -9,5 +9,14 @@ export function getImports(importsContext) {
         jsRoundTripOptionalGreeter: (greeter) => {
             return greeter;
         },
+        jsConsumeLeakCheck: (value) => {
+            // Explicitly release on JS side to mimic user cleanup.
+            value.release();
+        },
+        jsConsumeOptionalLeakCheck: (value) => {
+            if (value) {
+                value.release();
+            }
+        },
     };
-}
+}

Tests/BridgeJSRuntimeTests/SwiftClassSupportTests.swift

@@ -4,6 +4,8 @@ import JavaScriptKit
 @JSClass struct SwiftClassSupportImports {
     @JSFunction static func jsRoundTripGreeter(_ greeter: Greeter) throws(JSException) -> Greeter
     @JSFunction static func jsRoundTripOptionalGreeter(_ greeter: Greeter?) throws(JSException) -> Greeter?
+    @JSFunction static func jsConsumeLeakCheck(_ value: LeakCheck) throws(JSException) -> Void
+    @JSFunction static func jsConsumeOptionalLeakCheck(_ value: LeakCheck?) throws(JSException) -> Void
 }
 
 @JSFunction(from: .global) func gc() throws(JSException) -> Void
@@ -57,4 +59,39 @@ final class SwiftClassSupportTests: XCTestCase {
         // Here, the greeter should be deallocated
         XCTAssertNil(weakGreeter)
     }
+
+    func testJSReleaseDoesNotOverReleaseHeapObject() throws {
+        LeakCheck.deinits = 0
+        var obj: LeakCheck? = LeakCheck()
+
+        try SwiftClassSupportImports.jsConsumeLeakCheck(obj!)
+        XCTAssertEqual(LeakCheck.deinits, 0)
+
+        obj = nil
+        XCTAssertEqual(LeakCheck.deinits, 1)
+    }
+
+    func testJSReleaseOptionalDoesNotOverReleaseHeapObject() throws {
+        LeakCheck.deinits = 0
+
+        try SwiftClassSupportImports.jsConsumeOptionalLeakCheck(nil)
+        XCTAssertEqual(LeakCheck.deinits, 0)
+
+        var obj: LeakCheck? = LeakCheck()
+        try SwiftClassSupportImports.jsConsumeOptionalLeakCheck(obj)
+        XCTAssertEqual(LeakCheck.deinits, 0)
+
+        obj = nil
+        XCTAssertEqual(LeakCheck.deinits, 1)
+    }
+}
+
+@JS public class LeakCheck {
+    nonisolated(unsafe) public static var deinits: Int = 0
+
+    @JS public init() {}
+
+    deinit {
+        Self.deinits += 1
+    }
 }