Match upstream's catchable missing-identifier invariant in `PruneNonEscapingScopes`, preventing a later misleading `PreserveManualMemo` diagnostic. Adds the original-shaped named function expression regression.
AI-assisted and reviewed by the contributor.
Replace tree-based property-path sets with sorted inline sets and reuse scratch storage across fixpoint passes while preserving sorted block traversal.
Fixture benchmark: React Compiler time 10.30s → 9.26s.
AI assistance was used to investigate, implement, and benchmark this change.
Compute all post-dominator frontiers in one Cytron-style pass, avoiding a reverse CFG walk for every block. Reuse the result in reactive-place inference and set-state validation.
AI usage: Codex was used to implement and validate this change; the contributor remains responsible for review before merge.
Avoid repeatedly interning and deep-cloning aliasing effects during mutation inference. Cached effects are now interpreted by reference and cloned only when persisted.
Benchmarks improve by 8–14% on representative React Compiler workloads.
AI-assisted.
## Summary
- replace hot function-wide `IdentifierId` hash state in reactive-place inference with dense `IndexVec` storage
AI assistance was used to implement and review these changes. The contributor remains responsible for reviewing and understanding the submitted code.
Support for (;;) by lowering the omitted test to true and omitting the synthetic HIR initializer during codegen.
AI assistance was used to implement and verify this change.
Separate React Compiler emission from lint analysis so oxlint can dead-strip compiler codegen.
This reduces the stripped oxlint binary by 145 KiB (1.21%).
AI-assisted with Codex.
This PR contains the following updates:
| Package | Type | Update | Change |
|---|---|---|---|
| [rust](https://rust-lang.org/)
([source](https://redirect.github.com/rust-lang/rust),
[changelog](https://redirect.github.com/rust-lang/rust/blob/main/RELEASES.md))
| toolchain | minor | `1.97.1` → `1.98.0` |
---
### Configuration
📅 **Schedule**: (in timezone Asia/Shanghai)
- Branch creation
- "before 10am on monday"
- Automerge
- At any time (no schedule defined)
🚦 **Automerge**: Enabled.
♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.
🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.
---
- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box
---
This PR was generated by [Mend Renovate](https://mend.io/renovate/).
View the [repository job
log](https://developer.mend.io/github/oxc-project/oxc).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0NC4zNS40IiwidXBkYXRlZEluVmVyIjoiNDQuMzUuNCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->
---------
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Cameron <cameron.clark@hey.com>
Remove an unreachable React Compiler diagnostic for colons in JSX attribute identifiers. Oxc's parser represents namespaced attributes with `JSXNamespacedName`, so parser-produced identifiers cannot contain colons.
Validated with `cargo test -p oxc_react_compiler`. `just ready` passed formatting and workspace checks, but its full suite hit environment-sensitive ANSI snapshot mismatches in unrelated Oxlint CLI tests.
AI-assisted; reviewed and validated by the contributor.
Improve `react/no-deriving-state-in-effects` diagnostics with labeled state updates, named reactive dependencies, and actionable render guidance. Adds fixture coverage for single and multiple dependencies.
AI assistance was used for this change.
Use compact `Display` formatting for React Compiler terminals and reuse `ConfigBuilderError`'s existing `Display` implementation for `Debug`.
This reduces the release `oxlint` binary from 12,773,552 to 12,740,432 bytes: **-33,120 bytes (-0.26%)**, with `__text` reduced by 24,452 bytes.
Validated with the affected crate tests, workspace checks, and oxlint snapshot tests.
AI assistance was used for implementation and measurement.
BigInt object keys fell through generic unsupported-key handling. Lower
them through the exact parser-provided decimal string, preserving
alternate bases and values beyond Number precision.
Validated with `just ready`.
AI-assisted.
<sub>Stack created with <a
href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a
href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
React Compiler HIR already preserves both raw and cooked tagged-template
values, but lowering rejected templates whenever they differed. Remove
the stale bailout and cover escaped and invalid escape sequences.
Validated with `just ready`.
AI-assisted.
<sub>Stack created with <a
href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a
href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
Port `assertValidBlockNesting` to reject partially overlapping
program-block and reactive-scope ranges before and after scope-terminal
rewriting. Reuse the traversal when constructing scope terminals.
Validated with `just ready`.
AI-assisted.
<sub>Stack created with <a
href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a
href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
`known_incompatible` is already checked before both aliasing and legacy
signature handling, making the legacy-path TODO stale. Add
aliasing-signature coverage to guard the shared behavior.
Validated with `just ready`.
AI-assisted.
<sub>Stack created with <a
href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a
href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
Improve React Compiler diagnostics with actionable help and cause-oriented labels. Preserve-memoization and recursive-initialization diagnostics previously spanned entire callbacks; they now keep codeframes compact while refs and `try`/`finally` show related locations.
Validated with React Compiler and React linter suites, Clippy, `just ready`, and the 24-rule VS Code ecosystem audit.
AI-assisted: Codex was used to implement and validate this change. I reviewed and take responsibility for the result.
Bail out when JSX `ref` values are loaded through properties, matching React Compiler and preserving getter and live-binding evaluation semantics.
The validator previously stopped temporary tracking for every property result inferred as ref-like instead of only stopping for `ref.current`.
Validation: `cargo test -p oxc_react_compiler` and `just ready`.
AI assistance: Codex was used to investigate and prepare this change; the contributor remains responsible for reviewing it before merge.
Queue JSX-outlined components back through the normal `process_fn` pipeline, matching Babel's `Program.ts`. Oxc rebuilds immutable semantics once per FIFO generation and preserves Babel's outlined declaration order.
Validated against the React Compiler fixture suite, Babel output, and `just ready`.
AI-assisted; reviewed and validated by the contributor.
Ports Babel's identifier consistency invariant using Oxc's canonical identifier arena and runs it at every equivalent pipeline point.
Validated with the React compiler fixture corpus and clippy.
AI-assisted: Codex was used to implement and verify this change.
Ports Babel's terminal-predecessor invariant and runs it before HIR scope dependency propagation. Keeps terminal successor traversal inline to avoid per-edge heap allocations.
AI-assisted: Codex was used to implement and verify this change.
Ports React Compiler's terminal-successor invariant and runs it after CFG-rewriting passes. Uses the existing upstream `for-return.js` fixture for regression coverage.
AI-assisted: Codex was used to implement and verify this change.
Preserve named function expression names when the private name is unreferenced. This matches React Compiler lowering and avoids changing observable `Function.name` values.
Validated with `just ready`.
AI-assisted.
Improve React Compiler diagnostics with focused primary spans and related labels for declarations, dependencies, effects, nested functions, dynamic Hooks, and transitive ref access. This avoids full-function highlights and fixes zero-width arrow labels when lowered parameter spans are missing.
Validation: `env -u NO_COLOR just ready`.
AI-generated with Codex; reviewed and validated by the contributor.
Fix destructured function and rest parameters that become context variables by lowering them through temporaries before `StoreContext`. This avoids inconsistent `Destructure`/context HIR and compiles supported components correctly.
Validated with `just ready` and runtime equivalence checks against React 19.2.1's compiler runtime.
AI usage: Implemented with assistance from OpenAI Codex.
Splits the experimental `react/react-compiler` rule into 24 category-specific rules matching `eslint-plugin-react-hooks` v7.
- Runs React Compiler once per file and routes structured diagnostics to each enabled rule.
- Removes `react/react-compiler` and `reportAllBailouts`, with rules categorized by user-facing lint intent.
- Adds per-rule documentation and deduplicates shared React lint URLs.
- Preserves standardized compiler diagnostics while reporting each finding under its Oxlint rule name.
Breaking change: configurations using `react/react-compiler` must migrate to the category-specific rules.
Written with Claude Code and Codex.
Standardize React Compiler diagnostics with concise titles, primary labels, actionable help, notes, structured categories, and official guidance links.
Preserve React guidance when diagnostics are surfaced through Oxlint, and refresh affected snapshots.
AI-assisted; reviewed and validated by the contributor.
Centralizes React compiler diagnostics in explicit `#[cold]` functions and removes the `[ReactCompiler]` prefix, keeping diagnostic formatting off hot paths. Updates related NAPI expectations.
AI assistance was used.
Preserve tagged-template call, aliasing, and mutation effects instead of assuming no-substitution tags are primitive or pure.
Execute opaque or effectful tags unconditionally while retaining memoization only when a configured signature proves a read-only pure call and safe return.
AI-assisted investigation and implementation; reviewed and understood by the contributor.
Preserve inline TypeScript enums as opaque pass-through HIR nodes, matching upstream React Compiler behavior. Apply Oxc-specific raw AST reference renaming, and skip compilation when passthrough would hide nested captures or flatten block-local bindings.
AI-assisted: Codex was used to implement and validate this change.
Match the public validation defaults from babel-plugin-react-compiler 1.0 while retaining explicit opt-in for newer validations.
Validated with fixture snapshots and `just ready`.
AI-assisted investigation and implementation; reviewed and understood by the contributor.
React Compiler's JSX reconstruction preserved the HIR identifier expression kind, causing compiler-generated lowercase aliases such as `navTitle` to lower as variable references. Classify reconstructed tags by their emitted JSX spelling while preserving underscore-prefixed component references.
Validation: `cargo test -p oxc_react_compiler`, `cargo clippy -p oxc_react_compiler --all-targets -- -D warnings`, and the transform-react NAPI suite.
AI assistance: OpenAI Codex was used to investigate, implement, and validate this change.
Anchor React Compiler-generated imports before the first source statement so downstream JSX transforms continue to read leading `@jsxImportSource` pragmas.
Validated with `just ready` and the transform-react binding suite. AI-assisted; the author remains responsible for review.
Removes synthetic expression statements emitted after captured compound assignments when their value is unused. The lowering-created context load is tagged so analysis retains it, while codegen can omit it after the lvalue is pruned. Consumed assignment results are preserved.
Validated with `env -u NO_COLOR just ready`.
AI assistance: Codex was used to investigate, implement, and validate this change.
Retain exception-handler edges for value-block stores so caught throws do not commit the input/result memo entry. This preserves retries for identical inputs after a transient throw.
Adds a sequential-render evaluator fixture covering throw-once behavior.
Validated with `env -u NO_COLOR just ready` and a Sprout runtime comparison.
AI assistance was used to investigate and implement this change.
Preserve potentially throwing operations inside try/catch when dead-code elimination would otherwise remove their unused results. Share the throw classifier with try-edge pruning, retain caught destructuring, and use safe root dependencies without hoisting throwing operations outside their handlers.
This preserves source runtime behavior for property and computed reads, coercions, destructuring, computed keys, and spreads. Latest React Compiler currently has the same DCE divergence, so this follows JavaScript semantics rather than its incorrect output.
Validated with `just ready` and React Compiler’s Sprout evaluator.
AI assistance was used to investigate and implement this change.
Model `Symbol()` as identity-bearing so escaping symbols are memoized, matching Babel. The regression came from registering `Symbol` with copy-like primitive globals while allowing capitalized built-in calls.
Validation: `cargo test -p oxc_react_compiler`; Babel output comparison; runtime identity check. `just ready` is blocked by three unrelated ANSI-sensitive Oxlint snapshot mismatches in this environment.
AI-assisted: Codex was used to investigate, implement, verify, and prepare this PR.
Scopes `forwardRef`/`memo` discovery context to the direct callback so nested helpers are not incorrectly compiled with stale caches. Adds regression coverage for arrow and function callbacks.
Validated with `just ready`.
AI-assisted.
Closes#25536
## Problem
With `enableFunctionOutlining` (default on), the compiler outlines function expressions whose lowered **context** is empty. Context only counts variables captured from scopes inside the function being compiled — a free variable of the whole compiled function (e.g. a binding of an *enclosing* function) is modeled as a plain global load/store in HIR, so a callback referencing one still gets outlined. Correctness then depends entirely on where the outlined declaration is inserted: upstream uses Babel `originalFn.insertAfter(...)`, which splices into the statement list containing the original at **any nesting depth**, preserving the invariant that every name visible to the original is visible at its sibling position.
`ox_insert_outlined_after` searched only `program.body`. For a component declared inside another function, the search missed and the fallback appended the outlined declaration at module scope:
```js
export function makeProbe() {
let mounts = 0;
function MountCounter() {
useEffect(() => { mounts += 1; }, []);
return null;
}
return { MountCounter, read: () => mounts };
}
```
compiled to
```js
export function makeProbe() { /* ... useEffect(_temp, t0) ... */ }
function _temp() {
mounts = mounts + 1; // ReferenceError: mounts is not defined
}
```
with no diagnostic — a silent miscompilation that only fails when the effect fires.
A second instance of the same shape: gating ran before outlined insertion. The gating rewrite replaces the declaration statement with a `const`, destroying the scope-id anchor, so gated components' outlined functions always fell to the end-of-program fallback (upstream inserts them during the compile-queue loop, before any replacement, so they land right after the gated `const`).
## Fix
- `ox_insert_outlined_after` locates the declaring statement through a new `InsertOutlinedAfter` mode on the shared `OxcVisitor`, scanning each statement list before descending into it. Top-level originals (the common case) cost the same as before — the target is found in the first list scanned with no descent — and the walk prunes itself once insertion happens. Matching by `scope_id` cell stays sound because `ox_replace_function` mutates originals in place and discovery skips compiled bodies, so the anchor statement is always original AST. The top-level append survives only as a fallback for sloppy-mode annex-B positions (`if (c) function F() {}`).
- Outlined insertion now runs before `ox_apply_gated_conditional`, restoring upstream's sequencing.
Arrow/function-expression originals still append at module scope: upstream does the same (`program.pushContainer('body', ...)`) — including for nested originals, where upstream's own output breaks the same way — and the port reproduces upstream behavior rather than diverging (now documented in the placement comment).
Placement in all three added fixtures (nested declaration = the issue repro, nested block, gating + outlining) is byte-identical to `babel-plugin-react-compiler` built from react @ 22e4f993c7 with matching options; the existing 1310 fixture snapshots are unchanged.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Treat a named function expression’s private name as a function-entry binding through HIR, SSA, and alias analysis. This prevents self-references from reaching mutation inference uninitialized and adds fixture coverage.
Closes#23752.
Validated with targeted compiler and linter checks, workspace checking, and linting.
AI-assisted.
## Context
The reactive-function codegen keeps a map of compiler temporaries and
snapshots that map whenever it enters a block, a memoization scope or a
nested function, restoring it on the way out. Each snapshot deep-cloned
every value collected so far into the arena, so the cost grew with the
number of blocks times the size of the accumulated trees. That's cheap
on small components and expensive on large ones with a lot of JSX.
## This PR
Store the temporaries as arena-allocated `&OxValue` references instead
of owned values. Entries are only ever replaced, never mutated in place,
and the one place that reads a temporary (`ox_codegen_place`) already
clones the node into the arena. So a snapshot is now just a copy of the
map's references, `ox_clone_temporaries` goes away, and the emitted
program is unchanged.
### Performance
The effect scales with component size, so it barely shows on typical
open-source apps (their largest components compile in tens of
milliseconds) and grows on very large components. Two views:
**Size-scaling probe** (reproducible): one function component with N
repeated JSX sections, compiled on `main` vs this branch:
| Sections | Source size | main | this branch | Ratio |
| ---: | ---: | ---: | ---: | ---: |
| 25 | 17 KB | 26 ms | 17 ms | 1.51x |
| 50 | 33 KB | 83 ms | 50 ms | 1.66x |
| 100 | 66 KB | 327 ms | 188 ms | 1.74x |
| 200 | 133 KB | 1,663 ms | 1,096 ms | 1.52x |
| 400 | 267 KB | 7,952 ms | 5,692 ms | 1.40x |
Compile time still grows super-linearly with size on both sides: on
`main` the remaining hot pass for large components is
`infer_reactive_scope_variables`, which this change does not touch.
<details><summary>Probe generator (Node)</summary>
```js
// node gen_scaling.mjs <N> > Big.tsx
const N = Number(process.argv[2]);
const header = `import { useState } from "react";
declare const Child: any;
declare const Footer: any;
declare function cx(...args: any[]): string;
declare function format(v: number): string;
export default function Big({ data, flag, onSelect, onDone }: any) {
const [count, setCount] = useState(0);
return (
<div className="root" onClick={() => setCount(count + 1)}>
`;
const section = (i) => ` <section key="s${i}" className={cx("s${i}", flag ? "on" : "off")} onClick={() => onSelect(${i}, data.items[${i}])}>
<h2 title={data.titles[${i}]}>
{data.titles[${i}]} - {count + ${i}}
</h2>
{flag && <p className="note">{data.notes[${i}]}</p>}
<ul>
{data.items.map((it: any) => (
<li key={it.id} data-idx={${i}}>
{it.label} {format(it.value * ${i})}
</li>
))}
</ul>
<Child a={data.a} b={{ x: ${i}, y: data.y, nested: { k: "k${i}" } }} onDone={() => onDone(${i}, data.a)} />
<Footer id={${i}} label={\`row-${i}\`} total={data.total + ${i}} />
</section>
`;
const footer = ` </div>
);
}
`;
let body = "";
for (let i = 0; i < N; i++) body += section(i);
process.stdout.write(header + body + footer);
```
</details>
This PR was assisted by Claude Code.
Fix tagged template hooks so they are validated and treated like hook calls, including unconditional execution across renders.
Closes#24473.
AI-assisted: Codex was used to investigate and implement this change. I reviewed and take responsibility for it.
Fixes#25049.
Register `DeclareContext` bindings as locals before analyzing nested functions so local self-references are not treated as missing memo dependencies. Skip exhaustive dependency validation when both modes are disabled.
Validation: `just ready`
AI assistance was used to investigate and implement this change.
Fixes#24405.
The React Compiler global registry omitted `BigInt` and `Symbol`, causing `CapitalizedCalls` false positives. Register both primitives and expose the upstream-compatible `environment.validateNoCapitalizedCalls` option.
Validated with `just ready`.
AI-assisted: Codex was used to investigate and implement this change.
Prevent JSX callback-ref member expressions from marking their receiver as a React ref. Add a compiler fixture covering the regression.
Fixes#23753.
Validated with `just ready`.
AI assistance was used to prepare this change.
Normalize computed string-literal destructuring keys before React Compiler HIR lowering so aliased bindings are initialized correctly.
Fixes#23750.
AI assistance: Codex was used to investigate, implement, and validate this change.
## Summary
`oxlint` with `react/react-compiler` enabled aborted the whole process with
```
panicked at .../prune_non_escaping_scopes.rs:
Expected a node for all scopes
```
on inputs like:
```ts
export const Component = () => {
const raw = useValue();
return (() => {
try {
return check(raw) ? raw : null;
} catch {
return null;
}
})();
};
```
## Root cause
Running the same input through the version-matched `babel-plugin-react-compiler` fails the **identical invariant** (still present at facebook/react HEAD), so the analysis inconsistency is an upstream bug the port reproduces faithfully:
- IIFE inlining turns both inner `return`s into reassignments of a temporary, and scope alignment widens the `check(raw)` scope over the try/catch, so `visit_scope` associates the temporary with that scope;
- the scope's only own declarations sit in the ternary *test*, which `computeMemoizationInputs` deliberately never descends into ("Conditionals do not alias their test value"), so `visit_operand` — the only place scope nodes are registered — never fires for it;
- when the escaping temporary is memoized, `force_memoize_scope_dependencies` looks up the unregistered scope and fails the invariant.
The port's actual defect is the error channel: upstream raises a *catchable* `CompilerError`, so with `panicThreshold: 'none'` (what linting uses) the function is silently skipped and the rest of the file proceeds. The port had written this invariant as `.expect()`, turning the per-function bail-out into a process abort.
## Fix
- `compute_memoized_identifiers` and its recursive helpers now return `Result`; the invariant becomes `Err(ErrorCategory::Invariant.diagnostic(...))` and flows through the existing per-function `handle_error` / `panic_threshold` path — the same observable behavior as Babel (function skipped, everything else still compiles/lints).
- The `react/react-compiler` rule now drops `Invariant`-category diagnostics unless `reportAllBailouts` is enabled, matching the eslint plugin where the `invariant` rule is `preset: Off` ("only meant for the compiler team's consumption"); without this, the fix would have replaced the crash with a spurious error-level report on valid code. `ErrorCategory` is now exported from `oxc_react_compiler` for this check.
- New fixture `error.bug-prune-non-escaping-scopes-iife-try-catch-ternary.js` (upstream's `error.bug-*` convention for known compiler bugs) plus rule tests covering both configs.
With the rule enabled, `oxlint` on the repro now exits cleanly with no report — identical to ESLint on the same input.
## Also fixes#24842
The rule-side filter resolves#24842 as well: `react/react-compiler` reported `Invariant: Expected a variable declaration` on a `for` loop without a variable-declaration initializer (`for (; i < 3; i++)`). Same pattern, different stage: that invariant fires in `codegenForInit` and already flowed through the catchable `Err` channel, so it surfaced as a spurious error report rather than a panic. It too reproduces upstream faithfully — the version-matched `babel-plugin-react-compiler` fails the identical invariant (`Got ExpressionStatement`) and upstream's own `error.todo-kitchensink` fixture expects it; by default Babel silently skips the function and ESLint reports nothing. The #24842 repro is added to the rule tests (clean by default, surfaced under `reportAllBailouts`).
## Relation to #25347#25347 diagnosed this accurately (thanks @controversial!) but fixes it by registering scope nodes eagerly so compilation succeeds and emits memoized output. That would make oxc compile an input every upstream compiler version refuses to compile, producing memoization decisions with no upstream validation, exactly where upstream's invariant declares its internal model inconsistent — a wrong scope association would then surface as a missed invalidation (stale UI) instead of a crash, and the pass would permanently diverge from upstream for future syncs. The behavioral fix belongs upstream in facebook/react; this PR restores upstream's bail-out semantics so oxlint no longer crashes, and the port will inherit the upstream fix when it lands.
Closes#24710Closes#24842Closes#25347
---
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Boshen