fix(codemode): align mutable JavaScript semantics (#35598)

packages/codemode/test/parity.test.ts

@@ -264,6 +264,46 @@ describe("Error values and instanceof", () => {
 })
 
 describe("array methods: splice, fill, copyWithin, keys/values/entries", () => {
+  test("sort and reverse mutate and return the receiver", async () => {
+    expect(
+      await value(`
+        const sorted = [3, 1, 2]
+        const sortResult = sorted.sort((a, b) => a - b)
+        const reversed = [1, 2, 3]
+        const reverseResult = reversed.reverse()
+        return { sorted, sameSort: sorted === sortResult, reversed, sameReverse: reversed === reverseResult }
+      `),
+    ).toEqual({ sorted: [1, 2, 3], sameSort: true, reversed: [3, 2, 1], sameReverse: true })
+  })
+
+  test("array callbacks receive the receiver and observe later mutations", async () => {
+    expect(
+      await value(`
+        const values = [1, 2, 3]
+        const seen = values.map((value, index, receiver) => {
+          if (index === 0) values[1] = 9
+          return [value, receiver === values]
+        })
+        return seen
+      `),
+    ).toEqual([
+      [1, true],
+      [9, true],
+      [3, true],
+    ])
+    expect(
+      await value(`
+        const values = [1, 2, 3]
+        const seen = []
+        values.forEach((value, index) => {
+          seen.push(value)
+          if (index === 0) values.pop()
+        })
+        return seen
+      `),
+    ).toEqual([1, 2])
+  })
+
   test("splice removes in place and returns the removed elements", async () => {
     expect(await value(`const a = [1,2,3,4]; const removed = a.splice(1, 2); return { removed, a }`)).toEqual({
       removed: [2, 3],

packages/codemode/test/stdlib.test.ts

@@ -586,6 +586,26 @@ describe("Set", () => {
 })
 
 describe("stdlib integration", () => {
+  test("Object.assign mutates and returns its target", async () => {
+    expect(
+      await value(`
+        const target = { a: 1 }
+        const result = Object.assign(target, { b: 2 })
+        return { target, result, same: target === result }
+      `),
+    ).toEqual({ target: { a: 1, b: 2 }, result: { a: 1, b: 2 }, same: true })
+    expect(await value(`try { Object.assign(null, { a: 1 }); return false } catch { return true }`)).toBe(true)
+  })
+
+  test("assignment resolves and reads its left side before evaluating the right side", async () => {
+    expect(await value(`let x = 1; x += (x = 5); return x`)).toBe(6)
+    expect(await value(`let i = 0; const values = [9]; values[i++] = i; return [values, i]`)).toEqual([[1], 1])
+    expect(await value(`let i = 0; const values = [10, 20]; values[i++] += i; return [values, i]`)).toEqual([
+      [11, 20],
+      1,
+    ])
+  })
+
   test("typeof reports constructors as functions and never throws", async () => {
     expect(await value(`return typeof Map`)).toBe("function")
     expect(await value(`return typeof ((x) => x)`)).toBe("function")