@vxrn/compiler 1.25.16 → 1.26.0

package/src/transformHermesLoops.test.ts

@@ -0,0 +1,341 @@
+import { describe, expect, it } from 'vitest'
+import * as vm from 'node:vm'
+import { transformHermesLoops } from './transformHermesLoops'
+
+/**
+ * Hermes emits one CreateFunctionEnvironment before a loop rather than one per
+ * iteration, and that environment covers the loop's head AND everything its
+ * body declares, so every lexical binding under a loop behaves there exactly
+ * like `var`. Rewriting them all that way reproduces Hermes on a spec-correct
+ * runtime, which is what makes these assertions meaningful: every one of them
+ * returns the wrong answer against the untransformed source.
+ *
+ * Verified against `hermesc -dump-bytecode`, which emits a single
+ * CreateFunctionEnvironment before the loop and a StoreToEnvironment into the
+ * same slot on each iteration.
+ */
+function runAsHermes(code: string) {
+  const asHermesWouldSeeIt = code.replace(/\b(?:let|const)\b/g, 'var')
+  const sandbox: any = { result: undefined, console }
+  vm.runInNewContext(asHermesWouldSeeIt, sandbox)
+  return sandbox.result
+}
+
+function run(source: string) {
+  const out = transformHermesLoops(source, 'test.js')
+  return runAsHermes(out ? out.code : source)
+}
+
+describe('transformHermesLoops', () => {
+  it.each([
+    ['if (false)', []],
+    ['if (true)', [1, 2]],
+    ['for (var pass = 0; pass < 2; pass++)', [1, 2, 1, 2]],
+    ['while (passes++ < 2)', [1, 2, 1, 2]],
+  ])('keeps a captured loop inside a single-statement %s body', (parent, expected) => {
+    expect(
+      run(`
+        var fns = []
+        var passes = 0
+        ${parent} for (const n of [1, 2]) fns.push(() => n)
+        result = fns.map((f) => f())
+      `)
+    ).toEqual(expected)
+  })
+
+  it.each([true, false])(
+    'preserves if/else selection when the condition is %s',
+    (condition) => {
+      expect(
+        run(`
+        var fns = []
+        if (${condition}) for (const n of [1, 2]) fns.push(() => n)
+        else for (const n of [3, 4]) fns.push(() => n)
+        result = fns.map((f) => f())
+      `)
+      ).toEqual(condition ? [1, 2] : [3, 4])
+    }
+  )
+
+  it('preserves a do/while with a single-statement loop body', () => {
+    expect(
+      run(`
+        var fns = []
+        var passes = 0
+        do for (const n of [1, 2]) fns.push(() => n)
+        while (passes++ < 1)
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([1, 2, 1, 2])
+  })
+
+  it('guards optional Zero query patches through nested loop transforms', () => {
+    expect(
+      run(`
+        var fns = []
+        var parts = [{}, { desiredQueriesPatches: { a: ['x', 'y'], b: ['z'] } }]
+        for (const part of parts) {
+          if (part.desiredQueriesPatches)
+            for (const [clientID, queriesPatch] of Object.entries(part.desiredQueriesPatches))
+              for (const op of queriesPatch) fns.push(() => clientID + ':' + op)
+        }
+        result = fns.map((f) => f())
+      `)
+    ).toEqual(['a:x', 'a:y', 'b:z'])
+  })
+
+  it('gives a C-style loop a per-iteration binding', () => {
+    expect(
+      run(`
+        var fns = []
+        for (let i = 0; i < 3; i++) fns.push(() => i)
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([0, 1, 2])
+  })
+
+  it('gives for-of and for-in per-iteration bindings', () => {
+    expect(
+      run(`
+        var fns = []
+        for (const label of ['a', 'b']) fns.push(() => label)
+        for (const key in { x: 1, y: 2 }) fns.push(() => key)
+        result = fns.map((f) => f())
+      `)
+    ).toEqual(['a', 'b', 'x', 'y'])
+  })
+
+  it('preserves break', () => {
+    expect(
+      run(`
+        var fns = []
+        for (let i = 0; i < 10; i++) {
+          if (i === 3) break
+          fns.push(() => i)
+        }
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([0, 1, 2])
+  })
+
+  it('preserves continue', () => {
+    expect(
+      run(`
+        var fns = []
+        for (let i = 0; i < 5; i++) {
+          if (i % 2 === 0) continue
+          fns.push(() => i)
+        }
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([1, 3])
+  })
+
+  it('preserves return out of the enclosing function', () => {
+    expect(
+      run(`
+        function find() {
+          for (const n of [1, 2, 3]) {
+            const get = () => n
+            if (n === 2) return get()
+          }
+          return 'none'
+        }
+        result = find()
+      `)
+    ).toBe(2)
+  })
+
+  it('preserves a bare return', () => {
+    expect(
+      run(`
+        var fns = []
+        function go() {
+          for (let i = 0; i < 5; i++) {
+            if (i === 2) return
+            fns.push(() => i)
+          }
+        }
+        go()
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([0, 1])
+  })
+
+  it('leaves break and continue belonging to a nested loop alone', () => {
+    expect(
+      run(`
+        var fns = []
+        for (let i = 0; i < 2; i++) {
+          for (var j = 0; j < 5; j++) {
+            if (j > 0) break
+          }
+          fns.push(() => i)
+        }
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([0, 1])
+  })
+
+  it('handles nested capturing loops', () => {
+    expect(
+      run(`
+        var fns = []
+        for (let i = 0; i < 2; i++) {
+          for (let j = 0; j < 2; j++) {
+            fns.push(() => i + ':' + j)
+          }
+        }
+        result = fns.map((f) => f())
+      `)
+    ).toEqual(['0:0', '0:1', '1:0', '1:1'])
+  })
+
+  it('handles await in the loop body', async () => {
+    const out = transformHermesLoops(
+      `
+        var fns = []
+        async function go() {
+          for (const n of [1, 2]) {
+            await Promise.resolve()
+            fns.push(() => n)
+          }
+          return fns.map((f) => f())
+        }
+        result = go()
+      `,
+      'test.js'
+    )
+    expect(out).not.toBeNull()
+    await expect(runAsHermes(out!.code)).resolves.toEqual([1, 2])
+  })
+
+  it('destructures a for-of binding per iteration', () => {
+    expect(
+      run(`
+        var fns = []
+        for (const { id } of [{ id: 'a' }, { id: 'b' }]) fns.push(() => id)
+        result = fns.map((f) => f())
+      `)
+    ).toEqual(['a', 'b'])
+  })
+
+  it('rewrites the esbuild interop helper that broke every multi-export module', () => {
+    // this exact shape is what esbuild inlines into every commonjs-interop
+    // module, and under Hermes it made each named export resolve to the last one
+    expect(
+      run(`
+        var __defProp = Object.defineProperty
+        var __getOwnPropNames = Object.getOwnPropertyNames
+        var from = { a: 1, b: 2 }
+        var to = {}
+        for (let key of __getOwnPropNames(from)) {
+          __defProp(to, key, { get: () => from[key], enumerable: true })
+        }
+        result = [to.a, to.b]
+      `)
+    ).toEqual([1, 2])
+  })
+
+  it('leaves loops that never capture their binding untouched', () => {
+    expect(
+      transformHermesLoops('for (let i = 0; i < 3; i++) sum += i', 'test.js')
+    ).toBeNull()
+  })
+
+  it('gives a binding declared in the loop body a per-iteration copy', () => {
+    // react-native's NativeAnimatedHelper builds one wrapper per method this
+    // way; sharing `methodName` made every wrapper resolve the last method.
+    expect(
+      run(`
+        var names = ['createAnimatedNode', 'addListener', 'removeListener']
+        var wrappers = {}
+        for (var ii = 0; ii < names.length; ii++) {
+          const methodName = names[ii]
+          wrappers[methodName] = () => methodName
+        }
+        result = names.map((n) => wrappers[n]())
+      `)
+    ).toEqual(['createAnimatedNode', 'addListener', 'removeListener'])
+  })
+
+  it('gives a binding declared in a nested block of the loop body a per-iteration copy', () => {
+    expect(
+      run(`
+        var fns = []
+        for (var i = 0; i < 3; i++) {
+          if (i >= 0) {
+            const doubled = i * 2
+            fns.push(() => doubled)
+          }
+        }
+        result = fns.map((f) => f())
+      `)
+    ).toEqual([0, 2, 4])
+  })
+
+  it('keeps `this` and `arguments` meaning what they meant outside the loop', () => {
+    // reanimated's PropsFilter reads `this._map` from a closure inside a
+    // `for (const key in props)` body, so a lifted body that rebound `this`
+    // crashed every animated component.
+    expect(
+      run(`
+        class PropsFilter {
+          constructor() { this._map = { a: 'A', b: 'B' } }
+          filter(props) {
+            var out = []
+            for (const key in props) {
+              const label = key
+              out.push(() => this._map[label] + arguments.length)
+            }
+            return out
+          }
+        }
+        result = new PropsFilter().filter({ a: 1, b: 2 }).map((f) => f())
+      `)
+    ).toEqual(['A1', 'B1'])
+  })
+
+  it('leaves a loop with no lexical binding untouched', () => {
+    expect(
+      transformHermesLoops('for (var i = 0; i < 3; i++) fns.push(() => i)', 'test.js')
+    ).toBeNull()
+  })
+
+  it('leaves the head declaration alone so it cannot collide with a sibling', () => {
+    // react-native-gesture-handler's Pressable declares `const gesture` in the
+    // same block as `for (const gesture of gestures)`. hoisting the head to
+    // `var` made that a redeclaration and failed the whole bundle to parse.
+    const out = transformHermesLoops(
+      `function build(gestures) {
+         var handlers = []
+         for (const gesture of gestures) { handlers.push(() => gesture) }
+         const gesture = gestures[0]
+         return gesture
+       }`,
+      'Pressable.js'
+    )
+    // a redeclaration is a SyntaxError, so compiling is the whole assertion
+    expect(() => new vm.Script(out!.code)).not.toThrow()
+  })
+
+  it('rewrites a loop in a .js file that still contains jsx', () => {
+    // react-native and its dependencies ship jsx inside plain `.js`, and the
+    // rolldown native pipeline keeps jsx unlowered until after this transform.
+    const out = transformHermesLoops(
+      'for (const c of items) rows.push(() => <Row key={c} />)',
+      'Rows.js'
+    )
+    expect(out?.code).toContain('_hermesLoop0')
+  })
+
+  it('does not rewrite a loop that reassigns its own binding', () => {
+    // the update would be stranded inside the lifted function
+    expect(
+      transformHermesLoops(
+        'for (let i = 0; i < 3; i++) { i += 1; fns.push(() => i) }',
+        'test.js'
+      )
+    ).toBeNull()
+  })
+})