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

[everettbu]

Mirror of facebook/react#35851
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.

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

[greptile-apps]

Greptile Summary

This PR implements fault tolerance in the React Compiler by removing local CompilerError accumulators from 17 compiler passes and routing all errors through Environment.recordError(). The pipeline now runs all passes to completion and aggregates errors at the end, returning Result<CodegenFunction, CompilerError> instead of throwing on the first error encountered.

• Adds recordError(), recordErrors(), hasErrors(), and aggregateErrors() to Environment, with invariant errors still thrown immediately
• Changes lower() to always produce an HIRFunction (partial HIR on error), with best-effort handling for previously-unsupported constructs like var (treated as let), empty for-loop init/test, and expression-based for-loop init
• Updates runWithEnvironment/compileFn to return Result and check env.hasErrors() at pipeline end
• For passes with recursive error-detection patterns (ValidateNoRefAccessInRender, ValidateNoSetStateInRender), internal accumulators are kept but flushed via individual recordError() calls
• InferMutationAliasingRanges uses a shouldRecordErrors flag to preserve the conditional suppression logic (only records when enableValidations && !isFunctionExpression)
• Adds CompileUnexpectedThrow logger event and snap test detection for passes that incorrectly throw instead of recording errors
• CollectOptionalChainDependencies now returns null instead of throwing for unsupported optional chain patterns, allowing previously-erroring fixtures to compile successfully
• New test fixtures verify fault tolerance: multiple independent errors are reported together rather than stopping at the first

Confidence Score: 4/5

• This PR is a well-structured refactor with comprehensive test coverage and no behavioral regressions in the happy path.
• The changes are extensive (79 files) but follow a consistent, mechanical pattern: remove local error accumulator, record errors directly on Environment, simplify return types. The core infrastructure in Environment.ts is clean and correctly handles the invariant re-throw case. Test fixture updates confirm expected behavioral changes. The only minor concern is a style inconsistency in ValidateContextVariableLValues.ts (fn.env vs env parameter), which is harmless in practice.
• BuildHIR.ts has the most complex changes (partial HIR construction for unsupported syntax), and InferMutationAliasingRanges.ts has the shouldRecordErrors conditional logic that should be verified against the original validation gating.

Important Files Changed

Filename	Overview
compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts	Adds core error accumulation infrastructure: #errors field, recordError() (with Invariant re-throw), recordErrors(), hasErrors(), aggregateErrors(). Clean, well-designed API.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts	Changes runWithEnvironment/compileFn to return Result<CodegenFunction, CompilerError>. Removes .unwrap() calls on passes, checks env.hasErrors() at end of pipeline. Minor whitespace changes (blank lines).
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts	Updates tryCompileFunction to handle Result from compileFn. Adds detection of unexpected throws (non-invariant CompilerErrors) via new CompileUnexpectedThrow event.
compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts	Major refactor: lower() now always returns HIRFunction instead of Result. All builder.errors.push() calls replaced with builder.recordError(). Adds fault-tolerant handling for var (treats as let), empty for-init/test, and expression-based for-init. Removes effects field from return (not in type).
compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts	Removes local errors: CompilerError accumulator, adds recordError() method that delegates to env.recordError(). resolveBinding and build() now record errors instead of throwing.
compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts	Changes throwTodo to return null for unexpected terminal kinds in optional chain fallthrough, enabling the pipeline to continue gracefully.
compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/BuildReactiveFunction.ts	Changes throwTodo to CompilerError.invariant for non-branch test blocks, reflecting that this case should now be unreachable after earlier pipeline changes.
compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts	Removes local errors accumulator from Context and codegenReactiveFunction. All throwTodo calls replaced with cx.recordError() + early returns. codegenFunction returns CodegenFunction directly instead of Result.
compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts	Replaces local error accumulation with shouldRecordErrors flag that correctly preserves conditional suppression logic (!isFunctionExpression && env.enableValidations). Passes `Environment
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateContextVariableLValues.ts	Converts from throw-based to record-based error reporting. Passes Environment through recursive calls. Minor inconsistency: uses fn.env in default case instead of the env parameter (harmless since they're the same object).
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts	Keeps internal CompilerError accumulator for recursive analysis, but flushes to fn.env.recordError() at the top level. Inner function expressions use separate innerErrors for detection (consistent with original behavior).
compiler/packages/snap/src/compiler.ts	Adds detection of CompileUnexpectedThrow events in test runner, failing tests when passes throw instead of recording errors.

_{Last reviewed commit: ac48dcd}

[greptile-apps]

_{79 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

Inconsistent use of fn.env vs env parameter

In the default branch, fn.env.recordError(...) is used directly, while the rest of the function consistently uses the env parameter (which is threaded through for recursive calls into inner function expressions). These happen to be the same Environment instance in practice (inner HIRFunction objects share the same env), so this is not a bug, but for consistency with the rest of the function, consider using env here instead of fn.env.

Suggested change

	fn.env.recordError(
	env.recordError(

_{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/Validation/ValidateContextVariableLValues.ts
Line: 74

Comment:
**Inconsistent use of `fn.env` vs `env` parameter**

In the `default` branch, `fn.env.recordError(...)` is used directly, while the rest of the function consistently uses the `env` parameter (which is threaded through for recursive calls into inner function expressions). These happen to be the same `Environment` instance in practice (inner `HIRFunction` objects share the same env), so this is not a bug, but for consistency with the rest of the function, consider using `env` here instead of `fn.env`.

```suggestion
            env.recordError(
```

<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.