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

[everettbu]

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

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

[greptile-apps]

Greptile Summary

This PR implements fault tolerance for the React Compiler pipeline. Instead of throwing on the first error encountered, the compiler now accumulates errors across all passes and reports them together at the end of compilation.

• Error accumulation on Environment: Added #errors field with recordError(), recordErrors(), hasErrors(), and aggregateErrors() methods. Invariant errors are still thrown immediately since they represent internal bugs.
• Pipeline return type change: runWithEnvironment/compileFn now return Result<CodegenFunction, CompilerError> instead of throwing, with the error aggregated from env at the end.
• BuildHIR graceful degradation: lower() always produces an HIRFunction now. Previously-throwing cases (var declarations, empty for-loop init/test, try/finally) now record errors and produce best-effort partial HIR (e.g., var treated as let, empty test treated as while(true)).
• All validation passes updated: ~15 validation functions converted from returning Result<void, CompilerError> or throwing to recording errors directly on the environment.
• Codegen fault tolerance: codegenReactiveFunction and codegenFunction no longer return Result; unsupported terminal cases return t.emptyStatement() as fallback.
• Unexpected throw detection: New CompileUnexpectedThrow logger event in Program.ts catches passes that still throw non-invariant CompilerError exceptions, and the snap test infrastructure fails tests when this occurs.
• New test fixtures validate multi-error reporting (e.g., ref access + props mutation, try/finally + props mutation reported together).

Confidence Score: 4/5

• This is a well-structured refactor with comprehensive test fixtures validating the new behavior, safe to merge.
• Large refactor touching 79 files, but the pattern is consistent and mechanical across most files (removing Result wrappers, replacing throws with recordError). The core architectural change in Environment.ts is clean and well-documented. BuildHIR.ts has the most complex changes with graceful degradation paths for unsupported syntax, which are tested by new fixtures. One minor style issue found (as any cast in snap compiler).
• compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts (most complex changes with new graceful degradation paths), compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts (conditional error recording logic)

Important Files Changed

Filename	Overview
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts	Core pipeline change: runWithEnvironment now returns Result<CodegenFunction, CompilerError> instead of throwing. Errors accumulate on env and are checked at the end. All .unwrap() calls on pass results removed since passes now record errors directly.
compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts	Updated tryCompileFunction to handle Result from compileFn. Added CompileUnexpectedThrow logging for non-invariant CompilerError exceptions that were thrown instead of recorded.
compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts	Added error accumulation infrastructure: #errors field, recordError() (throws immediately for Invariants, accumulates otherwise), recordErrors(), hasErrors(), and aggregateErrors() methods.
compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts	Major refactor: lower() now always returns HIRFunction (no more Result). All builder.errors.push() replaced with builder.recordError(). Added graceful handling for previously-throwing cases: var treated as let, empty for-loop init/test handled, try/finally continues after recording error.
compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts	Removed local errors: CompilerError field, added recordError() that delegates to this.#env.recordError(). Converted throwDiagnostic/throwTodo calls to recordError for non-invariant errors.
compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts	Removed local errors from Context class, added recordError() method. codegenFunction and codegenReactiveFunction no longer return Result. Terminal codegen errors now return t.emptyStatement() as fallback.
compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts	Returns Array<AliasingEffect> directly instead of Result. Errors conditionally recorded based on shouldRecordErrors flag (only for non-function-expression context with validations enabled). Helper functions accept `Environment
compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts	Returns void instead of Result. Uses local CompilerError objects for flow-sensitive analysis (inner function expressions use separate innerErrors to determine readRefEffect), then propagates all outer errors to fn.env.recordError() at the top level.
compiler/packages/snap/src/compiler.ts	Added detection of CompileUnexpectedThrow events in test infrastructure, failing the test if any pass threw instead of recording errors. Uses as any cast for event data access.

_{Last reviewed commit: d97e4f2}

[greptile-apps]

_{79 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

Unnecessary as any cast

The as any cast here can be avoided with a type guard in the filter callback, which would give type-safe access to data:

Suggested change

	unexpectedThrows.map(l => (l.event as any).data).join('\n'),
	unexpectedThrows.map(l => {
	const event = l.event as import('babel-plugin-react-compiler').CompileUnexpectedThrowEvent;
	return event.data;
	}).join('\n'),

Alternatively, a simpler approach: use a type guard in the filter:

const unexpectedThrows = logs.filter(
  (log): log is {filename: string | null; event: CompileUnexpectedThrowEvent} =>
    log.event.kind === 'CompileUnexpectedThrow',
);

Then l.event.data would be properly typed without the cast.

_{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 `as any` cast here can be avoided with a type guard in the filter callback, which would give type-safe access to `data`:

```suggestion
        unexpectedThrows.map(l => {
          const event = l.event as import('babel-plugin-react-compiler').CompileUnexpectedThrowEvent;
          return event.data;
        }).join('\n'),
```

Alternatively, a simpler approach: use a type guard in the filter:
```ts
const unexpectedThrows = logs.filter(
  (log): log is {filename: string | null; event: CompileUnexpectedThrowEvent} =>
    log.event.kind === 'CompileUnexpectedThrow',
);
```
Then `l.event.data` would be properly typed without the cast.

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