Test: Cover Swift class without @js init

Author: kateinoigakukun

Tests/BridgeJSRuntimeTests/ExportAPITests.swift

@@ -74,13 +74,48 @@ struct TestError: Error {
     g.changeName(name: name)
 }
 
+// Test class without @JS init constructor  
+@JS class Calculator {
+    nonisolated(unsafe) static var onDeinit: () -> Void = {}
+    
+    @JS func square(value: Int) -> Int {
+        return value * value
+    }
+    
+    @JS func add(a: Int, b: Int) -> Int {
+        return a + b
+    }
+    
+    deinit {
+        Self.onDeinit()
+    }
+}
+
+@JS func createCalculator() -> Calculator {
+    return Calculator()
+}
+
+@JS func useCalculator(calc: Calculator, x: Int, y: Int) -> Int {
+    return calc.add(a: calc.square(value: x), b: y)
+}
+
+
 class ExportAPITests: XCTestCase {
     func testAll() {
         var hasDeinitGreeter = false
+        var hasDeinitCalculator = false
+        
         Greeter.onDeinit = {
             hasDeinitGreeter = true
         }
+        
+        Calculator.onDeinit = {
+            hasDeinitCalculator = true
+        }
+        
         runJsWorks()
-        XCTAssertTrue(hasDeinitGreeter)
+        
+        XCTAssertTrue(hasDeinitGreeter, "Greeter (with @JS init) should have been deinitialized")
+        XCTAssertTrue(hasDeinitCalculator, "Calculator (without @JS init) should have been deinitialized")
     }
 }

Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift

@@ -314,6 +314,28 @@ public func _bjs_takeGreeter(g: UnsafeMutableRawPointer, nameBytes: Int32, nameL
     #endif
 }
 
+@_expose(wasm, "bjs_createCalculator")
+@_cdecl("bjs_createCalculator")
+public func _bjs_createCalculator() -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    let ret = createCalculator()
+    return Unmanaged.passRetained(ret).toOpaque()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_useCalculator")
+@_cdecl("bjs_useCalculator")
+public func _bjs_useCalculator(calc: UnsafeMutableRawPointer, x: Int32, y: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = useCalculator(calc: Unmanaged<Calculator>.fromOpaque(calc).takeUnretainedValue(), x: Int(x), y: Int(y))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
 @_expose(wasm, "bjs_Greeter_init")
 @_cdecl("bjs_Greeter_init")
 public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {
@@ -360,4 +382,32 @@ public func _bjs_Greeter_changeName(_self: UnsafeMutableRawPointer, nameBytes: I
 @_cdecl("bjs_Greeter_deinit")
 public func _bjs_Greeter_deinit(pointer: UnsafeMutableRawPointer) {
     Unmanaged<Greeter>.fromOpaque(pointer).release()
+}
+
+@_expose(wasm, "bjs_Calculator_square")
+@_cdecl("bjs_Calculator_square")
+public func _bjs_Calculator_square(_self: UnsafeMutableRawPointer, value: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<Calculator>.fromOpaque(_self).takeUnretainedValue().square(value: Int(value))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Calculator_add")
+@_cdecl("bjs_Calculator_add")
+public func _bjs_Calculator_add(_self: UnsafeMutableRawPointer, a: Int32, b: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<Calculator>.fromOpaque(_self).takeUnretainedValue().add(a: Int(a), b: Int(b))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Calculator_deinit")
+@_cdecl("bjs_Calculator_deinit")
+public func _bjs_Calculator_deinit(pointer: UnsafeMutableRawPointer) {
+    Unmanaged<Calculator>.fromOpaque(pointer).release()
 }

Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ExportSwift.json

@@ -62,6 +62,68 @@
         }
       ],
       "name" : "Greeter"
+    },
+    {
+      "methods" : [
+        {
+          "abiName" : "bjs_Calculator_square",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "square",
+          "parameters" : [
+            {
+              "label" : "value",
+              "name" : "value",
+              "type" : {
+                "int" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "int" : {
+
+            }
+          }
+        },
+        {
+          "abiName" : "bjs_Calculator_add",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "add",
+          "parameters" : [
+            {
+              "label" : "a",
+              "name" : "a",
+              "type" : {
+                "int" : {
+
+                }
+              }
+            },
+            {
+              "label" : "b",
+              "name" : "b",
+              "type" : {
+                "int" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "int" : {
+
+            }
+          }
+        }
+      ],
+      "name" : "Calculator"
     }
   ],
   "functions" : [
@@ -415,6 +477,64 @@
       "returnType" : {
         "void" : {
 
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_createCalculator",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "createCalculator",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "swiftHeapObject" : {
+          "_0" : "Calculator"
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_useCalculator",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "useCalculator",
+      "parameters" : [
+        {
+          "label" : "calc",
+          "name" : "calc",
+          "type" : {
+            "swiftHeapObject" : {
+              "_0" : "Calculator"
+            }
+          }
+        },
+        {
+          "label" : "x",
+          "name" : "x",
+          "type" : {
+            "int" : {
+
+            }
+          }
+        },
+        {
+          "label" : "y",
+          "name" : "y",
+          "type" : {
+            "int" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "int" : {
+
         }
       }
     }

Tests/prelude.mjs

@@ -128,6 +128,14 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
 
     g.release();
 
+    // Test class without @JS init constructor
+    const calc = exports.createCalculator();
+    assert.equal(calc.square(5), 25);
+    assert.equal(calc.add(3, 4), 7);
+    assert.equal(exports.useCalculator(calc, 3, 10), 19); // 3^2 + 10 = 19
+    
+    calc.release();
+
     const anyObject = {};
     assert.equal(exports.roundTripJSObject(anyObject), anyObject);