[compiler] Remove local CompilerError accumulators, emit directly to env.recordError()

[everettbu]

Mirror of facebook/react#35838
Original author: josephsavona

---

Removes unnecessary indirection in 17 compiler passes that previously
accumulated errors in a local CompilerError instance before flushing
them to env.recordErrors() at the end of each pass. Errors are now
emitted directly via env.recordError() as they're discovered.

For passes with recursive error-detection patterns (ValidateNoRefAccessInRender,
ValidateNoSetStateInRender), the internal accumulator is kept but flushed
via individual recordError() calls. For InferMutationAliasingRanges,
a shouldRecordErrors flag preserves the conditional suppression logic.
For TransformFire, the throw-based error propagation is replaced with
direct recording plus an early-exit check in Pipeline.ts.

---

Stack created with Sapling. Best reviewed with ReviewStack.

• -> #35838
• #35837
• #35836
• #35835
• #35834
• #35833
• #35832
• #35831
• #35830
• #35829
• #35828

[greptile-apps]

Greptile Summary

This PR implements a major architectural shift in the React Compiler's error handling: moving from a fail-fast model (where passes throw or return Result errors that halt the pipeline) to a fault-tolerant accumulation model where all errors are recorded on Environment and the pipeline runs to completion before reporting them all at once. This allows users to see multiple independent compilation errors simultaneously instead of fixing them one-by-one.

• Core infrastructure: Environment gains #errors accumulator with recordError() (which immediately throws invariants), hasErrors(), and aggregateErrors() methods
• Pipeline changes: run/runWithEnvironment/compileFn return Result<CodegenFunction, CompilerError> and check env.hasErrors() at the end instead of failing mid-pipeline
• BuildHIR fault tolerance: lower() always returns HIRFunction instead of Result. Unsupported syntax like var is treated as let, empty for(;;) init/test blocks get fallback handling, and lowerFunction always returns non-null
• 17 validation/inference passes updated: Local CompilerError accumulators removed in favor of direct env.recordError() calls. Passes with recursive error detection (ValidateNoRefAccessInRender, ValidateNoSetStateInRender) keep internal accumulators but flush via recordError()
• CompileUnexpectedThrow event: New logger event type detects passes that incorrectly throw instead of recording, with test infrastructure in snap to catch regressions
• New test fixtures: Fault tolerance tests verify multiple independent errors are reported (e.g., ref access + props mutation, try/finally + ref access + mutation, var declaration + ref access)
• Previously failing optional chain patterns now compile successfully due to CollectOptionalChainDependencies returning null instead of throwing

Confidence Score: 4/5

• This PR is a well-structured refactoring with comprehensive test fixture updates that validate the new behavior; safe to merge with minor style nit.
• Score of 4 reflects that this is a large but systematic refactoring (95 files) that follows a clear, documented plan. The core pattern change (local error accumulators → centralized env.recordError()) is applied consistently across 17+ passes. New test fixtures validate fault tolerance behavior (multiple errors reported). The semantic changes in BuildHIR (var→let, for(;;) handling) are intentional per the design doc and backed by updated test snapshots. The only concern is the scope of changes - any regression would require careful debugging given how many passes were touched simultaneously. No logic bugs were found.
• compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts has the most semantic changes (var→let treatment, for-loop fallbacks, lowerFunction always returning non-null) and warrants careful review of the test snapshot changes to ensure no regressions.

Important Files Changed

Filename	Overview
compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts	Core infrastructure: adds #errors accumulator with recordError(), recordErrors(), hasErrors(), and aggregateErrors() methods. Invariant errors are immediately thrown, all others accumulated. Clean implementation.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts	Changes run/runWithEnvironment/compileFn return type from CodegenFunction to Result<CodegenFunction, CompilerError>. Removes .unwrap() calls on pass results, adds final error check via env.hasErrors(). Special early-exit for transformFire errors.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts	Updates tryCompileFunction and retryCompileFunction to handle Result from compileFn. Adds CompileUnexpectedThrow logging for non-invariant CompilerErrors that were thrown instead of recorded.
compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts	Major changes: lower() now always returns HIRFunction instead of Result. var is treated as let, for(;;) empty init/test are handled with fallback logic instead of erroring. builder.errors.push replaced with builder.recordError(). lowerFunction always returns non-null. Substantial semantic changes to enable fault tolerance.
compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts	Removes errors: CompilerError field, adds recordError() that delegates to this.#env.recordError(). Converts resolveBinding() from throwing to recording errors. Unreachable code with hoisted declarations now records error instead of throwing.
compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts	Changes throwTodo to return null when optional chain fallthrough block has unexpected terminal kind. Callers already handle null returns. This enables previously-failing optional chain patterns to compile.
compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts	Removes local errors accumulator from Context class, adds recordError() delegate. codegenFunction and codegenReactiveFunction now return direct values instead of Result. Todo throws in terminal codegen replaced with recordError + return t.emptyStatement().
compiler/packages/babel-plugin-react-compiler/src/Transform/TransformFire.ts	Replaces local #errors: CompilerError with #hasErrors: boolean flag. Errors pushed directly to env.recordError(). Removes throwIfErrorsFound() method; Pipeline.ts now handles the early exit via env.hasErrors() check.
compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts	Replaces local errors accumulator with conditional shouldRecordErrors flag. Errors recorded directly on fn.env when !isFunctionExpression && fn.env.enableValidations. Helper functions now accept `Environment
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts	Keeps internal CompilerError accumulator for recursive pattern but flushes via individual recordError() calls. Inner function expressions use separate innerErrors to detect ref access without polluting the outer error state prematurely.
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateLocalsNotReassignedAfterRender.ts	Converts throw errors to env.recordError() + return null. Threads env: Environment parameter through recursive calls. Async reassignment now records error and returns null instead of throwing.
compiler/packages/snap/src/compiler.ts	Adds detection for CompileUnexpectedThrow events in test runner, failing the fixture if any pass threw instead of recording. Uses as any cast to access .data field.

_{Last reviewed commit: f283c68}

[greptile-apps]

_{95 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

Unnecessary as any cast
The log.event.kind === 'CompileUnexpectedThrow' filter above should narrow the type sufficiently for TypeScript to know .data exists on CompileUnexpectedThrowEvent. If the type system doesn't narrow through .filter(), you could use a type guard function or a type assertion to the specific event type instead of any:

Suggested change

	unexpectedThrows.map(l => (l.event as any).data).join('\n'),
	unexpectedThrows.map(l => (l.event as CompileUnexpectedThrowEvent).data).join('\n'),

_{Note: If this suggestion doesn't match your team's coding style, reply to this and let me know. I'll remember it for next time!}

Prompt To Fix With AI

This is a comment left during a code review.
Path: compiler/packages/snap/src/compiler.ts
Line: 389

Comment:
**Unnecessary `as any` cast**
The `log.event.kind === 'CompileUnexpectedThrow'` filter above should narrow the type sufficiently for TypeScript to know `.data` exists on `CompileUnexpectedThrowEvent`. If the type system doesn't narrow through `.filter()`, you could use a type guard function or a type assertion to the specific event type instead of `any`:

```suggestion
        unexpectedThrows.map(l => (l.event as CompileUnexpectedThrowEvent).data).join('\n'),
```

<sub>Note: If this suggestion doesn't match your team's coding style, reply to this and let me know. I'll remember it for next time!</sub>

How can I resolve this? If you propose a fix, please make it concise.

[everettbu]

Upstream PR was closed or merged. Code is synced via branch mirror.