[compiler] Fix Pipeline.ts early-exit, formatting, and style issues by everettbu · Pull Request #573 · greptileai/react-mirror

everettbu · 2026-02-21T04:00:03Z

Mirror of facebook/react#35853
Original author: josephsavona

Fix the transformFire early-exit in Pipeline.ts to only trigger on new
errors from transformFire itself, not pre-existing errors from earlier
passes. The previous env.hasErrors() check was too broad — it would
early-exit on validation errors that existed before transformFire ran.

Also add missing blank line in CodegenReactiveFunction.ts Context class,
and fix formatting in ValidateMemoizedEffectDependencies.ts.

Stack created with Sapling. Best reviewed with ReviewStack.

-> #35853
#35852
#35851
#35850
#35849
#35848
#35847
#35845
#35844
#35843
#35842
#35841
#35840

Add detailed plan for making the React Compiler fault-tolerant by accumulating errors across all passes instead of stopping at the first error. This enables reporting multiple compilation errors at once.

Add error accumulation methods to the Environment class: - #errors field to accumulate CompilerErrors across passes - recordError() to record a single diagnostic (throws if Invariant) - recordErrors() to record all diagnostics from a CompilerError - hasErrors() to check if any errors have been recorded - aggregateErrors() to retrieve the accumulated CompilerError - tryRecord() to wrap callbacks and catch CompilerErrors

…erance - Change runWithEnvironment/run/compileFn to return Result<CodegenFunction, CompilerError> - Wrap all pipeline passes in env.tryRecord() to catch and record CompilerErrors - Record inference pass errors via env.recordErrors() instead of throwing - Handle codegen Result explicitly, returning Err on failure - Add final error check: return Err(env.aggregateErrors()) if any errors accumulated - Update tryCompileFunction and retryCompileFunction in Program.ts to handle Result - Keep lint-only passes using env.logErrors() (non-blocking) - Update 52 test fixture expectations that now report additional errors This is the core integration that enables fault tolerance: errors are caught, recorded, and the pipeline continues to discover more errors.

…rs on env Update 9 validation passes to record errors directly on fn.env instead of returning Result<void, CompilerError>: - validateHooksUsage - validateNoCapitalizedCalls (also changed throwInvalidReact to recordError) - validateUseMemo - dropManualMemoization - validateNoRefAccessInRender - validateNoSetStateInRender - validateNoImpureFunctionsInRender - validateNoFreezingKnownMutableFunctions - validateExhaustiveDependencies Each pass now calls fn.env.recordErrors() instead of returning errors.asResult(). Pipeline.ts call sites updated to remove tryRecord() wrappers and .unwrap().

… tolerance Update remaining validation passes to record errors on env: - validateMemoizedEffectDependencies - validatePreservedManualMemoization - validateSourceLocations (added env parameter) - validateContextVariableLValues (changed throwTodo to recordError) - validateLocalsNotReassignedAfterRender (changed throw to recordError) - validateNoDerivedComputationsInEffects (changed throw to recordError) Update inference passes: - inferMutationAliasingEffects: return void, errors on env - inferMutationAliasingRanges: return Array<AliasingEffect> directly, errors on env Update codegen: - codegenFunction: return CodegenFunction directly, errors on env - codegenReactiveFunction: same pattern Update Pipeline.ts to call all passes directly without tryRecord/unwrap. Also update AnalyseFunctions.ts which called inferMutationAliasingRanges.

Add test fixture demonstrating fault tolerance: the compiler now reports both a mutation error and a ref access error in the same function, where previously only one would be reported before bailing out. Update plan doc to mark all phases as complete.

…ing throws Remove `tryRecord()` from the compilation pipeline now that all passes record errors directly via `env.recordError()` / `env.recordErrors()`. A single catch-all try/catch in Program.ts provides the safety net for any pass that incorrectly throws instead of recording. Key changes: - Remove all ~64 `env.tryRecord()` wrappers in Pipeline.ts - Delete `tryRecord()` method from Environment.ts - Add `CompileUnexpectedThrow` logger event so thrown errors are detectable - Log `CompileUnexpectedThrow` in Program.ts catch-all for non-invariant throws - Fail snap tests on `CompileUnexpectedThrow` to surface pass bugs in dev - Convert throwTodo/throwDiagnostic calls in HIRBuilder (fbt, this), CodegenReactiveFunction (for-in/for-of), and BuildReactiveFunction to record errors or use invariants as appropriate - Remove try/catch from BuildHIR's lower() since inner throws are now recorded - CollectOptionalChainDependencies: return null instead of throwing on unsupported optional chain patterns (graceful optimization skip)

…env.recordError() 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.

Rename `state: Environment` to `env: Environment` in ValidateMemoizedEffectDependencies visitor methods, and `errorState: Environment` to `env: Environment` in ValidatePreservedManualMemoization's validateInferredDep.

Fix the transformFire early-exit in Pipeline.ts to only trigger on new errors from transformFire itself, not pre-existing errors from earlier passes. The previous `env.hasErrors()` check was too broad — it would early-exit on validation errors that existed before transformFire ran. Also add missing blank line in CodegenReactiveFunction.ts Context class, and fix formatting in ValidateMemoizedEffectDependencies.ts.

greptile-apps · 2026-02-21T04:05:33Z

Greptile Summary

This PR implements fault tolerance for the React Compiler pipeline, enabling it to accumulate all compilation errors across passes rather than stopping at the first error. This is a significant architectural improvement that gives users better error diagnostics.

Error accumulation infrastructure: Environment gains recordError(), recordErrors(), hasErrors(), and aggregateErrors() methods. Invariant errors are still thrown immediately; all other errors are accumulated.
Pipeline return type change: runWithEnvironment/compileFn now return Result<CodegenFunction, CompilerError> instead of CodegenFunction, with errors checked at the end of the pipeline via env.hasErrors().
Pass-level changes: All validation and inference passes (ValidateHooksUsage, ValidateNoRefAccessInRender, ValidateNoCapitalizedCalls, DropManualMemoization, InferMutationAliasingRanges, etc.) are updated to record errors via env.recordError() instead of throwing or returning Result. Return types simplified from Result<void, CompilerError> to void.
BuildHIR fault tolerance: lower() now always produces an HIR (never returns Err). Unsupported constructs like var, for(;;), and try/finally are handled gracefully with best-effort lowering while recording errors.
Codegen fault tolerance: codegenFunction and codegenReactiveFunction now return CodegenFunction directly. Unsupported codegen patterns emit t.emptyStatement() placeholders while recording errors.
Unexpected throw detection: A new CompileUnexpectedThrow logger event detects passes that still throw instead of recording errors, with the snap test runner failing on these events.
New test fixtures: Added fault tolerance tests verifying that multiple independent errors (e.g., try/finally + ref access, var + props mutation) are all reported together.

Confidence Score: 4/5

This PR is a well-structured architectural refactor with thorough test coverage; the changes are consistent and follow the documented plan.
The refactor is systematic and consistent across ~30 source files. All validation/inference passes follow the same pattern of recording errors to the environment instead of throwing. The new fault tolerance tests verify multi-error reporting. The only concerns are minor style issues (extra blank line, as any cast). The architectural change is sound — invariants still throw immediately while recoverable errors accumulate, and the pipeline checks for errors at the end.
Pay close attention to Pipeline.ts (orchestrates the new error flow), BuildHIR.ts (largest change with best-effort lowering of unsupported syntax), and ValidateNoRefAccessInRender.ts (complex error propagation between inner/outer function expressions).

Important Files Changed

Filename	Overview
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts	Core pipeline change: return type changed to Result<CodegenFunction, CompilerError>, all .unwrap() calls removed, errors now checked at end of pipeline via env.hasErrors()/aggregateErrors().
compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts	Adds error accumulation infrastructure: #errors field, recordError() (with Invariant re-throw), recordErrors(), hasErrors(), aggregateErrors(). Clean design.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts	Updated to handle Result from compileFn. Added CompileUnexpectedThrow logging for passes that still throw instead of recording errors.
compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts	Largest change: lower() now always produces HIR instead of returning Result. Errors recorded via builder.recordError(). Added fault tolerance for for(;;) loops, var declarations, and unsupported syntax.
compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts	Removed local errors accumulator, added recordError() that delegates to env.recordError(). Throws converted to recordError() calls.
compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts	codegenFunction/codegenReactiveFunction now return CodegenFunction directly instead of Result. Errors recorded via cx.recordError(). Context class's local errors removed.
compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts	Removed Result return type. Errors now recorded conditionally via env.recordError() based on shouldRecordErrors flag. Helper functions accept Environment
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts	Return type simplified to void. Uses local errors accumulator for inner function expressions to detect readRefEffect, then forwards all errors to env at top level.
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateLocalsNotReassignedAfterRender.ts	Changed from throwing errors to recording them via env.recordError(). Returns null instead of throwing for async reassignment errors.
compiler/packages/snap/src/compiler.ts	Adds detection of CompileUnexpectedThrow events, failing test fixtures that trigger passes throwing instead of recording errors.

_{Last reviewed commit: c65f41d}

greptile-apps

_{79 files reviewed, 2 comments}

_{Edit Code Review Agent Settings | Greptile}

greptile-apps · 2026-02-21T04:05:37Z

+

Extra blank line
There's an extraneous double blank line here. Given the PR description mentions fixing formatting, this may have been introduced accidentally.

Suggested change

_{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/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts Line: 502-503 Comment: **Extra blank line** There's an extraneous double blank line here. Given the PR description mentions fixing formatting, this may have been introduced accidentally. ```suggestion ``` <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.

greptile-apps · 2026-02-21T04:05:37Z

+      kind: 'err',
+      msg:
+        `Compiler pass(es) threw instead of recording errors:\n` +
+        unexpectedThrows.map(l => (l.event as any).data).join('\n'),


Avoidable as any cast
After the .filter() call checks log.event.kind === 'CompileUnexpectedThrow', TypeScript doesn't narrow the discriminated union automatically. You could avoid the as any cast by using a type guard or inline narrowing:

Suggested change

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

unexpectedThrows.map(l => l.event.kind === 'CompileUnexpectedThrow' ? l.event.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: **Avoidable `as any` cast** After the `.filter()` call checks `log.event.kind === 'CompileUnexpectedThrow'`, TypeScript doesn't narrow the discriminated union automatically. You could avoid the `as any` cast by using a type guard or inline narrowing: ```suggestion unexpectedThrows.map(l => l.event.kind === 'CompileUnexpectedThrow' ? l.event.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 · 2026-02-23T17:34:29Z

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

josephsavona added 13 commits February 20, 2026 17:57

[compiler] Add fault tolerance plan document

056a8e1

Add detailed plan for making the React Compiler fault-tolerant by accumulating errors across all passes instead of stopping at the first error. This enables reporting multiple compilation errors at once.

[compiler] Phase 3: Make lower() always produce HIRFunction

e9d30d5

[compiler] Add fault tolerance test fixtures

6337950

[compiler] Cleanup: consistent tryRecord() wrapping and error recording

9d81bee

[compiler] Rename mismatched variable names after type changes

31c0319

Rename `state: Environment` to `env: Environment` in ValidateMemoizedEffectDependencies visitor methods, and `errorState: Environment` to `env: Environment` in ValidatePreservedManualMemoization's validateInferredDep.

everettbu added CLA Signed React Core Team Opened by a member of the React Core Team labels Feb 21, 2026

greptile-apps Bot reviewed Feb 21, 2026

View reviewed changes

everettbu closed this Feb 23, 2026

everettbu deleted the pr35853 branch February 23, 2026 17:34

everettbu restored the pr35853 branch February 23, 2026 18:29

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[compiler] Fix Pipeline.ts early-exit, formatting, and style issues#573

[compiler] Fix Pipeline.ts early-exit, formatting, and style issues#573
everettbu wants to merge 13 commits into
mainfrom
pr35853

everettbu commented Feb 21, 2026

Uh oh!

greptile-apps Bot commented Feb 21, 2026

Uh oh!

greptile-apps Bot left a comment

Uh oh!

greptile-apps Bot Feb 21, 2026

Uh oh!

greptile-apps Bot Feb 21, 2026

Uh oh!

everettbu commented Feb 23, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

	unexpectedThrows.map(l => (l.event as any).data).join('\n'),
	unexpectedThrows.map(l => l.event.kind === 'CompileUnexpectedThrow' ? l.event.data : '').join('\n'),

Uh oh!

Conversation

everettbu commented Feb 21, 2026

Uh oh!

greptile-apps Bot commented Feb 21, 2026

Greptile Summary

Confidence Score: 4/5

Important Files Changed

Uh oh!

greptile-apps Bot left a comment

Choose a reason for hiding this comment

Uh oh!

greptile-apps Bot Feb 21, 2026

Choose a reason for hiding this comment

Uh oh!

greptile-apps Bot Feb 21, 2026

Choose a reason for hiding this comment

Uh oh!

everettbu commented Feb 23, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants