Summary

This batch targets 5 fixtures that compiled without error in oxc but throw an internal Invariant upstream — cases where oxc's output was silently wrong (worse than upstream's loud failure).

Root cause (shared by 4 of the 5)

codegen_function wrapped ox_codegen_reactive_function in a scaffolding shim that fell back to an empty function body on ANY codegen error. That turned genuine "this input cannot be compiled" invariants into silent miscompiles: the whole body was replaced with {} and applied to the program with no diagnostic.

The shim still had a legitimate job, though — a couple of codegen sub-emitters aren't ported yet (Destructuring reassignment targets, hook-guard wrapping), and upstream does compile those. Blindly propagating every error would regress ~26 fixtures that currently emit an (imperfect) empty body but would now spuriously error.

Fix: split the two error classes. A new CompilerError::unimplemented flag (set via unimplemented_err) marks the genuinely-unported sub-emitters; the shim keeps falling back to an empty body only for those. Every other codegen error now propagates as a diagnostic — matching upstream's Invariant — instead of emitting wrong code. Net diff: only the 5 genuine-invariant fixtures change; the ~26 not-yet-ported fixtures keep their prior output (no regressions).

Per-fixture status

Bonus: error.todo-kitchensink also flipped from a silent empty body (masked behind 8 accumulated warnings) to the single upstream invariant Expected a variable declaration.

Details

error.bug-invariant-unnamed-temporary — renderer={(...props) => <span {...props}>{displayValue}</span>}
Was silently compiled with the renderer arrow dropped to function _temp() {} (empty body). The codegen path hit Expected temporaries to be promoted to named identifiers in an earlier pass (an unnamed identifier reaching convert_identifier), which the shim swallowed. Now the error propagates and the function is left unchanged — identical to upstream's Invariant.

error.bug-invariant-codegen-methodcall — Math.floor(diff.bar())
Was silently compiled to const YearsAndMonthsSince = () => {}; (entire body dropped). diff.bar's property had been promoted/lowered into an Identifier so codegen's MethodCall::property must be an unpromoted + unmemoized MemberExpression invariant fired (Got: 'Identifier') and was swallowed. Now propagates — matches upstream.

error.todo-nested-method-calls-lower-property-load-into-temporary — Math.max(2, items.push(5), ...other)
Same MethodCall::property invariant as above (items.push property lowered into a temporary), same silent empty-body drop. Now propagates — matches upstream.

error.call-args-destructuring-asignment-complex — x.foo(([[x]] = makeObject()))
Was silently compiled to function Component() {} (body dropped). The complex destructuring assignment produced a const-declaration instruction that is also referenced as an expression, tripping codegen's Const declaration cannot be referenced as an expression invariant (this is Const), which was swallowed. Now propagates — matches upstream.

error.bug-invariant-local-or-context-references — catch (err) { setState(_prev => ({..., error: err})); }
Upstream throws Expected all references to a variable to be consistently local or context references (it mis-classifies a catch binding captured by a lambda as a context variable even though err is never reassigned). oxc already lowers this correctly: it renames the catch param and aliases it — catch (t0) { const err = t0; setState(...) } — so err stays a plain read-only local and no inconsistency arises. Verified semantically equivalent to the source on both the try-success and catch paths (identical setState call sequences, including error propagation). No code change needed — oxc legitimately handles a case upstream crashes on.

Notes / still-open

• The 4 now-erroring fixtures are cases upstream also fails on (its own passes emit these invariants). Producing correct memoized output for them would require fixing the earlier promotion/SSA passes so temporaries are named/unpromoted before codegen — upstream doesn't do this either, so erroring cleanly is the correct, achievable resolution here.
• todo-kitchensink's oxc message is Invariant: Expected a variable declaration (upstream adds a Got ExpressionStatement. description); the reason matches, the description is a cosmetic gap.