@pyreon/compiler 0.24.4 → 0.24.6

package/src/tests/r13-callback-stmt-equivalence.test.ts

@@ -1,58 +0,0 @@
-/**
- * Compiler hardening — Round 13 (REAL JS↔Rust divergence, FIXED + bisect).
- *
- * R7 (#687) taught the native `collect_prop_derived_idents` to recurse into
- * callback bodies — but its `collect_pd_in_stmt` only handled
- * Expression/Return/VarDecl/If/Block, with `_ => {}` skipping
- * For/While/DoWhile/Switch/Try/Labeled. So a prop-derived const used inside a
- * callback whose body is one of those shapes still lost reactivity in the
- * NATIVE backend (preferred in prod) while the JS backend inlined it — the
- * exact R7 reactivity-loss class, narrower shapes (e.g. `try { return <li
- * class={c}/> } catch …` in a render callback — plausible defensive render).
- *
- * Fix: native/src/lib.rs `collect_pd_in_stmt` now also handles
- * For/ForIn/ForOf/While/DoWhile/Switch/Try/Labeled, with the SAME
- * `pd_minus`/`collect_bind_pattern_names` shadow-filter discipline as the
- * Block/If arms (so loop/catch-param bindings shadow correctly and the
- * over-substitution clobber is NOT re-introduced — verified by the
- * catch-param spec).
- *
- * Bisect: replace the new arms with `_ => {}` + `bun scripts/build-native.ts`
- * → these specs fail (Rust emits `class={c}`, JS `class={(p.x+'-b')}`).
- * Restore + rebuild → all pass. The 180 native-equivalence tests + full
- * suite remain green (no regression).
- */
-import { describe, expect, it } from 'vitest'
-import { transformJSX, transformJSX_JS } from '../jsx'
-
-const j = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
-const r = (c: string): string => transformJSX(c, 'c.tsx').code ?? ''
-
-const CASES: Array<[string, string]> = [
-  ['while', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { while(i){ return <li class={c}/> } })}</ul> }`],
-  ['switch', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { switch(i){ default: return <li class={c}/> } })}</ul> }`],
-  ['labeled', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { lbl: { return <li class={c}/> } })}</ul> }`],
-  ['try-catch', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { try { return <li class={c}/> } catch { return null } })}</ul> }`],
-  ['for', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { for(let k=0;k<i;k++){ return <li class={c}/> } })}</ul> }`],
-]
-
-describe('Round 13 — prop-derived inlining inside callback statement shapes is JS≡Rust', () => {
-  for (const [name, src] of CASES) {
-    it(`${name}: native backend matches JS (inlines the prop-derived const)`, () => {
-      expect(r(src)).toBe(j(src))
-      expect(r(src)).toContain("class={(p.x+'-b')}")
-    })
-  }
-
-  it('catch-param shadowing is NOT clobbered (filter discipline, both backends)', () => {
-    const src = `function C(p){ const e=p.x+'-b'; return <ul>{p.i.map(i => { try {} catch (e) { return <li class={e}/> } })}</ul> }`
-    expect(r(src)).toBe(j(src))
-    expect(r(src)).not.toContain("class={(p.x+'-b')}") // `e` is the catch param
-  })
-
-  it('nested const inside a while body shadowing the prop-derived is NOT clobbered (no R2 regression)', () => {
-    const src = `function C(p){ const c=p.x; return <ul>{p.i.map(i => { while(i){ const c=2; return <li>{c}</li> } })}</ul> }`
-    expect(r(src)).toBe(j(src))
-    expect(r(src)).not.toContain('{(p.x)}') // inner `const c=2` shadows — must stay `{c}`
-  })
-})

package/src/tests/r14-ssr-mode-parity.test.ts

@@ -1,51 +0,0 @@
-/**
- * Compiler hardening — Round 14 (SSR-mode robustness; no bug found).
- *
- * Rounds 1–13 were all client-mode. SSR mode (`{ ssr: true }`) disables
- * template emission (`if (ssr) return false`) and leaves JSX as
- * accessor-wrapped expressions for the SSR renderer. Probed 8 adversarial
- * shapes — all emit parseable code, and the correctness-critical contracts
- * hold in SSR exactly as in client mode: prop-derived consts still inline,
- * signals still auto-call, and the R11 shadow fix still suppresses a
- * destructured callback param. This locks SSR-mode parity for the bug fixes
- * so a future SSR-path change can't silently regress them.
- */
-import { parseSync } from 'oxc-parser'
-import { describe, expect, it } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-const ssr = (c: string): string => transformJSX_JS(c, 'c.tsx', { ssr: true }).code ?? ''
-const parses = (o: string): boolean => {
-  try {
-    return (parseSync('o.tsx', o).errors?.length ?? 0) === 0
-  } catch {
-    return false
-  }
-}
-
-describe('Round 14 — SSR-mode codegen parity', () => {
-  it('SSR never throws / always emits parseable code (8 adversarial shapes)', () => {
-    const shapes = [
-      `function C(p){ return <div class={p.c}>{p.t}</div> }`,
-      `function C(p){ return <div {...p}>{p.k}</div> }`,
-      `function C(p){ return <>{p.a}<span>{p.b}</span></> }`,
-      `function C(){ const h=<h1>T</h1>; return <div>{h}<p>x</p></div> }`,
-      `function C(p){ return <section><h1>{p.t}</h1><p>{p.b}</p></section> }`,
-    ]
-    for (const s of shapes) expect(parses(ssr(s)), s).toBe(true)
-  })
-
-  it('prop-derived const still inlines in SSR (R2/R7 parity)', () => {
-    expect(ssr(`function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i=><li class={c}>{i}</li>)}</ul> }`))
-      .toContain("class={(p.x+'-b')}")
-  })
-
-  it('signal still auto-calls in SSR', () => {
-    expect(ssr(`function C(){ const s=signal(0); return <div>{s}</div> }`)).toContain('s()')
-  })
-
-  it('R11 shadow fix applies in SSR (destructured param NOT auto-called)', () => {
-    expect(ssr(`function C(){ const x=signal(0); return <ul>{[{x:1}].map(({x})=><li>{x}</li>)}</ul> }`))
-      .not.toContain('{x()}')
-  })
-})

package/src/tests/r15-elemconst-propderived.test.ts

@@ -1,47 +0,0 @@
-/**
- * Compiler hardening — Round 15 (element-const that references a prop-derived
- * var) — consolidated, deterministic JS-backend characterization.
- *
- * Original finding: `const cls = props.x + '-b'; const el = <i class={cls}/>;`
- * used as a bare `{el}` child sat at the intersection of R2 (prop-derived
- * inlining) and R9 (element-const → `_mountSlot`). The JS backend substitutes
- * the element-const's whole initializer into the mount call with the
- * prop-derived part inlined reactively:
- *   `_mountSlot((<i class={(props.x + '-b')}/>), …)`
- *
- * It was previously tracked by two duplicate, environment-fragile `it.fails`
- * JS↔Rust divergence locks. The R13 gate/collector fix
- * (`accesses_props` now recurses arrow/JSX → the element-const's prop-derived
- * ref is collected) realigned the native backend with JS — so the locks
- * correctly auto-flipped and were removed (lock→resolved, same lifecycle as
- * R7/R11/R13). JS↔Rust byte-equivalence is now gated generally by the R20
- * sweep + R13's own contract; this file keeps only the DETERMINISTIC,
- * native-independent JS-backend assertions (no `transformJSX` native call →
- * no build-artifact fragility, stable on every runner).
- */
-import { describe, expect, it } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
-
-const PD_ELEM = `function C(p){ const cls=p.x+'-b'; const el=<i class={cls}/>; return <div>{el}<span class={cls}/></div> }`
-const SIMPLE = `function C(){ const h=<h1>T</h1>; return <div>{h}<p>x</p></div> }`
-const REUSED = `function C(){ const ic=<svg/>; return <div>{ic}<span>{ic}</span></div> }`
-
-describe('Round 15 — element-const × prop-derived (JS backend characterization)', () => {
-  it('JS inlines a prop-derived-referencing element-const into _mountSlot with a reactive class', () => {
-    const out = emit(PD_ELEM)
-    expect(out).toContain("_mountSlot((<i class={(p.x+'-b')}/>)")
-    // the prop-derived class is the reactive form, not the frozen const ref
-    expect(out).not.toMatch(/_mountSlot\(\s*el\b/)
-  })
-
-  it('a simple element-const child routes through _mountSlot (R9 baseline)', () => {
-    expect(emit(SIMPLE)).toContain('_mountSlot(h')
-  })
-
-  it('an element-const reused at two sites routes both through _mountSlot', () => {
-    const out = emit(REUSED)
-    expect(out).toMatch(/_mountSlot\(\s*ic\b/)
-  })
-})

package/src/tests/r19-defer-inline-robust.test.ts

@@ -1,54 +0,0 @@
-/**
- * Compiler hardening — Round 19 (defer-inline robustness; no bug found).
- *
- * `transformDeferInline` (a separate compiler entry, unprobed in rounds
- * 1–18) rewrites `<Defer when={…}><X/></Defer>` to inline its children.
- * Probed 10 valid shapes (no-children, multi-child, expr/text child, nested
- * Defer, self-closing, spread child, comment child, passthrough) + a
- * malformed input — all valid cases emit parseable code, and malformed input
- * is passed through unchanged without throwing (same resilience contract as
- * Round 10). This locks the surface.
- */
-import { parseSync } from 'oxc-parser'
-import { describe, expect, it } from 'vitest'
-import { transformDeferInline } from '../defer-inline'
-
-const run = (c: string): string => {
-  const r = transformDeferInline(c, 'c.tsx') as { code?: string }
-  return r?.code ?? ''
-}
-const parses = (o: string): boolean => {
-  try {
-    return (parseSync('o.tsx', o).errors?.length ?? 0) === 0
-  } catch {
-    return false
-  }
-}
-
-const VALID: Array<[string, string]> = [
-  ['basic', `import { Modal } from './M'\nfunction C(){ const o=signal(0); return <Defer when={o()}><Modal title="hi"/></Defer> }`],
-  ['passthrough', `function C(){ return <div>{x}</div> }`],
-  ['no-children', `function C(){ return <Defer when={a}></Defer> }`],
-  ['multi-child', `import {A,B} from './x'\nfunction C(){ return <Defer when={c}><A/><B/></Defer> }`],
-  ['expr-child', `function C(){ return <Defer when={c}>{val}</Defer> }`],
-  ['nested-defer', `import {A} from './x'\nfunction C(){ return <Defer when={a}><Defer when={b}><A/></Defer></Defer> }`],
-  ['text-child', `function C(){ return <Defer when={c}>plain text</Defer> }`],
-  ['self-closing', `function C(){ return <Defer when={c}/> }`],
-  ['spread-child', `import {A} from './x'\nfunction C(p){ return <Defer when={c}><A {...p}/></Defer> }`],
-  ['comment-child', `function C(){ return <Defer when={c}>{/* x */}</Defer> }`],
-]
-
-describe('Round 19 — transformDeferInline robustness', () => {
-  for (const [name, src] of VALID) {
-    it(`emits parseable code: ${name}`, () => {
-      let out = ''
-      expect(() => {
-        out = run(src)
-      }).not.toThrow()
-      expect(parses(out)).toBe(true)
-    })
-  }
-  it('malformed input is passed through without throwing (resilience)', () => {
-    expect(() => run(`function C(){ return <Defer when={</Defer> }`)).not.toThrow()
-  })
-})

package/src/tests/r20-backend-equivalence-sweep.test.ts

@@ -1,50 +0,0 @@
-/**
- * Compiler hardening — Round 20 (JS↔Rust equivalence sweep, R11–R19 corpus).
- *
- * The dual backends MUST emit byte-identical output. This sweep locks the
- * adversarial corpus surfaced in rounds 11–19 where BOTH backends agree, so a
- * future one-backend change that introduces a divergence (the recurring
- * R7/R13/R15 one-backend-change failure mode) is caught immediately. R11's
- * and R13's fixes CONVERGED the backends (R11 brought JS onto the
- * already-correct Rust; R13's gate/collector fix realigned native with JS,
- * which also resolved the R15 element-const×prop-derived divergence) — those
- * shapes must now stay identical, asserted here. The earlier self-
- * discriminating `it.fails` divergence locks auto-flipped on resolution and
- * were removed; R15's residual is a deterministic JS-backend
- * characterization (r15-elemconst-propderived.test.ts).
- */
-import { describe, expect, it } from 'vitest'
-import { transformJSX, transformJSX_JS } from '../jsx'
-
-const EQUIVALENT: Array<[string, string]> = [
-  // R11 — signal-auto-call shadowing (JS converged to Rust)
-  ['r11-destructured-param', `function C(){ const x = signal(0); return <ul>{[{x:1}].map(({x}) => <li>{x}</li>)}</ul> }`],
-  ['r11-filter-obj-param', `function C(){ const id = signal(0); return <ul>{[{id:1}].filter(({id}) => id > 0).map(r => <li>{r}</li>)}</ul> }`],
-  ['r11-plain-param-shadow', `function C(){ const s = signal(0); return <ul>{[1].map(s => <li>{s}</li>)}</ul> }`],
-  ['r11-direct-signal', `function C(){ const s = signal(0); return <div>{s}</div> }`],
-  ['r11-signal-shadow-sibling', `function C(){ const s = signal(0); return <div>{[1].map(s => <i>{s}</i>)}<b>{s}</b></div> }`],
-  // R16 — knownSignals (cross-module signal) path
-  ['r16-knownsignal-shadow', `function C(){ return <ul>{[{count:1}].map(({count}) => <li>{count}</li>)}</ul> }`],
-  // R15 — element-const interactions that DO converge
-  ['r15-simple-elem-const', `function C(){ const h=<h1>T</h1>; return <div>{h}<p>x</p></div> }`],
-  ['r15-elem-const-reused', `function C(){ const ic=<svg/>; return <div>{ic}<span>{ic}</span></div> }`],
-  // R17 — spread depth
-  ['r17-root-spread-reactive', `function C(p){ const s=signal(0); return <div {...p} onClick={()=>s.set(1)}>{s}</div> }`],
-  ['r17-component-spread-pd', `function C(p){ const c=p.x+'-b'; return <Comp {...p} class={c}/> }`],
-  ['r17-double-spread', `function C(p){ return <div {...p.a} {...p.b}>{p.c}</div> }`],
-  // R18 — hoisting × elementVars
-  ['r18-hoist-vs-elemconst', `function C(){ const e=<b>x</b>; return <div>{<i/>}{e}</div> }`],
-  ['r18-elemconst-reused-3x', `function C(){ const e=<hr/>; return <div>{e}{e}{e}</div> }`],
-  // R13 — the convergent control (return-body callback)
-  ['r13-return-cb', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { return <li class={c}>{i}</li> })}</ul> }`],
-  // general
-  ['mixed', `function C(p){ const a=p.x; return <section><h1>{a}</h1>{p.i.map(i=><p key={i.id}>{i.t}</p>)}</section> }`],
-]
-
-describe('Round 20 — JS↔Rust byte-equivalence (R11–R19 corpus)', () => {
-  for (const [name, code] of EQUIVALENT) {
-    it(`${name}: JS ≡ Rust`, () => {
-      expect(transformJSX(code, 'c.tsx').code).toBe(transformJSX_JS(code, 'c.tsx').code)
-    })
-  }
-})