fix Object.defineProperty instance isolation for first instance

RealColdFry · RealColdFry · commit da8f1351f569 · 2026-03-27T17:28:40.000Z
Use a marker to always create per-instance metatables, not just when
_descriptors already exists on the shared metatable. Add more thorough
instance isolation tests.
diff --git a/src/lualib/SetDescriptor.ts b/src/lualib/SetDescriptor.ts
@@ -29,11 +29,9 @@ export function __TS__SetDescriptor(
     // When setting a descriptor on an instance (not a prototype), ensure it has
     // its own metatable so descriptors are not shared across instances.
     // See: https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1625
-    if (!isPrototype && rawget(metatable, "_descriptors")) {
-        // The metatable already has descriptors from a previous defineProperty
-        // call (likely on a different instance sharing the same class metatable).
-        // Create a per-instance metatable that chains to the original.
+    if (!isPrototype && !rawget(metatable, "_isOwnDescriptorMetatable")) {
         const instanceMetatable: any = {};
+        instanceMetatable._isOwnDescriptorMetatable = true;
         setmetatable(instanceMetatable, metatable);
         setmetatable(target, instanceMetatable);
         metatable = instanceMetatable;
diff --git a/test/unit/builtins/object.spec.ts b/test/unit/builtins/object.spec.ts
@@ -211,6 +211,66 @@ describe("Object.defineProperty", () => {
             return t1.obj === t2.obj;
         `.expectToMatchJsResult();
     });
+
+    test("instance isolation with three instances", () => {
+        util.testFunction`
+            class Test {
+                declare obj: object;
+                constructor() {
+                    Object.defineProperty(this, "obj", { value: {}, writable: true, configurable: true });
+                }
+            }
+            const t1 = new Test();
+            const t2 = new Test();
+            const t3 = new Test();
+            return [t1.obj === t2.obj, t1.obj === t3.obj, t2.obj === t3.obj];
+        `.expectToMatchJsResult();
+    });
+
+    test("instance isolation with mutation", () => {
+        util.testFunction`
+            class Test {
+                declare value: number;
+                constructor(v: number) {
+                    Object.defineProperty(this, "value", { value: v, writable: true, configurable: true });
+                }
+            }
+            const t1 = new Test(1);
+            const t2 = new Test(2);
+            return [t1.value, t2.value];
+        `.expectToMatchJsResult();
+    });
+
+    test("instance isolation with multiple properties", () => {
+        util.testFunction`
+            class Test {
+                declare a: string;
+                declare b: string;
+                constructor(a: string, b: string) {
+                    Object.defineProperty(this, "a", { value: a, writable: true, configurable: true });
+                    Object.defineProperty(this, "b", { value: b, writable: true, configurable: true });
+                }
+            }
+            const t1 = new Test("x", "y");
+            const t2 = new Test("p", "q");
+            return [t1.a, t1.b, t2.a, t2.b];
+        `.expectToMatchJsResult();
+    });
+
+    test("instance isolation preserves prototype methods", () => {
+        util.testFunction`
+            class Test {
+                declare val: number;
+                constructor(v: number) {
+                    Object.defineProperty(this, "val", { value: v, writable: true, configurable: true });
+                }
+                getVal() { return this.val; }
+            }
+            const t1 = new Test(10);
+            const t2 = new Test(20);
+            return [t1.getVal(), t2.getVal()];
+        `.expectToMatchJsResult();
+    });
 });
 
 describe("Object.getOwnPropertyDescriptor", () => {
