[compiler] Phase 8: Add multi-error test fixture and update plan

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.

compiler/fault-tolerance-overview.md

@@ -75,49 +75,49 @@ Change `runWithEnvironment` to run all passes and check for errors at the end in
 
 Currently `lower()` returns `Result<HIRFunction, CompilerError>`. It already accumulates errors internally via `builder.errors`, but returns `Err` when errors exist. Change it to always return `Ok(hir)` while recording errors on the environment.
 
-- [x] **3.1 Change `lower` to always return HIRFunction** (`src/HIR/BuildHIR.ts`)
+- [ ] **3.1 Change `lower` to always return HIRFunction** (`src/HIR/BuildHIR.ts`)
   - Change return type from `Result<HIRFunction, CompilerError>` to `HIRFunction`
-  - Instead of returning `Err(builder.errors)` at line 227-229, record errors on `env` via `env.recordErrors(builder.errors)` and return the (partial) HIR
+  - Instead of returning `Err(builder.errors)` at line 227-229, record errors on `env` via `env.recordError(builder.errors)` and return the (partial) HIR
   - Update the pipeline to call `lower(func, env)` directly instead of `lower(func, env).unwrap()`
-  - Added try/catch around body lowering to catch thrown CompilerErrors (e.g., from `resolveBinding`) and record them
 
-- [x] **3.2 Handle `var` declarations as `let`** (`src/HIR/BuildHIR.ts`, line ~855)
-  - Record the Todo error, then treat `var` as `let` and continue lowering (instead of skipping the declaration)
+- [ ] **3.2 Handle `var` declarations as `let`** (`src/HIR/BuildHIR.ts`, line ~855)
+  - Currently throws `Todo("Handle var kinds in VariableDeclaration")`
+  - Instead: record the Todo error on env, then treat the `var` as `let` and continue lowering
 
-- [x] **3.3 Handle `try/finally` by pruning `finally`** (`src/HIR/BuildHIR.ts`, lines ~1281-1296)
-  - Already handled: `try` without `catch` pushes error and returns; `try` with `finally` pushes error and continues with `try/catch` portion only
+- [ ] **3.3 Handle `try/finally` by pruning `finally`** (`src/HIR/BuildHIR.ts`, lines ~1281-1296)
+  - Currently throws Todo for `try` without `catch` and `try` with `finally`
+  - Instead: record the Todo error, then lower the `try/catch` portion only (put the `finally` block content in the fallthrough of the try/catch)
 
-- [x] **3.4 Handle `eval()` via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~3568)
-  - Already handled: records error via `builder.errors.push()` and continues
+- [ ] **3.4 Handle `eval()` via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~3568)
+  - Currently throws `UnsupportedSyntax("The 'eval' function is not supported")`
+  - Instead: record the error, emit an `UnsupportedNode` instruction value with the original AST node
 
-- [x] **3.5 Handle `with` statement via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~1382)
-  - Already handled: records error and emits `UnsupportedNode`
+- [ ] **3.5 Handle `with` statement via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~1382)
+  - Currently throws `UnsupportedSyntax`
+  - Instead: record the error, emit the body statements as-is (or skip them), continue
 
-- [x] **3.6 Handle inline `class` declarations** (`src/HIR/BuildHIR.ts`, line ~1402)
-  - Already handled: records error and emits `UnsupportedNode`
+- [ ] **3.6 Handle inline `class` declarations** (`src/HIR/BuildHIR.ts`, line ~1402)
+  - Currently throws `UnsupportedSyntax`
+  - Already creates an `UnsupportedNode`; just record the error instead of throwing
 
-- [x] **3.7 Handle remaining Todo errors in expression lowering** (`src/HIR/BuildHIR.ts`)
-  - Already handled: all ~60 error sites use `builder.errors.push()` to accumulate errors. The try/catch around body lowering provides a safety net for any that still throw.
+- [ ] **3.7 Handle remaining Todo errors in expression lowering** (`src/HIR/BuildHIR.ts`)
+  - For each of the ~35 Todo error sites in `lowerExpression`, `lowerAssignment`, `lowerMemberExpression`, etc.:
+    - Record the Todo error on the environment
+    - Emit an `UnsupportedNode` instruction value with the original Babel AST node as fallback
+  - Key sites include: pipe operator, tagged templates with interpolations, compound logical assignment (`&&=`, `||=`, `??=`), `for await...of`, object getters/setters, UpdateExpression on context variables, complex destructuring patterns
+  - The `UnsupportedNode` variant already exists in HIR and passes through codegen unchanged, so no new HIR types are needed for most cases
 
-- [x] **3.8 Handle `throw` inside `try/catch`** (`src/HIR/BuildHIR.ts`, line ~284)
-  - Already handled: records error via `builder.errors.push()` and continues
+- [ ] **3.8 Handle `throw` inside `try/catch`** (`src/HIR/BuildHIR.ts`, line ~284)
+  - Currently throws Todo
+  - Instead: record the error, and represent the `throw` as a terminal that ends the block (the existing `throw` terminal type may already handle this, or we can use `UnsupportedNode`)
 
-- [x] **3.9 Handle `for` loops with missing test or expression init** (`src/HIR/BuildHIR.ts`, lines ~559, ~632)
-  - For `for(;;)` (missing test): emit `true` as the test expression and add a branch terminal
-  - For empty init (`for (; ...)`): add a placeholder instruction to avoid invariant about empty blocks
-  - For expression init (`for (expr; ...)`): record error and lower the expression as best-effort
-  - Changed `'unsupported'` terminal to `'goto'` terminal for non-variable init to maintain valid CFG structure
+- [ ] **3.9 Handle `for` loops with missing test or expression init** (`src/HIR/BuildHIR.ts`, lines ~559, ~632)
+  - Record the error and construct a best-effort loop HIR (e.g., for `for(;;)`, use `true` as the test expression)
 
-- [x] **3.10 Handle nested function lowering failures** (`src/HIR/BuildHIR.ts`, `lowerFunction` at line ~3504)
-  - `lowerFunction()` now always returns `LoweredFunction` since `lower()` always returns `HIRFunction`
-  - Errors from nested functions are recorded on the shared environment
-  - Removed the `null` return case and the corresponding `UnsupportedNode` fallback in callers
-
-- [x] **3.11 Handle unreachable functions in `build()`** (`src/HIR/HIRBuilder.ts`, `build()`)
-  - Changed `CompilerError.throwTodo()` for unreachable code with hoisted declarations to `this.errors.push()` to allow HIR construction to complete
-
-- [x] **3.12 Handle duplicate fbt tags** (`src/HIR/BuildHIR.ts`, line ~2279)
-  - Changed `CompilerError.throwDiagnostic()` to `builder.errors.pushDiagnostic()` to record instead of throw
+- [ ] **3.10 Handle nested function lowering failures** (`src/HIR/BuildHIR.ts`, `lowerFunction` at line ~3504)
+  - Currently calls `lower()` recursively and merges errors if it fails (`builder.errors.merge(functionErrors)`)
+  - With the new approach, the nested `lower()` always returns an HIR, but errors are recorded on the shared environment
+  - Ensure the parent function continues lowering even if a nested function had errors
 
 ### Phase 4: Update Validation Passes
 
@@ -324,10 +324,4 @@ Walk through `runWithEnvironment` and wrap each pass call site. This is the inte
 * **Lint-only passes (Pattern B: `env.logErrors()`) should not use `tryRecord()`/`recordError()`** because those errors are intentionally non-blocking. They are reported via the logger only and should not cause the pipeline to return `Err`. The `logErrors` pattern was kept for `validateNoDerivedComputationsInEffects_exp`, `validateNoSetStateInEffects`, `validateNoJSXInTryStatement`, and `validateStaticComponents`.
 * **Inference passes that return `Result` with validation errors** (`inferMutationAliasingEffects`, `inferMutationAliasingRanges`) were changed to record errors via `env.recordErrors()` instead of throwing, allowing subsequent passes to proceed.
 * **Value-producing passes** (`memoizeFbtAndMacroOperandsInSameScope`, `renameVariables`, `buildReactiveFunction`) need safe default values when wrapped in `tryRecord()` since the callback can't return values. We initialize with empty defaults (e.g., `new Set()`) before the `tryRecord()` call.
-* **Phase 3 (BuildHIR) revealed that most error sites already used `builder.errors.push()` for accumulation.** The existing lowering code was designed to accumulate errors rather than throw. The main changes were: (1) changing `lower()` return type from `Result` to `HIRFunction`, (2) recording builder errors on env, (3) adding a try/catch around body lowering to catch thrown CompilerErrors from sub-calls like `resolveBinding()`, (4) treating `var` as `let` instead of skipping declarations, and (5) fixing ForStatement init/test handling to produce valid CFG structure.
-* **Partial HIR can trigger downstream invariants.** When lowering skips or partially handles constructs (e.g., unreachable hoisted functions, `var` declarations before the fix), downstream passes like `InferMutationAliasingEffects` may encounter uninitialized identifiers and throw invariants. This is acceptable since the function still correctly bails out of compilation, but error messages may be less specific. The fix for `var` (treating as `let`) demonstrates how to avoid this: continue lowering with a best-effort representation rather than skipping entirely.
-* **Errors accumulated on `env` are lost when an invariant propagates out of the pipeline.** Since invariant CompilerErrors always re-throw through `tryRecord()`, they exit the pipeline as exceptions. The caller only sees the invariant error, not any errors previously recorded on `env`. This is a design limitation that could be addressed by aggregating env errors with caught exceptions in `tryCompileFunction()`.
-* **Dedicated fault tolerance test fixtures** were added in `__tests__/fixtures/compiler/fault-tolerance/`. Each fixture combines two or more errors from different passes to verify the compiler reports all of them rather than short-circuiting on the first. Coverage includes: `var`+props mutation (BuildHIR→InferMutationAliasingEffects), `var`+ref access (BuildHIR→ValidateNoRefAccessInRender), `try/finally`+props mutation (BuildHIR→InferMutationAliasingEffects), `try/finally`+ref access (BuildHIR→ValidateNoRefAccessInRender), and a 3-error test combining try/finally+ref access+props mutation.
-* **Cleanup: consistent `tryRecord()` wrapping in Pipeline.ts.** All validation passes and inference passes are now wrapped in `env.tryRecord()` for defense-in-depth, consistent with the approach used for transform passes. Previously only transform passes were wrapped. Merged duplicate `env.enableValidations` guard blocks. Pattern B lint-only passes (`env.logErrors()`) were intentionally not wrapped since they use a different error recording strategy.
-* **Cleanup: normalized validation error recording pattern.** Four validation passes (`ValidateNoDerivedComputationsInEffects`, `ValidateMemoizedEffectDependencies`, `ValidatePreservedManualMemoization`, `ValidateSourceLocations`) were using `for (const detail of errors.details) { env.recordError(detail); }` instead of the simpler `env.recordErrors(errors)`. Normalized to use the batch method.
 

compiler/packages/babel-plugin-react-compiler/src/Babel/BabelPlugin.ts

@@ -11,7 +11,6 @@ import {
   injectReanimatedFlag,
   pipelineUsesReanimatedPlugin,
 } from '../Entrypoint/Reanimated';
-import validateNoUntransformedReferences from '../Entrypoint/ValidateNoUntransformedReferences';
 import {CompilerError} from '..';
 
 const ENABLE_REACT_COMPILER_TIMINGS =
@@ -64,19 +63,12 @@ export default function BabelPluginReactCompiler(
                 },
               };
             }
-            const result = compileProgram(prog, {
+            compileProgram(prog, {
               opts,
               filename: pass.filename ?? null,
               comments: pass.file.ast.comments ?? [],
               code: pass.file.code,
             });
-            validateNoUntransformedReferences(
-              prog,
-              pass.filename ?? null,
-              opts.logger,
-              opts.environment,
-              result,
-            );
             if (ENABLE_REACT_COMPILER_TIMINGS === true) {
               performance.mark(`${filename}:end`, {
                 detail: 'BabelPlugin:Program:end',

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Imports.ts

@@ -19,7 +19,7 @@ import {getOrInsertWith} from '../Utils/utils';
 import {ExternalFunction, isHookName} from '../HIR/Environment';
 import {Err, Ok, Result} from '../Utils/Result';
 import {LoggerEvent, ParsedPluginOptions} from './Options';
-import {BabelFn, getReactCompilerRuntimeModule} from './Program';
+import {getReactCompilerRuntimeModule} from './Program';
 import {SuppressionRange} from './Suppression';
 
 export function validateRestrictedImports(
@@ -84,11 +84,6 @@ export class ProgramContext {
   // generated imports
   imports: Map<string, Map<string, NonLocalImportSpecifier>> = new Map();
 
-  /**
-   * Metadata from compilation
-   */
-  retryErrors: Array<{fn: BabelFn; error: CompilerError}> = [];
-
   constructor({
     program,
     suppressions,

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts

@@ -228,8 +228,6 @@ const CompilerOutputModeSchema = z.enum([
   'ssr',
   // Build optimized for the client, with auto memoization
   'client',
-  // Build optimized for the client without auto memo
-  'client-no-memo',
   // Lint mode, the output is unused but validations should run
   'lint',
 ]);
@@ -254,7 +252,6 @@ export type LoggerEvent =
   | CompileErrorEvent
   | CompileDiagnosticEvent
   | CompileSkipEvent
-  | CompileUnexpectedThrowEvent
   | PipelineErrorEvent
   | TimingEvent;
 
@@ -289,11 +286,6 @@ export type PipelineErrorEvent = {
   fnLoc: t.SourceLocation | null;
   data: string;
 };
-export type CompileUnexpectedThrowEvent = {
-  kind: 'CompileUnexpectedThrow';
-  fnLoc: t.SourceLocation | null;
-  data: string;
-};
 export type TimingEvent = {
   kind: 'Timing';
   measurement: PerformanceMeasure;

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts

@@ -13,6 +13,7 @@ import {CompilerError} from '../CompilerError';
 import {Err, Ok, Result} from '../Utils/Result';
 import {
   HIRFunction,
+  IdentifierId,
   ReactiveFunction,
   assertConsistentIdentifiers,
   assertTerminalPredsExist,
@@ -91,7 +92,6 @@ import {validateNoJSXInTryStatement} from '../Validation/ValidateNoJSXInTryState
 import {propagateScopeDependenciesHIR} from '../HIR/PropagateScopeDependenciesHIR';
 import {outlineJSX} from '../Optimization/OutlineJsx';
 import {optimizePropsMethodCalls} from '../Optimization/OptimizePropsMethodCalls';
-import {validateNoImpureFunctionsInRender} from '../Validation/ValidateNoImpureFunctionsInRender';
 import {validateStaticComponents} from '../Validation/ValidateStaticComponents';
 import {validateNoFreezingKnownMutableFunctions} from '../Validation/ValidateNoFreezingKnownMutableFunctions';
 import {inferMutationAliasingEffects} from '../Inference/InferMutationAliasingEffects';
@@ -155,7 +155,7 @@ function runWithEnvironment(
   const log = (value: CompilerPipelineValue): void => {
     env.logger?.debugLogIRs?.(value);
   };
-  const hir = lower(func, env);
+  const hir = lower(func, env).unwrap();
   log({kind: 'hir', name: 'HIR', value: hir});
 
   pruneMaybeThrows(hir);
@@ -231,7 +231,9 @@ function runWithEnvironment(
   log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
   if (env.enableValidations) {
     validateLocalsNotReassignedAfterRender(hir);
+  }
 
+  if (env.enableValidations) {
     if (env.config.assertValidMutableRanges) {
       assertValidMutableRanges(hir);
     }
@@ -261,11 +263,9 @@ function runWithEnvironment(
       env.logErrors(validateNoJSXInTryStatement(hir));
     }
 
-    if (env.config.validateNoImpureFunctionsInRender) {
-      validateNoImpureFunctionsInRender(hir);
-    }
-
-    validateNoFreezingKnownMutableFunctions(hir);
+    env.tryRecord(() => {
+      validateNoFreezingKnownMutableFunctions(hir);
+    });
   }
 
   inferReactivePlaces(hir);
@@ -306,7 +306,8 @@ function runWithEnvironment(
     log({kind: 'hir', name: 'InferReactiveScopeVariables', value: hir});
   }
 
-  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
+  let fbtOperands: Set<IdentifierId> = new Set();
+  fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
   log({
     kind: 'hir',
     name: 'MemoizeFbtAndMacroOperandsInSameScope',
@@ -391,7 +392,6 @@ function runWithEnvironment(
   });
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-
   propagateScopeDependenciesHIR(hir);
   log({
     kind: 'hir',
@@ -399,7 +399,8 @@ function runWithEnvironment(
     value: hir,
   });
 
-  const reactiveFunction = buildReactiveFunction(hir);
+  let reactiveFunction!: ReactiveFunction;
+  reactiveFunction = buildReactiveFunction(hir);
   log({
     kind: 'reactive',
     name: 'BuildReactiveFunction',
@@ -486,7 +487,8 @@ function runWithEnvironment(
     value: reactiveFunction,
   });
 
-  const uniqueIdentifiers = renameVariables(reactiveFunction);
+  let uniqueIdentifiers: Set<string> = new Set();
+  uniqueIdentifiers = renameVariables(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'RenameVariables',
@@ -500,7 +502,6 @@ function runWithEnvironment(
     value: reactiveFunction,
   });
 
-
   if (
     env.config.enablePreserveExistingMemoizationGuarantees ||
     env.config.validatePreserveExistingMemoizationGuarantees

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts

@@ -350,9 +350,6 @@ function isFilePartOfSources(
   return false;
 }
 
-export type CompileProgramMetadata = {
-  retryErrors: Array<{fn: BabelFn; error: CompilerError}>;
-};
 /**
  * Main entrypoint for React Compiler.
  *
@@ -363,7 +360,7 @@ export type CompileProgramMetadata = {
 export function compileProgram(
   program: NodePath<t.Program>,
   pass: CompilerPass,
-): CompileProgramMetadata | null {
+): void {
   /**
    * This is directly invoked by the react-compiler babel plugin, so exceptions
    * thrown by this function will fail the babel build.
@@ -376,7 +373,7 @@ export function compileProgram(
    *   the outlined functions.
    */
   if (shouldSkipCompilation(program, pass)) {
-    return null;
+    return;
   }
   const restrictedImportsErr = validateRestrictedImports(
     program,
@@ -384,7 +381,7 @@ export function compileProgram(
   );
   if (restrictedImportsErr) {
     handleError(restrictedImportsErr, pass, null);
-    return null;
+    return;
   }
   /*
    * Record lint errors and critical errors as depending on Forget's config,
@@ -478,15 +475,11 @@ export function compileProgram(
       );
       handleError(error, programContext, null);
     }
-    return null;
+    return;
   }
 
   // Insert React Compiler generated functions into the Babel AST
   applyCompiledFunctions(program, compiledFns, pass, programContext);
-
-  return {
-    retryErrors: programContext.retryErrors,
-  };
 }
 
 type CompileSource = {
@@ -720,20 +713,6 @@ function tryCompileFunction(
       return {kind: 'error', error: result.unwrapErr()};
     }
   } catch (err) {
-    /**
-     * A pass incorrectly threw instead of recording the error.
-     * Log for detection in development.
-     */
-    if (
-      err instanceof CompilerError &&
-      err.details.every(detail => detail.category !== ErrorCategory.Invariant)
-    ) {
-      programContext.logEvent({
-        kind: 'CompileUnexpectedThrow',
-        fnLoc: fn.node.loc ?? null,
-        data: err.toString(),
-      });
-    }
     return {kind: 'error', error: err};
   }
 }

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/ValidateNoUntransformedReferences.ts

@@ -1,162 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {NodePath} from '@babel/core';
-import * as t from '@babel/types';
-
-import {CompilerError, EnvironmentConfig, Logger} from '..';
-import {getOrInsertWith} from '../Utils/utils';
-import {GeneratedSource} from '../HIR';
-import {DEFAULT_EXPORT} from '../HIR/Environment';
-import {CompileProgramMetadata} from './Program';
-export default function validateNoUntransformedReferences(
-  path: NodePath<t.Program>,
-  filename: string | null,
-  logger: Logger | null,
-  env: EnvironmentConfig,
-  compileResult: CompileProgramMetadata | null,
-): void {
-  const moduleLoadChecks = new Map<
-    string,
-    Map<string, CheckInvalidReferenceFn>
-  >();
-  if (moduleLoadChecks.size > 0) {
-    transformProgram(path, moduleLoadChecks, filename, logger, compileResult);
-  }
-}
-
-type TraversalState = {
-  shouldInvalidateScopes: boolean;
-  program: NodePath<t.Program>;
-  logger: Logger | null;
-  filename: string | null;
-  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>;
-};
-type CheckInvalidReferenceFn = (
-  paths: Array<NodePath<t.Node>>,
-  context: TraversalState,
-) => void;
-
-function validateImportSpecifier(
-  specifier: NodePath<t.ImportSpecifier>,
-  importSpecifierChecks: Map<string, CheckInvalidReferenceFn>,
-  state: TraversalState,
-): void {
-  const imported = specifier.get('imported');
-  const specifierName: string =
-    imported.node.type === 'Identifier'
-      ? imported.node.name
-      : imported.node.value;
-  const checkFn = importSpecifierChecks.get(specifierName);
-  if (checkFn == null) {
-    return;
-  }
-  if (state.shouldInvalidateScopes) {
-    state.shouldInvalidateScopes = false;
-    state.program.scope.crawl();
-  }
-
-  const local = specifier.get('local');
-  const binding = local.scope.getBinding(local.node.name);
-  CompilerError.invariant(binding != null, {
-    reason: 'Expected binding to be found for import specifier',
-    loc: local.node.loc ?? GeneratedSource,
-  });
-  checkFn(binding.referencePaths, state);
-}
-
-function validateNamespacedImport(
-  specifier: NodePath<t.ImportNamespaceSpecifier | t.ImportDefaultSpecifier>,
-  importSpecifierChecks: Map<string, CheckInvalidReferenceFn>,
-  state: TraversalState,
-): void {
-  if (state.shouldInvalidateScopes) {
-    state.shouldInvalidateScopes = false;
-    state.program.scope.crawl();
-  }
-  const local = specifier.get('local');
-  const binding = local.scope.getBinding(local.node.name);
-  const defaultCheckFn = importSpecifierChecks.get(DEFAULT_EXPORT);
-
-  CompilerError.invariant(binding != null, {
-    reason: 'Expected binding to be found for import specifier',
-    loc: local.node.loc ?? GeneratedSource,
-  });
-  const filteredReferences = new Map<
-    CheckInvalidReferenceFn,
-    Array<NodePath<t.Node>>
-  >();
-  for (const reference of binding.referencePaths) {
-    if (defaultCheckFn != null) {
-      getOrInsertWith(filteredReferences, defaultCheckFn, () => []).push(
-        reference,
-      );
-    }
-    const parent = reference.parentPath;
-    if (
-      parent != null &&
-      parent.isMemberExpression() &&
-      parent.get('object') === reference
-    ) {
-      if (parent.node.computed || parent.node.property.type !== 'Identifier') {
-        continue;
-      }
-      const checkFn = importSpecifierChecks.get(parent.node.property.name);
-      if (checkFn != null) {
-        getOrInsertWith(filteredReferences, checkFn, () => []).push(parent);
-      }
-    }
-  }
-
-  for (const [checkFn, references] of filteredReferences) {
-    checkFn(references, state);
-  }
-}
-function transformProgram(
-  path: NodePath<t.Program>,
-
-  moduleLoadChecks: Map<string, Map<string, CheckInvalidReferenceFn>>,
-  filename: string | null,
-  logger: Logger | null,
-  compileResult: CompileProgramMetadata | null,
-): void {
-  const traversalState: TraversalState = {
-    shouldInvalidateScopes: true,
-    program: path,
-    filename,
-    logger,
-    transformErrors: compileResult?.retryErrors ?? [],
-  };
-  path.traverse({
-    ImportDeclaration(path: NodePath<t.ImportDeclaration>) {
-      const importSpecifierChecks = moduleLoadChecks.get(
-        path.node.source.value,
-      );
-      if (importSpecifierChecks == null) {
-        return;
-      }
-      const specifiers = path.get('specifiers');
-      for (const specifier of specifiers) {
-        if (specifier.isImportSpecifier()) {
-          validateImportSpecifier(
-            specifier,
-            importSpecifierChecks,
-            traversalState,
-          );
-        } else {
-          validateNamespacedImport(
-            specifier as NodePath<
-              t.ImportNamespaceSpecifier | t.ImportDefaultSpecifier
-            >,
-            importSpecifierChecks,
-            traversalState,
-          );
-        }
-      }
-    },
-  });
-}

compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts

@@ -310,13 +310,16 @@ function traverseOptionalBlock(
      * - a optional base block with a separate nested optional-chain (e.g. a(c?.d)?.d)
      */
     const testBlock = context.blocks.get(maybeTest.terminal.fallthrough)!;
-    /**
-     * Fallthrough of the inner optional should be a block with no
-     * instructions, terminating with Test($<temporary written to from
-     * StoreLocal>)
-     */
-    if (testBlock.terminal.kind !== 'branch') {
-      return null;
+    if (testBlock!.terminal.kind !== 'branch') {
+      /**
+       * Fallthrough of the inner optional should be a block with no
+       * instructions, terminating with Test($<temporary written to from
+       * StoreLocal>)
+       */
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
+        loc: maybeTest.terminal.loc,
+      });
     }
     /**
      * Recurse into inner optional blocks to collect inner optional-chain

compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts

@@ -640,9 +640,6 @@ export class Environment {
       case 'ssr': {
         return true;
       }
-      case 'client-no-memo': {
-        return false;
-      }
       default: {
         assertExhaustive(
           this.outputMode,
@@ -659,8 +656,7 @@ export class Environment {
         // linting also enables memoization so that we can check if manual memoization is preserved
         return true;
       }
-      case 'ssr':
-      case 'client-no-memo': {
+      case 'ssr': {
         return false;
       }
       default: {
@@ -679,9 +675,6 @@ export class Environment {
       case 'ssr': {
         return true;
       }
-      case 'client-no-memo': {
-        return false;
-      }
       default: {
         assertExhaustive(
           this.outputMode,
@@ -741,13 +734,6 @@ export class Environment {
     } else {
       this.#errors.pushErrorDetail(error);
     }
-    if (this.logger != null) {
-      this.logger.logEvent(this.filename, {
-        kind: 'CompileError',
-        detail: error,
-        fnLoc: null,
-      });
-    }
   }
 
   /**
@@ -773,6 +759,29 @@ export class Environment {
     return this.#errors;
   }
 
+  /**
+   * Wraps a callback in try/catch: if the callback throws a CompilerError
+   * that is NOT an invariant, the error is recorded and execution continues.
+   * Non-CompilerError exceptions and invariants are re-thrown.
+   */
+  tryRecord(fn: () => void): void {
+    try {
+      fn();
+    } catch (err) {
+      if (err instanceof CompilerError) {
+        // Check if any detail is an invariant — if so, re-throw
+        for (const detail of err.details) {
+          if (detail.category === ErrorCategory.Invariant) {
+            throw err;
+          }
+        }
+        this.recordErrors(err);
+      } else {
+        throw err;
+      }
+    }
+  }
+
   isContextIdentifier(node: t.Identifier): boolean {
     return this.#contextIdentifiers.has(node);
   }

compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts

@@ -7,12 +7,7 @@
 
 import {Binding, NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {
-  CompilerError,
-  CompilerDiagnostic,
-  CompilerErrorDetail,
-  ErrorCategory,
-} from '../CompilerError';
+import {CompilerError, ErrorCategory} from '../CompilerError';
 import {Environment} from './Environment';
 import {
   BasicBlock,
@@ -115,6 +110,7 @@ export default class HIRBuilder {
   #bindings: Bindings;
   #env: Environment;
   #exceptionHandlerStack: Array<BlockId> = [];
+  errors: CompilerError = new CompilerError();
   /**
    * Traversal context: counts the number of `fbt` tag parents
    * of the current babel node.
@@ -152,10 +148,6 @@ export default class HIRBuilder {
     this.#current = newBlock(this.#entry, options?.entryBlockKind ?? 'block');
   }
 
-  recordError(error: CompilerDiagnostic | CompilerErrorDetail): void {
-    this.#env.recordError(error);
-  }
-
   currentBlockKind(): BlockKind {
     return this.#current.kind;
   }
@@ -316,28 +308,34 @@ export default class HIRBuilder {
 
   resolveBinding(node: t.Identifier): Identifier {
     if (node.name === 'fbt') {
-      this.recordError(
-        new CompilerErrorDetail({
-          category: ErrorCategory.Todo,
-          reason: 'Support local variables named `fbt`',
-          description:
-            'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
-          loc: node.loc ?? GeneratedSource,
-          suggestions: null,
-        }),
-      );
+      CompilerError.throwDiagnostic({
+        category: ErrorCategory.Todo,
+        reason: 'Support local variables named `fbt`',
+        description:
+          'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
+        details: [
+          {
+            kind: 'error',
+            message: 'Rename to avoid conflict with fbt plugin',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
+      });
     }
     if (node.name === 'this') {
-      this.recordError(
-        new CompilerErrorDetail({
-          category: ErrorCategory.UnsupportedSyntax,
-          reason: '`this` is not supported syntax',
-          description:
-            'React Compiler does not support compiling functions that use `this`',
-          loc: node.loc ?? GeneratedSource,
-          suggestions: null,
-        }),
-      );
+      CompilerError.throwDiagnostic({
+        category: ErrorCategory.UnsupportedSyntax,
+        reason: '`this` is not supported syntax',
+        description:
+          'React Compiler does not support compiling functions that use `this`',
+        details: [
+          {
+            kind: 'error',
+            message: '`this` was used here',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
+      });
     }
     const originalName = node.name;
     let name = originalName;
@@ -383,15 +381,12 @@ export default class HIRBuilder {
           instr => instr.value.kind === 'FunctionExpression',
         )
       ) {
-        this.recordError(
-          new CompilerErrorDetail({
-            reason: `Support functions with unreachable code that may contain hoisted declarations`,
-            loc: block.instructions[0]?.loc ?? block.terminal.loc,
-            description: null,
-            suggestions: null,
-            category: ErrorCategory.Todo,
-          }),
-        );
+        CompilerError.throwTodo({
+          reason: `Support functions with unreachable code that may contain hoisted declarations`,
+          loc: block.instructions[0]?.loc ?? block.terminal.loc,
+          description: null,
+          suggestions: null,
+        });
       }
     }
     ir.blocks = rpoBlocks;

compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts

@@ -293,7 +293,7 @@ function extractManualMemoizationArgs(
   instr: TInstruction<CallExpression> | TInstruction<MethodCall>,
   kind: 'useCallback' | 'useMemo',
   sidemap: IdentifierSidemap,
-  env: Environment,
+  errors: CompilerError,
 ): {
   fnPlace: Place;
   depsList: Array<ManualMemoDependency> | null;
@@ -303,7 +303,7 @@ function extractManualMemoizationArgs(
     Place | SpreadPattern | undefined
   >;
   if (fnPlace == null || fnPlace.kind !== 'Identifier') {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.UseMemo,
         reason: `Expected a callback function to be passed to ${kind}`,
@@ -335,7 +335,7 @@ function extractManualMemoizationArgs(
       ? sidemap.maybeDepsLists.get(depsListPlace.identifier.id)
       : null;
   if (maybeDepsList == null) {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.UseMemo,
         reason: `Expected the dependency list for ${kind} to be an array literal`,
@@ -354,7 +354,7 @@ function extractManualMemoizationArgs(
   for (const dep of maybeDepsList.deps) {
     const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
     if (maybeDep == null) {
-      env.recordError(
+      errors.pushDiagnostic(
         CompilerDiagnostic.create({
           category: ErrorCategory.UseMemo,
           reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
@@ -389,6 +389,7 @@ function extractManualMemoizationArgs(
  * is only used for memoizing values and not for running arbitrary side effects.
  */
 export function dropManualMemoization(func: HIRFunction): void {
+  const errors = new CompilerError();
   const isValidationEnabled =
     func.env.config.validatePreserveExistingMemoizationGuarantees ||
     func.env.config.validateNoSetStateInRender ||
@@ -435,7 +436,7 @@ export function dropManualMemoization(func: HIRFunction): void {
             instr as TInstruction<CallExpression> | TInstruction<MethodCall>,
             manualMemo.kind,
             sidemap,
-            func.env,
+            errors,
           );
 
           if (memoDetails == null) {
@@ -463,7 +464,7 @@ export function dropManualMemoization(func: HIRFunction): void {
              * is rare and likely sketchy.
              */
             if (!sidemap.functions.has(fnPlace.identifier.id)) {
-              func.env.recordError(
+              errors.pushDiagnostic(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.UseMemo,
                   reason: `Expected the first argument to be an inline function expression`,
@@ -548,6 +549,10 @@ export function dropManualMemoization(func: HIRFunction): void {
       markInstructionIds(func.body);
     }
   }
+
+  if (errors.hasAnyErrors()) {
+    func.env.recordErrors(errors);
+  }
 }
 
 function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {

compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts

@@ -20,7 +20,6 @@ import {
   Place,
   isPrimitiveType,
 } from '../HIR/HIR';
-import {Environment} from '../HIR/Environment';
 import {
   eachInstructionLValue,
   eachInstructionValueOperand,
@@ -108,7 +107,7 @@ export function inferMutationAliasingRanges(
 
   let index = 0;
 
-  const shouldRecordErrors = !isFunctionExpression && fn.env.enableValidations;
+  const errors = new CompilerError();
 
   for (const param of [...fn.params, ...fn.context, fn.returns]) {
     const place = param.kind === 'Identifier' ? param : param.place;
@@ -201,9 +200,7 @@ export function inferMutationAliasingRanges(
           effect.kind === 'MutateGlobal' ||
           effect.kind === 'Impure'
         ) {
-          if (shouldRecordErrors) {
-            fn.env.recordError(effect.error);
-          }
+          errors.pushDiagnostic(effect.error);
           functionEffects.push(effect);
         } else if (effect.kind === 'Render') {
           renders.push({index: index++, place: effect.place});
@@ -248,15 +245,11 @@ export function inferMutationAliasingRanges(
       mutation.kind,
       mutation.place.loc,
       mutation.reason,
-      shouldRecordErrors ? fn.env : null,
+      errors,
     );
   }
   for (const render of renders) {
-    state.render(
-      render.index,
-      render.place.identifier,
-      shouldRecordErrors ? fn.env : null,
-    );
+    state.render(render.index, render.place.identifier, errors);
   }
   for (const param of [...fn.context, ...fn.params]) {
     const place = param.kind === 'Identifier' ? param : param.place;
@@ -505,6 +498,7 @@ export function inferMutationAliasingRanges(
    * would be transitively mutated needs a capture relationship.
    */
   const tracked: Array<Place> = [];
+  const ignoredErrors = new CompilerError();
   for (const param of [...fn.params, ...fn.context, fn.returns]) {
     const place = param.kind === 'Identifier' ? param : param.place;
     tracked.push(place);
@@ -519,7 +513,7 @@ export function inferMutationAliasingRanges(
       MutationKind.Conditional,
       into.loc,
       null,
-      null,
+      ignoredErrors,
     );
     for (const from of tracked) {
       if (
@@ -553,17 +547,23 @@ export function inferMutationAliasingRanges(
     }
   }
 
+  if (
+    errors.hasAnyErrors() &&
+    !isFunctionExpression &&
+    fn.env.enableValidations
+  ) {
+    fn.env.recordErrors(errors);
+  }
   return functionEffects;
 }
 
-function appendFunctionErrors(env: Environment | null, fn: HIRFunction): void {
-  if (env == null) return;
+function appendFunctionErrors(errors: CompilerError, fn: HIRFunction): void {
   for (const effect of fn.aliasingEffects ?? []) {
     switch (effect.kind) {
       case 'Impure':
       case 'MutateFrozen':
       case 'MutateGlobal': {
-        env.recordError(effect.error);
+        errors.pushDiagnostic(effect.error);
         break;
       }
     }
@@ -664,7 +664,7 @@ class AliasingState {
     }
   }
 
-  render(index: number, start: Identifier, env: Environment | null): void {
+  render(index: number, start: Identifier, errors: CompilerError): void {
     const seen = new Set<Identifier>();
     const queue: Array<Identifier> = [start];
     while (queue.length !== 0) {
@@ -678,7 +678,7 @@ class AliasingState {
         continue;
       }
       if (node.value.kind === 'Function') {
-        appendFunctionErrors(env, node.value.function);
+        appendFunctionErrors(errors, node.value.function);
       }
       for (const [alias, when] of node.createdFrom) {
         if (when >= index) {
@@ -710,7 +710,7 @@ class AliasingState {
     startKind: MutationKind,
     loc: SourceLocation,
     reason: MutationReason | null,
-    env: Environment | null,
+    errors: CompilerError,
   ): void {
     const seen = new Map<Identifier, MutationKind>();
     const queue: Array<{
@@ -742,7 +742,7 @@ class AliasingState {
         node.transitive == null &&
         node.local == null
       ) {
-        appendFunctionErrors(env, node.value.function);
+        appendFunctionErrors(errors, node.value.function);
       }
       if (transitive) {
         if (node.transitive == null || node.transitive.kind < kind) {

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/BuildReactiveFunction.ts

@@ -1007,10 +1007,11 @@ class Driver {
     const test = this.visitValueBlock(testBlockId, loc);
     const testBlock = this.cx.ir.blocks.get(test.block)!;
     if (testBlock.terminal.kind !== 'branch') {
-      CompilerError.invariant(false, {
-        reason: `Expected a branch terminal for ${terminalKind} test block`,
-        description: `Got \`${testBlock.terminal.kind}\``,
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for ${terminalKind} test block`,
+        description: null,
         loc: testBlock.terminal.loc,
+        suggestions: null,
       });
     }
     return {

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts

@@ -13,11 +13,7 @@ import {
   pruneUnusedLabels,
   renameVariables,
 } from '.';
-import {
-  CompilerError,
-  CompilerErrorDetail,
-  ErrorCategory,
-} from '../CompilerError';
+import {CompilerError, ErrorCategory} from '../CompilerError';
 import {Environment, ExternalFunction} from '../HIR';
 import {
   ArrayPattern,
@@ -351,6 +347,10 @@ function codegenReactiveFunction(
     }
   }
 
+  if (cx.errors.hasAnyErrors()) {
+    fn.env.recordErrors(cx.errors);
+  }
+
   const countMemoBlockVisitor = new CountMemoBlockVisitor(fn.env);
   visitReactiveFunction(fn, countMemoBlockVisitor, undefined);
 
@@ -420,6 +420,7 @@ class Context {
    */
   #declarations: Set<DeclarationId> = new Set();
   temp: Temporaries;
+  errors: CompilerError = new CompilerError();
   objectMethods: Map<IdentifierId, ObjectMethod> = new Map();
   uniqueIdentifiers: Set<string>;
   fbtOperands: Set<IdentifierId>;
@@ -438,10 +439,6 @@ class Context {
     this.fbtOperands = fbtOperands;
     this.temp = temporaries !== null ? new Map(temporaries) : new Map();
   }
-
-  recordError(error: CompilerErrorDetail): void {
-    this.env.recordError(error);
-  }
   get nextCacheIndex(): number {
     return this.#nextCacheIndex++;
   }
@@ -778,15 +775,12 @@ function codegenTerminal(
         loc: terminal.init.loc,
       });
       if (terminal.init.instructions.length !== 2) {
-        cx.recordError(
-          new CompilerErrorDetail({
-            reason: 'Support non-trivial for..in inits',
-            category: ErrorCategory.Todo,
-            loc: terminal.init.loc,
-            suggestions: null,
-          }),
-        );
-        return t.emptyStatement();
+        CompilerError.throwTodo({
+          reason: 'Support non-trivial for..in inits',
+          description: null,
+          loc: terminal.init.loc,
+          suggestions: null,
+        });
       }
       const iterableCollection = terminal.init.instructions[0];
       const iterableItem = terminal.init.instructions[1];
@@ -801,15 +795,12 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          cx.recordError(
-            new CompilerErrorDetail({
-              reason: 'Support non-trivial for..in inits',
-              category: ErrorCategory.Todo,
-              loc: terminal.init.loc,
-              suggestions: null,
-            }),
-          );
-          return t.emptyStatement();
+          CompilerError.throwTodo({
+            reason: 'Support non-trivial for..in inits',
+            description: null,
+            loc: terminal.init.loc,
+            suggestions: null,
+          });
         }
         default:
           CompilerError.invariant(false, {
@@ -879,15 +870,12 @@ function codegenTerminal(
         loc: terminal.test.loc,
       });
       if (terminal.test.instructions.length !== 2) {
-        cx.recordError(
-          new CompilerErrorDetail({
-            reason: 'Support non-trivial for..of inits',
-            category: ErrorCategory.Todo,
-            loc: terminal.init.loc,
-            suggestions: null,
-          }),
-        );
-        return t.emptyStatement();
+        CompilerError.throwTodo({
+          reason: 'Support non-trivial for..of inits',
+          description: null,
+          loc: terminal.init.loc,
+          suggestions: null,
+        });
       }
       const iterableItem = terminal.test.instructions[1];
       let lval: t.LVal;
@@ -901,15 +889,12 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          cx.recordError(
-            new CompilerErrorDetail({
-              reason: 'Support non-trivial for..of inits',
-              category: ErrorCategory.Todo,
-              loc: terminal.init.loc,
-              suggestions: null,
-            }),
-          );
-          return t.emptyStatement();
+          CompilerError.throwTodo({
+            reason: 'Support non-trivial for..of inits',
+            description: null,
+            loc: terminal.init.loc,
+            suggestions: null,
+          });
         }
         default:
           CompilerError.invariant(false, {
@@ -1968,26 +1953,22 @@ function codegenInstructionValue(
         } else {
           if (t.isVariableDeclaration(stmt)) {
             const declarator = stmt.declarations[0];
-            cx.recordError(
-              new CompilerErrorDetail({
-                reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${
-                  (declarator.id as t.Identifier).name
-                }'`,
-                category: ErrorCategory.Todo,
-                loc: declarator.loc ?? null,
-                suggestions: null,
-              }),
-            );
+            cx.errors.push({
+              reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${
+                (declarator.id as t.Identifier).name
+              }'`,
+              category: ErrorCategory.Todo,
+              loc: declarator.loc ?? null,
+              suggestions: null,
+            });
             return t.stringLiteral(`TODO handle ${declarator.id}`);
           } else {
-            cx.recordError(
-              new CompilerErrorDetail({
-                reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
-                category: ErrorCategory.Todo,
-                loc: stmt.loc ?? null,
-                suggestions: null,
-              }),
-            );
+            cx.errors.push({
+              reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
+              category: ErrorCategory.Todo,
+              loc: stmt.loc ?? null,
+              suggestions: null,
+            });
             return t.stringLiteral(`TODO handle ${stmt.type}`);
           }
         }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateExhaustiveDependencies.ts

@@ -102,6 +102,7 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
       loc: place.loc,
     });
   }
+  const error = new CompilerError();
   let startMemo: StartMemoize | null = null;
 
   function onStartMemoize(
@@ -142,7 +143,7 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
         'all',
       );
       if (diagnostic != null) {
-        fn.env.recordError(diagnostic);
+        error.pushDiagnostic(diagnostic);
       }
     }
 
@@ -207,12 +208,15 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
           effectReportMode,
         );
         if (diagnostic != null) {
-          fn.env.recordError(diagnostic);
+          error.pushDiagnostic(diagnostic);
         }
       },
     },
     false, // isFunctionExpression
   );
+  if (error.hasAnyErrors()) {
+    fn.env.recordErrors(error);
+  }
 }
 
 function validateDependencies(

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateHooksUsage.ts

@@ -6,9 +6,13 @@
  */
 
 import * as t from '@babel/types';
-import {CompilerErrorDetail, ErrorCategory} from '../CompilerError';
+import {
+  CompilerError,
+  CompilerErrorDetail,
+  ErrorCategory,
+} from '../CompilerError';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
-import {Environment, isHookName} from '../HIR/Environment';
+import {isHookName} from '../HIR/Environment';
 import {
   HIRFunction,
   IdentifierId,
@@ -86,14 +90,15 @@ function joinKinds(a: Kind, b: Kind): Kind {
 export function validateHooksUsage(fn: HIRFunction): void {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
 
+  const errors = new CompilerError();
   const errorsByPlace = new Map<t.SourceLocation, CompilerErrorDetail>();
 
-  function trackError(
+  function recordError(
     loc: SourceLocation,
     errorDetail: CompilerErrorDetail,
   ): void {
     if (typeof loc === 'symbol') {
-      fn.env.recordError(errorDetail);
+      errors.pushErrorDetail(errorDetail);
     } else {
       errorsByPlace.set(loc, errorDetail);
     }
@@ -113,7 +118,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
      * If that same place is also used as a conditional call, upgrade the error to a conditonal hook error
      */
     if (previousError === undefined || previousError.reason !== reason) {
-      trackError(
+      recordError(
         place.loc,
         new CompilerErrorDetail({
           category: ErrorCategory.Hooks,
@@ -129,7 +134,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
     const previousError =
       typeof place.loc !== 'symbol' ? errorsByPlace.get(place.loc) : undefined;
     if (previousError === undefined) {
-      trackError(
+      recordError(
         place.loc,
         new CompilerErrorDetail({
           category: ErrorCategory.Hooks,
@@ -146,7 +151,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
     const previousError =
       typeof place.loc !== 'symbol' ? errorsByPlace.get(place.loc) : undefined;
     if (previousError === undefined) {
-      trackError(
+      recordError(
         place.loc,
         new CompilerErrorDetail({
           category: ErrorCategory.Hooks,
@@ -391,7 +396,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
         }
         case 'ObjectMethod':
         case 'FunctionExpression': {
-          visitFunctionExpression(fn.env, instr.value.loweredFunc.func);
+          visitFunctionExpression(errors, instr.value.loweredFunc.func);
           break;
         }
         default: {
@@ -416,17 +421,20 @@ export function validateHooksUsage(fn: HIRFunction): void {
   }
 
   for (const [, error] of errorsByPlace) {
-    fn.env.recordError(error);
+    errors.pushErrorDetail(error);
+  }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
   }
 }
 
-function visitFunctionExpression(env: Environment, fn: HIRFunction): void {
+function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
       switch (instr.value.kind) {
         case 'ObjectMethod':
         case 'FunctionExpression': {
-          visitFunctionExpression(env, instr.value.loweredFunc.func);
+          visitFunctionExpression(errors, instr.value.loweredFunc.func);
           break;
         }
         case 'MethodCall':
@@ -437,7 +445,7 @@ function visitFunctionExpression(env: Environment, fn: HIRFunction): void {
               : instr.value.property;
           const hookKind = getHookKind(fn.env, callee.identifier);
           if (hookKind != null) {
-            env.recordError(
+            errors.pushErrorDetail(
               new CompilerErrorDetail({
                 category: ErrorCategory.Hooks,
                 reason:

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoCapitalizedCalls.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerErrorDetail, EnvironmentConfig} from '..';
+import {CompilerError, CompilerErrorDetail, EnvironmentConfig} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId} from '../HIR';
 import {DEFAULT_GLOBALS} from '../HIR/Globals';
@@ -20,6 +20,7 @@ export function validateNoCapitalizedCalls(fn: HIRFunction): void {
     return ALLOW_LIST.has(name);
   };
 
+  const errors = new CompilerError();
   const capitalLoadGlobals = new Map<IdentifierId, string>();
   const capitalizedProperties = new Map<IdentifierId, string>();
   const reason =
@@ -71,19 +72,20 @@ export function validateNoCapitalizedCalls(fn: HIRFunction): void {
           const propertyIdentifier = value.property.identifier.id;
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
-            fn.env.recordError(
-              new CompilerErrorDetail({
-                category: ErrorCategory.CapitalizedCalls,
-                reason,
-                description: `${propertyName} may be a component`,
-                loc: value.loc,
-                suggestions: null,
-              }),
-            );
+            errors.push({
+              category: ErrorCategory.CapitalizedCalls,
+              reason,
+              description: `${propertyName} may be a component`,
+              loc: value.loc,
+              suggestions: null,
+            });
           }
           break;
         }
       }
     }
   }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects.ts

@@ -6,7 +6,7 @@
  */
 
 import {CompilerError, SourceLocation} from '..';
-import {CompilerErrorDetail, ErrorCategory} from '../CompilerError';
+import {ErrorCategory} from '../CompilerError';
 import {
   ArrayExpression,
   BlockId,
@@ -20,7 +20,6 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {Environment} from '../HIR/Environment';
 
 /**
  * Validates that useEffect is not used for derived computations which could/should
@@ -50,6 +49,8 @@ export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
   const functions: Map<IdentifierId, FunctionExpression> = new Map();
   const locals: Map<IdentifierId, IdentifierId> = new Map();
 
+  const errors = new CompilerError();
+
   for (const block of fn.body.blocks.values()) {
     for (const instr of block.instructions) {
       const {lvalue, value} = instr;
@@ -89,19 +90,22 @@ export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
             validateEffect(
               effectFunction.loweredFunc.func,
               dependencies,
-              fn.env,
+              errors,
             );
           }
         }
       }
     }
   }
+  for (const detail of errors.details) {
+    fn.env.recordError(detail);
+  }
 }
 
 function validateEffect(
   effectFunction: HIRFunction,
   effectDeps: Array<IdentifierId>,
-  env: Environment,
+  errors: CompilerError,
 ): void {
   for (const operand of effectFunction.context) {
     if (isSetStateType(operand.identifier)) {
@@ -215,15 +219,13 @@ function validateEffect(
   }
 
   for (const loc of setStateLocations) {
-    env.recordError(
-      new CompilerErrorDetail({
-        category: ErrorCategory.EffectDerivationsOfState,
-        reason:
-          'Values derived from props and state should be calculated during render, not in an effect. (https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state)',
-        description: null,
-        loc,
-        suggestions: null,
-      }),
-    );
+    errors.push({
+      category: ErrorCategory.EffectDerivationsOfState,
+      reason:
+        'Values derived from props and state should be calculated during render, not in an effect. (https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state)',
+      description: null,
+      loc,
+      suggestions: null,
+    });
   }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoFreezingKnownMutableFunctions.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, Effect} from '..';
+import {CompilerDiagnostic, CompilerError, Effect} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {
   HIRFunction,
@@ -43,6 +43,7 @@ import {AliasingEffect} from '../Inference/AliasingEffects';
  * that are passed where a frozen value is expected and rejects them.
  */
 export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
+  const errors = new CompilerError();
   const contextMutationEffects: Map<
     IdentifierId,
     Extract<AliasingEffect, {kind: 'Mutate'} | {kind: 'MutateTransitive'}>
@@ -59,7 +60,7 @@ export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
           place.identifier.name.kind === 'named'
             ? `\`${place.identifier.name.value}\``
             : 'a local variable';
-        fn.env.recordError(
+        errors.pushDiagnostic(
           CompilerDiagnostic.create({
             category: ErrorCategory.Immutability,
             reason: 'Cannot modify local variables after render completes',
@@ -158,4 +159,7 @@ export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
       visitOperand(operand);
     }
   }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoImpureFunctionsInRender.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic} from '..';
+import {CompilerDiagnostic, CompilerError} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {HIRFunction} from '../HIR';
 import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
@@ -20,6 +20,7 @@ import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffect
  * and use it here.
  */
 export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
+  const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
       const value = instr.value;
@@ -31,7 +32,7 @@ export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
           callee.identifier.type,
         );
         if (signature != null && signature.impure === true) {
-          fn.env.recordError(
+          errors.pushDiagnostic(
             CompilerDiagnostic.create({
               category: ErrorCategory.Purity,
               reason: 'Cannot call impure function during render',
@@ -51,4 +52,7 @@ export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
       }
     }
   }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts

@@ -124,8 +124,8 @@ export function validateNoRefAccessInRender(fn: HIRFunction): void {
   collectTemporariesSidemap(fn, env);
   const errors = new CompilerError();
   validateNoRefAccessInRenderImpl(fn, env, errors);
-  for (const detail of errors.details) {
-    fn.env.recordError(detail);
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
   }
 }
 

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInRender.ts

@@ -48,8 +48,8 @@ export function validateNoSetStateInRender(fn: HIRFunction): void {
     fn,
     unconditionalSetStateFunctions,
   );
-  for (const detail of errors.details) {
-    fn.env.recordError(detail);
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
   }
 }
 

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidatePreservedManualMemoization.ts

@@ -27,7 +27,6 @@ import {
   ScopeId,
   SourceLocation,
 } from '../HIR';
-import {Environment} from '../HIR/Environment';
 import {printIdentifier, printManualMemoDependency} from '../HIR/PrintHIR';
 import {
   eachInstructionValueLValue,
@@ -49,10 +48,13 @@ import {getOrInsertDefault} from '../Utils/utils';
  */
 export function validatePreservedManualMemoization(fn: ReactiveFunction): void {
   const state = {
-    env: fn.env,
+    errors: new CompilerError(),
     manualMemoState: null,
   };
   visitReactiveFunction(fn, new Visitor(), state);
+  for (const detail of state.errors.details) {
+    fn.env.recordError(detail);
+  }
 }
 
 const DEBUG = false;
@@ -110,7 +112,7 @@ type ManualMemoBlockState = {
 };
 
 type VisitorState = {
-  env: Environment;
+  errors: CompilerError;
   manualMemoState: ManualMemoBlockState | null;
 };
 
@@ -230,7 +232,7 @@ function validateInferredDep(
   temporaries: Map<IdentifierId, ManualMemoDependency>,
   declsWithinMemoBlock: Set<DeclarationId>,
   validDepsInMemoBlock: Array<ManualMemoDependency>,
-  env: Environment,
+  errorState: CompilerError,
   memoLocation: SourceLocation,
 ): void {
   let normalizedDep: ManualMemoDependency;
@@ -280,7 +282,7 @@ function validateInferredDep(
       errorDiagnostic = merge(errorDiagnostic ?? compareResult, compareResult);
     }
   }
-  env.recordError(
+  errorState.pushDiagnostic(
     CompilerDiagnostic.create({
       category: ErrorCategory.PreserveManualMemo,
       reason: 'Existing memoization could not be preserved',
@@ -426,7 +428,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           this.temporaries,
           state.manualMemoState.decls,
           state.manualMemoState.depsFromSource,
-          state.env,
+          state.errors,
           state.manualMemoState.loc,
         );
       }
@@ -529,7 +531,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           !this.scopes.has(identifier.scope.id) &&
           !this.prunedScopes.has(identifier.scope.id)
         ) {
-          state.env.recordError(
+          state.errors.pushDiagnostic(
             CompilerDiagnostic.create({
               category: ErrorCategory.PreserveManualMemo,
               reason: 'Existing memoization could not be preserved',
@@ -575,7 +577,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
 
           for (const identifier of decls) {
             if (isUnmemoized(identifier, this.scopes)) {
-              state.env.recordError(
+              state.errors.pushDiagnostic(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.PreserveManualMemo,
                   reason: 'Existing memoization could not be preserved',

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateSourceLocations.ts

@@ -7,7 +7,7 @@
 
 import {NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerDiagnostic, ErrorCategory} from '..';
+import {CompilerDiagnostic, CompilerError, ErrorCategory} from '..';
 import {CodegenFunction} from '../ReactiveScopes';
 import {Environment} from '../HIR/Environment';
 
@@ -125,6 +125,8 @@ export function validateSourceLocations(
   generatedAst: CodegenFunction,
   env: Environment,
 ): void {
+  const errors = new CompilerError();
+
   /*
    * Step 1: Collect important locations from the original source
    * Note: Multiple node types can share the same location (e.g. VariableDeclarator and Identifier)
@@ -239,7 +241,7 @@ export function validateSourceLocations(
     loc: t.SourceLocation,
     nodeType: string,
   ): void => {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.Todo,
         reason: 'Important source location missing in generated code',
@@ -259,7 +261,7 @@ export function validateSourceLocations(
     expectedType: string,
     actualTypes: Set<string>,
   ): void => {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.Todo,
         reason:
@@ -307,4 +309,8 @@ export function validateSourceLocations(
       }
     }
   }
+
+  for (const detail of errors.details) {
+    env.recordError(detail);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateUseMemo.ts

@@ -16,13 +16,13 @@ import {
   IdentifierId,
   SourceLocation,
 } from '../HIR';
-import {Environment} from '../HIR/Environment';
 import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
 
 export function validateUseMemo(fn: HIRFunction): void {
+  const errors = new CompilerError();
   const voidMemoErrors = new CompilerError();
   const useMemos = new Set<IdentifierId>();
   const react = new Set<IdentifierId>();
@@ -90,7 +90,7 @@ export function validateUseMemo(fn: HIRFunction): void {
               firstParam.kind === 'Identifier'
                 ? firstParam.loc
                 : firstParam.place.loc;
-            fn.env.recordError(
+            errors.pushDiagnostic(
               CompilerDiagnostic.create({
                 category: ErrorCategory.UseMemo,
                 reason: 'useMemo() callbacks may not accept parameters',
@@ -106,7 +106,7 @@ export function validateUseMemo(fn: HIRFunction): void {
           }
 
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
-            fn.env.recordError(
+            errors.pushDiagnostic(
               CompilerDiagnostic.create({
                 category: ErrorCategory.UseMemo,
                 reason:
@@ -122,7 +122,7 @@ export function validateUseMemo(fn: HIRFunction): void {
             );
           }
 
-          validateNoContextVariableAssignment(body.loweredFunc.func, fn.env);
+          validateNoContextVariableAssignment(body.loweredFunc.func, errors);
 
           if (fn.env.config.validateNoVoidUseMemo) {
             if (!hasNonVoidReturn(body.loweredFunc.func)) {
@@ -176,11 +176,14 @@ export function validateUseMemo(fn: HIRFunction): void {
     }
   }
   fn.env.logErrors(voidMemoErrors.asResult());
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }
 
 function validateNoContextVariableAssignment(
   fn: HIRFunction,
-  env: Environment,
+  errors: CompilerError,
 ): void {
   const context = new Set(fn.context.map(place => place.identifier.id));
   for (const block of fn.body.blocks.values()) {
@@ -189,7 +192,7 @@ function validateNoContextVariableAssignment(
       switch (value.kind) {
         case 'StoreContext': {
           if (context.has(value.lvalue.place.identifier.id)) {
-            env.recordError(
+            errors.pushDiagnostic(
               CompilerDiagnostic.create({
                 category: ErrorCategory.UseMemo,
                 reason:

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ecma/error.reserved-words.expect.md

@@ -24,9 +24,18 @@ function useThing(fn) {
 ```
 Found 1 error:
 
-Error: Expected a non-reserved identifier name
+Compilation Skipped: `this` is not supported syntax
 
-`this` is a reserved word in JavaScript and cannot be used as an identifier name.
+React Compiler does not support compiling functions that use `this`.
+
+error.reserved-words.ts:8:28
+   6 |
+   7 |   if (ref.current === null) {
+>  8 |     ref.current = function (this: unknown, ...args) {
+     |                             ^^^^^^^^^^^^^ `this` was used here
+   9 |       return fnRef.current.call(this, ...args);
+  10 |     };
+  11 |   }
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error._todo.computed-lval-in-destructure.expect.md

@@ -17,17 +17,16 @@ function Component(props) {
 ```
 Found 1 error:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
 
-<unknown> x$8.
-
-error._todo.computed-lval-in-destructure.ts:5:9
-  3 |   const {[computedKey]: x} = props.val;
+error._todo.computed-lval-in-destructure.ts:3:9
+  1 | function Component(props) {
+  2 |   const computedKey = props.key;
+> 3 |   const {[computedKey]: x} = props.val;
+    |          ^^^^^^^^^^^^^^^^ (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
   4 |
-> 5 |   return x;
-    |          ^ this is uninitialized
+  5 |   return x;
   6 | }
-  7 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-impure-functions-in-render.expect.md

@@ -17,7 +17,7 @@ function Component() {
 ## Error
 
 ```
-Found 6 errors:
+Found 3 errors:
 
 Error: Cannot call impure function during render
 
@@ -57,45 +57,6 @@ error.invalid-impure-functions-in-render.ts:6:15
   7 |   return <Foo date={date} now={now} rand={rand} />;
   8 | }
   9 |
-
-Error: Cannot call impure function during render
-
-`Date.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:4:15
-  2 |
-  3 | function Component() {
-> 4 |   const date = Date.now();
-    |                ^^^^^^^^ Cannot call impure function
-  5 |   const now = performance.now();
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-
-Error: Cannot call impure function during render
-
-`performance.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:5:14
-  3 | function Component() {
-  4 |   const date = Date.now();
-> 5 |   const now = performance.now();
-    |               ^^^^^^^^^^^^^^^ Cannot call impure function
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-
-Error: Cannot call impure function during render
-
-`Math.random` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:6:15
-  4 |   const date = Date.now();
-  5 |   const now = performance.now();
-> 6 |   const rand = Math.random();
-    |                ^^^^^^^^^^^ Cannot call impure function
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-  9 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-hoisted-function-in-unreachable-code.expect.md

@@ -18,18 +18,15 @@ function Component() {
 ```
 Found 1 error:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: Support functions with unreachable code that may contain hoisted declarations
 
-<unknown> Foo$0.
-
-error.todo-hoisted-function-in-unreachable-code.ts:3:10
-  1 | // @compilationMode:"infer"
-  2 | function Component() {
-> 3 |   return <Foo />;
-    |           ^^^ this is uninitialized
+error.todo-hoisted-function-in-unreachable-code.ts:6:2
   4 |
   5 |   // This is unreachable from a control-flow perspective, but it gets hoisted
-  6 |   function Foo() {}
+> 6 |   function Foo() {}
+    |   ^^^^^^^^^^^^^^^^^ Support functions with unreachable code that may contain hoisted declarations
+  7 | }
+  8 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-kitchensink.expect.md

@@ -79,11 +79,43 @@ let moduleLocal = false;
 ## Error
 
 ```
-Found 1 error:
+Found 10 errors:
 
-Invariant: Expected a variable declaration
+Todo: (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
 
-Got ExpressionStatement.
+error.todo-kitchensink.ts:3:2
+  1 | function foo([a, b], {c, d, e = 'e'}, f = 'f', ...args) {
+  2 |   let i = 0;
+> 3 |   var x = [];
+    |   ^^^^^^^^^^^ (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
+  4 |
+  5 |   class Bar {
+  6 |     #secretSauce = 42;
+
+Compilation Skipped: Inline `class` declarations are not supported
+
+Move class declarations outside of components/hooks.
+
+error.todo-kitchensink.ts:5:2
+   3 |   var x = [];
+   4 |
+>  5 |   class Bar {
+     |   ^^^^^^^^^^^
+>  6 |     #secretSauce = 42;
+     | ^^^^^^^^^^^^^^^^^^^^^^
+>  7 |     constructor() {
+     | ^^^^^^^^^^^^^^^^^^^^^^
+>  8 |       console.log(this.#secretSauce);
+     | ^^^^^^^^^^^^^^^^^^^^^^
+>  9 |     }
+     | ^^^^^^^^^^^^^^^^^^^^^^
+> 10 |   }
+     | ^^^^ Inline `class` declarations are not supported
+  11 |
+  12 |   const g = {b() {}, c: () => {}};
+  13 |   const {z, aa = 'aa'} = useCustom();
+
+Todo: (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
 
 error.todo-kitchensink.ts:20:2
   18 |   const j = function bar([quz, qux], ...args) {};
@@ -93,10 +125,103 @@ error.todo-kitchensink.ts:20:2
 > 21 |     x.push(i);
      | ^^^^^^^^^^^^^^
 > 22 |   }
-     | ^^^^ Expected a variable declaration
+     | ^^^^ (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
   23 |   for (; i < 3; ) {
   24 |     break;
   25 |   }
+
+Todo: (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+
+error.todo-kitchensink.ts:23:2
+  21 |     x.push(i);
+  22 |   }
+> 23 |   for (; i < 3; ) {
+     |   ^^^^^^^^^^^^^^^^^
+> 24 |     break;
+     | ^^^^^^^^^^
+> 25 |   }
+     | ^^^^ (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+  26 |   for (;;) {
+  27 |     break;
+  28 |   }
+
+Todo: (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+
+error.todo-kitchensink.ts:26:2
+  24 |     break;
+  25 |   }
+> 26 |   for (;;) {
+     |   ^^^^^^^^^^
+> 27 |     break;
+     | ^^^^^^^^^^
+> 28 |   }
+     | ^^^^ (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+  29 |
+  30 |   graphql`
+  31 |     ${g}
+
+Todo: (BuildHIR::lowerStatement) Handle empty test in ForStatement
+
+error.todo-kitchensink.ts:26:2
+  24 |     break;
+  25 |   }
+> 26 |   for (;;) {
+     |   ^^^^^^^^^^
+> 27 |     break;
+     | ^^^^^^^^^^
+> 28 |   }
+     | ^^^^ (BuildHIR::lowerStatement) Handle empty test in ForStatement
+  29 |
+  30 |   graphql`
+  31 |     ${g}
+
+Todo: (BuildHIR::lowerExpression) Handle tagged template with interpolations
+
+error.todo-kitchensink.ts:30:2
+  28 |   }
+  29 |
+> 30 |   graphql`
+     |   ^^^^^^^^
+> 31 |     ${g}
+     | ^^^^^^^^
+> 32 |   `;
+     | ^^^^ (BuildHIR::lowerExpression) Handle tagged template with interpolations
+  33 |
+  34 |   graphql`\\t\n`;
+  35 |
+
+Todo: (BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value
+
+error.todo-kitchensink.ts:34:2
+  32 |   `;
+  33 |
+> 34 |   graphql`\\t\n`;
+     |   ^^^^^^^^^^^^^^ (BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value
+  35 |
+  36 |   for (c of [1, 2]) {
+  37 |   }
+
+Todo: (BuildHIR::node.lowerReorderableExpression) Expression type `MemberExpression` cannot be safely reordered
+
+error.todo-kitchensink.ts:57:9
+  55 |     case foo(): {
+  56 |     }
+> 57 |     case x.y: {
+     |          ^^^ (BuildHIR::node.lowerReorderableExpression) Expression type `MemberExpression` cannot be safely reordered
+  58 |     }
+  59 |     default: {
+  60 |     }
+
+Todo: (BuildHIR::node.lowerReorderableExpression) Expression type `BinaryExpression` cannot be safely reordered
+
+error.todo-kitchensink.ts:53:9
+  51 |
+  52 |   switch (i) {
+> 53 |     case 1 + 1: {
+     |          ^^^^^ (BuildHIR::node.lowerReorderableExpression) Expression type `BinaryExpression` cannot be safely reordered
+  54 |     }
+  55 |     case foo(): {
+  56 |     }
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-optional-call-chain-in-optional.expect.md

@@ -0,0 +1,39 @@
+
+## Input
+
+```javascript
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return createArray(value?.x, value?.y)?.join(', ');
+}
+
+function createArray<T>(...args: Array<T>): Array<T> {
+  return args;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Todo: Unexpected terminal kind `optional` for optional fallthrough block
+
+error.todo-optional-call-chain-in-optional.ts:3:21
+  1 | function useFoo(props: {value: {x: string; y: string} | null}) {
+  2 |   const value = props.value;
+> 3 |   return createArray(value?.x, value?.y)?.join(', ');
+    |                      ^^^^^^^^ Unexpected terminal kind `optional` for optional fallthrough block
+  4 | }
+  5 |
+  6 | function createArray<T>(...args: Array<T>): Array<T> {
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useMemo-callback-generator.expect.md

@@ -18,7 +18,7 @@ function component(a, b) {
 ## Error
 
 ```
-Found 2 errors:
+Found 1 error:
 
 Todo: (BuildHIR::lowerExpression) Handle YieldExpression expressions
 
@@ -30,23 +30,6 @@ error.useMemo-callback-generator.ts:6:4
   7 |   }, []);
   8 |   return x;
   9 | }
-
-Error: useMemo() callbacks may not be async or generator functions
-
-useMemo() callbacks are called once and must synchronously return a value.
-
-error.useMemo-callback-generator.ts:5:18
-   3 |   // useful for now, but adding this test in case we do
-   4 |   // add support for generators in the future.
->  5 |   let x = useMemo(function* () {
-     |                   ^^^^^^^^^^^^^^
->  6 |     yield a;
-     | ^^^^^^^^^^^^
->  7 |   }, []);
-     | ^^^^ Async and generator functions are not supported
-   8 |   return x;
-   9 | }
-  10 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-mutation-of-props.expect.md

@@ -1,66 +0,0 @@
-
-## Input
-
-```javascript
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    doCleanup();
-  }
-
-  // Error: mutating frozen props
-  props.value = 1;
-
-  return <div>{props.value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-
-error.try-finally-and-mutation-of-props.ts:9:2
-   7 | function Component(props) {
-   8 |   // Error: try/finally (Todo from BuildHIR)
->  9 |   try {
-     |   ^^^^^
-> 10 |     doWork();
-     | ^^^^^^^^^^^^^
-> 11 |   } finally {
-     | ^^^^^^^^^^^^^
-> 12 |     doCleanup();
-     | ^^^^^^^^^^^^^
-> 13 |   }
-     | ^^^^ (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-  14 |
-  15 |   // Error: mutating frozen props
-  16 |   props.value = 1;
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.try-finally-and-mutation-of-props.ts:16:2
-  14 |
-  15 |   // Error: mutating frozen props
-> 16 |   props.value = 1;
-     |   ^^^^^ value cannot be modified
-  17 |
-  18 |   return <div>{props.value}</div>;
-  19 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-mutation-of-props.js

@@ -1,19 +0,0 @@
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    doCleanup();
-  }
-
-  // Error: mutating frozen props
-  props.value = 1;
-
-  return <div>{props.value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-ref-access.expect.md

@@ -1,69 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doSomething();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return <div>{value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-
-error.try-finally-and-ref-access.ts:12:2
-  10 |
-  11 |   // Error: try/finally (Todo from BuildHIR)
-> 12 |   try {
-     |   ^^^^^
-> 13 |     doSomething();
-     | ^^^^^^^^^^^^^^^^^^
-> 14 |   } finally {
-     | ^^^^^^^^^^^^^^^^^^
-> 15 |     cleanup();
-     | ^^^^^^^^^^^^^^^^^^
-> 16 |   }
-     | ^^^^ (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-  17 |
-  18 |   // Error: reading ref during render
-  19 |   const value = ref.current;
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.try-finally-and-ref-access.ts:19:16
-  17 |
-  18 |   // Error: reading ref during render
-> 19 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  20 |
-  21 |   return <div>{value}</div>;
-  22 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-ref-access.js

@@ -1,22 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doSomething();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return <div>{value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-ref-access-and-mutation.expect.md

@@ -1,86 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: three independent errors should all be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- * Error 3 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  // Error: mutating frozen props
-  props.items = [];
-
-  return <div>{value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 3 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-
-error.try-finally-ref-access-and-mutation.ts:13:2
-  11 |
-  12 |   // Error: try/finally (Todo from BuildHIR)
-> 13 |   try {
-     |   ^^^^^
-> 14 |     doWork();
-     | ^^^^^^^^^^^^^
-> 15 |   } finally {
-     | ^^^^^^^^^^^^^
-> 16 |     cleanup();
-     | ^^^^^^^^^^^^^
-> 17 |   }
-     | ^^^^ (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-  18 |
-  19 |   // Error: reading ref during render
-  20 |   const value = ref.current;
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.try-finally-ref-access-and-mutation.ts:23:2
-  21 |
-  22 |   // Error: mutating frozen props
-> 23 |   props.items = [];
-     |   ^^^^^ value cannot be modified
-  24 |
-  25 |   return <div>{value}</div>;
-  26 | }
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.try-finally-ref-access-and-mutation.ts:20:16
-  18 |
-  19 |   // Error: reading ref during render
-> 20 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  21 |
-  22 |   // Error: mutating frozen props
-  23 |   props.items = [];
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-ref-access-and-mutation.js

@@ -1,26 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: three independent errors should all be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- * Error 3 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  // Error: mutating frozen props
-  props.items = [];
-
-  return <div>{value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-mutation-of-props.expect.md

@@ -1,54 +0,0 @@
-
-## Input
-
-```javascript
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: var declaration (Todo from BuildHIR)
-  var items = props.items;
-
-  // Error: mutating frozen props (detected during inference)
-  props.items = [];
-
-  return <div>{items.length}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-
-error.var-declaration-and-mutation-of-props.ts:9:2
-   7 | function Component(props) {
-   8 |   // Error: var declaration (Todo from BuildHIR)
->  9 |   var items = props.items;
-     |   ^^^^^^^^^^^^^^^^^^^^^^^^ (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-  10 |
-  11 |   // Error: mutating frozen props (detected during inference)
-  12 |   props.items = [];
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.var-declaration-and-mutation-of-props.ts:12:2
-  10 |
-  11 |   // Error: mutating frozen props (detected during inference)
-> 12 |   props.items = [];
-     |   ^^^^^ value cannot be modified
-  13 |
-  14 |   return <div>{items.length}</div>;
-  15 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-mutation-of-props.js

@@ -1,15 +0,0 @@
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: var declaration (Todo from BuildHIR)
-  var items = props.items;
-
-  // Error: mutating frozen props (detected during inference)
-  props.items = [];
-
-  return <div>{items.length}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-ref-access.expect.md

@@ -1,62 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: var declaration (Todo from BuildHIR)
-  var items = [1, 2, 3];
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return (
-    <div>
-      {value}
-      {items.length}
-    </div>
-  );
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-
-error.var-declaration-and-ref-access.ts:12:2
-  10 |
-  11 |   // Error: var declaration (Todo from BuildHIR)
-> 12 |   var items = [1, 2, 3];
-     |   ^^^^^^^^^^^^^^^^^^^^^^ (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-  13 |
-  14 |   // Error: reading ref during render
-  15 |   const value = ref.current;
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.var-declaration-and-ref-access.ts:15:16
-  13 |
-  14 |   // Error: reading ref during render
-> 15 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  16 |
-  17 |   return (
-  18 |     <div>
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-ref-access.js

@@ -1,23 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: var declaration (Todo from BuildHIR)
-  var items = [1, 2, 3];
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return (
-    <div>
-      {value}
-      {items.length}
-    </div>
-  );
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fbt/error.todo-fbt-as-local.expect.md

@@ -50,7 +50,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Error
 
 ```
-Found 4 errors:
+Found 1 error:
 
 Todo: Support local variables named `fbt`
 
@@ -60,49 +60,10 @@ error.todo-fbt-as-local.ts:18:19
   16 |
   17 | function Foo(props) {
 > 18 |   const getText1 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
+     |                    ^^^ Rename to avoid conflict with fbt plugin
   19 |     fbt(
   20 |       `Hello, ${fbt.param('(key) name', identity(props.name))}!`,
   21 |       '(description) Greeting'
-
-Todo: Support local variables named `fbt`
-
-Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
-
-error.todo-fbt-as-local.ts:18:19
-  16 |
-  17 | function Foo(props) {
-> 18 |   const getText1 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
-  19 |     fbt(
-  20 |       `Hello, ${fbt.param('(key) name', identity(props.name))}!`,
-  21 |       '(description) Greeting'
-
-Todo: Support local variables named `fbt`
-
-Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
-
-error.todo-fbt-as-local.ts:18:19
-  16 |
-  17 | function Foo(props) {
-> 18 |   const getText1 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
-  19 |     fbt(
-  20 |       `Hello, ${fbt.param('(key) name', identity(props.name))}!`,
-  21 |       '(description) Greeting'
-
-Todo: Support local variables named `fbt`
-
-Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
-
-error.todo-fbt-as-local.ts:24:19
-  22 |     );
-  23 |
-> 24 |   const getText2 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
-  25 |     fbt(
-  26 |       `Goodbye, ${fbt.param('(key) name', identity(props.name))}!`,
-  27 |       '(description) Greeting2'
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fbt/error.todo-locally-require-fbt.expect.md

@@ -16,15 +16,17 @@ function Component(props) {
 ```
 Found 1 error:
 
-Invariant: <fbt> tags should be module-level imports
+Todo: Support local variables named `fbt`
 
-error.todo-locally-require-fbt.ts:4:10
-  2 |   const fbt = require('fbt');
+Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
+
+error.todo-locally-require-fbt.ts:2:8
+  1 | function Component(props) {
+> 2 |   const fbt = require('fbt');
+    |         ^^^ Rename to avoid conflict with fbt plugin
   3 |
-> 4 |   return <fbt desc="Description">{'Text'}</fbt>;
-    |           ^^^ <fbt> tags should be module-level imports
+  4 |   return <fbt desc="Description">{'Text'}</fbt>;
   5 | }
-  6 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-bailout-nopanic.expect.md

@@ -58,7 +58,6 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","detail":{"options":{"category":"PreserveManualMemo","reason":"Existing memoization could not be preserved","description":"React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected. The inferred dependency was `value`, but the source dependencies were []. Inferred dependency not present in source","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":9,"column":31,"index":337},"end":{"line":9,"column":52,"index":358},"filename":"dynamic-gating-bailout-nopanic.ts"},"message":"Could not preserve existing manual memoization"}]}},"fnLoc":null}
 {"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":255},"end":{"line":16,"column":1,"index":482},"filename":"dynamic-gating-bailout-nopanic.ts"},"detail":{"options":{"category":"PreserveManualMemo","reason":"Existing memoization could not be preserved","description":"React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected. The inferred dependency was `value`, but the source dependencies were []. Inferred dependency not present in source","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":9,"column":31,"index":337},"end":{"line":9,"column":52,"index":358},"filename":"dynamic-gating-bailout-nopanic.ts"},"message":"Could not preserve existing manual memoization"}]}}}
 ```
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/new-mutability/error.invalid-impure-functions-in-render.expect.md

@@ -17,7 +17,7 @@ function Component() {
 ## Error
 
 ```
-Found 6 errors:
+Found 3 errors:
 
 Error: Cannot call impure function during render
 
@@ -57,45 +57,6 @@ error.invalid-impure-functions-in-render.ts:6:15
   7 |   return <Foo date={date} now={now} rand={rand} />;
   8 | }
   9 |
-
-Error: Cannot call impure function during render
-
-`Date.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:4:15
-  2 |
-  3 | function Component() {
-> 4 |   const date = Date.now();
-    |                ^^^^^^^^ Cannot call impure function
-  5 |   const now = performance.now();
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-
-Error: Cannot call impure function during render
-
-`performance.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:5:14
-  3 | function Component() {
-  4 |   const date = Date.now();
-> 5 |   const now = performance.now();
-    |               ^^^^^^^^^^^^^^^ Cannot call impure function
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-
-Error: Cannot call impure function during render
-
-`Math.random` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:6:15
-  4 |   const date = Date.now();
-  5 |   const now = performance.now();
-> 6 |   const rand = Math.random();
-    |                ^^^^^^^^^^^ Cannot call impure function
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-  9 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/propagate-scope-deps-hir-fork/error.todo-optional-call-chain-in-optional.expect.md

@@ -0,0 +1,40 @@
+
+## Input
+
+```javascript
+// @enablePropagateDepsInHIR
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return createArray(value?.x, value?.y)?.join(', ');
+}
+
+function createArray<T>(...args: Array<T>): Array<T> {
+  return args;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Todo: Unexpected terminal kind `optional` for optional fallthrough block
+
+error.todo-optional-call-chain-in-optional.ts:4:21
+  2 | function useFoo(props: {value: {x: string; y: string} | null}) {
+  3 |   const value = props.value;
+> 4 |   return createArray(value?.x, value?.y)?.join(', ');
+    |                      ^^^^^^^^ Unexpected terminal kind `optional` for optional fallthrough block
+  5 | }
+  6 |
+  7 | function createArray<T>(...args: Array<T>): Array<T> {
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/propagate-scope-deps-hir-fork/todo-optional-call-chain-in-optional.expect.md

@@ -1,54 +0,0 @@
-
-## Input
-
-```javascript
-// @enablePropagateDepsInHIR
-function useFoo(props: {value: {x: string; y: string} | null}) {
-  const value = props.value;
-  return createArray(value?.x, value?.y)?.join(', ');
-}
-
-function createArray<T>(...args: Array<T>): Array<T> {
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{value: null}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enablePropagateDepsInHIR
-function useFoo(props) {
-  const $ = _c(3);
-  const value = props.value;
-  let t0;
-  if ($[0] !== value?.x || $[1] !== value?.y) {
-    t0 = createArray(value?.x, value?.y)?.join(", ");
-    $[0] = value?.x;
-    $[1] = value?.y;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  return t0;
-}
-
-function createArray(...t0) {
-  const args = t0;
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{ value: null }],
-};
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/todo-optional-call-chain-in-optional.expect.md

@@ -1,53 +0,0 @@
-
-## Input
-
-```javascript
-function useFoo(props: {value: {x: string; y: string} | null}) {
-  const value = props.value;
-  return createArray(value?.x, value?.y)?.join(', ');
-}
-
-function createArray<T>(...args: Array<T>): Array<T> {
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{value: null}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-function useFoo(props) {
-  const $ = _c(3);
-  const value = props.value;
-  let t0;
-  if ($[0] !== value?.x || $[1] !== value?.y) {
-    t0 = createArray(value?.x, value?.y)?.join(", ");
-    $[0] = value?.x;
-    $[1] = value?.y;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  return t0;
-}
-
-function createArray(...t0) {
-  const args = t0;
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{ value: null }],
-};
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/todo.error.object-pattern-computed-key.expect.md

@@ -23,18 +23,16 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
 
-<unknown> value$3.
-
-todo.error.object-pattern-computed-key.ts:6:9
+todo.error.object-pattern-computed-key.ts:5:9
+  3 | const SCALE = 2;
   4 | function Component(props) {
-  5 |   const {[props.name]: value} = props;
-> 6 |   return value;
-    |          ^^^^^ this is uninitialized
+> 5 |   const {[props.name]: value} = props;
+    |          ^^^^^^^^^^^^^^^^^^^ (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
+  6 |   return value;
   7 | }
   8 |
-  9 | export const FIXTURE_ENTRYPOINT = {
 ```
           
       

compiler/packages/eslint-plugin-react-compiler/__tests__/NoCapitalizedCallsRule-test.ts

@@ -64,6 +64,9 @@ testRule(
           makeTestCaseError(
             'Capitalized functions are reserved for components',
           ),
+          makeTestCaseError(
+            'Capitalized functions are reserved for components',
+          ),
         ],
       },
     ],

compiler/packages/eslint-plugin-react-compiler/__tests__/PluginTest-test.ts

@@ -57,7 +57,6 @@ testRule('plugin-recommended', TestRecommendedRules, {
   ],
   invalid: [
     {
-      // TODO: actually return multiple diagnostics in this case
       name: 'Multiple diagnostic kinds from the same function are surfaced',
       code: normalizeIndent`
         import Child from './Child';
@@ -70,6 +69,7 @@ testRule('plugin-recommended', TestRecommendedRules, {
       `,
       errors: [
         makeTestCaseError('Hooks must always be called in a consistent order'),
+        makeTestCaseError('Capitalized functions are reserved for components'),
       ],
     },
     {
@@ -128,6 +128,7 @@ testRule('plugin-recommended', TestRecommendedRules, {
         makeTestCaseError(
           'Calling setState from useMemo may trigger an infinite loop',
         ),
+        makeTestCaseError('Found extra memoization dependencies'),
       ],
     },
   ],

compiler/packages/snap/src/compiler.ts

@@ -378,17 +378,6 @@ export async function transformFixtureInput(
       msg: 'Expected nothing to be compiled (from `// @expectNothingCompiled`), but some functions compiled or errored',
     };
   }
-  const unexpectedThrows = logs.filter(
-    log => log.event.kind === 'CompileUnexpectedThrow',
-  );
-  if (unexpectedThrows.length > 0) {
-    return {
-      kind: 'err',
-      msg:
-        `Compiler pass(es) threw instead of recording errors:\n` +
-        unexpectedThrows.map(l => (l.event as any).data).join('\n'),
-    };
-  }
   return {
     kind: 'ok',
     value: {

packages/react-reconciler/src/ReactFiberBeginWork.js

@@ -3991,9 +3991,23 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
         // whether to retry the primary children, or to skip over it and
         // go straight to the fallback. Check the priority of the primary
         // child fragment.
+        //
+        // Propagate context changes first. If a parent context changed
+        // and the primary children's consumer fibers were discarded
+        // during initial mount suspension, normal propagation can't find
+        // them. In that case we conservatively retry the boundary — the
+        // re-mounted children will read the updated context value.
+        const contextChanged = lazilyPropagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+        );
         const primaryChildFragment: Fiber = (workInProgress.child: any);
         const primaryChildLanes = primaryChildFragment.childLanes;
-        if (includesSomeLane(renderLanes, primaryChildLanes)) {
+        if (
+          contextChanged ||
+          includesSomeLane(renderLanes, primaryChildLanes)
+        ) {
           // The primary children have pending work. Use the normal path
           // to attempt to render the primary children again.
           return updateSuspenseComponent(current, workInProgress, renderLanes);

packages/react-reconciler/src/ReactFiberNewContext.js

@@ -20,7 +20,11 @@ import type {Hook} from './ReactFiberHooks';
 
 import {isPrimaryRenderer, HostTransitionContext} from './ReactFiberConfig';
 import {createCursor, push, pop} from './ReactFiberStack';
-import {ContextProvider, DehydratedFragment} from './ReactWorkTags';
+import {
+  ContextProvider,
+  DehydratedFragment,
+  SuspenseComponent,
+} from './ReactWorkTags';
 import {NoLanes, isSubsetOfLanes, mergeLanes} from './ReactFiberLane';
 import {
   NoFlags,
@@ -295,6 +299,37 @@ function propagateContextChanges<T>(
         workInProgress,
       );
       nextFiber = null;
+    } else if (
+      fiber.tag === SuspenseComponent &&
+      fiber.memoizedState !== null &&
+      fiber.memoizedState.dehydrated === null
+    ) {
+      // This is a client-rendered Suspense boundary that is currently
+      // showing its fallback. The primary children may include context
+      // consumers, but their fibers may not exist in the tree — during
+      // initial mount, if the primary children suspended, their fibers
+      // were discarded since there was no current tree to preserve them.
+      // We can't walk into the primary tree to find consumers, so
+      // conservatively mark the Suspense boundary itself for retry.
+      // When it re-renders, it will re-mount the primary children,
+      // which will read the updated context value.
+      fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+      const alternate = fiber.alternate;
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      }
+      scheduleContextWorkOnParentPath(
+        fiber.return,
+        renderLanes,
+        workInProgress,
+      );
+      if (!forcePropagateEntireTree) {
+        // During lazy propagation, we can defer propagating changes to
+        // the children, same as the consumer match above.
+        nextFiber = null;
+      } else {
+        nextFiber = fiber.child;
+      }
     } else {
       // Traverse down.
       nextFiber = fiber.child;
@@ -331,9 +366,9 @@ export function lazilyPropagateParentContextChanges(
   current: Fiber,
   workInProgress: Fiber,
   renderLanes: Lanes,
-) {
+): boolean {
   const forcePropagateEntireTree = false;
-  propagateParentContextChanges(
+  return propagateParentContextChanges(
     current,
     workInProgress,
     renderLanes,
@@ -364,7 +399,7 @@ function propagateParentContextChanges(
   workInProgress: Fiber,
   renderLanes: Lanes,
   forcePropagateEntireTree: boolean,
-) {
+): boolean {
   // Collect all the parent providers that changed. Since this is usually small
   // number, we use an Array instead of Set.
   let contexts = null;
@@ -460,6 +495,7 @@ function propagateParentContextChanges(
   // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
   // Consider this as part of the next refactor to the fiber tree structure.
   workInProgress.flags |= DidPropagateContext;
+  return contexts !== null;
 }
 
 export function checkIfContextChanged(

packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js

@@ -2,6 +2,7 @@ let React;
 let ReactNoop;
 let Scheduler;
 let act;
+let use;
 let useState;
 let useContext;
 let Suspense;
@@ -19,6 +20,7 @@ describe('ReactLazyContextPropagation', () => {
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
     act = require('internal-test-utils').act;
+    use = React.use;
     useState = React.useState;
     useContext = React.useContext;
     Suspense = React.Suspense;
@@ -937,4 +939,102 @@ describe('ReactLazyContextPropagation', () => {
     assertLog(['B', 'B']);
     expect(root).toMatchRenderedOutput('BB');
   });
+
+  it('regression: context change triggers retry of suspended Suspense boundary on initial mount', async () => {
+    // Regression test for a bug where a context change above a suspended
+    // Suspense boundary would fail to trigger a retry. When a Suspense
+    // boundary suspends during initial mount, the primary children's fibers
+    // are discarded because there is no current tree to preserve them. If
+    // the suspended promise never resolves, the only way to retry is
+    // something external — like a context change. Context propagation must
+    // mark suspended Suspense boundaries for retry even though the consumer
+    // fibers no longer exist in the tree.
+    //
+    // The Provider component owns the state update. The children are
+    // passed in from above, so they are not re-created when the Provider
+    // re-renders — this means the Suspense boundary bails out, exercising
+    // the lazy context propagation path where the bug manifests.
+    const Context = React.createContext(null);
+    const neverResolvingPromise = new Promise(() => {});
+    const resolvedThenable = {status: 'fulfilled', value: 'Result', then() {}};
+
+    function Consumer() {
+      return <Text text={use(use(Context))} />;
+    }
+
+    let setPromise;
+    function Provider({children}) {
+      const [promise, _setPromise] = useState(neverResolvingPromise);
+      setPromise = _setPromise;
+      return <Context.Provider value={promise}>{children}</Context.Provider>;
+    }
+
+    const root = ReactNoop.createRoot();
+    await act(() => {
+      root.render(
+        <Provider>
+          <Suspense fallback={<Text text="Loading" />}>
+            <Consumer />
+          </Suspense>
+        </Provider>,
+      );
+    });
+    assertLog(['Loading']);
+    expect(root).toMatchRenderedOutput('Loading');
+
+    await act(() => {
+      setPromise(resolvedThenable);
+    });
+    assertLog(['Result']);
+    expect(root).toMatchRenderedOutput('Result');
+  });
+
+  it('regression: context change triggers retry of suspended Suspense boundary on initial mount (nested)', async () => {
+    // Same as above, but with an additional indirection component between
+    // the provider and the Suspense boundary. This exercises the
+    // propagateContextChanges walker path rather than the
+    // propagateParentContextChanges path.
+    const Context = React.createContext(null);
+    const neverResolvingPromise = new Promise(() => {});
+    const resolvedThenable = {status: 'fulfilled', value: 'Result', then() {}};
+
+    function Consumer() {
+      return <Text text={use(use(Context))} />;
+    }
+
+    function Indirection({children}) {
+      Scheduler.log('Indirection');
+      return children;
+    }
+
+    let setPromise;
+    function Provider({children}) {
+      const [promise, _setPromise] = useState(neverResolvingPromise);
+      setPromise = _setPromise;
+      return <Context.Provider value={promise}>{children}</Context.Provider>;
+    }
+
+    const root = ReactNoop.createRoot();
+    await act(() => {
+      root.render(
+        <Provider>
+          <Indirection>
+            <Suspense fallback={<Text text="Loading" />}>
+              <Consumer />
+            </Suspense>
+          </Indirection>
+        </Provider>,
+      );
+    });
+    assertLog(['Indirection', 'Loading']);
+    expect(root).toMatchRenderedOutput('Loading');
+
+    // Indirection should not re-render — only the Suspense boundary
+    // should be retried.
+    await act(() => {
+      setPromise(resolvedThenable);
+    });
+    assertLog(['Result']);
+    expect(root).toMatchRenderedOutput('Result');
+  });
 });