[compiler] Add fault tolerance test fixtures

[everettbu]

Mirror of facebook/react#35835
Original author: josephsavona

---

---

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 adds fault tolerance to the React Compiler, enabling it to continue through compilation passes and report all errors rather than stopping at the first one. The key architectural change is that the Environment class now accumulates errors via recordError/tryRecord methods, and the pipeline returns Result<CodegenFunction, CompilerError> with aggregated errors at the end.

• Adds error accumulation infrastructure to Environment (#errors, recordError, recordErrors, tryRecord, hasErrors, aggregateErrors) with invariants still re-thrown immediately
• Changes lower() to always produce an HIRFunction (even partial), treating unsupported constructs like var as let and handling for(;;) with placeholder expressions
• Wraps all pipeline passes in env.tryRecord() as a safety net, catching non-invariant CompilerError exceptions so compilation continues
• Migrates ~15 validation passes from returning Result or throwing to recording errors on env
• Updates codegenFunction and inference passes to record errors on env instead of returning Result
• Adds dedicated fault-tolerance test fixtures (fault-tolerance/) that verify multiple independent errors are reported in a single compilation
• Updates 60+ existing test fixture expectations where additional previously-masked errors are now surfaced

Confidence Score: 4/5

• This is a well-designed architectural refactor with comprehensive test coverage and a thorough design document; the changes are internal to the compiler and do not affect runtime output for correctly-compiled code.
• The PR follows a systematic, phased approach documented in the overview. All validation and inference passes are consistently migrated. Invariant errors still propagate immediately for safety. The test fixtures demonstrate the fault tolerance working as intended. The main risk area is the definite assignment assertion pattern for value-producing passes (e.g., let reactiveFunction!: ReactiveFunction) which could lead to runtime TypeErrors if those passes throw, though the outer try/catch in Program.ts provides a safety net.
• Pipeline.ts (definite assignment assertions for value-producing passes) and BuildHIR.ts (partial HIR generation paths) are the most complex changes

Important Files Changed

Filename	Overview
compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts	Core infrastructure: adds #errors accumulator, recordError/recordErrors/tryRecord/hasErrors/aggregateErrors methods. Invariant errors are correctly re-thrown immediately. Well-structured foundation for fault tolerance.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts	Wraps all pipeline passes in env.tryRecord(), changes return type to Result<CodegenFunction, CompilerError>. Uses definite assignment assertion (!) for reactiveFunction which could be undefined if buildReactiveFunction throws. Value-producing passes use safe defaults. Final error aggregation at end of pipeline.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts	Updates tryCompileFunction and retryCompileFunction to handle Result return type from compileFn. Error handling paths correctly preserve existing behavior for retry logic.
compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts	Changes lower() to always return HIRFunction. Handles var as let, fixes ForStatement init/test handling for partial HIR, adds try/catch around body lowering. Contains a redundant ternary in the catch handler. Removes effects field (not part of HIRFunction type).
compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts	Changes codegenFunction and codegenReactiveFunction to return directly instead of via Result. Records codegen errors on env. Outlined function codegen also updated.
compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts	Changes return type to always produce Array<AliasingEffect>. Errors only recorded when enableValidations is true (matching old pipeline behavior where errors were only thrown inside enableValidations guard).
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts	Refactored to pass errors from the outer function into the implementation. Inner function expressions use a separate innerErrors to avoid contaminating the outer analysis. Fixed-point loop behavior preserved.

_{Last reviewed commit: f773cbc}

[greptile-apps]

_{92 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

Redundant ternary expression
The ternary (detail instanceof CompilerDiagnostic ? detail.category : detail.category) evaluates to detail.category in both branches. Both CompilerDiagnostic and CompilerErrorDetail expose category as a direct property, so the instanceof check has no effect.

Suggested change

	if (
	(detail instanceof CompilerDiagnostic
	? detail.category
	: detail.category) === ErrorCategory.Invariant
	) {
	if (detail.category === ErrorCategory.Invariant) {

Prompt To Fix With AI

This is a comment left during a code review.
Path: compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
Line: 220-224

Comment:
**Redundant ternary expression**
The ternary `(detail instanceof CompilerDiagnostic ? detail.category : detail.category)` evaluates to `detail.category` in both branches. Both `CompilerDiagnostic` and `CompilerErrorDetail` expose `category` as a direct property, so the `instanceof` check has no effect.

```suggestion
          if (detail.category === ErrorCategory.Invariant) {
```

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.