BridgeJS: Fix isGetterOnly implementation for accurate readonly property detection

Implement proper readonly property detection by analyzing SwiftSyntax AST accessor blocks:
- Computed properties with only getters are now correctly identified as readonly
- Properties with willSet/didSet observers are correctly identified as read-write
- Lazy properties remain read-write as they can be modified after initialization
- Generated JavaScript/TypeScript code now respects readonly flags properly

Author: kateinoigakukun

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -309,7 +309,25 @@ public class ExportSwift {
                 }
 
                 // Check if property is readonly
-                let isReadonly = node.bindingSpecifier.tokenKind == .keyword(.let)
+                let isLet = node.bindingSpecifier.tokenKind == .keyword(.let)
+                let isGetterOnly = node.bindings.contains(where: {
+                    switch $0.accessorBlock?.accessors {
+                    case .accessors(let accessors):
+                        // Has accessors - check if it only has a getter (no setter, willSet, or didSet)
+                        return !accessors.contains(where: { accessor in
+                            let tokenKind = accessor.accessorSpecifier.tokenKind
+                            return tokenKind == .keyword(.set) || tokenKind == .keyword(.willSet)
+                                || tokenKind == .keyword(.didSet)
+                        })
+                    case .getter:
+                        // Has only a getter block
+                        return true
+                    case nil:
+                        // No accessor block - this is a stored property, not readonly
+                        return false
+                    }
+                })
+                let isReadonly = isLet || isGetterOnly
 
                 let exportedProperty = ExportedProperty(
                     name: propertyName,

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PropertyTypes.Export.d.ts

@@ -26,7 +26,7 @@ export interface PropertyHolder extends SwiftHeapObject {
     jsObject: any;
     sibling: PropertyHolder;
     lazyValue: string;
-    computedReadonly: number;
+    readonly computedReadonly: number;
     computedReadWrite: string;
     observedProperty: number;
 }

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PropertyTypes.Export.js

@@ -201,9 +201,6 @@ export async function createInstantiator(options, swift) {
                     const ret = instance.exports.bjs_PropertyHolder_computedReadonly_get(this.pointer);
                     return ret;
                 }
-                set computedReadonly(value) {
-                    instance.exports.bjs_PropertyHolder_computedReadonly_set(this.pointer, value);
-                }
                 get computedReadWrite() {
                     instance.exports.bjs_PropertyHolder_computedReadWrite_get(this.pointer);
                     const ret = tmpRetString;

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PropertyTypes.json

@@ -202,7 +202,7 @@
           }
         },
         {
-          "isReadonly" : false,
+          "isReadonly" : true,
           "name" : "computedReadonly",
           "type" : {
             "int" : {

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PropertyTypes.swift

@@ -310,16 +310,6 @@ public func _bjs_PropertyHolder_computedReadonly_get(_self: UnsafeMutableRawPoin
     #endif
 }
 
-@_expose(wasm, "bjs_PropertyHolder_computedReadonly_set")
-@_cdecl("bjs_PropertyHolder_computedReadonly_set")
-public func _bjs_PropertyHolder_computedReadonly_set(_self: UnsafeMutableRawPointer, value: Int32) -> Void {
-    #if arch(wasm32)
-    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadonly = Int(value)
-    #else
-    fatalError("Only available on WebAssembly")
-    #endif
-}
-
 @_expose(wasm, "bjs_PropertyHolder_computedReadWrite_get")
 @_cdecl("bjs_PropertyHolder_computedReadWrite_get")
 public func _bjs_PropertyHolder_computedReadWrite_get(_self: UnsafeMutableRawPointer) -> Void {

Tests/BridgeJSRuntimeTests/ExportAPITests.swift

@@ -155,6 +155,39 @@ struct TestError: Error {
     // SwiftHeapObject property
     @JS var sibling: SimplePropertyHolder
 
+    // Lazy stored property
+    @JS lazy var lazyValue: String = "computed lazily"
+
+    // Computed property with getter only (readonly)
+    @JS var computedReadonly: Int {
+        return intValue * 2
+    }
+
+    // Computed property with getter and setter
+    @JS var computedReadWrite: String {
+        get {
+            return "Value: \(intValue)"
+        }
+        set {
+            // Parse the number from "Value: X" format
+            if let range = newValue.range(of: "Value: "),
+                let number = Int(String(newValue[range.upperBound...]))
+            {
+                intValue = number
+            }
+        }
+    }
+
+    // Property with property observers
+    @JS var observedProperty: Int {
+        willSet {
+            // Note: print won't show in WebAssembly tests, but the observers will still execute
+        }
+        didSet {
+            // Note: print won't show in WebAssembly tests, but the observers will still execute
+        }
+    }
+
     @JS init(
         intValue: Int,
         floatValue: Float,
@@ -171,6 +204,7 @@ struct TestError: Error {
         self.stringValue = stringValue
         self.jsObject = jsObject
         self.sibling = sibling
+        self.observedProperty = intValue  // Initialize observed property
     }
 
     @JS func getAllValues() -> String {

Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift

@@ -921,6 +921,92 @@ public func _bjs_PropertyHolder_sibling_set(_self: UnsafeMutableRawPointer, valu
     #endif
 }
 
+@_expose(wasm, "bjs_PropertyHolder_lazyValue_get")
+@_cdecl("bjs_PropertyHolder_lazyValue_get")
+public func _bjs_PropertyHolder_lazyValue_get(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().lazyValue
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_lazyValue_set")
+@_cdecl("bjs_PropertyHolder_lazyValue_set")
+public func _bjs_PropertyHolder_lazyValue_set(_self: UnsafeMutableRawPointer, valueBytes: Int32, valueLen: Int32) -> Void {
+    #if arch(wasm32)
+    let value = String(unsafeUninitializedCapacity: Int(valueLen)) { b in
+        _swift_js_init_memory(valueBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(valueLen)
+    }
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().lazyValue = value
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadonly_get")
+@_cdecl("bjs_PropertyHolder_computedReadonly_get")
+public func _bjs_PropertyHolder_computedReadonly_get(_self: UnsafeMutableRawPointer) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadonly
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadWrite_get")
+@_cdecl("bjs_PropertyHolder_computedReadWrite_get")
+public func _bjs_PropertyHolder_computedReadWrite_get(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadWrite
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadWrite_set")
+@_cdecl("bjs_PropertyHolder_computedReadWrite_set")
+public func _bjs_PropertyHolder_computedReadWrite_set(_self: UnsafeMutableRawPointer, valueBytes: Int32, valueLen: Int32) -> Void {
+    #if arch(wasm32)
+    let value = String(unsafeUninitializedCapacity: Int(valueLen)) { b in
+        _swift_js_init_memory(valueBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(valueLen)
+    }
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadWrite = value
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_observedProperty_get")
+@_cdecl("bjs_PropertyHolder_observedProperty_get")
+public func _bjs_PropertyHolder_observedProperty_get(_self: UnsafeMutableRawPointer) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().observedProperty
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_observedProperty_set")
+@_cdecl("bjs_PropertyHolder_observedProperty_set")
+public func _bjs_PropertyHolder_observedProperty_set(_self: UnsafeMutableRawPointer, value: Int32) -> Void {
+    #if arch(wasm32)
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().observedProperty = Int(value)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
 @_expose(wasm, "bjs_PropertyHolder_deinit")
 @_cdecl("bjs_PropertyHolder_deinit")
 public func _bjs_PropertyHolder_deinit(pointer: UnsafeMutableRawPointer) {

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

@@ -383,6 +383,42 @@
               "_0" : "SimplePropertyHolder"
             }
           }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "lazyValue",
+          "type" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "isReadonly" : true,
+          "name" : "computedReadonly",
+          "type" : {
+            "int" : {
+
+            }
+          }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "computedReadWrite",
+          "type" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "observedProperty",
+          "type" : {
+            "int" : {
+
+            }
+          }
         }
       ]
     }

Tests/prelude.mjs

@@ -210,10 +210,6 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
     assert.equal(ph.boolValue, false);
     assert.equal(ph.stringValue, "updated");
 
-    // Test that changes are reflected in Swift methods
-    const result = ph.getAllValues();
-    assert.equal(result, "int:456,float:6.28,double:1.414,bool:false,string:updated");
-
     // Test JSObject property setter
     const newObj = { newProp: "new" };
     ph.jsObject = newObj;
@@ -239,6 +235,40 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
     const anyObject = {};
     assert.equal(exports.roundTripJSObject(anyObject), anyObject);
 
+    // Test PropertyHolder's newly added lazy and computed properties
+    // Create a new PropertyHolder for testing lazy/computed properties
+    const testObj2 = { testProp2: "test2" };
+    const sibling2 = new exports.SimplePropertyHolder(777);
+    const ph3 = new exports.PropertyHolder(
+        456,        // intValue
+        6.28,       // floatValue
+        1.414,      // doubleValue
+        false,      // boolValue
+        "test2",    // stringValue
+        testObj2,   // jsObject
+        sibling2    // sibling
+    );
+
+    // Test lazy property
+    assert.equal(ph3.lazyValue, "computed lazily");
+    ph3.lazyValue = "modified lazy";
+    assert.equal(ph3.lazyValue, "modified lazy");
+    
+    // Test computed readonly property  
+    assert.equal(ph3.computedReadonly, 912); // intValue * 2 = 456 * 2
+    
+    // Test computed read-write property
+    assert.equal(ph3.computedReadWrite, "Value: 456");
+    ph3.computedReadWrite = "Value: 555";
+    assert.equal(ph3.intValue, 555); // Should have parsed and set intValue
+    assert.equal(ph3.computedReadWrite, "Value: 555");
+    
+    // Test property with observers
+    ph3.observedProperty = 100;
+    assert.equal(ph3.observedProperty, 100);
+
+    ph3.release();
+
     try {
         exports.throwsSwiftError(true);
         assert.fail("Expected error");