[compiler] Add hint to name variables with "Ref" suffix

If you have a ref that the compiler doesn't know is a ref (say, a value returned from a custom hook) and try to assign its `.current = ...`, we currently fail with a generic error that hook return values are not mutable. However, an assignment to `.current` specifically is a very strong hint that the value is likely to be a ref. So in this PR, we track the reason for the mutation and if it ends up being an error, we use it to show an additional hint to the user. See the fixture for an example of the message.

.eslintignore

@@ -28,6 +28,3 @@ packages/react-devtools-shared/src/hooks/__tests__/__source__/__untransformed__/
 packages/react-devtools-shell/dist
 packages/react-devtools-timeline/dist
 packages/react-devtools-timeline/static
-
-# Imported third-party Flow types
-flow-typed/

.eslintrc.js

@@ -468,7 +468,6 @@ module.exports = {
       files: ['packages/react-server-dom-webpack/**/*.js'],
       globals: {
         __webpack_chunk_load__: 'readonly',
-        __webpack_get_script_filename__: 'readonly',
         __webpack_require__: 'readonly',
       },
     },
@@ -547,10 +546,13 @@ module.exports = {
   },
 
   globals: {
+    $Call: 'readonly',
+    $ElementType: 'readonly',
     $Flow$ModuleRef: 'readonly',
     $FlowFixMe: 'readonly',
     $Keys: 'readonly',
     $NonMaybeType: 'readonly',
+    $PropertyType: 'readonly',
     $ReadOnly: 'readonly',
     $ReadOnlyArray: 'readonly',
     $ArrayBufferView: 'readonly',
@@ -565,7 +567,6 @@ module.exports = {
     BigInt: 'readonly',
     BigInt64Array: 'readonly',
     BigUint64Array: 'readonly',
-    CacheType: 'readonly',
     Class: 'readonly',
     ClientRect: 'readonly',
     CopyInspectedElementPath: 'readonly',
@@ -580,15 +581,13 @@ module.exports = {
     IteratorResult: 'readonly',
     JSONValue: 'readonly',
     JSResourceReference: 'readonly',
-    mixin$Animatable: 'readonly',
     MouseEventHandler: 'readonly',
     NavigateEvent: 'readonly',
-    PerformanceMeasureOptions: 'readonly',
     PropagationPhases: 'readonly',
     PropertyDescriptor: 'readonly',
-    PropertyDescriptorMap: 'readonly',
-    Proxy$traps: 'readonly',
+    React$AbstractComponent: 'readonly',
     React$Component: 'readonly',
+    React$ComponentType: 'readonly',
     React$Config: 'readonly',
     React$Context: 'readonly',
     React$Element: 'readonly',
@@ -620,6 +619,7 @@ module.exports = {
     PropertyIndexedKeyframes: 'readonly',
     KeyframeAnimationOptions: 'readonly',
     GetAnimationsOptions: 'readonly',
+    Animatable: 'readonly',
     ScrollTimeline: 'readonly',
     EventListenerOptionsOrUseCapture: 'readonly',
     FocusOptions: 'readonly',

.github/workflows/compiler_playground.yml

@@ -57,6 +57,8 @@ jobs:
           key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
       - run: npx playwright install --with-deps chromium
         if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
+      - run: npx playwright install-deps
+        if: steps.cache_playwright_browsers.outputs.cache-hit == 'true'
       - run: CI=true yarn test
       - run: ls -R test-results
         if: '!cancelled()'

.github/workflows/runtime_build_and_test.yml

@@ -316,7 +316,7 @@ jobs:
         if: steps.node_modules.outputs.cache-hit != 'true'
       - run: ./scripts/react-compiler/build-compiler.sh && ./scripts/react-compiler/link-compiler.sh
       - run: yarn workspace eslint-plugin-react-hooks test
-
+        
   # ----- BUILD -----
   build_and_lint:
     name: yarn build and lint
@@ -811,18 +811,9 @@ jobs:
           pattern: _build_*
           path: build
           merge-multiple: true
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
-      - name: Playwright install deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-        run: npx playwright install --with-deps chromium
+      - run: |
+          npx playwright install
+          sudo npx playwright install-deps
       - run: ./scripts/ci/run_devtools_e2e_tests.js
         env:
           RELEASE_CHANNEL: experimental

.github/workflows/shared_close_direct_sync_branch_prs.yml

@@ -18,7 +18,6 @@ jobs:
     permissions:
       # Used to create a review and close PRs
       pull-requests: write
-      contents: write
     steps:
       - name: Close PR
         uses: actions/github-script@v7

babel.config-ts.js

@@ -8,7 +8,6 @@ module.exports = {
     '@babel/plugin-syntax-jsx',
     '@babel/plugin-transform-flow-strip-types',
     ['@babel/plugin-transform-class-properties', {loose: true}],
-    ['@babel/plugin-transform-private-methods', {loose: true}],
     '@babel/plugin-transform-classes',
   ],
   presets: [

compiler/apps/playground/components/Editor/ConfigEditor.tsx

@@ -1,103 +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 MonacoEditor, {loader, type Monaco} from '@monaco-editor/react';
-import {parseConfigPragmaAsString} from 'babel-plugin-react-compiler';
-import type {editor} from 'monaco-editor';
-import * as monaco from 'monaco-editor';
-import parserBabel from 'prettier/plugins/babel';
-import * as prettierPluginEstree from 'prettier/plugins/estree';
-import * as prettier from 'prettier/standalone';
-import {useState, useEffect} from 'react';
-import {Resizable} from 're-resizable';
-import {useStore} from '../StoreContext';
-import {monacoOptions} from './monacoOptions';
-
-loader.config({monaco});
-
-export default function ConfigEditor(): JSX.Element {
-  const [, setMonaco] = useState<Monaco | null>(null);
-  const store = useStore();
-
-  // Parse string-based override config from pragma comment and format it
-  const [configJavaScript, setConfigJavaScript] = useState('');
-
-  useEffect(() => {
-    const pragma = store.source.substring(0, store.source.indexOf('\n'));
-    const configString = `(${parseConfigPragmaAsString(pragma)})`;
-
-    prettier
-      .format(configString, {
-        semi: true,
-        parser: 'babel-ts',
-        plugins: [parserBabel, prettierPluginEstree],
-      })
-      .then(formatted => {
-        setConfigJavaScript(formatted);
-      })
-      .catch(error => {
-        console.error('Error formatting config:', error);
-        setConfigJavaScript('({})'); // Return empty object if not valid for now
-        //TODO: Add validation and error handling for config
-      });
-    console.log('Config:', configString);
-  }, [store.source]);
-
-  const handleChange: (value: string | undefined) => void = value => {
-    if (!value) return;
-
-    // TODO: Implement sync logic to update pragma comments in the source
-    console.log('Config changed:', value);
-  };
-
-  const handleMount: (
-    _: editor.IStandaloneCodeEditor,
-    monaco: Monaco,
-  ) => void = (_, monaco) => {
-    setMonaco(monaco);
-
-    const uri = monaco.Uri.parse(`file:///config.js`);
-    const model = monaco.editor.getModel(uri);
-    if (model) {
-      model.updateOptions({tabSize: 2});
-    }
-  };
-
-  return (
-    <div className="relative flex flex-col flex-none border-r border-gray-200">
-      <h2 className="p-4 duration-150 ease-in border-b cursor-default border-grey-200 font-light text-secondary">
-        Config Overrides
-      </h2>
-      <Resizable
-        minWidth={300}
-        maxWidth={600}
-        defaultSize={{width: 350, height: 'auto'}}
-        enable={{right: true}}
-        className="!h-[calc(100vh_-_3.5rem_-_4rem)]">
-        <MonacoEditor
-          path={'config.js'}
-          language={'javascript'}
-          value={configJavaScript}
-          onMount={handleMount}
-          onChange={handleChange}
-          options={{
-            ...monacoOptions,
-            readOnly: true,
-            lineNumbers: 'off',
-            folding: false,
-            renderLineHighlight: 'none',
-            scrollBeyondLastLine: false,
-            hideCursorInOverviewRuler: true,
-            overviewRulerBorder: false,
-            overviewRulerLanes: 0,
-            fontSize: 12,
-          }}
-        />
-      </Resizable>
-    </div>
-  );
-}

compiler/apps/playground/components/Editor/EditorImpl.tsx

@@ -37,7 +37,6 @@ import {
   type Store,
 } from '../../lib/stores';
 import {useStore, useStoreDispatch} from '../StoreContext';
-import ConfigEditor from './ConfigEditor';
 import Input from './Input';
 import {
   CompilerOutput,
@@ -47,7 +46,6 @@ import {
 } from './Output';
 import {transformFromAstSync} from '@babel/core';
 import {LoggerEvent} from 'babel-plugin-react-compiler/dist/Entrypoint';
-import {useSearchParams} from 'next/navigation';
 
 function parseInput(
   input: string,
@@ -293,13 +291,7 @@ export default function Editor(): JSX.Element {
     [deferredStore.source],
   );
 
-  // TODO: Remove this once the config editor is more stable
-  const searchParams = useSearchParams();
-  const search = searchParams.get('showConfig');
-  const shouldShowConfig = search === 'true';
-
   useMountEffect(() => {
-    // Initialize store
     let mountStore: Store;
     try {
       mountStore = initStoreFromUrlOrLocalStorage();
@@ -336,7 +328,6 @@ export default function Editor(): JSX.Element {
   return (
     <>
       <div className="relative flex basis top-14">
-        {shouldShowConfig && <ConfigEditor />}
         <div className={clsx('relative sm:basis-1/4')}>
           <Input language={language} errors={errors} />
         </div>

compiler/package.json

@@ -19,8 +19,7 @@
     "test": "yarn workspaces run test",
     "snap": "yarn workspace babel-plugin-react-compiler run snap",
     "snap:build": "yarn workspace snap run build",
-    "npm:publish": "node scripts/release/publish",
-    "eslint-docs": "yarn workspace babel-plugin-react-compiler build && node scripts/build-eslint-docs.js"
+    "npm:publish": "node scripts/release/publish"
   },
   "dependencies": {
     "fs-extra": "^4.0.2",

compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts

@@ -7,10 +7,9 @@
 
 import * as t from '@babel/types';
 import {codeFrameColumns} from '@babel/code-frame';
-import {type SourceLocation} from './HIR';
+import type {SourceLocation} from './HIR';
 import {Err, Ok, Result} from './Utils/Result';
 import {assertExhaustive} from './Utils/utils';
-import invariant from 'invariant';
 
 export enum ErrorSeverity {
   /**
@@ -48,9 +47,8 @@ export enum ErrorSeverity {
 }
 
 export type CompilerDiagnosticOptions = {
-  category: ErrorCategory;
   severity: ErrorSeverity;
-  reason: string;
+  category: string;
   description: string;
   details: Array<CompilerDiagnosticDetail>;
   suggestions?: Array<CompilerSuggestion> | null | undefined;
@@ -60,15 +58,11 @@ export type CompilerDiagnosticDetail =
   /**
    * A/the source of the error
    */
-  | {
-      kind: 'error';
-      loc: SourceLocation | null;
-      message: string;
-    }
-  | {
-      kind: 'hint';
-      message: string;
-    };
+  {
+    kind: 'error';
+    loc: SourceLocation | null;
+    message: string;
+  };
 
 export enum CompilerSuggestionOperation {
   InsertBefore,
@@ -93,10 +87,9 @@ export type CompilerSuggestion =
     };
 
 export type CompilerErrorDetailOptions = {
-  category: ErrorCategory;
-  severity: ErrorSeverity;
   reason: string;
   description?: string | null | undefined;
+  severity: ErrorSeverity;
   loc: SourceLocation | null;
   suggestions?: Array<CompilerSuggestion> | null | undefined;
 };
@@ -122,8 +115,8 @@ export class CompilerDiagnostic {
     return new CompilerDiagnostic({...options, details: []});
   }
 
-  get reason(): CompilerDiagnosticOptions['reason'] {
-    return this.options.reason;
+  get category(): CompilerDiagnosticOptions['category'] {
+    return this.options.category;
   }
   get description(): CompilerDiagnosticOptions['description'] {
     return this.options.description;
@@ -134,9 +127,6 @@ export class CompilerDiagnostic {
   get suggestions(): CompilerDiagnosticOptions['suggestions'] {
     return this.options.suggestions;
   }
-  get category(): ErrorCategory {
-    return this.options.category;
-  }
 
   withDetail(detail: CompilerDiagnosticDetail): CompilerDiagnostic {
     this.options.details.push(detail);
@@ -144,17 +134,12 @@ export class CompilerDiagnostic {
   }
 
   primaryLocation(): SourceLocation | null {
-    const firstErrorDetail = this.options.details.filter(
-      d => d.kind === 'error',
-    )[0];
-    return firstErrorDetail != null && firstErrorDetail.kind === 'error'
-      ? firstErrorDetail.loc
-      : null;
+    return this.options.details.filter(d => d.kind === 'error')[0]?.loc ?? null;
   }
 
   printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
     const buffer = [
-      printErrorSummary(this.severity, this.reason),
+      printErrorSummary(this.severity, this.category),
       '\n\n',
       this.description,
     ];
@@ -182,14 +167,9 @@ export class CompilerDiagnostic {
           buffer.push(codeFrame);
           break;
         }
-        case 'hint': {
-          buffer.push('\n\n');
-          buffer.push(detail.message);
-          break;
-        }
         default: {
           assertExhaustive(
-            detail,
+            detail.kind,
             `Unexpected detail kind ${(detail as any).kind}`,
           );
         }
@@ -199,7 +179,7 @@ export class CompilerDiagnostic {
   }
 
   toString(): string {
-    const buffer = [printErrorSummary(this.severity, this.reason)];
+    const buffer = [printErrorSummary(this.severity, this.category)];
     if (this.description != null) {
       buffer.push(`. ${this.description}.`);
     }
@@ -237,9 +217,6 @@ export class CompilerErrorDetail {
   get suggestions(): CompilerErrorDetailOptions['suggestions'] {
     return this.options.suggestions;
   }
-  get category(): ErrorCategory {
-    return this.options.category;
-  }
 
   primaryLocation(): SourceLocation | null {
     return this.loc;
@@ -289,14 +266,13 @@ export class CompilerError extends Error {
 
   static invariant(
     condition: unknown,
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
   ): asserts condition {
     if (!condition) {
       const errors = new CompilerError();
       errors.pushErrorDetail(
         new CompilerErrorDetail({
           ...options,
-          category: ErrorCategory.Invariant,
           severity: ErrorSeverity.Invariant,
         }),
       );
@@ -311,28 +287,23 @@ export class CompilerError extends Error {
   }
 
   static throwTodo(
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
   ): never {
     const errors = new CompilerError();
     errors.pushErrorDetail(
-      new CompilerErrorDetail({
-        ...options,
-        severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
-      }),
+      new CompilerErrorDetail({...options, severity: ErrorSeverity.Todo}),
     );
     throw errors;
   }
 
   static throwInvalidJS(
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
   ): never {
     const errors = new CompilerError();
     errors.pushErrorDetail(
       new CompilerErrorDetail({
         ...options,
         severity: ErrorSeverity.InvalidJS,
-        category: ErrorCategory.Syntax,
       }),
     );
     throw errors;
@@ -352,14 +323,13 @@ export class CompilerError extends Error {
   }
 
   static throwInvalidConfig(
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
   ): never {
     const errors = new CompilerError();
     errors.pushErrorDetail(
       new CompilerErrorDetail({
         ...options,
         severity: ErrorSeverity.InvalidConfig,
-        category: ErrorCategory.Config,
       }),
     );
     throw errors;
@@ -423,7 +393,6 @@ export class CompilerError extends Error {
 
   push(options: CompilerErrorDetailOptions): CompilerErrorDetail {
     const detail = new CompilerErrorDetail({
-      category: options.category,
       reason: options.reason,
       description: options.description ?? null,
       severity: options.severity,
@@ -524,358 +493,3 @@ function printErrorSummary(severity: ErrorSeverity, message: string): string {
   }
   return `${severityCategory}: ${message}`;
 }
-
-/**
- * See getRuleForCategory() for how these map to ESLint rules
- */
-export enum ErrorCategory {
-  // Checking for valid hooks usage (non conditional, non-first class, non reactive, etc)
-  Hooks = 'Hooks',
-
-  // Checking for no capitalized calls (not definitively an error, hence separating)
-  CapitalizedCalls = 'CapitalizedCalls',
-
-  // Checking for static components
-  StaticComponents = 'StaticComponents',
-
-  // Checking for valid usage of manual memoization
-  UseMemo = 'UseMemo',
-
-  // Checking for higher order functions acting as factories for components/hooks
-  Factories = 'Factories',
-
-  // Checks that manual memoization is preserved
-  PreserveManualMemo = 'PreserveManualMemo',
-
-  // Checking for no mutations of props, hook arguments, hook return values
-  Immutability = 'Immutability',
-
-  // Checking for assignments to globals
-  Globals = 'Globals',
-
-  // Checking for valid usage of refs, ie no access during render
-  Refs = 'Refs',
-
-  // Checks for memoized effect deps
-  EffectDependencies = 'EffectDependencies',
-
-  // Checks for no setState in effect bodies
-  EffectSetState = 'EffectSetState',
-
-  EffectDerivationsOfState = 'EffectDerivationsOfState',
-
-  // Validates against try/catch in place of error boundaries
-  ErrorBoundaries = 'ErrorBoundaries',
-
-  // Checking for pure functions
-  Purity = 'Purity',
-
-  // Validates against setState in render
-  RenderSetState = 'RenderSetState',
-
-  // Internal invariants
-  Invariant = 'Invariant',
-
-  // Todos
-  Todo = 'Todo',
-
-  // Syntax errors
-  Syntax = 'Syntax',
-
-  // Checks for use of unsupported syntax
-  UnsupportedSyntax = 'UnsupportedSyntax',
-
-  // Config errors
-  Config = 'Config',
-
-  // Gating error
-  Gating = 'Gating',
-
-  // Suppressions
-  Suppression = 'Suppression',
-
-  // Issues with auto deps
-  AutomaticEffectDependencies = 'AutomaticEffectDependencies',
-
-  // Issues with `fire`
-  Fire = 'Fire',
-
-  // fbt-specific issues
-  FBT = 'FBT',
-}
-
-export type LintRule = {
-  // Stores the category the rule corresponds to, used to filter errors when reporting
-  category: ErrorCategory;
-
-  /**
-   * The "name" of the rule as it will be used by developers to enable/disable, eg
-   * "eslint-disable-nest line <name>"
-   */
-  name: string;
-
-  /**
-   * A description of the rule that appears somewhere in ESLint. This does not affect
-   * how error messages are formatted
-   */
-  description: string;
-
-  /**
-   * If true, this rule will automatically appear in the default, "recommended" ESLint
-   * rule set. Otherwise it will be part of an `allRules` export that developers can
-   * use to opt-in to showing output of all possible rules.
-   *
-   * NOTE: not all validations are enabled by default! Setting this flag only affects
-   * whether a given rule is part of the recommended set. The corresponding validation
-   * also should be enabled by default if you want the error to actually show up!
-   */
-  recommended: boolean;
-};
-
-const RULE_NAME_PATTERN = /^[a-z]+(-[a-z]+)*$/;
-
-export function getRuleForCategory(category: ErrorCategory): LintRule {
-  const rule = getRuleForCategoryImpl(category);
-  invariant(
-    RULE_NAME_PATTERN.test(rule.name),
-    `Invalid rule name, got '${rule.name}' but rules must match ${RULE_NAME_PATTERN.toString()}`,
-  );
-  return rule;
-}
-
-function getRuleForCategoryImpl(category: ErrorCategory): LintRule {
-  switch (category) {
-    case ErrorCategory.AutomaticEffectDependencies: {
-      return {
-        category,
-        name: 'automatic-effect-dependencies',
-        description:
-          'Verifies that automatic effect dependencies are compiled if opted-in',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.CapitalizedCalls: {
-      return {
-        category,
-        name: 'capitalized-calls',
-        description:
-          'Validates against calling capitalized functions/methods instead of using JSX',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Config: {
-      return {
-        category,
-        name: 'config',
-        description: 'Validates the compiler configuration options',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.EffectDependencies: {
-      return {
-        category,
-        name: 'memoized-effect-dependencies',
-        description: 'Validates that effect dependencies are memoized',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.EffectDerivationsOfState: {
-      return {
-        category,
-        name: 'no-deriving-state-in-effects',
-        description:
-          'Validates against deriving values from state in an effect',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.EffectSetState: {
-      return {
-        category,
-        name: 'set-state-in-effect',
-        description:
-          'Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.ErrorBoundaries: {
-      return {
-        category,
-        name: 'error-boundaries',
-        description:
-          'Validates usage of error boundaries instead of try/catch for errors in child components',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Factories: {
-      return {
-        category,
-        name: 'component-hook-factories',
-        description:
-          'Validates against higher order functions defining nested components or hooks. ' +
-          'Components and hooks should be defined at the module level',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.FBT: {
-      return {
-        category,
-        name: 'fbt',
-        description: 'Validates usage of fbt',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Fire: {
-      return {
-        category,
-        name: 'fire',
-        description: 'Validates usage of `fire`',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Gating: {
-      return {
-        category,
-        name: 'gating',
-        description:
-          'Validates configuration of [gating mode](https://react.dev/reference/react-compiler/gating)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Globals: {
-      return {
-        category,
-        name: 'globals',
-        description:
-          'Validates against assignment/mutation of globals during render, part of ensuring that ' +
-          '[side effects must render outside of render](https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Hooks: {
-      return {
-        category,
-        name: 'hooks',
-        description: 'Validates the rules of hooks',
-        /**
-         * TODO: the "Hooks" rule largely reimplements the "rules-of-hooks" non-compiler rule.
-         * We need to dedeupe these (moving the remaining bits into the compiler) and then enable
-         * this rule.
-         */
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Immutability: {
-      return {
-        category,
-        name: 'immutability',
-        description:
-          'Validates against mutating props, state, and other values that [are immutable](https://react.dev/reference/rules/components-and-hooks-must-be-pure#props-and-state-are-immutable)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Invariant: {
-      return {
-        category,
-        name: 'invariant',
-        description: 'Internal invariants',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.PreserveManualMemo: {
-      return {
-        category,
-        name: 'preserve-manual-memoization',
-        description:
-          'Validates that existing manual memoized is preserved by the compiler. ' +
-          'React Compiler will only compile components and hooks if its inference ' +
-          '[matches or exceeds the existing manual memoization](https://react.dev/learn/react-compiler/introduction#what-should-i-do-about-usememo-usecallback-and-reactmemo)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Purity: {
-      return {
-        category,
-        name: 'purity',
-        description:
-          'Validates that [components/hooks are pure](https://react.dev/reference/rules/components-and-hooks-must-be-pure) by checking that they do not call known-impure functions',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Refs: {
-      return {
-        category,
-        name: 'refs',
-        description:
-          'Validates correct usage of refs, not reading/writing during render. See the "pitfalls" section in [`useRef()` usage](https://react.dev/reference/react/useRef#usage)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.RenderSetState: {
-      return {
-        category,
-        name: 'set-state-in-render',
-        description:
-          'Validates against setting state during render, which can trigger additional renders and potential infinite render loops',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.StaticComponents: {
-      return {
-        category,
-        name: 'static-components',
-        description:
-          'Validates that components are static, not recreated every render. Components that are recreated dynamically can reset state and trigger excessive re-rendering',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Suppression: {
-      return {
-        category,
-        name: 'rule-suppression',
-        description: 'Validates against suppression of other rules',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Syntax: {
-      return {
-        category,
-        name: 'syntax',
-        description: 'Validates against invalid syntax',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Todo: {
-      return {
-        category,
-        name: 'todo',
-        description: 'Unimplemented features',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.UnsupportedSyntax: {
-      return {
-        category,
-        name: 'unsupported-syntax',
-        description:
-          'Validates against syntax that we do not plan to support in React Compiler',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.UseMemo: {
-      return {
-        category,
-        name: 'use-memo',
-        description:
-          'Validates usage of the useMemo() hook against common mistakes. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
-        recommended: true,
-      };
-    }
-    default: {
-      assertExhaustive(category, `Unsupported category ${category}`);
-    }
-  }
-}
-
-export const LintRules: Array<LintRule> = Object.keys(ErrorCategory).map(
-  category => getRuleForCategory(category as any),
-);

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

@@ -9,7 +9,7 @@ import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
 import {Scope as BabelScope} from '@babel/traverse';
 
-import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
+import {CompilerError, ErrorSeverity} from '../CompilerError';
 import {
   EnvironmentConfig,
   GeneratedSource,
@@ -38,7 +38,6 @@ export function validateRestrictedImports(
     ImportDeclaration(importDeclPath) {
       if (restrictedImports.has(importDeclPath.node.source.value)) {
         error.push({
-          category: ErrorCategory.Todo,
           severity: ErrorSeverity.Todo,
           reason: 'Bailing out due to blocklisted import',
           description: `Import from module ${importDeclPath.node.source.value}`,
@@ -206,7 +205,6 @@ export class ProgramContext {
     }
     const error = new CompilerError();
     error.push({
-      category: ErrorCategory.Todo,
       severity: ErrorSeverity.Todo,
       reason: 'Encountered conflicting global in generated program',
       description: `Conflict from local binding ${name}`,

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

@@ -33,7 +33,9 @@ import {findContextIdentifiers} from '../HIR/FindContextIdentifiers';
 import {
   analyseFunctions,
   dropManualMemoization,
+  inferMutableRanges,
   inferReactivePlaces,
+  inferReferenceEffects,
   inlineImmediatelyInvokedFunctionExpressions,
   inferEffectDependencies,
 } from '../Inference';
@@ -98,6 +100,7 @@ import {outlineJSX} from '../Optimization/OutlineJsx';
 import {optimizePropsMethodCalls} from '../Optimization/OptimizePropsMethodCalls';
 import {transformFire} from '../Transform';
 import {validateNoImpureFunctionsInRender} from '../Validation/ValidateNoImpureFunctionsInRender';
+import {CompilerError} from '..';
 import {validateStaticComponents} from '../Validation/ValidateStaticComponents';
 import {validateNoFreezingKnownMutableFunctions} from '../Validation/ValidateNoFreezingKnownMutableFunctions';
 import {inferMutationAliasingEffects} from '../Inference/InferMutationAliasingEffects';
@@ -226,12 +229,26 @@ function runWithEnvironment(
   analyseFunctions(hir);
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
-  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
-  log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
-  if (env.isInferredMemoEnabled) {
-    if (mutabilityAliasingErrors.isErr()) {
-      throw mutabilityAliasingErrors.unwrapErr();
+  if (!env.config.enableNewMutationAliasingModel) {
+    const fnEffectErrors = inferReferenceEffects(hir);
+    if (env.isInferredMemoEnabled) {
+      if (fnEffectErrors.length > 0) {
+        CompilerError.throw(fnEffectErrors[0]);
+      }
     }
+    log({kind: 'hir', name: 'InferReferenceEffects', value: hir});
+  } else {
+    const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
+    log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
+    if (env.isInferredMemoEnabled) {
+      if (mutabilityAliasingErrors.isErr()) {
+        throw mutabilityAliasingErrors.unwrapErr();
+      }
+    }
+  }
+
+  if (!env.config.enableNewMutationAliasingModel) {
+    validateLocalsNotReassignedAfterRender(hir);
   }
 
   // Note: Has to come after infer reference effects because "dead" code may still affect inference
@@ -246,15 +263,20 @@ function runWithEnvironment(
   pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  const mutabilityAliasingRangeErrors = inferMutationAliasingRanges(hir, {
-    isFunctionExpression: false,
-  });
-  log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
-  if (env.isInferredMemoEnabled) {
-    if (mutabilityAliasingRangeErrors.isErr()) {
-      throw mutabilityAliasingRangeErrors.unwrapErr();
+  if (!env.config.enableNewMutationAliasingModel) {
+    inferMutableRanges(hir);
+    log({kind: 'hir', name: 'InferMutableRanges', value: hir});
+  } else {
+    const mutabilityAliasingErrors = inferMutationAliasingRanges(hir, {
+      isFunctionExpression: false,
+    });
+    log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
+    if (env.isInferredMemoEnabled) {
+      if (mutabilityAliasingErrors.isErr()) {
+        throw mutabilityAliasingErrors.unwrapErr();
+      }
+      validateLocalsNotReassignedAfterRender(hir);
     }
-    validateLocalsNotReassignedAfterRender(hir);
   }
 
   if (env.isInferredMemoEnabled) {
@@ -286,7 +308,12 @@ function runWithEnvironment(
       validateNoImpureFunctionsInRender(hir).unwrap();
     }
 
-    validateNoFreezingKnownMutableFunctions(hir).unwrap();
+    if (
+      env.config.validateNoFreezingKnownMutableFunctions ||
+      env.config.enableNewMutationAliasingModel
+    ) {
+      validateNoFreezingKnownMutableFunctions(hir).unwrap();
+    }
   }
 
   inferReactivePlaces(hir);

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

@@ -10,7 +10,6 @@ import * as t from '@babel/types';
 import {
   CompilerError,
   CompilerErrorDetail,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {ExternalFunction, ReactFunctionType} from '../HIR/Environment';
@@ -106,7 +105,6 @@ function findDirectivesDynamicGating(
           reason: `Dynamic gating directive is not a valid JavaScript identifier`,
           description: `Found '${directive.value.value}'`,
           severity: ErrorSeverity.InvalidReact,
-          category: ErrorCategory.Gating,
           loc: directive.loc ?? null,
           suggestions: null,
         });
@@ -123,7 +121,6 @@ function findDirectivesDynamicGating(
         .map(r => r.directive.value.value)
         .join(', ')}]`,
       severity: ErrorSeverity.InvalidReact,
-      category: ErrorCategory.Gating,
       loc: result[0].directive.loc ?? null,
       suggestions: null,
     });
@@ -459,7 +456,6 @@ export function compileProgram(
           reason:
             'Unexpected compiled functions when module scope opt-out is present',
           severity: ErrorSeverity.Invariant,
-          category: ErrorCategory.Invariant,
           loc: null,
         }),
       );
@@ -494,20 +490,7 @@ function findFunctionsToCompile(
 ): Array<CompileSource> {
   const queue: Array<CompileSource> = [];
   const traverseFunction = (fn: BabelFn, pass: CompilerPass): void => {
-    // In 'all' mode, compile only top level functions
-    if (
-      pass.opts.compilationMode === 'all' &&
-      fn.scope.getProgramParent() !== fn.scope.parent
-    ) {
-      return;
-    }
-
     const fnType = getReactFunctionType(fn, pass);
-
-    if (pass.opts.environment.validateNoDynamicallyCreatedComponentsOrHooks) {
-      validateNoDynamicallyCreatedComponentsOrHooks(fn, pass, programContext);
-    }
-
     if (fnType === null || programContext.alreadyCompiled.has(fn.node)) {
       return;
     }
@@ -828,7 +811,6 @@ function shouldSkipCompilation(
           description:
             "When the 'sources' config options is specified, the React compiler will only compile files with a name",
           severity: ErrorSeverity.InvalidConfig,
-          category: ErrorCategory.Config,
           loc: null,
         }),
       );
@@ -852,73 +834,6 @@ function shouldSkipCompilation(
   return false;
 }
 
-/**
- * Validates that Components/Hooks are always defined at module level. This prevents scope reference
- * errors that occur when the compiler attempts to optimize the nested component/hook while its
- * parent function remains uncompiled.
- */
-function validateNoDynamicallyCreatedComponentsOrHooks(
-  fn: BabelFn,
-  pass: CompilerPass,
-  programContext: ProgramContext,
-): void {
-  const parentNameExpr = getFunctionName(fn);
-  const parentName =
-    parentNameExpr !== null && parentNameExpr.isIdentifier()
-      ? parentNameExpr.node.name
-      : '<anonymous>';
-
-  const validateNestedFunction = (
-    nestedFn: NodePath<
-      t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression
-    >,
-  ): void => {
-    if (
-      nestedFn.node === fn.node ||
-      programContext.alreadyCompiled.has(nestedFn.node)
-    ) {
-      return;
-    }
-
-    if (nestedFn.scope.getProgramParent() !== nestedFn.scope.parent) {
-      const nestedFnType = getReactFunctionType(nestedFn as BabelFn, pass);
-      const nestedFnNameExpr = getFunctionName(nestedFn as BabelFn);
-      const nestedName =
-        nestedFnNameExpr !== null && nestedFnNameExpr.isIdentifier()
-          ? nestedFnNameExpr.node.name
-          : '<anonymous>';
-      if (nestedFnType === 'Component' || nestedFnType === 'Hook') {
-        CompilerError.throwDiagnostic({
-          category: ErrorCategory.Factories,
-          severity: ErrorSeverity.InvalidReact,
-          reason: `Components and hooks cannot be created dynamically`,
-          description: `The function \`${nestedName}\` appears to be a React ${nestedFnType.toLowerCase()}, but it's defined inside \`${parentName}\`. Components and Hooks should always be declared at module scope`,
-          details: [
-            {
-              kind: 'error',
-              message: 'this function dynamically created a component/hook',
-              loc: parentNameExpr?.node.loc ?? fn.node.loc ?? null,
-            },
-            {
-              kind: 'error',
-              message: 'the component is created here',
-              loc: nestedFnNameExpr?.node.loc ?? nestedFn.node.loc ?? null,
-            },
-          ],
-        });
-      }
-    }
-
-    nestedFn.skip();
-  };
-
-  fn.traverse({
-    FunctionDeclaration: validateNestedFunction,
-    FunctionExpression: validateNestedFunction,
-    ArrowFunctionExpression: validateNestedFunction,
-  });
-}
-
 function getReactFunctionType(
   fn: BabelFn,
   pass: CompilerPass,
@@ -957,6 +872,11 @@ function getReactFunctionType(
       return componentSyntaxType;
     }
     case 'all': {
+      // Compile only top level functions
+      if (fn.scope.getProgramParent() !== fn.scope.parent) {
+        return null;
+      }
+
       return getComponentOrHookLike(fn, hookPattern) ?? 'Other';
     }
     default: {

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

@@ -11,7 +11,6 @@ import {
   CompilerDiagnostic,
   CompilerError,
   CompilerSuggestionOperation,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
@@ -184,10 +183,9 @@ export function suppressionsToCompilerError(
     }
     error.pushDiagnostic(
       CompilerDiagnostic.create({
-        reason: reason,
+        category: reason,
         description: `React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression \`${suppressionRange.disableComment.value.trim()}\``,
         severity: ErrorSeverity.InvalidReact,
-        category: ErrorCategory.Suppression,
         suggestions: [
           {
             description: suggestion,

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

@@ -13,11 +13,7 @@ import {getOrInsertWith} from '../Utils/utils';
 import {Environment, GeneratedSource} from '../HIR';
 import {DEFAULT_EXPORT} from '../HIR/Environment';
 import {CompileProgramMetadata} from './Program';
-import {
-  CompilerDiagnostic,
-  CompilerDiagnosticOptions,
-  ErrorCategory,
-} from '../CompilerError';
+import {CompilerDiagnostic, CompilerDiagnosticOptions} from '../CompilerError';
 
 function throwInvalidReact(
   options: Omit<CompilerDiagnosticOptions, 'severity'>,
@@ -96,8 +92,7 @@ function assertValidEffectImportReference(
          */
         throwInvalidReact(
           {
-            category: ErrorCategory.AutomaticEffectDependencies,
-            reason:
+            category:
               'Cannot infer dependencies of this effect. This will break your build!',
             description:
               'To resolve, either pass a dependency array or fix reported compiler bailout diagnostics.' +
@@ -128,8 +123,8 @@ function assertValidFireImportReference(
     );
     throwInvalidReact(
       {
-        category: ErrorCategory.Fire,
-        reason: '[Fire] Untransformed reference to compiler-required feature.',
+        category:
+          '[Fire] Untransformed reference to compiler-required feature.',
         description:
           'Either remove this `fire` call or ensure it is successfully transformed by the compiler' +
           maybeErrorDiagnostic

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

@@ -12,7 +12,6 @@ import {
   CompilerDiagnostic,
   CompilerError,
   CompilerSuggestionOperation,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {Err, Ok, Result} from '../Utils/Result';
@@ -109,8 +108,7 @@ export function lower(
         builder.errors.pushDiagnostic(
           CompilerDiagnostic.create({
             severity: ErrorSeverity.Invariant,
-            category: ErrorCategory.Invariant,
-            reason: 'Could not find binding',
+            category: 'Could not find binding',
             description: `[BuildHIR] Could not find binding for param \`${param.node.name}\`.`,
           }).withDetail({
             kind: 'error',
@@ -174,8 +172,7 @@ export function lower(
       builder.errors.pushDiagnostic(
         CompilerDiagnostic.create({
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
-          reason: `Handle ${param.node.type} parameters`,
+          category: `Handle ${param.node.type} parameters`,
           description: `[BuildHIR] Add support for ${param.node.type} parameters.`,
         }).withDetail({
           kind: 'error',
@@ -206,8 +203,7 @@ export function lower(
     builder.errors.pushDiagnostic(
       CompilerDiagnostic.create({
         severity: ErrorSeverity.InvalidJS,
-        category: ErrorCategory.Syntax,
-        reason: `Unexpected function body kind`,
+        category: `Unexpected function body kind`,
         description: `Expected function body to be an expression or a block statement, got \`${body.type}\`.`,
       }).withDetail({
         kind: 'error',
@@ -277,7 +273,6 @@ function lowerStatement(
           reason:
             '(BuildHIR::lowerStatement) Support ThrowStatement inside of try/catch',
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -465,7 +460,6 @@ function lowerStatement(
           } else if (!binding.path.isVariableDeclarator()) {
             builder.errors.push({
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               reason: 'Unsupported declaration type for hoisting',
               description: `variable "${binding.identifier.name}" declared with ${binding.path.type}`,
               suggestions: null,
@@ -475,7 +469,6 @@ function lowerStatement(
           } else {
             builder.errors.push({
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               reason: 'Handle non-const declarations for hoisting',
               description: `variable "${binding.identifier.name}" declared with ${binding.kind}`,
               suggestions: null,
@@ -556,7 +549,6 @@ function lowerStatement(
             reason:
               '(BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement',
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: stmt.node.loc ?? null,
             suggestions: null,
           });
@@ -629,7 +621,6 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle empty test in ForStatement`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -781,7 +772,6 @@ function lowerStatement(
             builder.errors.push({
               reason: `Expected at most one \`default\` branch in a switch statement, this code should have failed to parse`,
               severity: ErrorSeverity.InvalidJS,
-              category: ErrorCategory.Syntax,
               loc: case_.node.loc ?? null,
               suggestions: null,
             });
@@ -854,7 +844,6 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle ${nodeKind} kinds in VariableDeclaration`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -883,7 +872,6 @@ function lowerStatement(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Could not find binding for declaration.`,
               severity: ErrorSeverity.Invariant,
-              category: ErrorCategory.Invariant,
               loc: id.node.loc ?? null,
               suggestions: null,
             });
@@ -901,7 +889,6 @@ function lowerStatement(
                 builder.errors.push({
                   reason: `Expect \`const\` declaration not to be reassigned`,
                   severity: ErrorSeverity.InvalidJS,
-                  category: ErrorCategory.Syntax,
                   loc: id.node.loc ?? null,
                   suggestions: [
                     {
@@ -949,7 +936,6 @@ function lowerStatement(
             reason: `Expected variable declaration to be an identifier if no initializer was provided`,
             description: `Got a \`${id.type}\``,
             severity: ErrorSeverity.InvalidJS,
-            category: ErrorCategory.Syntax,
             loc: stmt.node.loc ?? null,
             suggestions: null,
           });
@@ -1058,7 +1044,6 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle for-await loops`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -1291,7 +1276,6 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle TryStatement without a catch clause`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -1301,7 +1285,6 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle TryStatement with a finalizer ('finally') clause`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -1395,7 +1378,6 @@ function lowerStatement(
         reason: `JavaScript 'with' syntax is not supported`,
         description: `'with' syntax is considered deprecated and removed from JavaScript standards, consider alternatives`,
         severity: ErrorSeverity.UnsupportedJS,
-        category: ErrorCategory.UnsupportedSyntax,
         loc: stmtPath.node.loc ?? null,
         suggestions: null,
       });
@@ -1416,7 +1398,6 @@ function lowerStatement(
         reason: 'Inline `class` declarations are not supported',
         description: `Move class declarations outside of components/hooks`,
         severity: ErrorSeverity.UnsupportedJS,
-        category: ErrorCategory.UnsupportedSyntax,
         loc: stmtPath.node.loc ?? null,
         suggestions: null,
       });
@@ -1446,7 +1427,6 @@ function lowerStatement(
         reason:
           'JavaScript `import` and `export` statements may only appear at the top level of a module',
         severity: ErrorSeverity.InvalidJS,
-        category: ErrorCategory.Syntax,
         loc: stmtPath.node.loc ?? null,
         suggestions: null,
       });
@@ -1462,7 +1442,6 @@ function lowerStatement(
         reason:
           'TypeScript `namespace` statements may only appear at the top level of a module',
         severity: ErrorSeverity.InvalidJS,
-        category: ErrorCategory.Syntax,
         loc: stmtPath.node.loc ?? null,
         suggestions: null,
       });
@@ -1541,7 +1520,6 @@ function lowerObjectPropertyKey(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Expected Identifier, got ${key.type} key in ObjectExpression`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: key.node.loc ?? null,
         suggestions: null,
       });
@@ -1567,7 +1545,6 @@ function lowerObjectPropertyKey(
   builder.errors.push({
     reason: `(BuildHIR::lowerExpression) Expected Identifier, got ${key.type} key in ObjectExpression`,
     severity: ErrorSeverity.Todo,
-    category: ErrorCategory.Todo,
     loc: key.node.loc ?? null,
     suggestions: null,
   });
@@ -1625,7 +1602,6 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${valuePath.type} values in ObjectExpression`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: valuePath.node.loc ?? null,
               suggestions: null,
             });
@@ -1652,7 +1628,6 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${propertyPath.node.kind} functions in ObjectExpression`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: propertyPath.node.loc ?? null,
               suggestions: null,
             });
@@ -1674,7 +1649,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${propertyPath.type} properties in ObjectExpression`,
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: propertyPath.node.loc ?? null,
             suggestions: null,
           });
@@ -1708,7 +1682,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${element.type} elements in ArrayExpression`,
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: element.node.loc ?? null,
             suggestions: null,
           });
@@ -1729,7 +1702,6 @@ function lowerExpression(
           reason: `Expected an expression as the \`new\` expression receiver (v8 intrinsics are not supported)`,
           description: `Got a \`${calleePath.node.type}\``,
           severity: ErrorSeverity.InvalidJS,
-          category: ErrorCategory.Syntax,
           loc: calleePath.node.loc ?? null,
           suggestions: null,
         });
@@ -1756,7 +1728,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `Expected Expression, got ${calleePath.type} in CallExpression (v8 intrinsics not supported). This error is likely caused by a bug in React Compiler. Please file an issue`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: calleePath.node.loc ?? null,
           suggestions: null,
         });
@@ -1791,7 +1762,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Expected Expression, got ${leftPath.type} lval in BinaryExpression`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: leftPath.node.loc ?? null,
           suggestions: null,
         });
@@ -1804,7 +1774,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Pipe operator not supported`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: leftPath.node.loc ?? null,
           suggestions: null,
         });
@@ -1834,7 +1803,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `Expected sequence expression to have at least one expression`,
             severity: ErrorSeverity.InvalidJS,
-            category: ErrorCategory.Syntax,
             loc: expr.node.loc ?? null,
             suggestions: null,
           });
@@ -2047,7 +2015,6 @@ function lowerExpression(
             reason: `(BuildHIR::lowerExpression) Unsupported syntax on the left side of an AssignmentExpression`,
             description: `Expected an LVal, got: ${left.type}`,
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: left.node.loc ?? null,
             suggestions: null,
           });
@@ -2076,7 +2043,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle ${operator} operators in AssignmentExpression`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: expr.node.loc ?? null,
           suggestions: null,
         });
@@ -2176,7 +2142,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Expected Identifier or MemberExpression, got ${expr.type} lval in AssignmentExpression`,
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: expr.node.loc ?? null,
             suggestions: null,
           });
@@ -2216,7 +2181,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${attribute.type} attributes in JSXElement`,
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: attribute.node.loc ?? null,
             suggestions: null,
           });
@@ -2230,7 +2194,6 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Unexpected colon in attribute name \`${propName}\``,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: namePath.node.loc ?? null,
               suggestions: null,
             });
@@ -2261,7 +2224,6 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${valueExpr.type} attribute values in JSXElement`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: valueExpr.node?.loc ?? null,
               suggestions: null,
             });
@@ -2272,7 +2234,6 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${expression.type} expressions in JSXExpressionContainer within JSXElement`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: valueExpr.node.loc ?? null,
               suggestions: null,
             });
@@ -2330,8 +2291,7 @@ function lowerExpression(
           if (locations.length > 1) {
             CompilerError.throwDiagnostic({
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.FBT,
-              reason: 'Support duplicate fbt tags',
+              category: 'Support duplicate fbt tags',
               description: `Support \`<${tagName}>\` tags with multiple \`<${tagName}:${name}>\` values`,
               details: locations.map(loc => {
                 return {
@@ -2392,7 +2352,6 @@ function lowerExpression(
           reason:
             '(BuildHIR::lowerExpression) Handle tagged template with interpolations',
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2411,7 +2370,6 @@ function lowerExpression(
           reason:
             '(BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value',
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2434,7 +2392,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `Unexpected quasi and subexpression lengths in template literal`,
           severity: ErrorSeverity.InvalidJS,
-          category: ErrorCategory.Syntax,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2445,7 +2402,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerAssignment) Handle TSType in TemplateLiteral.`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2488,7 +2444,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `Only object properties can be deleted`,
             severity: ErrorSeverity.InvalidJS,
-            category: ErrorCategory.Syntax,
             loc: expr.node.loc ?? null,
             suggestions: [
               {
@@ -2504,7 +2459,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `Throw expressions are not supported`,
           severity: ErrorSeverity.InvalidJS,
-          category: ErrorCategory.Syntax,
           loc: expr.node.loc ?? null,
           suggestions: [
             {
@@ -2626,7 +2580,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle UpdateExpression with ${argument.type} argument`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2635,7 +2588,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle UpdateExpression to variables captured within lambdas.`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2656,7 +2608,6 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Found an invalid UpdateExpression without a previously reported error`,
             severity: ErrorSeverity.Invariant,
-            category: ErrorCategory.Invariant,
             loc: exprLoc,
             suggestions: null,
           });
@@ -2666,7 +2617,6 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Support UpdateExpression where argument is a global`,
           severity: ErrorSeverity.Todo,
-          category: ErrorCategory.Todo,
           loc: exprLoc,
           suggestions: null,
         });
@@ -2722,7 +2672,6 @@ function lowerExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle MetaProperty expressions other than import.meta`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: exprPath.node.loc ?? null,
         suggestions: null,
       });
@@ -2732,7 +2681,6 @@ function lowerExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle ${exprPath.type} expressions`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: exprPath.node.loc ?? null,
         suggestions: null,
       });
@@ -3030,7 +2978,6 @@ function lowerReorderableExpression(
     builder.errors.push({
       reason: `(BuildHIR::node.lowerReorderableExpression) Expression type \`${expr.type}\` cannot be safely reordered`,
       severity: ErrorSeverity.Todo,
-      category: ErrorCategory.Todo,
       loc: expr.node.loc ?? null,
       suggestions: null,
     });
@@ -3227,7 +3174,6 @@ function lowerArguments(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle ${argPath.type} arguments in CallExpression`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: argPath.node.loc ?? null,
         suggestions: null,
       });
@@ -3263,7 +3209,6 @@ function lowerMemberExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerMemberExpression) Handle ${propertyNode.type} property`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: propertyNode.node.loc ?? null,
         suggestions: null,
       });
@@ -3285,7 +3230,6 @@ function lowerMemberExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerMemberExpression) Expected Expression, got ${propertyNode.type} property`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: propertyNode.node.loc ?? null,
         suggestions: null,
       });
@@ -3345,7 +3289,6 @@ function lowerJsxElementName(
         reason: `Expected JSXNamespacedName to have no colons in the namespace or name`,
         description: `Got \`${namespace}\` : \`${name}\``,
         severity: ErrorSeverity.InvalidJS,
-        category: ErrorCategory.Syntax,
         loc: exprPath.node.loc ?? null,
         suggestions: null,
       });
@@ -3360,7 +3303,6 @@ function lowerJsxElementName(
     builder.errors.push({
       reason: `(BuildHIR::lowerJsxElementName) Handle ${exprPath.type} tags`,
       severity: ErrorSeverity.Todo,
-      category: ErrorCategory.Todo,
       loc: exprPath.node.loc ?? null,
       suggestions: null,
     });
@@ -3459,7 +3401,6 @@ function lowerJsxElement(
     builder.errors.push({
       reason: `(BuildHIR::lowerJsxElement) Unhandled JsxElement, got: ${exprPath.type}`,
       severity: ErrorSeverity.Todo,
-      category: ErrorCategory.Todo,
       loc: exprPath.node.loc ?? null,
       suggestions: null,
     });
@@ -3647,7 +3588,6 @@ function lowerIdentifier(
           description:
             'Eval is an anti-pattern in JavaScript, and the code executed cannot be evaluated by React Compiler',
           severity: ErrorSeverity.UnsupportedJS,
-          category: ErrorCategory.UnsupportedSyntax,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -3704,7 +3644,6 @@ function lowerIdentifierForAssignment(
       builder.errors.push({
         reason: `(BuildHIR::lowerAssignment) Could not find binding for declaration.`,
         severity: ErrorSeverity.Invariant,
-        category: ErrorCategory.Invariant,
         loc: path.node.loc ?? null,
         suggestions: null,
       });
@@ -3717,7 +3656,6 @@ function lowerIdentifierForAssignment(
     builder.errors.push({
       reason: `Cannot reassign a \`const\` variable`,
       severity: ErrorSeverity.InvalidJS,
-      category: ErrorCategory.Syntax,
       loc: path.node.loc ?? null,
       description:
         binding.identifier.name != null
@@ -3775,7 +3713,6 @@ function lowerAssignment(
           builder.errors.push({
             reason: `Expected \`const\` declaration not to be reassigned`,
             severity: ErrorSeverity.InvalidJS,
-            category: ErrorCategory.Syntax,
             loc: lvalue.node.loc ?? null,
             suggestions: null,
           });
@@ -3790,7 +3727,6 @@ function lowerAssignment(
           builder.errors.push({
             reason: `Unexpected context variable kind`,
             severity: ErrorSeverity.InvalidJS,
-            category: ErrorCategory.Syntax,
             loc: lvalue.node.loc ?? null,
             suggestions: null,
           });
@@ -3862,7 +3798,6 @@ function lowerAssignment(
           builder.errors.push({
             reason: `(BuildHIR::lowerAssignment) Handle ${property.type} properties in MemberExpression`,
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: property.node.loc ?? null,
             suggestions: null,
           });
@@ -3875,7 +3810,6 @@ function lowerAssignment(
             reason:
               '(BuildHIR::lowerAssignment) Expected private name to appear as a non-computed property',
             severity: ErrorSeverity.Todo,
-            category: ErrorCategory.Todo,
             loc: property.node.loc ?? null,
             suggestions: null,
           });
@@ -3941,7 +3875,6 @@ function lowerAssignment(
             } else if (identifier.kind === 'Global') {
               builder.errors.push({
                 severity: ErrorSeverity.Todo,
-                category: ErrorCategory.Todo,
                 reason:
                   'Expected reassignment of globals to enable forceTemporaries',
                 loc: element.node.loc ?? GeneratedSource,
@@ -3981,7 +3914,6 @@ function lowerAssignment(
           } else if (identifier.kind === 'Global') {
             builder.errors.push({
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               reason:
                 'Expected reassignment of globals to enable forceTemporaries',
               loc: element.node.loc ?? GeneratedSource,
@@ -4055,7 +3987,6 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Handle ${argument.node.type} rest element in ObjectPattern`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: argument.node.loc ?? null,
               suggestions: null,
             });
@@ -4087,7 +4018,6 @@ function lowerAssignment(
             } else if (identifier.kind === 'Global') {
               builder.errors.push({
                 severity: ErrorSeverity.Todo,
-                category: ErrorCategory.Todo,
                 reason:
                   'Expected reassignment of globals to enable forceTemporaries',
                 loc: property.node.loc ?? GeneratedSource,
@@ -4105,7 +4035,6 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Handle ${property.type} properties in ObjectPattern`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: property.node.loc ?? null,
               suggestions: null,
             });
@@ -4115,7 +4044,6 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: property.node.loc ?? null,
               suggestions: null,
             });
@@ -4130,7 +4058,6 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Expected object property value to be an LVal, got: ${element.type}`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: element.node.loc ?? null,
               suggestions: null,
             });
@@ -4153,7 +4080,6 @@ function lowerAssignment(
             } else if (identifier.kind === 'Global') {
               builder.errors.push({
                 severity: ErrorSeverity.Todo,
-                category: ErrorCategory.Todo,
                 reason:
                   'Expected reassignment of globals to enable forceTemporaries',
                 loc: element.node.loc ?? GeneratedSource,
@@ -4303,7 +4229,6 @@ function lowerAssignment(
       builder.errors.push({
         reason: `(BuildHIR::lowerAssignment) Handle ${lvaluePath.type} assignments`,
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
         loc: lvaluePath.node.loc ?? null,
         suggestions: null,
       });

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

@@ -250,6 +250,11 @@ export const EnvironmentConfigSchema = z.object({
    */
   flowTypeProvider: z.nullable(z.function().args(z.string())).default(null),
 
+  /**
+   * Enable a new model for mutability and aliasing inference
+   */
+  enableNewMutationAliasingModel: z.boolean().default(true),
+
   /**
    * Enables inference of optional dependency chains. Without this flag
    * a property chain such as `props?.items?.foo` will infer as a dep on
@@ -650,13 +655,6 @@ export const EnvironmentConfigSchema = z.object({
    *   useMemo(() => { ... }, [...]);
    */
   validateNoVoidUseMemo: z.boolean().default(false),
-
-  /**
-   * Validates that Components/Hooks are always defined at module level. This prevents scope
-   * reference errors that occur when the compiler attempts to optimize the nested component/hook
-   * while its parent function remains uncompiled.
-   */
-  validateNoDynamicallyCreatedComponentsOrHooks: z.boolean().default(false),
 });
 
 export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;

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

@@ -7,7 +7,7 @@
 
 import {BindingKind} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerError} from '../CompilerError';
+import {CompilerError, CompilerErrorDetailOptions} from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
 import {Environment, ReactFunctionType} from './Environment';
 import type {HookKind} from './ObjectShape';
@@ -282,13 +282,30 @@ export type HIRFunction = {
   returnTypeAnnotation: t.FlowType | t.TSType | null;
   returns: Place;
   context: Array<Place>;
+  effects: Array<FunctionEffect> | null;
   body: HIR;
   generator: boolean;
   async: boolean;
   directives: Array<string>;
-  aliasingEffects: Array<AliasingEffect> | null;
+  aliasingEffects?: Array<AliasingEffect> | null;
 };
 
+export type FunctionEffect =
+  | {
+      kind: 'GlobalMutation';
+      error: CompilerErrorDetailOptions;
+    }
+  | {
+      kind: 'ReactMutation';
+      error: CompilerErrorDetailOptions;
+    }
+  | {
+      kind: 'ContextMutation';
+      places: ReadonlySet<Place>;
+      effect: Effect;
+      loc: SourceLocation;
+    };
+
 /*
  * Each reactive scope may have its own control-flow, so the instructions form
  * a control-flow graph. The graph comprises a set of basic blocks which reference

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

@@ -7,7 +7,7 @@
 
 import {Binding, NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
+import {CompilerError, ErrorSeverity} from '../CompilerError';
 import {Environment} from './Environment';
 import {
   BasicBlock,
@@ -310,8 +310,7 @@ export default class HIRBuilder {
     if (node.name === 'fbt') {
       CompilerError.throwDiagnostic({
         severity: ErrorSeverity.Todo,
-        category: ErrorCategory.FBT,
-        reason: 'Support local variables named `fbt`',
+        category: 'Support local variables named `fbt`',
         description:
           'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
         details: [
@@ -323,22 +322,6 @@ export default class HIRBuilder {
         ],
       });
     }
-    if (node.name === 'this') {
-      CompilerError.throwDiagnostic({
-        severity: ErrorSeverity.UnsupportedJS,
-        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;
     let index = 0;

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

@@ -554,11 +554,23 @@ export function printInstructionValue(instrValue: ReactiveValue): string {
       const context = instrValue.loweredFunc.func.context
         .map(dep => printPlace(dep))
         .join(',');
+      const effects =
+        instrValue.loweredFunc.func.effects
+          ?.map(effect => {
+            if (effect.kind === 'ContextMutation') {
+              return `ContextMutation places=[${[...effect.places]
+                .map(place => printPlace(place))
+                .join(', ')}] effect=${effect.effect}`;
+            } else {
+              return `GlobalMutation`;
+            }
+          })
+          .join(', ') ?? '';
       const aliasingEffects =
         instrValue.loweredFunc.func.aliasingEffects
           ?.map(printAliasingEffect)
           ?.join(', ') ?? '';
-      value = `${kind} ${name} @context[${context}] @aliasingEffects=[${aliasingEffects}]\n${fn}`;
+      value = `${kind} ${name} @context[${context}] @effects[${effects}] @aliasingEffects=[${aliasingEffects}]\n${fn}`;
       break;
     }
     case 'TaggedTemplateExpression': {
@@ -880,8 +892,7 @@ export function printType(type: Type): string {
   if (type.kind === 'Object' && type.shapeId != null) {
     return `:T${type.kind}<${type.shapeId}>`;
   } else if (type.kind === 'Function' && type.shapeId != null) {
-    const returnType = printType(type.return);
-    return `:T${type.kind}<${type.shapeId}>()${returnType !== '' ? `:  ${returnType}` : ''}`;
+    return `:T${type.kind}<${type.shapeId}>`;
   } else {
     return `:T${type.kind}`;
   }
@@ -984,16 +995,16 @@ export function printAliasingEffect(effect: AliasingEffect): string {
     case 'MutateConditionally':
     case 'MutateTransitive':
     case 'MutateTransitiveConditionally': {
-      return `${effect.kind} ${printPlaceForAliasEffect(effect.value)}${effect.kind === 'Mutate' && effect.reason?.kind === 'AssignCurrentProperty' ? ' (assign `.current`)' : ''}`;
+      return `${effect.kind} ${printPlaceForAliasEffect(effect.value)}`;
     }
     case 'MutateFrozen': {
-      return `MutateFrozen ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
+      return `MutateFrozen ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.category)}`;
     }
     case 'MutateGlobal': {
-      return `MutateGlobal ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
+      return `MutateGlobal ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.category)}`;
     }
     case 'Impure': {
-      return `Impure ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
+      return `Impure ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.category)}`;
     }
     case 'Render': {
       return `Render ${printPlaceForAliasEffect(effect.place)}`;

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

@@ -231,7 +231,7 @@ export function hashEffect(effect: AliasingEffect): string {
         effect.kind,
         effect.place.identifier.id,
         effect.error.severity,
-        effect.error.reason,
+        effect.error.category,
         effect.error.description,
         printSourceLocation(effect.error.primaryLocation() ?? GeneratedSource),
       ].join(':');

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

@@ -6,10 +6,20 @@
  */
 
 import {CompilerError} from '../CompilerError';
-import {Effect, HIRFunction, IdentifierId, makeInstructionId} from '../HIR';
+import {
+  Effect,
+  HIRFunction,
+  Identifier,
+  IdentifierId,
+  LoweredFunction,
+  isRefOrRefValue,
+  makeInstructionId,
+} from '../HIR';
 import {deadCodeElimination} from '../Optimization';
 import {inferReactiveScopeVariables} from '../ReactiveScopes';
 import {rewriteInstructionKindsBasedOnReassignment} from '../SSA';
+import {inferMutableRanges} from './InferMutableRanges';
+import inferReferenceEffects from './InferReferenceEffects';
 import {assertExhaustive} from '../Utils/utils';
 import {inferMutationAliasingEffects} from './InferMutationAliasingEffects';
 import {inferMutationAliasingRanges} from './InferMutationAliasingRanges';
@@ -20,7 +30,12 @@ export default function analyseFunctions(func: HIRFunction): void {
       switch (instr.value.kind) {
         case 'ObjectMethod':
         case 'FunctionExpression': {
-          lowerWithMutationAliasing(instr.value.loweredFunc.func);
+          if (!func.env.config.enableNewMutationAliasingModel) {
+            lower(instr.value.loweredFunc.func);
+            infer(instr.value.loweredFunc);
+          } else {
+            lowerWithMutationAliasing(instr.value.loweredFunc.func);
+          }
 
           /**
            * Reset mutable range for outer inferReferenceEffects
@@ -125,3 +140,58 @@ function lowerWithMutationAliasing(fn: HIRFunction): void {
     value: fn,
   });
 }
+
+function lower(func: HIRFunction): void {
+  analyseFunctions(func);
+  inferReferenceEffects(func, {isFunctionExpression: true});
+  deadCodeElimination(func);
+  inferMutableRanges(func);
+  rewriteInstructionKindsBasedOnReassignment(func);
+  inferReactiveScopeVariables(func);
+  func.env.logger?.debugLogIRs?.({
+    kind: 'hir',
+    name: 'AnalyseFunction (inner)',
+    value: func,
+  });
+}
+
+function infer(loweredFunc: LoweredFunction): void {
+  for (const operand of loweredFunc.func.context) {
+    const identifier = operand.identifier;
+    CompilerError.invariant(operand.effect === Effect.Unknown, {
+      reason:
+        '[AnalyseFunctions] Expected Function context effects to not have been set',
+      loc: operand.loc,
+    });
+    if (isRefOrRefValue(identifier)) {
+      /*
+       * TODO: this is a hack to ensure we treat functions which reference refs
+       * as having a capture and therefore being considered mutable. this ensures
+       * the function gets a mutable range which accounts for anywhere that it
+       * could be called, and allows us to help ensure it isn't called during
+       * render
+       */
+      operand.effect = Effect.Capture;
+    } else if (isMutatedOrReassigned(identifier)) {
+      /**
+       * Reflects direct reassignments, PropertyStores, and ConditionallyMutate
+       * (directly or through maybe-aliases)
+       */
+      operand.effect = Effect.Capture;
+    } else {
+      operand.effect = Effect.Read;
+    }
+  }
+}
+
+function isMutatedOrReassigned(id: Identifier): boolean {
+  /*
+   * This check checks for mutation and reassingnment, so the usual check for
+   * mutation (ie, `mutableRange.end - mutableRange.start > 1`) isn't quite
+   * enough.
+   *
+   * We need to track re-assignments in context refs as we need to reflect the
+   * re-assignment back to the captured refs.
+   */
+  return id.mutableRange.end > id.mutableRange.start;
+}

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

@@ -11,7 +11,6 @@ import {
   ErrorSeverity,
   SourceLocation,
 } from '..';
-import {ErrorCategory} from '../CompilerError';
 import {
   CallExpression,
   Effect,
@@ -301,9 +300,8 @@ function extractManualMemoizationArgs(
   if (fnPlace == null) {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.UseMemo,
         severity: ErrorSeverity.InvalidReact,
-        reason: `Expected a callback function to be passed to ${kind}`,
+        category: `Expected a callback function to be passed to ${kind}`,
         description: `Expected a callback function to be passed to ${kind}`,
         suggestions: null,
       }).withDetail({
@@ -317,9 +315,8 @@ function extractManualMemoizationArgs(
   if (fnPlace.kind === 'Spread' || depsListPlace?.kind === 'Spread') {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.UseMemo,
         severity: ErrorSeverity.InvalidReact,
-        reason: `Unexpected spread argument to ${kind}`,
+        category: `Unexpected spread argument to ${kind}`,
         description: `Unexpected spread argument to ${kind}`,
         suggestions: null,
       }).withDetail({
@@ -338,9 +335,8 @@ function extractManualMemoizationArgs(
     if (maybeDepsList == null) {
       errors.pushDiagnostic(
         CompilerDiagnostic.create({
-          category: ErrorCategory.UseMemo,
           severity: ErrorSeverity.InvalidReact,
-          reason: `Expected the dependency list for ${kind} to be an array literal`,
+          category: `Expected the dependency list for ${kind} to be an array literal`,
           description: `Expected the dependency list for ${kind} to be an array literal`,
           suggestions: null,
         }).withDetail({
@@ -357,9 +353,8 @@ function extractManualMemoizationArgs(
       if (maybeDep == null) {
         errors.pushDiagnostic(
           CompilerDiagnostic.create({
-            category: ErrorCategory.UseMemo,
             severity: ErrorSeverity.InvalidReact,
-            reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+            category: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
             description: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
             suggestions: null,
           }).withDetail({
@@ -464,8 +459,7 @@ export function dropManualMemoization(
                 errors.pushDiagnostic(
                   CompilerDiagnostic.create({
                     severity: ErrorSeverity.InvalidReact,
-                    category: ErrorCategory.UseMemo,
-                    reason: 'useMemo() callbacks must return a value',
+                    category: 'useMemo() callbacks must return a value',
                     description: `This ${
                       manualMemo.loadInstr.value.kind === 'PropertyLoad'
                         ? 'React.useMemo'
@@ -504,9 +498,8 @@ export function dropManualMemoization(
             if (!sidemap.functions.has(fnPlace.identifier.id)) {
               errors.pushDiagnostic(
                 CompilerDiagnostic.create({
-                  category: ErrorCategory.UseMemo,
                   severity: ErrorSeverity.InvalidReact,
-                  reason: `Expected the first argument to be an inline function expression`,
+                  category: `Expected the first argument to be an inline function expression`,
                   description: `Expected the first argument to be an inline function expression`,
                   suggestions: [],
                 }).withDetail({

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

@@ -0,0 +1,134 @@
+/**
+ * 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 {
+  Effect,
+  HIRFunction,
+  Identifier,
+  isMutableEffect,
+  isRefOrRefLikeMutableType,
+  makeInstructionId,
+} from '../HIR/HIR';
+import {eachInstructionValueOperand} from '../HIR/visitors';
+import {isMutable} from '../ReactiveScopes/InferReactiveScopeVariables';
+import DisjointSet from '../Utils/DisjointSet';
+
+/**
+ * If a function captures a mutable value but never gets called, we don't infer a
+ * mutable range for that function. This means that we also don't alias the function
+ * with its mutable captures.
+ *
+ * This case is tricky, because we don't generally know for sure what is a mutation
+ * and what may just be a normal function call. For example:
+ *
+ * ```
+ * hook useFoo() {
+ *   const x = makeObject();
+ *   return () => {
+ *     return readObject(x); // could be a mutation!
+ *   }
+ * }
+ * ```
+ *
+ * If we pessimistically assume that all such cases are mutations, we'd have to group
+ * lots of memo scopes together unnecessarily. However, if there is definitely a mutation:
+ *
+ * ```
+ * hook useFoo(createEntryForKey) {
+ *   const cache = new WeakMap();
+ *   return (key) => {
+ *     let entry = cache.get(key);
+ *     if (entry == null) {
+ *       entry = createEntryForKey(key);
+ *       cache.set(key, entry); // known mutation!
+ *     }
+ *     return entry;
+ *   }
+ * }
+ * ```
+ *
+ * Then we have to ensure that the function and its mutable captures alias together and
+ * end up in the same scope. However, aliasing together isn't enough if the function
+ * and operands all have empty mutable ranges (end = start + 1).
+ *
+ * This pass finds function expressions and object methods that have an empty mutable range
+ * and known-mutable operands which also don't have a mutable range, and ensures that the
+ * function and those operands are aliased together *and* that their ranges are updated to
+ * end after the function expression. This is sufficient to ensure that a reactive scope is
+ * created for the alias set.
+ */
+export function inferAliasForUncalledFunctions(
+  fn: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  for (const block of fn.body.blocks.values()) {
+    instrs: for (const instr of block.instructions) {
+      const {lvalue, value} = instr;
+      if (
+        value.kind !== 'ObjectMethod' &&
+        value.kind !== 'FunctionExpression'
+      ) {
+        continue;
+      }
+      /*
+       * If the function is known to be mutated, we will have
+       * already aliased any mutable operands with it
+       */
+      const range = lvalue.identifier.mutableRange;
+      if (range.end > range.start + 1) {
+        continue;
+      }
+      /*
+       * If the function already has operands with an active mutable range,
+       * then we don't need to do anything — the function will have already
+       * been visited and included in some mutable alias set. This case can
+       * also occur due to visiting the same function in an earlier iteration
+       * of the outer fixpoint loop.
+       */
+      for (const operand of eachInstructionValueOperand(value)) {
+        if (isMutable(instr, operand)) {
+          continue instrs;
+        }
+      }
+      const operands: Set<Identifier> = new Set();
+      for (const effect of value.loweredFunc.func.effects ?? []) {
+        if (effect.kind !== 'ContextMutation') {
+          continue;
+        }
+        /*
+         * We're looking for known-mutations only, so we look at the effects
+         * rather than function context
+         */
+        if (effect.effect === Effect.Store || effect.effect === Effect.Mutate) {
+          for (const operand of effect.places) {
+            /*
+             * It's possible that function effect analysis thinks there was a context mutation,
+             * but then InferReferenceEffects figures out some operands are globals and therefore
+             * creates a non-mutable effect for those operands.
+             * We should change InferReferenceEffects to swap the ContextMutation for a global
+             * mutation in that case, but for now we just filter them out here
+             */
+            if (
+              isMutableEffect(operand.effect, operand.loc) &&
+              !isRefOrRefLikeMutableType(operand.identifier.type)
+            ) {
+              operands.add(operand.identifier);
+            }
+          }
+        }
+      }
+      if (operands.size !== 0) {
+        operands.add(lvalue.identifier);
+        aliases.union([...operands]);
+        // Update mutable ranges, if the ranges are empty then a reactive scope isn't created
+        for (const operand of operands) {
+          operand.mutableRange.end = makeInstructionId(instr.id + 1);
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,68 @@
+/**
+ * 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 {
+  HIRFunction,
+  Identifier,
+  Instruction,
+  isPrimitiveType,
+  Place,
+} from '../HIR/HIR';
+import DisjointSet from '../Utils/DisjointSet';
+
+export type AliasSet = Set<Identifier>;
+
+export function inferAliases(func: HIRFunction): DisjointSet<Identifier> {
+  const aliases = new DisjointSet<Identifier>();
+  for (const [_, block] of func.body.blocks) {
+    for (const instr of block.instructions) {
+      inferInstr(instr, aliases);
+    }
+  }
+
+  return aliases;
+}
+
+function inferInstr(
+  instr: Instruction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  const {lvalue, value: instrValue} = instr;
+  let alias: Place | null = null;
+  switch (instrValue.kind) {
+    case 'LoadLocal':
+    case 'LoadContext': {
+      if (isPrimitiveType(instrValue.place.identifier)) {
+        return;
+      }
+      alias = instrValue.place;
+      break;
+    }
+    case 'StoreLocal':
+    case 'StoreContext': {
+      alias = instrValue.value;
+      break;
+    }
+    case 'Destructure': {
+      alias = instrValue.value;
+      break;
+    }
+    case 'ComputedLoad':
+    case 'PropertyLoad': {
+      alias = instrValue.object;
+      break;
+    }
+    case 'TypeCastExpression': {
+      alias = instrValue.value;
+      break;
+    }
+    default:
+      return;
+  }
+
+  aliases.union([lvalue.identifier, alias.identifier]);
+}

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

@@ -0,0 +1,27 @@
+/**
+ * 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 {HIRFunction, Identifier} from '../HIR/HIR';
+import DisjointSet from '../Utils/DisjointSet';
+
+export function inferAliasForPhis(
+  func: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  for (const [_, block] of func.body.blocks) {
+    for (const phi of block.phis) {
+      const isPhiMutatedAfterCreation: boolean =
+        phi.place.identifier.mutableRange.end >
+        (block.instructions.at(0)?.id ?? block.terminal.id);
+      if (isPhiMutatedAfterCreation) {
+        for (const [, operand] of phi.operands) {
+          aliases.union([phi.place.identifier, operand.identifier]);
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,68 @@
+/**
+ * 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 {
+  Effect,
+  HIRFunction,
+  Identifier,
+  InstructionId,
+  Place,
+} from '../HIR/HIR';
+import {
+  eachInstructionLValue,
+  eachInstructionValueOperand,
+} from '../HIR/visitors';
+import DisjointSet from '../Utils/DisjointSet';
+
+export function inferAliasForStores(
+  func: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  for (const [_, block] of func.body.blocks) {
+    for (const instr of block.instructions) {
+      const {value, lvalue} = instr;
+      const isStore =
+        lvalue.effect === Effect.Store ||
+        /*
+         * Some typed functions annotate callees or arguments
+         * as Effect.Store.
+         */
+        ![...eachInstructionValueOperand(value)].every(
+          operand => operand.effect !== Effect.Store,
+        );
+
+      if (!isStore) {
+        continue;
+      }
+      for (const operand of eachInstructionLValue(instr)) {
+        maybeAlias(aliases, lvalue, operand, instr.id);
+      }
+      for (const operand of eachInstructionValueOperand(value)) {
+        if (
+          operand.effect === Effect.Capture ||
+          operand.effect === Effect.Store
+        ) {
+          maybeAlias(aliases, lvalue, operand, instr.id);
+        }
+      }
+    }
+  }
+}
+
+function maybeAlias(
+  aliases: DisjointSet<Identifier>,
+  lvalue: Place,
+  rvalue: Place,
+  id: InstructionId,
+): void {
+  if (
+    lvalue.identifier.mutableRange.end > id + 1 ||
+    rvalue.identifier.mutableRange.end > id
+  ) {
+    aliases.union([lvalue.identifier, rvalue.identifier]);
+  }
+}

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

@@ -0,0 +1,351 @@
+/**
+ * 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 {
+  CompilerError,
+  CompilerErrorDetailOptions,
+  ErrorSeverity,
+  ValueKind,
+} from '..';
+import {
+  AbstractValue,
+  BasicBlock,
+  Effect,
+  Environment,
+  FunctionEffect,
+  Instruction,
+  InstructionValue,
+  Place,
+  ValueReason,
+  getHookKind,
+  isRefOrRefValue,
+} from '../HIR';
+import {eachInstructionOperand, eachTerminalOperand} from '../HIR/visitors';
+import {assertExhaustive} from '../Utils/utils';
+
+interface State {
+  kind(place: Place): AbstractValue;
+  values(place: Place): Array<InstructionValue>;
+  isDefined(place: Place): boolean;
+}
+
+function inferOperandEffect(state: State, place: Place): null | FunctionEffect {
+  const value = state.kind(place);
+  CompilerError.invariant(value != null, {
+    reason: 'Expected operand to have a kind',
+    loc: null,
+  });
+
+  switch (place.effect) {
+    case Effect.Store:
+    case Effect.Mutate: {
+      if (isRefOrRefValue(place.identifier)) {
+        break;
+      } else if (value.kind === ValueKind.Context) {
+        CompilerError.invariant(value.context.size > 0, {
+          reason:
+            "[InferFunctionEffects] Expected Context-kind value's capture list to be non-empty.",
+          loc: place.loc,
+        });
+        return {
+          kind: 'ContextMutation',
+          loc: place.loc,
+          effect: place.effect,
+          places: value.context,
+        };
+      } else if (
+        value.kind !== ValueKind.Mutable &&
+        // We ignore mutations of primitives since this is not a React-specific problem
+        value.kind !== ValueKind.Primitive
+      ) {
+        let reason = getWriteErrorReason(value);
+        return {
+          kind:
+            value.reason.size === 1 && value.reason.has(ValueReason.Global)
+              ? 'GlobalMutation'
+              : 'ReactMutation',
+          error: {
+            reason,
+            description:
+              place.identifier.name !== null &&
+              place.identifier.name.kind === 'named'
+                ? `Found mutation of \`${place.identifier.name.value}\``
+                : null,
+            loc: place.loc,
+            suggestions: null,
+            severity: ErrorSeverity.InvalidReact,
+          },
+        };
+      }
+      break;
+    }
+  }
+  return null;
+}
+
+function inheritFunctionEffects(
+  state: State,
+  place: Place,
+): Array<FunctionEffect> {
+  const effects = inferFunctionInstrEffects(state, place);
+
+  return effects
+    .flatMap(effect => {
+      if (effect.kind === 'GlobalMutation' || effect.kind === 'ReactMutation') {
+        return [effect];
+      } else {
+        const effects: Array<FunctionEffect | null> = [];
+        CompilerError.invariant(effect.kind === 'ContextMutation', {
+          reason: 'Expected ContextMutation',
+          loc: null,
+        });
+        /**
+         * Contextual effects need to be replayed against the current inference
+         * state, which may know more about the value to which the effect applied.
+         * The main cases are:
+         * 1. The mutated context value is _still_ a context value in the current scope,
+         *    so we have to continue propagating the original context mutation.
+         * 2. The mutated context value is a mutable value in the current scope,
+         *    so the context mutation was fine and we can skip propagating the effect.
+         * 3. The mutated context value  is an immutable value in the current scope,
+         *    resulting in a non-ContextMutation FunctionEffect. We propagate that new,
+         *    more detailed effect to the current function context.
+         */
+        for (const place of effect.places) {
+          if (state.isDefined(place)) {
+            const replayedEffect = inferOperandEffect(state, {
+              ...place,
+              loc: effect.loc,
+              effect: effect.effect,
+            });
+            if (replayedEffect != null) {
+              if (replayedEffect.kind === 'ContextMutation') {
+                // Case 1, still a context value so propagate the original effect
+                effects.push(effect);
+              } else {
+                // Case 3, immutable value so propagate the more precise effect
+                effects.push(replayedEffect);
+              }
+            } // else case 2, local mutable value so this effect was fine
+          }
+        }
+        return effects;
+      }
+    })
+    .filter((effect): effect is FunctionEffect => effect != null);
+}
+
+function inferFunctionInstrEffects(
+  state: State,
+  place: Place,
+): Array<FunctionEffect> {
+  const effects: Array<FunctionEffect> = [];
+  const instrs = state.values(place);
+  CompilerError.invariant(instrs != null, {
+    reason: 'Expected operand to have instructions',
+    loc: null,
+  });
+
+  for (const instr of instrs) {
+    if (
+      (instr.kind === 'FunctionExpression' || instr.kind === 'ObjectMethod') &&
+      instr.loweredFunc.func.effects != null
+    ) {
+      effects.push(...instr.loweredFunc.func.effects);
+    }
+  }
+
+  return effects;
+}
+
+function operandEffects(
+  state: State,
+  place: Place,
+  filterRenderSafe: boolean,
+): Array<FunctionEffect> {
+  const functionEffects: Array<FunctionEffect> = [];
+  const effect = inferOperandEffect(state, place);
+  effect && functionEffects.push(effect);
+  functionEffects.push(...inheritFunctionEffects(state, place));
+  if (filterRenderSafe) {
+    return functionEffects.filter(effect => !isEffectSafeOutsideRender(effect));
+  } else {
+    return functionEffects;
+  }
+}
+
+export function inferInstructionFunctionEffects(
+  env: Environment,
+  state: State,
+  instr: Instruction,
+): Array<FunctionEffect> {
+  const functionEffects: Array<FunctionEffect> = [];
+  switch (instr.value.kind) {
+    case 'JsxExpression': {
+      if (instr.value.tag.kind === 'Identifier') {
+        functionEffects.push(...operandEffects(state, instr.value.tag, false));
+      }
+      instr.value.children?.forEach(child =>
+        functionEffects.push(...operandEffects(state, child, false)),
+      );
+      for (const attr of instr.value.props) {
+        if (attr.kind === 'JsxSpreadAttribute') {
+          functionEffects.push(...operandEffects(state, attr.argument, false));
+        } else {
+          functionEffects.push(...operandEffects(state, attr.place, true));
+        }
+      }
+      break;
+    }
+    case 'ObjectMethod':
+    case 'FunctionExpression': {
+      /**
+       * If this function references other functions, propagate the referenced function's
+       * effects to this function.
+       *
+       * ```
+       * let f = () => global = true;
+       * let g = () => f();
+       * g();
+       * ```
+       *
+       * In this example, because `g` references `f`, we propagate the GlobalMutation from
+       * `f` to `g`. Thus, referencing `g` in `g()` will evaluate the GlobalMutation in the outer
+       * function effect context and report an error. But if instead we do:
+       *
+       * ```
+       * let f = () => global = true;
+       * let g = () => f();
+       * useEffect(() => g(), [g])
+       * ```
+       *
+       * Now `g`'s effects will be discarded since they're in a useEffect.
+       */
+      for (const operand of eachInstructionOperand(instr)) {
+        instr.value.loweredFunc.func.effects ??= [];
+        instr.value.loweredFunc.func.effects.push(
+          ...inferFunctionInstrEffects(state, operand),
+        );
+      }
+      break;
+    }
+    case 'MethodCall':
+    case 'CallExpression': {
+      let callee;
+      if (instr.value.kind === 'MethodCall') {
+        callee = instr.value.property;
+        functionEffects.push(
+          ...operandEffects(state, instr.value.receiver, false),
+        );
+      } else {
+        callee = instr.value.callee;
+      }
+      functionEffects.push(...operandEffects(state, callee, false));
+      let isHook = getHookKind(env, callee.identifier) != null;
+      for (const arg of instr.value.args) {
+        const place = arg.kind === 'Identifier' ? arg : arg.place;
+        /*
+         * Join the effects of the argument with the effects of the enclosing function,
+         * unless the we're detecting a global mutation inside a useEffect hook
+         */
+        functionEffects.push(...operandEffects(state, place, isHook));
+      }
+      break;
+    }
+    case 'StartMemoize':
+    case 'FinishMemoize':
+    case 'LoadLocal':
+    case 'StoreLocal': {
+      break;
+    }
+    case 'StoreGlobal': {
+      functionEffects.push({
+        kind: 'GlobalMutation',
+        error: {
+          reason:
+            'Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
+          loc: instr.loc,
+          suggestions: null,
+          severity: ErrorSeverity.InvalidReact,
+        },
+      });
+      break;
+    }
+    default: {
+      for (const operand of eachInstructionOperand(instr)) {
+        functionEffects.push(...operandEffects(state, operand, false));
+      }
+    }
+  }
+  return functionEffects;
+}
+
+export function inferTerminalFunctionEffects(
+  state: State,
+  block: BasicBlock,
+): Array<FunctionEffect> {
+  const functionEffects: Array<FunctionEffect> = [];
+  for (const operand of eachTerminalOperand(block.terminal)) {
+    functionEffects.push(...operandEffects(state, operand, true));
+  }
+  return functionEffects;
+}
+
+export function transformFunctionEffectErrors(
+  functionEffects: Array<FunctionEffect>,
+): Array<CompilerErrorDetailOptions> {
+  return functionEffects.map(eff => {
+    switch (eff.kind) {
+      case 'ReactMutation':
+      case 'GlobalMutation': {
+        return eff.error;
+      }
+      case 'ContextMutation': {
+        return {
+          severity: ErrorSeverity.Invariant,
+          reason: `Unexpected ContextMutation in top-level function effects`,
+          loc: eff.loc,
+        };
+      }
+      default:
+        assertExhaustive(
+          eff,
+          `Unexpected function effect kind \`${(eff as any).kind}\``,
+        );
+    }
+  });
+}
+
+function isEffectSafeOutsideRender(effect: FunctionEffect): boolean {
+  return effect.kind === 'GlobalMutation';
+}
+
+export function getWriteErrorReason(abstractValue: AbstractValue): string {
+  if (abstractValue.reason.has(ValueReason.Global)) {
+    return 'Modifying a variable defined outside a component or hook is not allowed. Consider using an effect';
+  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
+    return 'Modifying a value used previously in JSX is not allowed. Consider moving the modification before the JSX';
+  } else if (abstractValue.reason.has(ValueReason.Context)) {
+    return `Modifying a value returned from 'useContext()' is not allowed.`;
+  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
+    return 'Modifying a value returned from a function whose return value should not be mutated';
+  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
+    return 'Modifying component props or hook arguments is not allowed. Consider using a local variable instead';
+  } else if (abstractValue.reason.has(ValueReason.State)) {
+    return "Modifying a value returned from 'useState()', which should not be modified directly. Use the setter function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
+    return "Modifying a value returned from 'useReducer()', which should not be modified directly. Use the dispatch function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.Effect)) {
+    return 'Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect()';
+  } else if (abstractValue.reason.has(ValueReason.HookCaptured)) {
+    return 'Modifying a value previously passed as an argument to a hook is not allowed. Consider moving the modification before calling the hook';
+  } else if (abstractValue.reason.has(ValueReason.HookReturn)) {
+    return 'Modifying a value returned from a hook is not allowed. Consider moving the modification into the hook where the value is constructed';
+  } else {
+    return 'This modifies a variable that React considers immutable';
+  }
+}

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

@@ -0,0 +1,218 @@
+/**
+ * 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 {
+  Effect,
+  HIRFunction,
+  Identifier,
+  InstructionId,
+  InstructionKind,
+  isArrayType,
+  isMapType,
+  isRefOrRefValue,
+  isSetType,
+  makeInstructionId,
+  Place,
+} from '../HIR/HIR';
+import {printPlace} from '../HIR/PrintHIR';
+import {
+  eachInstructionLValue,
+  eachInstructionOperand,
+  eachTerminalOperand,
+} from '../HIR/visitors';
+import {assertExhaustive} from '../Utils/utils';
+
+/*
+ * For each usage of a value in the given function, determines if the usage
+ * may be succeeded by a mutable usage of that same value and if so updates
+ * the usage to be mutable.
+ *
+ * Stated differently, this inference ensures that inferred capabilities of
+ * each reference are as follows:
+ * - freeze: the value is frozen at this point
+ * - readonly: the value is not modified at this point *or any subsequent
+ *    point*
+ * - mutable: the value is modified at this point *or some subsequent point*.
+ *
+ * Note that this refines the capabilities inferered by InferReferenceCapability,
+ * which looks at individual references and not the lifetime of a value's mutability.
+ *
+ * == Algorithm
+ *
+ * TODO:
+ * 1. Forward data-flow analysis to determine aliasing. Unlike InferReferenceCapability
+ *     which only tracks aliasing of top-level variables (`y = x`), this analysis needs
+ *     to know if a value is aliased anywhere (`y.x = x`). The forward data flow tracks
+ *     all possible locations which may have aliased a value. The concrete result is
+ *     a mapping of each Place to the set of possibly-mutable values it may alias.
+ *
+ * ```
+ * const x = []; // {x: v0; v0: mutable []}
+ * const y = {}; // {x: v0, y: v1; v0: mutable [], v1: mutable []}
+ * y.x = x;      // {x: v0, y: v1; v0: mutable [v1], v1: mutable [v0]}
+ * read(x);      // {x: v0, y: v1; v0: mutable [v1], v1: mutable [v0]}
+ * mutate(y);    // can infer that y mutates v0 and v1
+ * ```
+ *
+ * DONE:
+ * 2. Forward data-flow analysis to compute mutability liveness. Walk forwards over
+ *     the CFG and track which values are mutated in a successor.
+ *
+ * ```
+ * mutate(y);    // mutable y => v0, v1 mutated
+ * read(x);      // x maps to v0, v1, those are in the mutated-later set, so x is mutable here
+ * ...
+ * ```
+ */
+
+function infer(place: Place, instrId: InstructionId): void {
+  if (!isRefOrRefValue(place.identifier)) {
+    place.identifier.mutableRange.end = makeInstructionId(instrId + 1);
+  }
+}
+
+function inferPlace(
+  place: Place,
+  instrId: InstructionId,
+  inferMutableRangeForStores: boolean,
+): void {
+  switch (place.effect) {
+    case Effect.Unknown: {
+      throw new Error(`Found an unknown place ${printPlace(place)}}!`);
+    }
+    case Effect.Capture:
+    case Effect.Read:
+    case Effect.Freeze:
+      return;
+    case Effect.Store:
+      if (inferMutableRangeForStores) {
+        infer(place, instrId);
+      }
+      return;
+    case Effect.ConditionallyMutateIterator: {
+      const identifier = place.identifier;
+      if (
+        !isArrayType(identifier) &&
+        !isSetType(identifier) &&
+        !isMapType(identifier)
+      ) {
+        infer(place, instrId);
+      }
+      return;
+    }
+    case Effect.ConditionallyMutate:
+    case Effect.Mutate: {
+      infer(place, instrId);
+      return;
+    }
+    default:
+      assertExhaustive(place.effect, `Unexpected ${printPlace(place)} effect`);
+  }
+}
+
+export function inferMutableLifetimes(
+  func: HIRFunction,
+  inferMutableRangeForStores: boolean,
+): void {
+  /*
+   * Context variables only appear to mutate where they are assigned, but we need
+   * to force their range to start at their declaration. Track the declaring instruction
+   * id so that the ranges can be extended if/when they are reassigned
+   */
+  const contextVariableDeclarationInstructions = new Map<
+    Identifier,
+    InstructionId
+  >();
+  for (const [_, block] of func.body.blocks) {
+    for (const phi of block.phis) {
+      const isPhiMutatedAfterCreation: boolean =
+        phi.place.identifier.mutableRange.end >
+        (block.instructions.at(0)?.id ?? block.terminal.id);
+      if (
+        inferMutableRangeForStores &&
+        isPhiMutatedAfterCreation &&
+        phi.place.identifier.mutableRange.start === 0
+      ) {
+        for (const [, operand] of phi.operands) {
+          if (phi.place.identifier.mutableRange.start === 0) {
+            phi.place.identifier.mutableRange.start =
+              operand.identifier.mutableRange.start;
+          } else {
+            phi.place.identifier.mutableRange.start = makeInstructionId(
+              Math.min(
+                phi.place.identifier.mutableRange.start,
+                operand.identifier.mutableRange.start,
+              ),
+            );
+          }
+        }
+      }
+    }
+
+    for (const instr of block.instructions) {
+      for (const operand of eachInstructionLValue(instr)) {
+        const lvalueId = operand.identifier;
+
+        /*
+         * lvalue start being mutable when they're initially assigned a
+         * value.
+         */
+        lvalueId.mutableRange.start = instr.id;
+
+        /*
+         * Let's be optimistic and assume this lvalue is not mutable by
+         * default.
+         */
+        lvalueId.mutableRange.end = makeInstructionId(instr.id + 1);
+      }
+      for (const operand of eachInstructionOperand(instr)) {
+        inferPlace(operand, instr.id, inferMutableRangeForStores);
+      }
+
+      if (
+        instr.value.kind === 'DeclareContext' ||
+        (instr.value.kind === 'StoreContext' &&
+          instr.value.lvalue.kind !== InstructionKind.Reassign &&
+          !contextVariableDeclarationInstructions.has(
+            instr.value.lvalue.place.identifier,
+          ))
+      ) {
+        /**
+         * Save declarations of context variables if they hasn't already been
+         * declared (due to hoisted declarations).
+         */
+        contextVariableDeclarationInstructions.set(
+          instr.value.lvalue.place.identifier,
+          instr.id,
+        );
+      } else if (instr.value.kind === 'StoreContext') {
+        /*
+         * Else this is a reassignment, extend the range from the declaration (if present).
+         * Note that declarations may not be present for context variables that are reassigned
+         * within a function expression before (or without) a read of the same variable
+         */
+        const declaration = contextVariableDeclarationInstructions.get(
+          instr.value.lvalue.place.identifier,
+        );
+        if (
+          declaration != null &&
+          !isRefOrRefValue(instr.value.lvalue.place.identifier)
+        ) {
+          const range = instr.value.lvalue.place.identifier.mutableRange;
+          if (range.start === 0) {
+            range.start = declaration;
+          } else {
+            range.start = makeInstructionId(Math.min(range.start, declaration));
+          }
+        }
+      }
+    }
+    for (const operand of eachTerminalOperand(block.terminal)) {
+      inferPlace(operand, block.terminal.id, inferMutableRangeForStores);
+    }
+  }
+}

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

@@ -0,0 +1,102 @@
+/**
+ * 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 {HIRFunction, Identifier} from '../HIR/HIR';
+import {inferAliasForUncalledFunctions} from './InerAliasForUncalledFunctions';
+import {inferAliases} from './InferAlias';
+import {inferAliasForPhis} from './InferAliasForPhis';
+import {inferAliasForStores} from './InferAliasForStores';
+import {inferMutableLifetimes} from './InferMutableLifetimes';
+import {inferMutableRangesForAlias} from './InferMutableRangesForAlias';
+import {inferTryCatchAliases} from './InferTryCatchAliases';
+
+export function inferMutableRanges(ir: HIRFunction): void {
+  // Infer mutable ranges for non fields
+  inferMutableLifetimes(ir, false);
+
+  // Calculate aliases
+  const aliases = inferAliases(ir);
+  /*
+   * Calculate aliases for try/catch, where any value created
+   * in the try block could be aliased to the catch param
+   */
+  inferTryCatchAliases(ir, aliases);
+
+  /*
+   * Eagerly canonicalize so that if nothing changes we can bail out
+   * after a single iteration
+   */
+  let prevAliases: Map<Identifier, Identifier> = aliases.canonicalize();
+  while (true) {
+    // Infer mutable ranges for aliases that are not fields
+    inferMutableRangesForAlias(ir, aliases);
+
+    // Update aliasing information of fields
+    inferAliasForStores(ir, aliases);
+
+    // Update aliasing information of phis
+    inferAliasForPhis(ir, aliases);
+
+    const nextAliases = aliases.canonicalize();
+    if (areEqualMaps(prevAliases, nextAliases)) {
+      break;
+    }
+    prevAliases = nextAliases;
+  }
+
+  // Re-infer mutable ranges for all values
+  inferMutableLifetimes(ir, true);
+
+  /**
+   * The second inferMutableLifetimes() call updates mutable ranges
+   * of values to account for Store effects. Now we need to update
+   * all aliases of such values to extend their ranges as well. Note
+   * that the store only mutates the the directly aliased value and
+   * not any of its inner captured references. For example:
+   *
+   * ```
+   * let y;
+   * if (cond) {
+   *   y = [];
+   * } else {
+   *   y = [{}];
+   * }
+   * y.push(z);
+   * ```
+   *
+   * The Store effect from the `y.push` modifies the values that `y`
+   * directly aliases - the two arrays from the if/else branches -
+   * but does not modify values that `y` "contains" such as the
+   * object literal or `z`.
+   */
+  prevAliases = aliases.canonicalize();
+  while (true) {
+    inferMutableRangesForAlias(ir, aliases);
+    inferAliasForPhis(ir, aliases);
+    inferAliasForUncalledFunctions(ir, aliases);
+    const nextAliases = aliases.canonicalize();
+    if (areEqualMaps(prevAliases, nextAliases)) {
+      break;
+    }
+    prevAliases = nextAliases;
+  }
+}
+
+function areEqualMaps<T, U>(a: Map<T, U>, b: Map<T, U>): boolean {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const [key, value] of a) {
+    if (!b.has(key)) {
+      return false;
+    }
+    if (b.get(key) !== value) {
+      return false;
+    }
+  }
+  return true;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * 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 {
+  HIRFunction,
+  Identifier,
+  InstructionId,
+  isRefOrRefValue,
+} from '../HIR/HIR';
+import DisjointSet from '../Utils/DisjointSet';
+
+export function inferMutableRangesForAlias(
+  _fn: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  const aliasSets = aliases.buildSets();
+  for (const aliasSet of aliasSets) {
+    /*
+     * Update mutableRange.end only if the identifiers have actually been
+     * mutated.
+     */
+    const mutatingIdentifiers = [...aliasSet].filter(
+      id =>
+        id.mutableRange.end - id.mutableRange.start > 1 && !isRefOrRefValue(id),
+    );
+
+    if (mutatingIdentifiers.length > 0) {
+      // Find final instruction which mutates this alias set.
+      let lastMutatingInstructionId = 0;
+      for (const id of mutatingIdentifiers) {
+        if (id.mutableRange.end > lastMutatingInstructionId) {
+          lastMutatingInstructionId = id.mutableRange.end;
+        }
+      }
+
+      /*
+       * Update mutableRange.end for all aliases in this set ending before the
+       * last mutation.
+       */
+      for (const alias of aliasSet) {
+        if (
+          alias.mutableRange.end < lastMutatingInstructionId &&
+          !isRefOrRefValue(alias)
+        ) {
+          alias.mutableRange.end = lastMutatingInstructionId as InstructionId;
+        }
+      }
+    }
+  }
+}

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

@@ -19,14 +19,13 @@ import {
   DeclarationId,
   Environment,
   FunctionExpression,
-  GeneratedSource,
   HIRFunction,
   Hole,
   IdentifierId,
   Instruction,
   InstructionKind,
+  InstructionValue,
   isArrayType,
-  isJsxType,
   isMapType,
   isPrimitiveType,
   isRefOrRefValue,
@@ -35,7 +34,6 @@ import {
   Phi,
   Place,
   SpreadPattern,
-  Type,
   ValueReason,
 } from '../HIR';
 import {
@@ -45,6 +43,12 @@ import {
   eachTerminalSuccessor,
 } from '../HIR/visitors';
 import {Ok, Result} from '../Utils/Result';
+import {
+  getArgumentEffect,
+  getFunctionCallSignature,
+  isKnownMutableEffect,
+  mergeValueKinds,
+} from './InferReferenceEffects';
 import {
   assertExhaustive,
   getOrInsertDefault,
@@ -56,10 +60,12 @@ import {
   printAliasingSignature,
   printIdentifier,
   printInstruction,
+  printInstructionValue,
   printPlace,
   printSourceLocation,
 } from '../HIR/PrintHIR';
 import {FunctionSignature} from '../HIR/ObjectShape';
+import {getWriteErrorReason} from './InferFunctionEffects';
 import prettyFormat from 'pretty-format';
 import {createTemporaryPlace} from '../HIR/HIRBuilder';
 import {
@@ -68,7 +74,6 @@ import {
   hashEffect,
   MutationReason,
 } from './AliasingEffects';
-import {ErrorCategory} from '../CompilerError';
 
 const DEBUG = false;
 
@@ -106,11 +111,11 @@ export function inferMutationAliasingEffects(
   const statesByBlock: Map<BlockId, InferenceState> = new Map();
 
   for (const ref of fn.context) {
-    const value: AliasingEffect = {
-      kind: 'Create',
-      into: ref,
-      value: ValueKind.Context,
-      reason: ValueReason.Other,
+    // TODO: using InstructionValue as a bit of a hack, but it's pragmatic
+    const value: InstructionValue = {
+      kind: 'ObjectExpression',
+      properties: [],
+      loc: ref.loc,
     };
     initialState.initialize(value, {
       kind: ValueKind.Context,
@@ -143,11 +148,10 @@ export function inferMutationAliasingEffects(
     }
     if (ref != null) {
       const place = ref.kind === 'Identifier' ? ref : ref.place;
-      const value: AliasingEffect = {
-        kind: 'Create',
-        into: place,
-        value: ValueKind.Mutable,
-        reason: ValueReason.Other,
+      const value: InstructionValue = {
+        kind: 'ObjectExpression',
+        properties: [],
+        loc: place.loc,
       };
       initialState.initialize(value, {
         kind: ValueKind.Mutable,
@@ -264,6 +268,8 @@ function findHoistedContextDeclarations(
 class Context {
   internedEffects: Map<string, AliasingEffect> = new Map();
   instructionSignatureCache: Map<Instruction, InstructionSignature> = new Map();
+  effectInstructionValueCache: Map<AliasingEffect, InstructionValue> =
+    new Map();
   applySignatureCache: Map<
     AliasingSignature,
     Map<AliasingEffect, Array<AliasingEffect> | null>
@@ -315,11 +321,10 @@ function inferParam(
   paramKind: AbstractValue,
 ): void {
   const place = param.kind === 'Identifier' ? param : param.place;
-  const value: AliasingEffect = {
-    kind: 'Create',
-    into: place,
-    value: paramKind.kind,
-    reason: ValueReason.Other,
+  const value: InstructionValue = {
+    kind: 'Primitive',
+    loc: place.loc,
+    value: undefined,
   };
   initialState.initialize(value, paramKind);
   initialState.define(place, value);
@@ -445,6 +450,7 @@ function applySignature(
             const reason = getWriteErrorReason({
               kind: value.kind,
               reason: value.reason,
+              context: new Set(),
             });
             const variable =
               effect.value.identifier.name !== null &&
@@ -452,9 +458,8 @@ function applySignature(
                 ? `\`${effect.value.identifier.name.value}\``
                 : 'value';
             const diagnostic = CompilerDiagnostic.create({
-              category: ErrorCategory.Immutability,
               severity: ErrorSeverity.InvalidReact,
-              reason: 'This value cannot be modified',
+              category: 'This value cannot be modified',
               description: `${reason}.`,
             }).withDetail({
               kind: 'error',
@@ -466,7 +471,8 @@ function applySignature(
               effect.reason?.kind === 'AssignCurrentProperty'
             ) {
               diagnostic.withDetail({
-                kind: 'hint',
+                kind: 'error',
+                loc: effect.value.loc,
                 message: `Hint: If this value is a Ref (value returned by \`useRef()\`), rename the variable to end in "Ref".`,
               });
             }
@@ -540,11 +546,20 @@ function applyEffect(
       });
       initialized.add(effect.into.identifier.id);
 
-      state.initialize(effect, {
+      let value = context.effectInstructionValueCache.get(effect);
+      if (value == null) {
+        value = {
+          kind: 'ObjectExpression',
+          properties: [],
+          loc: effect.into.loc,
+        };
+        context.effectInstructionValueCache.set(effect, value);
+      }
+      state.initialize(value, {
         kind: effect.value,
         reason: new Set([effect.reason]),
       });
-      state.define(effect.into, effect);
+      state.define(effect.into, value);
       effects.push(effect);
       break;
     }
@@ -571,11 +586,20 @@ function applyEffect(
       initialized.add(effect.into.identifier.id);
 
       const fromValue = state.kind(effect.from);
-      state.initialize(effect, {
+      let value = context.effectInstructionValueCache.get(effect);
+      if (value == null) {
+        value = {
+          kind: 'ObjectExpression',
+          properties: [],
+          loc: effect.into.loc,
+        };
+        context.effectInstructionValueCache.set(effect, value);
+      }
+      state.initialize(value, {
         kind: fromValue.kind,
         reason: new Set(fromValue.reason),
       });
-      state.define(effect.into, effect);
+      state.define(effect.into, value);
       switch (fromValue.kind) {
         case ValueKind.Primitive:
         case ValueKind.Global: {
@@ -663,11 +687,11 @@ function applyEffect(
           operand.effect = Effect.Read;
         }
       }
-      state.initialize(effect, {
+      state.initialize(effect.function, {
         kind: isMutable ? ValueKind.Mutable : ValueKind.Frozen,
         reason: new Set([]),
       });
-      state.define(effect.into, effect);
+      state.define(effect.into, effect.function);
       for (const capture of effect.captures) {
         applyEffect(
           context,
@@ -773,20 +797,38 @@ function applyEffect(
             initialized,
             effects,
           );
-          state.initialize(effect, {
+          let value = context.effectInstructionValueCache.get(effect);
+          if (value == null) {
+            value = {
+              kind: 'Primitive',
+              value: undefined,
+              loc: effect.from.loc,
+            };
+            context.effectInstructionValueCache.set(effect, value);
+          }
+          state.initialize(value, {
             kind: fromKind,
             reason: new Set(fromValue.reason),
           });
-          state.define(effect.into, effect);
+          state.define(effect.into, value);
           break;
         }
         case ValueKind.Global:
         case ValueKind.Primitive: {
-          state.initialize(effect, {
+          let value = context.effectInstructionValueCache.get(effect);
+          if (value == null) {
+            value = {
+              kind: 'Primitive',
+              value: undefined,
+              loc: effect.from.loc,
+            };
+            context.effectInstructionValueCache.set(effect, value);
+          }
+          state.initialize(value, {
             kind: fromKind,
             reason: new Set(fromValue.reason),
           });
-          state.define(effect.into, effect);
+          state.define(effect.into, value);
           break;
         }
         default: {
@@ -801,15 +843,14 @@ function applyEffect(
       const functionValues = state.values(effect.function);
       if (
         functionValues.length === 1 &&
-        functionValues[0].kind === 'CreateFunction' &&
-        functionValues[0].function.kind === 'FunctionExpression' &&
-        functionValues[0].function.loweredFunc.func.aliasingEffects != null
+        functionValues[0].kind === 'FunctionExpression' &&
+        functionValues[0].loweredFunc.func.aliasingEffects != null
       ) {
         /*
          * We're calling a locally declared function, we already know it's effects!
          * We just have to substitute in the args for the params
          */
-        const functionExpr = functionValues[0].function;
+        const functionExpr = functionValues[0];
         let signature = context.functionSignatureCache.get(functionExpr);
         if (signature == null) {
           signature = buildSignatureFromFunctionExpression(
@@ -1002,9 +1043,8 @@ function applyEffect(
             effect.value.identifier.declarationId,
           );
           const diagnostic = CompilerDiagnostic.create({
-            category: ErrorCategory.Immutability,
             severity: ErrorSeverity.InvalidReact,
-            reason: 'Cannot access variable before it is declared',
+            category: 'Cannot access variable before it is declared',
             description: `${variable ?? 'This variable'} is accessed before it is declared, which prevents the earlier access from updating when this value changes over time.`,
           });
           if (hoistedAccess != null && hoistedAccess.loc != effect.value.loc) {
@@ -1035,6 +1075,7 @@ function applyEffect(
           const reason = getWriteErrorReason({
             kind: value.kind,
             reason: value.reason,
+            context: new Set(),
           });
           const variable =
             effect.value.identifier.name !== null &&
@@ -1042,9 +1083,8 @@ function applyEffect(
               ? `\`${effect.value.identifier.name.value}\``
               : 'value';
           const diagnostic = CompilerDiagnostic.create({
-            category: ErrorCategory.Immutability,
             severity: ErrorSeverity.InvalidReact,
-            reason: 'This value cannot be modified',
+            category: 'This value cannot be modified',
             description: `${reason}.`,
           }).withDetail({
             kind: 'error',
@@ -1056,7 +1096,8 @@ function applyEffect(
             effect.reason?.kind === 'AssignCurrentProperty'
           ) {
             diagnostic.withDetail({
-              kind: 'hint',
+              kind: 'error',
+              loc: effect.value.loc,
               message: `Hint: If this value is a Ref (value returned by \`useRef()\`), rename the variable to end in "Ref".`,
             });
           }
@@ -1099,19 +1140,19 @@ class InferenceState {
   #isFunctionExpression: boolean;
 
   // The kind of each value, based on its allocation site
-  #values: Map<AliasingEffect, AbstractValue>;
+  #values: Map<InstructionValue, AbstractValue>;
   /*
    * The set of values pointed to by each identifier. This is a set
    * to accomodate phi points (where a variable may have different
    * values from different control flow paths).
    */
-  #variables: Map<IdentifierId, Set<AliasingEffect>>;
+  #variables: Map<IdentifierId, Set<InstructionValue>>;
 
   constructor(
     env: Environment,
     isFunctionExpression: boolean,
-    values: Map<AliasingEffect, AbstractValue>,
-    variables: Map<IdentifierId, Set<AliasingEffect>>,
+    values: Map<InstructionValue, AbstractValue>,
+    variables: Map<IdentifierId, Set<InstructionValue>>,
   ) {
     this.env = env;
     this.#isFunctionExpression = isFunctionExpression;
@@ -1131,11 +1172,18 @@ class InferenceState {
   }
 
   // (Re)initializes a @param value with its default @param kind.
-  initialize(value: AliasingEffect, kind: AbstractValue): void {
+  initialize(value: InstructionValue, kind: AbstractValue): void {
+    CompilerError.invariant(value.kind !== 'LoadLocal', {
+      reason:
+        '[InferMutationAliasingEffects] Expected all top-level identifiers to be defined as variables, not values',
+      description: null,
+      loc: value.loc,
+      suggestions: null,
+    });
     this.#values.set(value, kind);
   }
 
-  values(place: Place): Array<AliasingEffect> {
+  values(place: Place): Array<InstructionValue> {
     const values = this.#variables.get(place.identifier.id);
     CompilerError.invariant(values != null, {
       reason: `[InferMutationAliasingEffects] Expected value kind to be initialized`,
@@ -1198,13 +1246,13 @@ class InferenceState {
   }
 
   // Defines (initializing or updating) a variable with a specific kind of value.
-  define(place: Place, value: AliasingEffect): void {
+  define(place: Place, value: InstructionValue): void {
     CompilerError.invariant(this.#values.has(value), {
       reason: `[InferMutationAliasingEffects] Expected value to be initialized at '${printSourceLocation(
-        place.loc,
+        value.loc,
       )}'`,
-      description: printAliasingEffect(value),
-      loc: place.loc,
+      description: printInstructionValue(value),
+      loc: value.loc,
       suggestions: null,
     });
     this.#variables.set(place.identifier.id, new Set([value]));
@@ -1244,17 +1292,17 @@ class InferenceState {
     }
   }
 
-  freezeValue(value: AliasingEffect, reason: ValueReason): void {
+  freezeValue(value: InstructionValue, reason: ValueReason): void {
     this.#values.set(value, {
       kind: ValueKind.Frozen,
       reason: new Set([reason]),
     });
     if (
-      value.kind === 'CreateFunction' &&
+      value.kind === 'FunctionExpression' &&
       (this.env.config.enablePreserveExistingMemoizationGuarantees ||
         this.env.config.enableTransitivelyFreezeFunctionExpressions)
     ) {
-      for (const place of value.function.loweredFunc.func.context) {
+      for (const place of value.loweredFunc.func.context) {
         this.freeze(place, reason);
       }
     }
@@ -1329,8 +1377,8 @@ class InferenceState {
    * termination.
    */
   merge(other: InferenceState): InferenceState | null {
-    let nextValues: Map<AliasingEffect, AbstractValue> | null = null;
-    let nextVariables: Map<IdentifierId, Set<AliasingEffect>> | null = null;
+    let nextValues: Map<InstructionValue, AbstractValue> | null = null;
+    let nextVariables: Map<IdentifierId, Set<InstructionValue>> | null = null;
 
     for (const [id, thisValue] of this.#values) {
       const otherValue = other.#values.get(id);
@@ -1354,7 +1402,7 @@ class InferenceState {
     for (const [id, thisValues] of this.#variables) {
       const otherValues = other.#variables.get(id);
       if (otherValues !== undefined) {
-        let mergedValues: Set<AliasingEffect> | null = null;
+        let mergedValues: Set<InstructionValue> | null = null;
         for (const otherValue of otherValues) {
           if (!thisValues.has(otherValue)) {
             mergedValues = mergedValues ?? new Set(thisValues);
@@ -1407,8 +1455,8 @@ class InferenceState {
    */
   debug(): any {
     const result: any = {values: {}, variables: {}};
-    const objects: Map<AliasingEffect, number> = new Map();
-    function identify(value: AliasingEffect): number {
+    const objects: Map<InstructionValue, number> = new Map();
+    function identify(value: InstructionValue): number {
       let id = objects.get(value);
       if (id == null) {
         id = objects.size;
@@ -1420,7 +1468,7 @@ class InferenceState {
       const id = identify(value);
       result.values[id] = {
         abstract: this.debugAbstractValue(kind),
-        value: printAliasingEffect(value),
+        value: printInstructionValue(value),
       };
     }
     for (const [variable, values] of this.#variables) {
@@ -1437,7 +1485,7 @@ class InferenceState {
   }
 
   inferPhi(phi: Phi): void {
-    const values: Set<AliasingEffect> = new Set();
+    const values: Set<InstructionValue> = new Set();
     for (const [_, operand] of phi.operands) {
       const operandValues = this.#variables.get(operand.identifier.id);
       // This is a backedge that will be handled later by State.merge
@@ -1828,23 +1876,6 @@ function computeSignatureForInstruction(
             });
           }
         }
-        for (const prop of value.props) {
-          if (
-            prop.kind === 'JsxAttribute' &&
-            prop.place.identifier.type.kind === 'Function' &&
-            (isJsxType(prop.place.identifier.type.return) ||
-              (prop.place.identifier.type.return.kind === 'Phi' &&
-                prop.place.identifier.type.return.operands.some(operand =>
-                  isJsxType(operand),
-                )))
-          ) {
-            // Any props which return jsx are assumed to be called during render
-            effects.push({
-              kind: 'Render',
-              place: prop.place,
-            });
-          }
-        }
       }
       break;
     }
@@ -2011,9 +2042,8 @@ function computeSignatureForInstruction(
         kind: 'MutateGlobal',
         place: value.value,
         error: CompilerDiagnostic.create({
-          category: ErrorCategory.Globals,
           severity: ErrorSeverity.InvalidReact,
-          reason:
+          category:
             'Cannot reassign variables declared outside of the component/hook',
           description: `Variable ${variable} is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)`,
         }).withDetail({
@@ -2111,9 +2141,8 @@ function computeEffectsForLegacySignature(
       kind: 'Impure',
       place: receiver,
       error: CompilerDiagnostic.create({
-        category: ErrorCategory.Purity,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot call impure function during render',
+        category: 'Cannot call impure function during render',
         description:
           (signature.canonicalName != null
             ? `\`${signature.canonicalName}\` is an impure function. `
@@ -2303,9 +2332,8 @@ function areArgumentsImmutableAndNonMutating(
     const values = state.values(place);
     for (const value of values) {
       if (
-        value.kind === 'CreateFunction' &&
-        value.function.kind === 'FunctionExpression' &&
-        value.function.loweredFunc.func.params.some(param => {
+        value.kind === 'FunctionExpression' &&
+        value.loweredFunc.func.params.some(param => {
           const place = param.kind === 'Identifier' ? param : param.place;
           const range = place.identifier.mutableRange;
           return range.end > range.start + 1;
@@ -2498,47 +2526,10 @@ function computeEffectsForSignature(
         break;
       }
       case 'CreateFunction': {
-        const applyInto = substitutions.get(effect.into.identifier.id);
-        if (applyInto == null || applyInto.length !== 1) {
-          return null;
-        }
-        const captures: Array<Place> = [];
-        for (let i = 0; i < effect.captures.length; i++) {
-          const substitution = substitutions.get(
-            effect.captures[i].identifier.id,
-          );
-          if (substitution == null || substitution.length !== 1) {
-            return null;
-          }
-          captures.push(substitution[0]);
-        }
-        const context: Array<Place> = [];
-        const originalContext = effect.function.loweredFunc.func.context;
-        for (let i = 0; i < originalContext.length; i++) {
-          const substitution = substitutions.get(
-            originalContext[i].identifier.id,
-          );
-          if (substitution == null || substitution.length !== 1) {
-            return null;
-          }
-          context.push(substitution[0]);
-        }
-        effects.push({
-          kind: 'CreateFunction',
-          into: applyInto[0],
-          function: {
-            ...effect.function,
-            loweredFunc: {
-              ...effect.function.loweredFunc,
-              func: {
-                ...effect.function.loweredFunc.func,
-                context,
-              },
-            },
-          },
-          captures,
+        CompilerError.throwTodo({
+          reason: `Support CreateFrom effects in signatures`,
+          loc: receiver.loc,
         });
-        break;
       }
       default: {
         assertExhaustive(
@@ -2578,196 +2569,3 @@ export type AbstractValue = {
   kind: ValueKind;
   reason: ReadonlySet<ValueReason>;
 };
-
-export function getWriteErrorReason(abstractValue: AbstractValue): string {
-  if (abstractValue.reason.has(ValueReason.Global)) {
-    return 'Modifying a variable defined outside a component or hook is not allowed. Consider using an effect';
-  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
-    return 'Modifying a value used previously in JSX is not allowed. Consider moving the modification before the JSX';
-  } else if (abstractValue.reason.has(ValueReason.Context)) {
-    return `Modifying a value returned from 'useContext()' is not allowed.`;
-  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
-    return 'Modifying a value returned from a function whose return value should not be mutated';
-  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
-    return 'Modifying component props or hook arguments is not allowed. Consider using a local variable instead';
-  } else if (abstractValue.reason.has(ValueReason.State)) {
-    return "Modifying a value returned from 'useState()', which should not be modified directly. Use the setter function to update instead";
-  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
-    return "Modifying a value returned from 'useReducer()', which should not be modified directly. Use the dispatch function to update instead";
-  } else if (abstractValue.reason.has(ValueReason.Effect)) {
-    return 'Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect()';
-  } else if (abstractValue.reason.has(ValueReason.HookCaptured)) {
-    return 'Modifying a value previously passed as an argument to a hook is not allowed. Consider moving the modification before calling the hook';
-  } else if (abstractValue.reason.has(ValueReason.HookReturn)) {
-    return 'Modifying a value returned from a hook is not allowed. Consider moving the modification into the hook where the value is constructed';
-  } else {
-    return 'This modifies a variable that React considers immutable';
-  }
-}
-
-function getArgumentEffect(
-  signatureEffect: Effect | null,
-  arg: Place | SpreadPattern,
-): Effect {
-  if (signatureEffect != null) {
-    if (arg.kind === 'Identifier') {
-      return signatureEffect;
-    } else if (
-      signatureEffect === Effect.Mutate ||
-      signatureEffect === Effect.ConditionallyMutate
-    ) {
-      return signatureEffect;
-    } else {
-      // see call-spread-argument-mutable-iterator test fixture
-      if (signatureEffect === Effect.Freeze) {
-        CompilerError.throwTodo({
-          reason: 'Support spread syntax for hook arguments',
-          loc: arg.place.loc,
-        });
-      }
-      // effects[i] is Effect.Capture | Effect.Read | Effect.Store
-      return Effect.ConditionallyMutateIterator;
-    }
-  } else {
-    return Effect.ConditionallyMutate;
-  }
-}
-
-export function getFunctionCallSignature(
-  env: Environment,
-  type: Type,
-): FunctionSignature | null {
-  if (type.kind !== 'Function') {
-    return null;
-  }
-  return env.getFunctionSignature(type);
-}
-
-export function isKnownMutableEffect(effect: Effect): boolean {
-  switch (effect) {
-    case Effect.Store:
-    case Effect.ConditionallyMutate:
-    case Effect.ConditionallyMutateIterator:
-    case Effect.Mutate: {
-      return true;
-    }
-
-    case Effect.Unknown: {
-      CompilerError.invariant(false, {
-        reason: 'Unexpected unknown effect',
-        description: null,
-        loc: GeneratedSource,
-        suggestions: null,
-      });
-    }
-    case Effect.Read:
-    case Effect.Capture:
-    case Effect.Freeze: {
-      return false;
-    }
-    default: {
-      assertExhaustive(effect, `Unexpected effect \`${effect}\``);
-    }
-  }
-}
-
-/**
- * Joins two values using the following rules:
- * == Effect Transitions ==
- *
- * Freezing an immutable value has not effect:
- *                ┌───────────────┐
- *                │               │
- *                ▼               │ Freeze
- * ┌──────────────────────────┐  │
- * │        Immutable         │──┘
- * └──────────────────────────┘
- *
- * Freezing a mutable or maybe-frozen value makes it frozen. Freezing a frozen
- * value has no effect:
- *                                                     ┌───────────────┐
- * ┌─────────────────────────┐     Freeze             │               │
- * │       MaybeFrozen       │────┐                   ▼               │ Freeze
- * └─────────────────────────┘    │     ┌──────────────────────────┐  │
- *                                 ├────▶│          Frozen          │──┘
- *                                 │     └──────────────────────────┘
- * ┌─────────────────────────┐    │
- * │         Mutable         │────┘
- * └─────────────────────────┘
- *
- * == Join Lattice ==
- * - immutable | mutable => mutable
- *     The justification is that immutable and mutable values are different types,
- *     and functions can introspect them to tell the difference (if the argument
- *     is null return early, else if its an object mutate it).
- * - frozen | mutable => maybe-frozen
- *     Frozen values are indistinguishable from mutable values at runtime, so callers
- *     cannot dynamically avoid mutation of "frozen" values. If a value could be
- *     frozen we have to distinguish it from a mutable value. But it also isn't known
- *     frozen yet, so we distinguish as maybe-frozen.
- * - immutable | frozen => frozen
- *     This is subtle and falls out of the above rules. If a value could be any of
- *     immutable, mutable, or frozen, then at runtime it could either be a primitive
- *     or a reference type, and callers can't distinguish frozen or not for reference
- *     types. To ensure that any sequence of joins btw those three states yields the
- *     correct maybe-frozen, these two have to produce a frozen value.
- * - <any> | maybe-frozen => maybe-frozen
- * - immutable | context => context
- * - mutable | context => context
- * - frozen | context => maybe-frozen
- *
- * ┌──────────────────────────┐
- * │        Immutable         │───┐
- * └──────────────────────────┘   │
- *                                 │    ┌─────────────────────────┐
- *                                 ├───▶│         Frozen          │──┐
- * ┌──────────────────────────┐   │    └─────────────────────────┘  │
- * │          Frozen          │───┤                                 │  ┌─────────────────────────┐
- * └──────────────────────────┘   │                                 ├─▶│       MaybeFrozen       │
- *                                 │    ┌─────────────────────────┐  │  └─────────────────────────┘
- *                                 ├───▶│       MaybeFrozen       │──┘
- * ┌──────────────────────────┐   │    └─────────────────────────┘
- * │         Mutable          │───┘
- * └──────────────────────────┘
- */
-function mergeValueKinds(a: ValueKind, b: ValueKind): ValueKind {
-  if (a === b) {
-    return a;
-  } else if (a === ValueKind.MaybeFrozen || b === ValueKind.MaybeFrozen) {
-    return ValueKind.MaybeFrozen;
-    // after this a and b differ and neither are MaybeFrozen
-  } else if (a === ValueKind.Mutable || b === ValueKind.Mutable) {
-    if (a === ValueKind.Frozen || b === ValueKind.Frozen) {
-      // frozen | mutable
-      return ValueKind.MaybeFrozen;
-    } else if (a === ValueKind.Context || b === ValueKind.Context) {
-      // context | mutable
-      return ValueKind.Context;
-    } else {
-      // mutable | immutable
-      return ValueKind.Mutable;
-    }
-  } else if (a === ValueKind.Context || b === ValueKind.Context) {
-    if (a === ValueKind.Frozen || b === ValueKind.Frozen) {
-      // frozen | context
-      return ValueKind.MaybeFrozen;
-    } else {
-      // context | immutable
-      return ValueKind.Context;
-    }
-  } else if (a === ValueKind.Frozen || b === ValueKind.Frozen) {
-    return ValueKind.Frozen;
-  } else if (a === ValueKind.Global || b === ValueKind.Global) {
-    return ValueKind.Global;
-  } else {
-    CompilerError.invariant(
-      a === ValueKind.Primitive && b == ValueKind.Primitive,
-      {
-        reason: `Unexpected value kind in mergeValues()`,
-        description: `Found kinds ${a} and ${b}`,
-        loc: GeneratedSource,
-      },
-    );
-    return ValueKind.Primitive;
-  }
-}

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

@@ -27,7 +27,7 @@ import {
 } from '../HIR/visitors';
 import {assertExhaustive, getOrInsertWith} from '../Utils/utils';
 import {Err, Ok, Result} from '../Utils/Result';
-import {AliasingEffect, MutationReason} from './AliasingEffects';
+import {AliasingEffect} from './AliasingEffects';
 
 /**
  * This pass builds an abstract model of the heap and interprets the effects of the
@@ -101,7 +101,6 @@ export function inferMutationAliasingRanges(
     transitive: boolean;
     kind: MutationKind;
     place: Place;
-    reason: MutationReason | null;
   }> = [];
   const renders: Array<{index: number; place: Place}> = [];
 
@@ -141,7 +140,7 @@ export function inferMutationAliasingRanges(
         } else if (effect.kind === 'CreateFunction') {
           state.create(effect.into, {
             kind: 'Function',
-            effect,
+            function: effect.function.loweredFunc.func,
           });
         } else if (effect.kind === 'CreateFrom') {
           state.createFrom(index++, effect.from, effect.into);
@@ -156,7 +155,7 @@ export function inferMutationAliasingRanges(
            * invariant here.
            */
           if (!state.nodes.has(effect.into.identifier)) {
-            state.create(effect.into, {kind: 'Assign'});
+            state.create(effect.into, {kind: 'Object'});
           }
           state.assign(index++, effect.from, effect.into);
         } else if (effect.kind === 'Alias') {
@@ -177,7 +176,6 @@ export function inferMutationAliasingRanges(
               effect.kind === 'MutateTransitive'
                 ? MutationKind.Definite
                 : MutationKind.Conditional,
-            reason: null,
             place: effect.value,
           });
         } else if (
@@ -192,7 +190,6 @@ export function inferMutationAliasingRanges(
               effect.kind === 'Mutate'
                 ? MutationKind.Definite
                 : MutationKind.Conditional,
-            reason: effect.kind === 'Mutate' ? (effect.reason ?? null) : null,
             place: effect.value,
           });
         } else if (
@@ -244,7 +241,6 @@ export function inferMutationAliasingRanges(
       mutation.transitive,
       mutation.kind,
       mutation.place.loc,
-      mutation.reason,
       errors,
     );
   }
@@ -271,7 +267,6 @@ export function inferMutationAliasingRanges(
         functionEffects.push({
           kind: 'Mutate',
           value: {...place, loc: node.local.loc},
-          reason: node.mutationReason,
         });
       }
     }
@@ -474,99 +469,6 @@ export function inferMutationAliasingRanges(
     }
   }
 
-  const tracked: Array<Place> = [];
-  for (const param of [...fn.params, ...fn.context, fn.returns]) {
-    const place = param.kind === 'Identifier' ? param : param.place;
-    tracked.push(place);
-  }
-
-  const returned: Set<Node> = new Set();
-  const queue: Array<Node> = [state.nodes.get(fn.returns.identifier)!];
-  const seen: Set<Node> = new Set();
-  while (queue.length !== 0) {
-    const node = queue.pop()!;
-    if (seen.has(node)) {
-      continue;
-    }
-    seen.add(node);
-    for (const id of node.aliases.keys()) {
-      queue.push(state.nodes.get(id)!);
-    }
-    for (const id of node.createdFrom.keys()) {
-      queue.push(state.nodes.get(id)!);
-    }
-    if (node.id.id === fn.returns.identifier.id) {
-      continue;
-    }
-    switch (node.value.kind) {
-      case 'Assign':
-      case 'CreateFrom': {
-        break;
-      }
-      case 'Phi':
-      case 'Object':
-      case 'Function': {
-        returned.add(node);
-        break;
-      }
-      default: {
-        assertExhaustive(
-          node.value,
-          `Unexpected node value kind '${(node.value as any).kind}'`,
-        );
-      }
-    }
-  }
-  const returnedValues = [...returned];
-  if (
-    returnedValues.length === 1 &&
-    returnedValues[0].value.kind === 'Object' &&
-    tracked.some(place => place.identifier.id === returnedValues[0].id.id)
-  ) {
-    const from = tracked.find(
-      place => place.identifier.id === returnedValues[0].id.id,
-    )!;
-    functionEffects.push({
-      kind: 'Assign',
-      from,
-      into: fn.returns,
-    });
-  } else if (
-    returnedValues.length === 1 &&
-    returnedValues[0].value.kind === 'Function'
-  ) {
-    const outerContext = new Set(fn.context.map(p => p.identifier.id));
-    const effect = returnedValues[0].value.effect;
-    functionEffects.push({
-      kind: 'CreateFunction',
-      function: {
-        ...effect.function,
-        loweredFunc: {
-          func: {
-            ...effect.function.loweredFunc.func,
-            context: effect.function.loweredFunc.func.context.filter(p =>
-              outerContext.has(p.identifier.id),
-            ),
-          },
-        },
-      },
-      captures: effect.captures.filter(p => outerContext.has(p.identifier.id)),
-      into: fn.returns,
-    });
-  } else {
-    const returns = fn.returns.identifier;
-    functionEffects.push({
-      kind: 'Create',
-      into: fn.returns,
-      value: isPrimitiveType(returns)
-        ? ValueKind.Primitive
-        : isJsxType(returns.type)
-          ? ValueKind.Frozen
-          : ValueKind.Mutable,
-      reason: ValueReason.KnownReturnSignature,
-    });
-  }
-
   /**
    * Part 3
    * Finish populating the externally visible effects. Above we bubble-up the side effects
@@ -574,12 +476,28 @@ export function inferMutationAliasingRanges(
    * Here we populate an effect to create the return value as well as populating alias/capture
    * effects for how data flows between the params, context vars, and return.
    */
+  const returns = fn.returns.identifier;
+  functionEffects.push({
+    kind: 'Create',
+    into: fn.returns,
+    value: isPrimitiveType(returns)
+      ? ValueKind.Primitive
+      : isJsxType(returns.type)
+        ? ValueKind.Frozen
+        : ValueKind.Mutable,
+    reason: ValueReason.KnownReturnSignature,
+  });
   /**
    * Determine precise data-flow effects by simulating transitive mutations of the params/
    * captures and seeing what other params/context variables are affected. Anything that
    * 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);
+  }
   for (const into of tracked) {
     const mutationIndex = index++;
     state.mutate(
@@ -589,7 +507,6 @@ export function inferMutationAliasingRanges(
       true,
       MutationKind.Conditional,
       into.loc,
-      null,
       ignoredErrors,
     );
     for (const from of tracked) {
@@ -663,16 +580,10 @@ type Node = {
   transitive: {kind: MutationKind; loc: SourceLocation} | null;
   local: {kind: MutationKind; loc: SourceLocation} | null;
   lastMutated: number;
-  mutationReason: MutationReason | null;
   value:
-    | {kind: 'Assign'}
-    | {kind: 'CreateFrom'}
     | {kind: 'Object'}
     | {kind: 'Phi'}
-    | {
-        kind: 'Function';
-        effect: Extract<AliasingEffect, {kind: 'CreateFunction'}>;
-      };
+    | {kind: 'Function'; function: HIRFunction};
 };
 class AliasingState {
   nodes: Map<Identifier, Node> = new Map();
@@ -688,13 +599,12 @@ class AliasingState {
       transitive: null,
       local: null,
       lastMutated: 0,
-      mutationReason: null,
       value,
     });
   }
 
   createFrom(index: number, from: Place, into: Place): void {
-    this.create(into, {kind: 'CreateFrom'});
+    this.create(into, {kind: 'Object'});
     const fromNode = this.nodes.get(from.identifier);
     const toNode = this.nodes.get(into.identifier);
     if (fromNode == null || toNode == null) {
@@ -756,10 +666,7 @@ class AliasingState {
         continue;
       }
       if (node.value.kind === 'Function') {
-        appendFunctionErrors(
-          errors,
-          node.value.effect.function.loweredFunc.func,
-        );
+        appendFunctionErrors(errors, node.value.function);
       }
       for (const [alias, when] of node.createdFrom) {
         if (when >= index) {
@@ -790,7 +697,6 @@ class AliasingState {
     transitive: boolean,
     startKind: MutationKind,
     loc: SourceLocation,
-    reason: MutationReason | null,
     errors: CompilerError,
   ): void {
     const seen = new Map<Identifier, MutationKind>();
@@ -811,7 +717,6 @@ class AliasingState {
       if (node == null) {
         continue;
       }
-      node.mutationReason ??= reason;
       node.lastMutated = Math.max(node.lastMutated, index);
       if (end != null) {
         node.id.mutableRange.end = makeInstructionId(
@@ -823,10 +728,7 @@ class AliasingState {
         node.transitive == null &&
         node.local == null
       ) {
-        appendFunctionErrors(
-          errors,
-          node.value.effect.function.loweredFunc.func,
-        );
+        appendFunctionErrors(errors, node.value.function);
       }
       if (transitive) {
         if (node.transitive == null || node.transitive.kind < kind) {

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

@@ -0,0 +1,49 @@
+/**
+ * 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 {BlockId, HIRFunction, Identifier} from '../HIR';
+import DisjointSet from '../Utils/DisjointSet';
+
+/*
+ * Any values created within a try/catch block could be aliased to the try handler.
+ * Our lowering ensures that every instruction within a try block will be lowered into a
+ * basic block ending in a maybe-throw terminal that points to its catch block, so we can
+ * iterate such blocks and alias their instruction lvalues to the handler's param (if present).
+ */
+export function inferTryCatchAliases(
+  fn: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  const handlerParams: Map<BlockId, Identifier> = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    if (
+      block.terminal.kind === 'try' &&
+      block.terminal.handlerBinding !== null
+    ) {
+      handlerParams.set(
+        block.terminal.handler,
+        block.terminal.handlerBinding.identifier,
+      );
+    } else if (block.terminal.kind === 'maybe-throw') {
+      const handlerParam = handlerParams.get(block.terminal.handler);
+      if (handlerParam === undefined) {
+        /*
+         * There's no catch clause param, nothing to alias to so
+         * skip this block
+         */
+        continue;
+      }
+      /*
+       * Otherwise alias all values created in this block to the
+       * catch clause param
+       */
+      for (const instr of block.instructions) {
+        aliases.union([handlerParam, instr.lvalue.identifier]);
+      }
+    }
+  }
+}

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

@@ -7,6 +7,8 @@
 
 export {default as analyseFunctions} from './AnalyseFunctions';
 export {dropManualMemoization} from './DropManualMemoization';
+export {inferMutableRanges} from './InferMutableRanges';
 export {inferReactivePlaces} from './InferReactivePlaces';
+export {default as inferReferenceEffects} from './InferReferenceEffects';
 export {inlineImmediatelyInvokedFunctionExpressions} from './InlineImmediatelyInvokedFunctionExpressions';
 export {inferEffectDependencies} from './InferEffectDependencies';

compiler/packages/babel-plugin-react-compiler/src/Optimization/InlineJsxTransform.ts

@@ -42,7 +42,6 @@ import {
   mapInstructionValueOperands,
   mapTerminalOperands,
 } from '../HIR/visitors';
-import {ErrorCategory} from '../CompilerError';
 
 type InlinedJsxDeclarationMap = Map<
   DeclarationId,
@@ -84,7 +83,6 @@ export function inlineJsxTransform(
           kind: 'CompileDiagnostic',
           fnLoc: null,
           detail: {
-            category: ErrorCategory.Todo,
             reason: 'JSX Inlining is not supported on value blocks',
             loc: instr.loc,
           },

compiler/packages/babel-plugin-react-compiler/src/Optimization/LowerContextAccess.ts

@@ -255,6 +255,7 @@ function emitSelectorFn(env: Environment, keys: Array<string>): Instruction {
     returnTypeAnnotation: null,
     returns: createTemporaryPlace(env, GeneratedSource),
     context: [],
+    effects: null,
     body: {
       entry: block.id,
       blocks: new Map([[block.id, block]]),
@@ -262,7 +263,6 @@ function emitSelectorFn(env: Environment, keys: Array<string>): Instruction {
     generator: false,
     async: false,
     directives: [],
-    aliasingEffects: [],
   };
 
   reversePostorderBlocks(fn.body);

compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineJsx.ts

@@ -370,6 +370,7 @@ function emitOutlinedFn(
     returnTypeAnnotation: null,
     returns: createTemporaryPlace(env, GeneratedSource),
     context: [],
+    effects: null,
     body: {
       entry: block.id,
       blocks: new Map([[block.id, block]]),
@@ -377,7 +378,6 @@ function emitOutlinedFn(
     generator: false,
     async: false,
     directives: [],
-    aliasingEffects: [],
   };
   return fn;
 }

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

@@ -13,7 +13,7 @@ import {
   pruneUnusedLabels,
   renameVariables,
 } from '.';
-import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
+import {CompilerError, ErrorSeverity} from '../CompilerError';
 import {Environment, ExternalFunction} from '../HIR';
 import {
   ArrayPattern,
@@ -2185,7 +2185,6 @@ function codegenInstructionValue(
                 (declarator.id as t.Identifier).name
               }'`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: declarator.loc ?? null,
               suggestions: null,
             });
@@ -2194,7 +2193,6 @@ function codegenInstructionValue(
             cx.errors.push({
               reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
               severity: ErrorSeverity.Todo,
-              category: ErrorCategory.Todo,
               loc: stmt.loc ?? null,
               suggestions: null,
             });

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

@@ -24,6 +24,7 @@ import {
   getHookKind,
   isMutableEffect,
 } from '../HIR';
+import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
 import {assertExhaustive, getOrInsertDefault} from '../Utils/utils';
 import {getPlaceScope, ReactiveScope} from '../HIR/HIR';
 import {
@@ -34,7 +35,6 @@ import {
   visitReactiveFunction,
 } from './visitors';
 import {printPlace} from '../HIR/PrintHIR';
-import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
 
 /*
  * This pass prunes reactive scopes that are not necessary to bound downstream computation.

compiler/packages/babel-plugin-react-compiler/src/Transform/TransformFire.ts

@@ -42,7 +42,6 @@ import {
 import {eachInstructionOperand} from '../HIR/visitors';
 import {printSourceLocationLine} from '../HIR/PrintHIR';
 import {USE_FIRE_FUNCTION_NAME} from '../HIR/Environment';
-import {ErrorCategory} from '../CompilerError';
 
 /*
  * TODO(jmbrown):
@@ -134,7 +133,6 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
                   loc: value.loc,
                   description: null,
                   severity: ErrorSeverity.Invariant,
-                  category: ErrorCategory.Invariant,
                   reason: '[InsertFire] No LoadGlobal found for useEffect call',
                   suggestions: null,
                 });
@@ -181,7 +179,6 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
                 description:
                   'You must use an array literal for an effect dependency array when that effect uses `fire()`',
                 severity: ErrorSeverity.Invariant,
-                category: ErrorCategory.Fire,
                 reason: CANNOT_COMPILE_FIRE,
                 suggestions: null,
               });
@@ -192,7 +189,6 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
               description:
                 'You must use an array literal for an effect dependency array when that effect uses `fire()`',
               severity: ErrorSeverity.Invariant,
-              category: ErrorCategory.Fire,
               reason: CANNOT_COMPILE_FIRE,
               suggestions: null,
             });
@@ -227,7 +223,6 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
                 loc: value.loc,
                 description: null,
                 severity: ErrorSeverity.Invariant,
-                category: ErrorCategory.Invariant,
                 reason:
                   '[InsertFire] No loadLocal found for fire call argument',
                 suggestions: null,
@@ -251,7 +246,6 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
               description:
                 '`fire()` can only receive a function call such as `fire(fn(a,b)). Method calls and other expressions are not allowed',
               severity: ErrorSeverity.InvalidReact,
-              category: ErrorCategory.Fire,
               reason: CANNOT_COMPILE_FIRE,
               suggestions: null,
             });
@@ -270,7 +264,6 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
             loc: value.loc,
             description,
             severity: ErrorSeverity.InvalidReact,
-            category: ErrorCategory.Fire,
             reason: CANNOT_COMPILE_FIRE,
             suggestions: null,
           });
@@ -402,7 +395,6 @@ function ensureNoRemainingCalleeCaptures(
 this effect or not used with a fire() call at all. ${calleeName} was used with fire() on line \
 ${printSourceLocationLine(calleeInfo.fireLoc)} in this effect`,
         severity: ErrorSeverity.InvalidReact,
-        category: ErrorCategory.Fire,
         reason: CANNOT_COMPILE_FIRE,
         suggestions: null,
       });
@@ -419,7 +411,6 @@ function ensureNoMoreFireUses(fn: HIRFunction, context: Context): void {
       context.pushError({
         loc: place.identifier.loc,
         description: 'Cannot use `fire` outside of a useEffect function',
-        category: ErrorCategory.Fire,
         severity: ErrorSeverity.Invariant,
         reason: CANNOT_COMPILE_FIRE,
         suggestions: null,

compiler/packages/babel-plugin-react-compiler/src/TypeInference/InferTypes.ts

@@ -777,15 +777,6 @@ class Unifier {
       return {kind: 'Phi', operands: type.operands.map(o => this.get(o))};
     }
 
-    if (type.kind === 'Function') {
-      return {
-        kind: 'Function',
-        isConstructor: type.isConstructor,
-        shapeId: type.shapeId,
-        return: this.get(type.return),
-      };
-    }
-
     return type;
   }
 }

compiler/packages/babel-plugin-react-compiler/src/Utils/Result.ts

@@ -90,13 +90,10 @@ export function Ok<T>(val: T): OkImpl<T> {
 }
 
 class OkImpl<T> implements Result<T, never> {
-  #val: T;
-  constructor(val: T) {
-    this.#val = val;
-  }
+  constructor(private val: T) {}
 
   map<U>(fn: (val: T) => U): Result<U, never> {
-    return new OkImpl(fn(this.#val));
+    return new OkImpl(fn(this.val));
   }
 
   mapErr<F>(_fn: (val: never) => F): Result<T, F> {
@@ -104,15 +101,15 @@ class OkImpl<T> implements Result<T, never> {
   }
 
   mapOr<U>(_fallback: U, fn: (val: T) => U): U {
-    return fn(this.#val);
+    return fn(this.val);
   }
 
   mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U {
-    return fn(this.#val);
+    return fn(this.val);
   }
 
   andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never> {
-    return fn(this.#val);
+    return fn(this.val);
   }
 
   and<U>(res: Result<U, never>): Result<U, never> {
@@ -136,30 +133,30 @@ class OkImpl<T> implements Result<T, never> {
   }
 
   expect(_msg: string): T {
-    return this.#val;
+    return this.val;
   }
 
   expectErr(msg: string): never {
-    throw new Error(`${msg}: ${this.#val}`);
+    throw new Error(`${msg}: ${this.val}`);
   }
 
   unwrap(): T {
-    return this.#val;
+    return this.val;
   }
 
   unwrapOr(_fallback: T): T {
-    return this.#val;
+    return this.val;
   }
 
   unwrapOrElse(_fallback: (val: never) => T): T {
-    return this.#val;
+    return this.val;
   }
 
   unwrapErr(): never {
-    if (this.#val instanceof Error) {
-      throw this.#val;
+    if (this.val instanceof Error) {
+      throw this.val;
     }
-    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.#val}`);
+    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.val}`);
   }
 }
 
@@ -168,17 +165,14 @@ export function Err<E>(val: E): ErrImpl<E> {
 }
 
 class ErrImpl<E> implements Result<never, E> {
-  #val: E;
-  constructor(val: E) {
-    this.#val = val;
-  }
+  constructor(private val: E) {}
 
   map<U>(_fn: (val: never) => U): Result<U, E> {
     return this;
   }
 
   mapErr<F>(fn: (val: E) => F): Result<never, F> {
-    return new ErrImpl(fn(this.#val));
+    return new ErrImpl(fn(this.val));
   }
 
   mapOr<U>(fallback: U, _fn: (val: never) => U): U {
@@ -202,7 +196,7 @@ class ErrImpl<E> implements Result<never, E> {
   }
 
   orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F> {
-    return fn(this.#val);
+    return fn(this.val);
   }
 
   isOk(): this is OkImpl<never> {
@@ -214,18 +208,18 @@ class ErrImpl<E> implements Result<never, E> {
   }
 
   expect(msg: string): never {
-    throw new Error(`${msg}: ${this.#val}`);
+    throw new Error(`${msg}: ${this.val}`);
   }
 
   expectErr(_msg: string): E {
-    return this.#val;
+    return this.val;
   }
 
   unwrap(): never {
-    if (this.#val instanceof Error) {
-      throw this.#val;
+    if (this.val instanceof Error) {
+      throw this.val;
     }
-    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.#val}`);
+    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.val}`);
   }
 
   unwrapOr<T>(fallback: T): T {
@@ -233,10 +227,10 @@ class ErrImpl<E> implements Result<never, E> {
   }
 
   unwrapOrElse<T>(fallback: (val: E) => T): T {
-    return fallback(this.#val);
+    return fallback(this.val);
   }
 
   unwrapErr(): E {
-    return this.#val;
+    return this.val;
   }
 }

compiler/packages/babel-plugin-react-compiler/src/Utils/TestUtils.ts

@@ -182,11 +182,6 @@ export function parseConfigPragmaForTests(
     environment?: PartialEnvironmentConfig;
   },
 ): PluginOptions {
-  const overridePragma = parseConfigPragmaAsString(pragma);
-  if (overridePragma !== '') {
-    return parseConfigStringAsJS(overridePragma, defaults);
-  }
-
   const environment = parseConfigPragmaEnvironmentForTest(
     pragma,
     defaults.environment ?? {},
@@ -222,104 +217,3 @@ export function parseConfigPragmaForTests(
   }
   return parsePluginOptions(options);
 }
-
-export function parseConfigPragmaAsString(pragma: string): string {
-  // Check if it's in JS override format
-  for (const {key, value: val} of splitPragma(pragma)) {
-    if (key === 'OVERRIDE' && val != null) {
-      return val;
-    }
-  }
-  return '';
-}
-
-function parseConfigStringAsJS(
-  configString: string,
-  defaults: {
-    compilationMode: CompilationMode;
-    environment?: PartialEnvironmentConfig;
-  },
-): PluginOptions {
-  let parsedConfig: any;
-  try {
-    // Parse the JavaScript object literal
-    parsedConfig = new Function(`return ${configString}`)();
-  } catch (error) {
-    CompilerError.invariant(false, {
-      reason: 'Failed to parse config pragma as JavaScript object',
-      description: `Could not parse: ${configString}. Error: ${error}`,
-      loc: null,
-      suggestions: null,
-    });
-  }
-
-  console.log('OVERRIDE:', parsedConfig);
-
-  const options: Record<keyof PluginOptions, unknown> = {
-    ...defaultOptions,
-    panicThreshold: 'all_errors',
-    compilationMode: defaults.compilationMode,
-    environment: defaults.environment ?? defaultOptions.environment,
-  };
-
-  // Apply parsed config, merging environment if it exists
-  if (parsedConfig.environment) {
-    const mergedEnvironment = {
-      ...(options.environment as Record<string, unknown>),
-      ...parsedConfig.environment,
-    };
-
-    // Apply complex defaults for environment flags that are set to true
-    const environmentConfig: Partial<Record<keyof EnvironmentConfig, unknown>> =
-      {};
-    for (const [key, value] of Object.entries(mergedEnvironment)) {
-      if (hasOwnProperty(EnvironmentConfigSchema.shape, key)) {
-        if (value === true && key in testComplexConfigDefaults) {
-          environmentConfig[key] = testComplexConfigDefaults[key];
-        } else {
-          environmentConfig[key] = value;
-        }
-      }
-    }
-
-    // Validate environment config
-    const validatedEnvironment =
-      EnvironmentConfigSchema.safeParse(environmentConfig);
-    if (!validatedEnvironment.success) {
-      CompilerError.invariant(false, {
-        reason: 'Invalid environment configuration in config pragma',
-        description: `${fromZodError(validatedEnvironment.error)}`,
-        loc: null,
-        suggestions: null,
-      });
-    }
-
-    if (validatedEnvironment.data.enableResetCacheOnSourceFileChanges == null) {
-      validatedEnvironment.data.enableResetCacheOnSourceFileChanges = false;
-    }
-
-    options.environment = validatedEnvironment.data;
-  }
-
-  // Apply other config options
-  for (const [key, value] of Object.entries(parsedConfig)) {
-    if (key === 'environment') {
-      continue;
-    }
-
-    if (hasOwnProperty(defaultOptions, key)) {
-      if (value === true && key in testComplexPluginOptionDefaults) {
-        options[key] = testComplexPluginOptionDefaults[key];
-      } else if (key === 'target' && value === 'donotuse_meta_internal') {
-        options[key] = {
-          kind: value,
-          runtimeModule: 'react',
-        };
-      } else {
-        options[key] = value;
-      }
-    }
-  }
-
-  return parsePluginOptions(options);
-}

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

@@ -9,7 +9,6 @@ import * as t from '@babel/types';
 import {
   CompilerError,
   CompilerErrorDetail,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
@@ -125,7 +124,6 @@ export function validateHooksUsage(
       recordError(
         place.loc,
         new CompilerErrorDetail({
-          category: ErrorCategory.Hooks,
           description: null,
           reason,
           loc: place.loc,
@@ -142,7 +140,6 @@ export function validateHooksUsage(
       recordError(
         place.loc,
         new CompilerErrorDetail({
-          category: ErrorCategory.Hooks,
           description: null,
           reason:
             'Hooks may not be referenced as normal values, they must be called. See https://react.dev/reference/rules/react-calls-components-and-hooks#never-pass-around-hooks-as-regular-values',
@@ -160,7 +157,6 @@ export function validateHooksUsage(
       recordError(
         place.loc,
         new CompilerErrorDetail({
-          category: ErrorCategory.Hooks,
           description: null,
           reason:
             'Hooks must be the same function on every render, but this value may change over time to a different function. See https://react.dev/reference/rules/react-calls-components-and-hooks#dont-dynamically-use-hooks',
@@ -428,7 +424,7 @@ export function validateHooksUsage(
   }
 
   for (const [, error] of errorsByPlace) {
-    errors.pushErrorDetail(error);
+    errors.push(error);
   }
   return errors.asResult();
 }
@@ -452,7 +448,6 @@ function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {
           if (hookKind != null) {
             errors.pushErrorDetail(
               new CompilerErrorDetail({
-                category: ErrorCategory.Hooks,
                 severity: ErrorSeverity.InvalidReact,
                 reason:
                   'Hooks must be called at the top level in the body of a function component or custom hook, and may not be called within function expressions. See the Rules of Hooks (https://react.dev/warnings/invalid-hook-call-warning)',

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

@@ -6,14 +6,13 @@
  */
 
 import {CompilerDiagnostic, CompilerError, Effect, ErrorSeverity} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId, Place} from '../HIR';
 import {
   eachInstructionLValue,
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
+import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
 
 /**
  * Validates that local variables cannot be reassigned after render.
@@ -37,9 +36,8 @@ export function validateLocalsNotReassignedAfterRender(fn: HIRFunction): void {
         : 'variable';
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.Immutability,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot reassign variable after render completes',
+        category: 'Cannot reassign variable after render completes',
         description: `Reassigning ${variable} after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.`,
       }).withDetail({
         kind: 'error',
@@ -93,9 +91,8 @@ function getContextReassignment(
                   : 'variable';
               errors.pushDiagnostic(
                 CompilerDiagnostic.create({
-                  category: ErrorCategory.Immutability,
                   severity: ErrorSeverity.InvalidReact,
-                  reason: 'Cannot reassign variable in async function',
+                  category: 'Cannot reassign variable in async function',
                   description:
                     'Reassigning a variable in an async function can cause inconsistent behavior on subsequent renders. Consider using state instead',
                 }).withDetail({

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

@@ -6,7 +6,6 @@
  */
 
 import {CompilerError, ErrorSeverity} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {
   Identifier,
   Instruction,
@@ -109,7 +108,6 @@ class Visitor extends ReactiveFunctionVisitor<CompilerError> {
           isUnmemoized(deps.identifier, this.scopes))
       ) {
         state.push({
-          category: ErrorCategory.EffectDependencies,
           reason:
             'React Compiler has skipped optimizing this component because the effect dependencies could not be memoized. Unmemoized effect dependencies can trigger an infinite loop or other unexpected behavior',
           description: null,

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

@@ -6,7 +6,6 @@
  */
 
 import {CompilerError, EnvironmentConfig, ErrorSeverity} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId} from '../HIR';
 import {DEFAULT_GLOBALS} from '../HIR/Globals';
 import {Result} from '../Utils/Result';
@@ -57,7 +56,6 @@ export function validateNoCapitalizedCalls(
           const calleeName = capitalLoadGlobals.get(calleeIdentifier);
           if (calleeName != null) {
             CompilerError.throwInvalidReact({
-              category: ErrorCategory.CapitalizedCalls,
               reason,
               description: `${calleeName} may be a component.`,
               loc: value.loc,
@@ -81,7 +79,6 @@ export function validateNoCapitalizedCalls(
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
             errors.push({
-              category: ErrorCategory.CapitalizedCalls,
               severity: ErrorSeverity.InvalidReact,
               reason,
               description: `${propertyName} may be a component.`,

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

@@ -6,7 +6,6 @@
  */
 
 import {CompilerError, ErrorSeverity, SourceLocation} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {
   ArrayExpression,
   BlockId,
@@ -220,7 +219,6 @@ function validateEffect(
 
   for (const loc of setStateLocations) {
     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,

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

@@ -6,10 +6,11 @@
  */
 
 import {CompilerDiagnostic, CompilerError, Effect, ErrorSeverity} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {
+  FunctionEffect,
   HIRFunction,
   IdentifierId,
+  isMutableEffect,
   isRefOrRefLikeMutableType,
   Place,
 } from '../HIR';
@@ -17,8 +18,8 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {AliasingEffect} from '../Inference/AliasingEffects';
 import {Result} from '../Utils/Result';
+import {Iterable_some} from '../Utils/utils';
 
 /**
  * Validates that functions with known mutations (ie due to types) cannot be passed
@@ -49,14 +50,14 @@ export function validateNoFreezingKnownMutableFunctions(
   const errors = new CompilerError();
   const contextMutationEffects: Map<
     IdentifierId,
-    Extract<AliasingEffect, {kind: 'Mutate'} | {kind: 'MutateTransitive'}>
+    Extract<FunctionEffect, {kind: 'ContextMutation'}>
   > = new Map();
 
   function visitOperand(operand: Place): void {
     if (operand.effect === Effect.Freeze) {
       const effect = contextMutationEffects.get(operand.identifier.id);
       if (effect != null) {
-        const place = effect.value;
+        const place = [...effect.places][0];
         const variable =
           place != null &&
           place.identifier.name != null &&
@@ -65,9 +66,8 @@ export function validateNoFreezingKnownMutableFunctions(
             : 'a local variable';
         errors.pushDiagnostic(
           CompilerDiagnostic.create({
-            category: ErrorCategory.Immutability,
             severity: ErrorSeverity.InvalidReact,
-            reason: 'Cannot modify local variables after render completes',
+            category: 'Cannot modify local variables after render completes',
             description: `This argument is a function which may reassign or mutate ${variable} after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.`,
           })
             .withDetail({
@@ -77,7 +77,7 @@ export function validateNoFreezingKnownMutableFunctions(
             })
             .withDetail({
               kind: 'error',
-              loc: effect.value.loc,
+              loc: effect.loc,
               message: `This modifies ${variable}`,
             }),
         );
@@ -108,7 +108,27 @@ export function validateNoFreezingKnownMutableFunctions(
           break;
         }
         case 'FunctionExpression': {
-          if (value.loweredFunc.func.aliasingEffects != null) {
+          const knownMutation = (value.loweredFunc.func.effects ?? []).find(
+            effect => {
+              return (
+                effect.kind === 'ContextMutation' &&
+                (effect.effect === Effect.Store ||
+                  effect.effect === Effect.Mutate) &&
+                Iterable_some(effect.places, place => {
+                  return (
+                    isMutableEffect(place.effect, place.loc) &&
+                    !isRefOrRefLikeMutableType(place.identifier.type)
+                  );
+                })
+              );
+            },
+          );
+          if (knownMutation && knownMutation.kind === 'ContextMutation') {
+            contextMutationEffects.set(lvalue.identifier.id, knownMutation);
+          } else if (
+            fn.env.config.enableNewMutationAliasingModel &&
+            value.loweredFunc.func.aliasingEffects != null
+          ) {
             const context = new Set(
               value.loweredFunc.func.context.map(p => p.identifier.id),
             );
@@ -129,7 +149,12 @@ export function validateNoFreezingKnownMutableFunctions(
                     context.has(effect.value.identifier.id) &&
                     !isRefOrRefLikeMutableType(effect.value.identifier.type)
                   ) {
-                    contextMutationEffects.set(lvalue.identifier.id, effect);
+                    contextMutationEffects.set(lvalue.identifier.id, {
+                      kind: 'ContextMutation',
+                      effect: Effect.Mutate,
+                      loc: effect.value.loc,
+                      places: new Set([effect.value]),
+                    });
                     break effects;
                   }
                   break;

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

@@ -6,9 +6,8 @@
  */
 
 import {CompilerDiagnostic, CompilerError, ErrorSeverity} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {HIRFunction} from '../HIR';
-import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
+import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
 import {Result} from '../Utils/Result';
 
 /**
@@ -37,8 +36,7 @@ export function validateNoImpureFunctionsInRender(
         if (signature != null && signature.impure === true) {
           errors.pushDiagnostic(
             CompilerDiagnostic.create({
-              category: ErrorCategory.Purity,
-              reason: 'Cannot call impure function during render',
+              category: 'Cannot call impure function during render',
               description:
                 (signature.canonicalName != null
                   ? `\`${signature.canonicalName}\` is an impure function. `

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

@@ -6,7 +6,6 @@
  */
 
 import {CompilerDiagnostic, CompilerError, ErrorSeverity} from '..';
-import {ErrorCategory} from '../CompilerError';
 import {BlockId, HIRFunction} from '../HIR';
 import {Result} from '../Utils/Result';
 import {retainWhere} from '../Utils/utils';
@@ -37,9 +36,8 @@ export function validateNoJSXInTryStatement(
           case 'JsxFragment': {
             errors.pushDiagnostic(
               CompilerDiagnostic.create({
-                category: ErrorCategory.ErrorBoundaries,
                 severity: ErrorSeverity.InvalidReact,
-                reason: 'Avoid constructing JSX within try/catch',
+                category: 'Avoid constructing JSX within try/catch',
                 description: `React does not immediately render components when JSX is rendered, so any errors from this component will not be caught by the try/catch. To catch errors in rendering a given component, wrap that component in an error boundary. (https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary)`,
               }).withDetail({
                 kind: 'error',

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

@@ -8,7 +8,6 @@
 import {
   CompilerDiagnostic,
   CompilerError,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {
@@ -469,9 +468,8 @@ function validateNoRefAccessInRenderImpl(
                 didError = true;
                 errors.pushDiagnostic(
                   CompilerDiagnostic.create({
-                    category: ErrorCategory.Refs,
                     severity: ErrorSeverity.InvalidReact,
-                    reason: 'Cannot access refs during render',
+                    category: 'Cannot access refs during render',
                     description: ERROR_DESCRIPTION,
                   }).withDetail({
                     kind: 'error',
@@ -733,9 +731,8 @@ function guardCheck(errors: CompilerError, operand: Place, env: Env): void {
   if (env.get(operand.identifier.id)?.kind === 'Guard') {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.Refs,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot access refs during render',
+        category: 'Cannot access refs during render',
         description: ERROR_DESCRIPTION,
       }).withDetail({
         kind: 'error',
@@ -758,9 +755,8 @@ function validateNoRefValueAccess(
   ) {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.Refs,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot access refs during render',
+        category: 'Cannot access refs during render',
         description: ERROR_DESCRIPTION,
       }).withDetail({
         kind: 'error',
@@ -785,9 +781,8 @@ function validateNoRefPassedToFunction(
   ) {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.Refs,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot access refs during render',
+        category: 'Cannot access refs during render',
         description: ERROR_DESCRIPTION,
       }).withDetail({
         kind: 'error',
@@ -808,9 +803,8 @@ function validateNoRefUpdate(
   if (type?.kind === 'Ref' || type?.kind === 'RefValue') {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.Refs,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot access refs during render',
+        category: 'Cannot access refs during render',
         description: ERROR_DESCRIPTION,
       }).withDetail({
         kind: 'error',
@@ -830,9 +824,8 @@ function validateNoDirectRefValueAccess(
   if (type?.kind === 'RefValue') {
     errors.pushDiagnostic(
       CompilerDiagnostic.create({
-        category: ErrorCategory.Refs,
         severity: ErrorSeverity.InvalidReact,
-        reason: 'Cannot access refs during render',
+        category: 'Cannot access refs during render',
         description: ERROR_DESCRIPTION,
       }).withDetail({
         kind: 'error',

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

@@ -8,7 +8,6 @@
 import {
   CompilerDiagnostic,
   CompilerError,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {
@@ -97,8 +96,7 @@ export function validateNoSetStateInEffects(
               if (setState !== undefined) {
                 errors.pushDiagnostic(
                   CompilerDiagnostic.create({
-                    category: ErrorCategory.EffectSetState,
-                    reason:
+                    category:
                       'Calling setState synchronously within an effect can trigger cascading renders',
                     description:
                       'Effects are intended to synchronize state between React and external systems such as manually updating the DOM, state management libraries, or other platform APIs. ' +

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

@@ -8,7 +8,6 @@
 import {
   CompilerDiagnostic,
   CompilerError,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {HIRFunction, IdentifierId, isSetStateType} from '../HIR';
@@ -129,8 +128,7 @@ function validateNoSetStateInRenderImpl(
             if (activeManualMemoId !== null) {
               errors.pushDiagnostic(
                 CompilerDiagnostic.create({
-                  category: ErrorCategory.RenderSetState,
-                  reason:
+                  category:
                     'Calling setState from useMemo may trigger an infinite loop',
                   description:
                     'Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState)',
@@ -145,8 +143,7 @@ function validateNoSetStateInRenderImpl(
             } else if (unconditionalBlocks.has(block.id)) {
               errors.pushDiagnostic(
                 CompilerDiagnostic.create({
-                  category: ErrorCategory.RenderSetState,
-                  reason:
+                  category:
                     'Calling setState during render may trigger an infinite loop',
                   description:
                     'Calling setState during render will trigger another render, and can lead to infinite loops. (https://react.dev/reference/react/useState)',
@@ -155,7 +152,7 @@ function validateNoSetStateInRenderImpl(
                 }).withDetail({
                   kind: 'error',
                   loc: callee.loc,
-                  message: 'Found setState() in render',
+                  message: 'Found setState() within useMemo()',
                 }),
               );
             }

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

@@ -8,7 +8,6 @@
 import {
   CompilerDiagnostic,
   CompilerError,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {
@@ -282,9 +281,8 @@ function validateInferredDep(
   }
   errorState.pushDiagnostic(
     CompilerDiagnostic.create({
-      category: ErrorCategory.PreserveManualMemo,
       severity: ErrorSeverity.CannotPreserveMemoization,
-      reason:
+      category:
         'Compilation skipped because existing memoization could not be preserved',
       description: [
         'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. ',
@@ -537,9 +535,8 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
         ) {
           state.errors.pushDiagnostic(
             CompilerDiagnostic.create({
-              category: ErrorCategory.PreserveManualMemo,
               severity: ErrorSeverity.CannotPreserveMemoization,
-              reason:
+              category:
                 'Compilation skipped because existing memoization could not be preserved',
               description: [
                 'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. ',
@@ -586,9 +583,8 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
             if (isUnmemoized(identifier, this.scopes)) {
               state.errors.pushDiagnostic(
                 CompilerDiagnostic.create({
-                  category: ErrorCategory.PreserveManualMemo,
                   severity: ErrorSeverity.CannotPreserveMemoization,
-                  reason:
+                  category:
                     'Compilation skipped because existing memoization could not be preserved',
                   description: [
                     'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. This value was memoized in source but not in compilation output. ',

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

@@ -8,7 +8,6 @@
 import {
   CompilerDiagnostic,
   CompilerError,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {HIRFunction, IdentifierId, SourceLocation} from '../HIR';
@@ -66,9 +65,8 @@ export function validateStaticComponents(
             if (location != null) {
               error.pushDiagnostic(
                 CompilerDiagnostic.create({
-                  category: ErrorCategory.StaticComponents,
                   severity: ErrorSeverity.InvalidReact,
-                  reason: 'Cannot create components during render',
+                  category: 'Cannot create components during render',
                   description: `Components created during render will reset their state each time they are created. Declare components outside of render. `,
                 })
                   .withDetail({

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

@@ -8,7 +8,6 @@
 import {
   CompilerDiagnostic,
   CompilerError,
-  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {FunctionExpression, HIRFunction, IdentifierId} from '../HIR';
@@ -75,9 +74,8 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
                 : firstParam.place.loc;
             errors.pushDiagnostic(
               CompilerDiagnostic.create({
-                category: ErrorCategory.UseMemo,
                 severity: ErrorSeverity.InvalidReact,
-                reason: 'useMemo() callbacks may not accept parameters',
+                category: 'useMemo() callbacks may not accept parameters',
                 description:
                   'useMemo() callbacks are called by React to cache calculations across re-renders. They should not take parameters. Instead, directly reference the props, state, or local variables needed for the computation.',
                 suggestions: null,
@@ -92,9 +90,8 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
             errors.pushDiagnostic(
               CompilerDiagnostic.create({
-                category: ErrorCategory.UseMemo,
                 severity: ErrorSeverity.InvalidReact,
-                reason:
+                category:
                   'useMemo() callbacks may not be async or generator functions',
                 description:
                   'useMemo() callbacks are called once and must synchronously return a value.',

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/allow-assigning-to-global-in-function-spread-as-jsx.expect.md

@@ -1,39 +0,0 @@
-
-## Input
-
-```javascript
-// @enableNewMutationAliasingModel:false
-function Component() {
-  const foo = () => {
-    someGlobal = true;
-  };
-  // spreading a function is weird, but it doesn't call the function so this is allowed
-  return <div {...foo} />;
-}
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel:false
-function Component() {
-  const $ = _c(1);
-  const foo = _temp;
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = <div {...foo} />;
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return t0;
-}
-function _temp() {
-  someGlobal = true;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-aliased-mutate.expect.md

@@ -0,0 +1,107 @@
+
+## Input
+
+```javascript
+// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
+import {arrayPush, setPropertyByKey, Stringify} from 'shared-runtime';
+
+/**
+ * 1. `InferMutableRanges` derives the mutable range of identifiers and their
+ *     aliases from `LoadLocal`, `PropertyLoad`, etc
+ *   - After this pass, y's mutable range only extends to `arrayPush(x, y)`
+ *   - We avoid assigning mutable ranges to loads after y's mutable range, as
+ *     these are working with an immutable value. As a result, `LoadLocal y` and
+ *     `PropertyLoad y` do not get mutable ranges
+ * 2. `InferReactiveScopeVariables` extends mutable ranges and creates scopes,
+ *    as according to the 'co-mutation' of different values
+ *   - Here, we infer that
+ *     - `arrayPush(y, x)` might alias `x` and `y` to each other
+ *     - `setPropertyKey(x, ...)` may mutate both `x` and `y`
+ *   - This pass correctly extends the mutable range of `y`
+ *   - Since we didn't run `InferMutableRange` logic again, the LoadLocal /
+ *     PropertyLoads still don't have a mutable range
+ *
+ * Note that the this bug is an edge case. Compiler output is only invalid for:
+ *  - function expressions with
+ *    `enableTransitivelyFreezeFunctionExpressions:false`
+ *  - functions that throw and get retried without clearing the memocache
+ *
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":11},"shouldInvokeFns":true}</div>
+ * Forget:
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
+ */
+function useFoo({a, b}: {a: number, b: number}) {
+  const x = [];
+  const y = {value: a};
+
+  arrayPush(x, y); // x and y co-mutate
+  const y_alias = y;
+  const cb = () => y_alias.value;
+  setPropertyByKey(x[0], 'value', b); // might overwrite y.value
+  return <Stringify cb={cb} shouldInvokeFns={true} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [{a: 2, b: 10}],
+  sequentialRenders: [
+    {a: 2, b: 10},
+    {a: 2, b: 11},
+  ],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { arrayPush, setPropertyByKey, Stringify } from "shared-runtime";
+
+function useFoo(t0) {
+  const $ = _c(5);
+  const { a, b } = t0;
+  let t1;
+  if ($[0] !== a || $[1] !== b) {
+    const x = [];
+    const y = { value: a };
+
+    arrayPush(x, y);
+    const y_alias = y;
+    let t2;
+    if ($[3] !== y_alias.value) {
+      t2 = () => y_alias.value;
+      $[3] = y_alias.value;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    const cb = t2;
+    setPropertyByKey(x[0], "value", b);
+    t1 = <Stringify cb={cb} shouldInvokeFns={true} />;
+    $[0] = a;
+    $[1] = b;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [{ a: 2, b: 10 }],
+  sequentialRenders: [
+    { a: 2, b: 10 },
+    { a: 2, b: 11 },
+  ],
+};
+
+```
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-aliased-mutate.js

@@ -0,0 +1,53 @@
+// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
+import {arrayPush, setPropertyByKey, Stringify} from 'shared-runtime';
+
+/**
+ * 1. `InferMutableRanges` derives the mutable range of identifiers and their
+ *     aliases from `LoadLocal`, `PropertyLoad`, etc
+ *   - After this pass, y's mutable range only extends to `arrayPush(x, y)`
+ *   - We avoid assigning mutable ranges to loads after y's mutable range, as
+ *     these are working with an immutable value. As a result, `LoadLocal y` and
+ *     `PropertyLoad y` do not get mutable ranges
+ * 2. `InferReactiveScopeVariables` extends mutable ranges and creates scopes,
+ *    as according to the 'co-mutation' of different values
+ *   - Here, we infer that
+ *     - `arrayPush(y, x)` might alias `x` and `y` to each other
+ *     - `setPropertyKey(x, ...)` may mutate both `x` and `y`
+ *   - This pass correctly extends the mutable range of `y`
+ *   - Since we didn't run `InferMutableRange` logic again, the LoadLocal /
+ *     PropertyLoads still don't have a mutable range
+ *
+ * Note that the this bug is an edge case. Compiler output is only invalid for:
+ *  - function expressions with
+ *    `enableTransitivelyFreezeFunctionExpressions:false`
+ *  - functions that throw and get retried without clearing the memocache
+ *
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":11},"shouldInvokeFns":true}</div>
+ * Forget:
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
+ */
+function useFoo({a, b}: {a: number, b: number}) {
+  const x = [];
+  const y = {value: a};
+
+  arrayPush(x, y); // x and y co-mutate
+  const y_alias = y;
+  const cb = () => y_alias.value;
+  setPropertyByKey(x[0], 'value', b); // might overwrite y.value
+  return <Stringify cb={cb} shouldInvokeFns={true} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [{a: 2, b: 10}],
+  sequentialRenders: [
+    {a: 2, b: 10},
+    {a: 2, b: 11},
+  ],
+};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-mutate.expect.md

@@ -0,0 +1,87 @@
+
+## Input
+
+```javascript
+// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
+import {setPropertyByKey, Stringify} from 'shared-runtime';
+
+/**
+ * Variation of bug in `bug-aliased-capture-aliased-mutate`
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":3},"shouldInvokeFns":true}</div>
+ * Forget:
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
+ */
+
+function useFoo({a}: {a: number, b: number}) {
+  const arr = [];
+  const obj = {value: a};
+
+  setPropertyByKey(obj, 'arr', arr);
+  const obj_alias = obj;
+  const cb = () => obj_alias.arr.length;
+  for (let i = 0; i < a; i++) {
+    arr.push(i);
+  }
+  return <Stringify cb={cb} shouldInvokeFns={true} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [{a: 2}],
+  sequentialRenders: [{a: 2}, {a: 3}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { setPropertyByKey, Stringify } from "shared-runtime";
+
+function useFoo(t0) {
+  const $ = _c(4);
+  const { a } = t0;
+  let t1;
+  if ($[0] !== a) {
+    const arr = [];
+    const obj = { value: a };
+
+    setPropertyByKey(obj, "arr", arr);
+    const obj_alias = obj;
+    let t2;
+    if ($[2] !== obj_alias.arr.length) {
+      t2 = () => obj_alias.arr.length;
+      $[2] = obj_alias.arr.length;
+      $[3] = t2;
+    } else {
+      t2 = $[3];
+    }
+    const cb = t2;
+    for (let i = 0; i < a; i++) {
+      arr.push(i);
+    }
+
+    t1 = <Stringify cb={cb} shouldInvokeFns={true} />;
+    $[0] = a;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [{ a: 2 }],
+  sequentialRenders: [{ a: 2 }, { a: 3 }],
+};
+
+```
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-mutate.js

@@ -0,0 +1,34 @@
+// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
+import {setPropertyByKey, Stringify} from 'shared-runtime';
+
+/**
+ * Variation of bug in `bug-aliased-capture-aliased-mutate`
+ * Found differences in evaluator results
+ * Non-forget (expected):
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":3},"shouldInvokeFns":true}</div>
+ * Forget:
+ *   (kind: ok)
+ *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
+ *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
+ */
+
+function useFoo({a}: {a: number, b: number}) {
+  const arr = [];
+  const obj = {value: a};
+
+  setPropertyByKey(obj, 'arr', arr);
+  const obj_alias = obj;
+  const cb = () => obj_alias.arr.length;
+  for (let i = 0; i < a; i++) {
+    arr.push(i);
+  }
+  return <Stringify cb={cb} shouldInvokeFns={true} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: useFoo,
+  params: [{a: 2}],
+  sequentialRenders: [{a: 2}, {a: 3}],
+};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.expect.md

@@ -85,11 +85,19 @@ import { makeArray, mutate } from "shared-runtime";
  * used when we analyze CallExpressions.
  */
 function Component(t0) {
-  const $ = _c(3);
+  const $ = _c(5);
   const { foo, bar } = t0;
+  let t1;
+  if ($[0] !== foo) {
+    t1 = { foo };
+    $[0] = foo;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const x = t1;
   let y;
-  if ($[0] !== bar || $[1] !== foo) {
-    const x = { foo };
+  if ($[2] !== bar || $[3] !== x) {
     y = { bar };
     const f0 = function () {
       const a = makeArray(y);
@@ -100,11 +108,11 @@ function Component(t0) {
 
     f0();
     mutate(y.x);
-    $[0] = bar;
-    $[1] = foo;
-    $[2] = y;
+    $[2] = bar;
+    $[3] = x;
+    $[4] = y;
   } else {
-    y = $[2];
+    y = $[4];
   }
   return y;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-invalid-phi-as-dependency.expect.md

@@ -0,0 +1,92 @@
+
+## Input
+
+```javascript
+// @enableNewMutationAliasingModel:false
+import {CONST_TRUE, Stringify, mutate, useIdentity} from 'shared-runtime';
+
+/**
+ * Fixture showing an edge case for ReactiveScope variable propagation.
+ *
+ * Found differences in evaluator results
+ *   Non-forget (expected):
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   Forget:
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   [[ (exception in render) Error: invariant broken ]]
+ *
+ */
+function Component() {
+  const obj = CONST_TRUE ? {inner: {value: 'hello'}} : null;
+  const boxedInner = [obj?.inner];
+  useIdentity(null);
+  mutate(obj);
+  if (boxedInner[0] !== obj?.inner) {
+    throw new Error('invariant broken');
+  }
+  return <Stringify obj={obj} inner={boxedInner} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{arg: 0}],
+  sequentialRenders: [{arg: 0}, {arg: 1}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel:false
+import { CONST_TRUE, Stringify, mutate, useIdentity } from "shared-runtime";
+
+/**
+ * Fixture showing an edge case for ReactiveScope variable propagation.
+ *
+ * Found differences in evaluator results
+ *   Non-forget (expected):
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   Forget:
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   [[ (exception in render) Error: invariant broken ]]
+ *
+ */
+function Component() {
+  const $ = _c(4);
+  const obj = CONST_TRUE ? { inner: { value: "hello" } } : null;
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [obj?.inner];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const boxedInner = t0;
+  useIdentity(null);
+  mutate(obj);
+  if (boxedInner[0] !== obj?.inner) {
+    throw new Error("invariant broken");
+  }
+  let t1;
+  if ($[1] !== boxedInner || $[2] !== obj) {
+    t1 = <Stringify obj={obj} inner={boxedInner} />;
+    $[1] = boxedInner;
+    $[2] = obj;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  return t1;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ arg: 0 }],
+  sequentialRenders: [{ arg: 0 }, { arg: 1 }],
+};
+
+```
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-invalid-phi-as-dependency.tsx

@@ -0,0 +1,31 @@
+// @enableNewMutationAliasingModel:false
+import {CONST_TRUE, Stringify, mutate, useIdentity} from 'shared-runtime';
+
+/**
+ * Fixture showing an edge case for ReactiveScope variable propagation.
+ *
+ * Found differences in evaluator results
+ *   Non-forget (expected):
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   Forget:
+ *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
+ *   [[ (exception in render) Error: invariant broken ]]
+ *
+ */
+function Component() {
+  const obj = CONST_TRUE ? {inner: {value: 'hello'}} : null;
+  const boxedInner = [obj?.inner];
+  useIdentity(null);
+  mutate(obj);
+  if (boxedInner[0] !== obj?.inner) {
+    throw new Error('invariant broken');
+  }
+  return <Stringify obj={obj} inner={boxedInner} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{arg: 0}],
+  sequentialRenders: [{arg: 0}, {arg: 1}],
+};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-object-expression-computed-key-modified-during-after-construction-hoisted-sequence-expr.expect.md

@@ -0,0 +1,110 @@
+
+## Input
+
+```javascript
+// @enableNewMutationAliasingModel:false
+import {identity, mutate} from 'shared-runtime';
+
+/**
+ * Bug: copy of error.todo-object-expression-computed-key-modified-during-after-construction-sequence-expr
+ * with the mutation hoisted to a named variable instead of being directly
+ * inlined into the Object key.
+ *
+ * Found differences in evaluator results
+ *   Non-forget (expected):
+ *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   Forget:
+ *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe","wat2":"joe"}]
+ */
+function Component(props) {
+  const key = {};
+  const tmp = (mutate(key), key);
+  const context = {
+    // Here, `tmp` is frozen (as it's inferred to be a primitive/string)
+    [tmp]: identity([props.value]),
+  };
+  mutate(key);
+  return [context, key];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{value: 42}],
+  sequentialRenders: [{value: 42}, {value: 42}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel:false
+import { identity, mutate } from "shared-runtime";
+
+/**
+ * Bug: copy of error.todo-object-expression-computed-key-modified-during-after-construction-sequence-expr
+ * with the mutation hoisted to a named variable instead of being directly
+ * inlined into the Object key.
+ *
+ * Found differences in evaluator results
+ *   Non-forget (expected):
+ *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   Forget:
+ *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe","wat2":"joe"}]
+ */
+function Component(props) {
+  const $ = _c(8);
+  let key;
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    key = {};
+    t0 = (mutate(key), key);
+    $[0] = key;
+    $[1] = t0;
+  } else {
+    key = $[0];
+    t0 = $[1];
+  }
+  const tmp = t0;
+  let t1;
+  if ($[2] !== props.value) {
+    t1 = identity([props.value]);
+    $[2] = props.value;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== t1) {
+    t2 = { [tmp]: t1 };
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const context = t2;
+
+  mutate(key);
+  let t3;
+  if ($[6] !== context) {
+    t3 = [context, key];
+    $[6] = context;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  return t3;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{ value: 42 }],
+  sequentialRenders: [{ value: 42 }, { value: 42 }],
+};
+
+```
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-object-expression-computed-key-modified-during-after-construction-hoisted-sequence-expr.js

@@ -0,0 +1,32 @@
+// @enableNewMutationAliasingModel:false
+import {identity, mutate} from 'shared-runtime';
+
+/**
+ * Bug: copy of error.todo-object-expression-computed-key-modified-during-after-construction-sequence-expr
+ * with the mutation hoisted to a named variable instead of being directly
+ * inlined into the Object key.
+ *
+ * Found differences in evaluator results
+ *   Non-forget (expected):
+ *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   Forget:
+ *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
+ *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe","wat2":"joe"}]
+ */
+function Component(props) {
+  const key = {};
+  const tmp = (mutate(key), key);
+  const context = {
+    // Here, `tmp` is frozen (as it's inferred to be a primitive/string)
+    [tmp]: identity([props.value]),
+  };
+  mutate(key);
+  return [context, key];
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{value: 42}],
+  sequentialRenders: [{value: 42}, {value: 42}],
+};

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

@@ -24,18 +24,9 @@ function useThing(fn) {
 ```
 Found 1 error:
 
-Error: `this` is not supported syntax
+Error: Expected a non-reserved 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 |   }
+`this` is a reserved word in JavaScript and cannot be used as an identifier name.
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-global-in-jsx-spread-attribute.expect.md

@@ -0,0 +1,33 @@
+
+## Input
+
+```javascript
+// @enableNewMutationAliasingModel:false
+function Component() {
+  const foo = () => {
+    someGlobal = true;
+  };
+  return <div {...foo} />;
+}
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Error: Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
+
+error.assign-global-in-jsx-spread-attribute.ts:4:4
+  2 | function Component() {
+  3 |   const foo = () => {
+> 4 |     someGlobal = true;
+    |     ^^^^^^^^^^ Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
+  5 |   };
+  6 |   return <div {...foo} />;
+  7 | }
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-global-in-jsx-spread-attribute.js

@@ -3,6 +3,5 @@ function Component() {
   const foo = () => {
     someGlobal = true;
   };
-  // spreading a function is weird, but it doesn't call the function so this is allowed
   return <div {...foo} />;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-ref-in-effect-hint.expect.md

@@ -1,37 +0,0 @@
-
-## Input
-
-```javascript
-// Fixture to test that we show a hint to name as `ref` or `-Ref` when attempting
-// to assign .current inside an effect
-function Component({foo}) {
-  useEffect(() => {
-    foo.current = true;
-  }, [foo]);
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.assign-ref-in-effect-hint.ts:5:4
-  3 | function Component({foo}) {
-  4 |   useEffect(() => {
-> 5 |     foo.current = true;
-    |     ^^^ `foo` cannot be modified
-  6 |   }, [foo]);
-  7 | }
-  8 |
-
-Hint: If this value is a Ref (value returned by `useRef()`), rename the variable to end in "Ref".
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-ref-in-effect-hint.js

@@ -1,7 +0,0 @@
-// Fixture to test that we show a hint to name as `ref` or `-Ref` when attempting
-// to assign .current inside an effect
-function Component({foo}) {
-  useEffect(() => {
-    foo.current = true;
-  }, [foo]);
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.bug-old-inference-false-positive-ref-validation-in-use-effect.expect.md

@@ -0,0 +1,72 @@
+
+## Input
+
+```javascript
+// @validateNoFreezingKnownMutableFunctions @enableNewMutationAliasingModel:false
+
+import {useCallback, useEffect, useRef} from 'react';
+import {useHook} from 'shared-runtime';
+
+function Component() {
+  const params = useHook();
+  const update = useCallback(
+    partialParams => {
+      const nextParams = {
+        ...params,
+        ...partialParams,
+      };
+      nextParams.param = 'value';
+      console.log(nextParams);
+    },
+    [params]
+  );
+  const ref = useRef(null);
+  useEffect(() => {
+    if (ref.current === null) {
+      update();
+    }
+  }, [update]);
+
+  return 'ok';
+}
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Error: Cannot modify local variables after render completes
+
+This argument is a function which may reassign or mutate a local variable after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.
+
+error.bug-old-inference-false-positive-ref-validation-in-use-effect.ts:20:12
+  18 |   );
+  19 |   const ref = useRef(null);
+> 20 |   useEffect(() => {
+     |             ^^^^^^^
+> 21 |     if (ref.current === null) {
+     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> 22 |       update();
+     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> 23 |     }
+     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> 24 |   }, [update]);
+     | ^^^^ This function may (indirectly) reassign or modify a local variable after render
+  25 |
+  26 |   return 'ok';
+  27 | }
+
+error.bug-old-inference-false-positive-ref-validation-in-use-effect.ts:14:6
+  12 |         ...partialParams,
+  13 |       };
+> 14 |       nextParams.param = 'value';
+     |       ^^^^^^^^^^ This modifies a local variable
+  15 |       console.log(nextParams);
+  16 |     },
+  17 |     [params]
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.bug-old-inference-false-positive-ref-validation-in-use-effect.js

@@ -0,0 +1,27 @@
+// @validateNoFreezingKnownMutableFunctions @enableNewMutationAliasingModel:false
+
+import {useCallback, useEffect, useRef} from 'react';
+import {useHook} from 'shared-runtime';
+
+function Component() {
+  const params = useHook();
+  const update = useCallback(
+    partialParams => {
+      const nextParams = {
+        ...params,
+        ...partialParams,
+      };
+      nextParams.param = 'value';
+      console.log(nextParams);
+    },
+    [params]
+  );
+  const ref = useRef(null);
+  useEffect(() => {
+    if (ref.current === null) {
+      update();
+    }
+  }, [update]);
+
+  return 'ok';
+}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-assign-global-in-function-factory.js

@@ -1,7 +0,0 @@
-function Component() {
-  const f = () => () => {
-    global.property = true;
-  };
-  f()();
-  return <div>Ooops</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-assing-to-ref-current-in-render.expect.md

@@ -30,7 +30,13 @@ Modifying a value returned from a hook is not allowed. Consider moving the modif
   7 | }
   8 |
 
-Hint: If this value is a Ref (value returned by `useRef()`), rename the variable to end in "Ref".
+  3 | component Foo() {
+  4 |   const foo = useFoo();
+> 5 |   foo.current = true;
+    |   ^^^ Hint: If this value is a Ref (value returned by `useRef()`), rename the variable to end in "Ref".
+  6 |   return <div />;
+  7 | }
+  8 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-context-in-callback.expect.md

@@ -38,8 +38,6 @@ error.invalid-mutate-context-in-callback.ts:12:4
   13 |   };
   14 |   return <div onClick={onClick} />;
   15 | }
-
-Hint: If this value is a Ref (value returned by `useRef()`), rename the variable to end in "Ref".
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-global-in-render-helper-phi-return-prop.expect.md

@@ -1,44 +0,0 @@
-
-## Input
-
-```javascript
-function Component() {
-  const renderItem = item => {
-    // Multiple returns so that the return type is a Phi (union)
-    if (item == null) {
-      return null;
-    }
-    // Normally we assume that it's safe to mutate globals in a function passed
-    // as a prop, because the prop could be used as an event handler or effect.
-    // But if the function returns JSX we can assume it's a render helper, ie
-    // called during render, and thus it's unsafe to mutate globals or call
-    // other impure code.
-    global.property = true;
-    return <Item item={item} value={rand} />;
-  };
-  return <ItemList renderItem={renderItem} />;
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: This value cannot be modified
-
-Modifying a variable defined outside a component or hook is not allowed. Consider using an effect.
-
-error.invalid-mutate-global-in-render-helper-phi-return-prop.ts:12:4
-  10 |     // called during render, and thus it's unsafe to mutate globals or call
-  11 |     // other impure code.
-> 12 |     global.property = true;
-     |     ^^^^^^ value cannot be modified
-  13 |     return <Item item={item} value={rand} />;
-  14 |   };
-  15 |   return <ItemList renderItem={renderItem} />;
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-global-in-render-helper-phi-return-prop.js

@@ -1,16 +0,0 @@
-function Component() {
-  const renderItem = item => {
-    // Multiple returns so that the return type is a Phi (union)
-    if (item == null) {
-      return null;
-    }
-    // Normally we assume that it's safe to mutate globals in a function passed
-    // as a prop, because the prop could be used as an event handler or effect.
-    // But if the function returns JSX we can assume it's a render helper, ie
-    // called during render, and thus it's unsafe to mutate globals or call
-    // other impure code.
-    global.property = true;
-    return <Item item={item} value={rand} />;
-  };
-  return <ItemList renderItem={renderItem} />;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-global-in-render-helper-prop.expect.md

@@ -1,40 +0,0 @@
-
-## Input
-
-```javascript
-function Component() {
-  const renderItem = item => {
-    // Normally we assume that it's safe to mutate globals in a function passed
-    // as a prop, because the prop could be used as an event handler or effect.
-    // But if the function returns JSX we can assume it's a render helper, ie
-    // called during render, and thus it's unsafe to mutate globals or call
-    // other impure code.
-    global.property = true;
-    return <Item item={item} value={rand} />;
-  };
-  return <ItemList renderItem={renderItem} />;
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: This value cannot be modified
-
-Modifying a variable defined outside a component or hook is not allowed. Consider using an effect.
-
-error.invalid-mutate-global-in-render-helper-prop.ts:8:4
-   6 |     // called during render, and thus it's unsafe to mutate globals or call
-   7 |     // other impure code.
->  8 |     global.property = true;
-     |     ^^^^^^ value cannot be modified
-   9 |     return <Item item={item} value={rand} />;
-  10 |   };
-  11 |   return <ItemList renderItem={renderItem} />;
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-global-in-render-helper-prop.js

@@ -1,12 +0,0 @@
-function Component() {
-  const renderItem = item => {
-    // Normally we assume that it's safe to mutate globals in a function passed
-    // as a prop, because the prop could be used as an event handler or effect.
-    // But if the function returns JSX we can assume it's a render helper, ie
-    // called during render, and thus it's unsafe to mutate globals or call
-    // other impure code.
-    global.property = true;
-    return <Item item={item} value={rand} />;
-  };
-  return <ItemList renderItem={renderItem} />;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-unconditional-set-state-in-render.expect.md

@@ -29,7 +29,7 @@ error.invalid-unconditional-set-state-in-render.ts:6:2
   4 |   const aliased = setX;
   5 |
 > 6 |   setX(1);
-    |   ^^^^ Found setState() in render
+    |   ^^^^ Found setState() within useMemo()
   7 |   aliased(2);
   8 |
   9 |   return x;
@@ -42,7 +42,7 @@ error.invalid-unconditional-set-state-in-render.ts:7:2
    5 |
    6 |   setX(1);
 >  7 |   aliased(2);
-     |   ^^^^^^^ Found setState() in render
+     |   ^^^^^^^ Found setState() within useMemo()
    8 |
    9 |   return x;
   10 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.nested-component-in-normal-function.expect.md

@@ -1,54 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDynamicallyCreatedComponentsOrHooks
-export function getInput(a) {
-  const Wrapper = () => {
-    const handleChange = () => {
-      a.onChange();
-    };
-
-    return <input onChange={handleChange} />;
-  };
-
-  return Wrapper;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: getInput,
-  isComponent: false,
-  params: [{onChange() {}}],
-};
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: Components and hooks cannot be created dynamically
-
-The function `Wrapper` appears to be a React component, but it's defined inside `getInput`. Components and Hooks should always be declared at module scope
-
-error.nested-component-in-normal-function.ts:2:16
-  1 | // @validateNoDynamicallyCreatedComponentsOrHooks
-> 2 | export function getInput(a) {
-    |                 ^^^^^^^^ this function dynamically created a component/hook
-  3 |   const Wrapper = () => {
-  4 |     const handleChange = () => {
-  5 |       a.onChange();
-
-error.nested-component-in-normal-function.ts:3:8
-  1 | // @validateNoDynamicallyCreatedComponentsOrHooks
-  2 | export function getInput(a) {
-> 3 |   const Wrapper = () => {
-    |         ^^^^^^^ the component is created here
-  4 |     const handleChange = () => {
-  5 |       a.onChange();
-  6 |     };
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.nested-component-in-normal-function.js

@@ -1,18 +0,0 @@
-// @validateNoDynamicallyCreatedComponentsOrHooks
-export function getInput(a) {
-  const Wrapper = () => {
-    const handleChange = () => {
-      a.onChange();
-    };
-
-    return <input onChange={handleChange} />;
-  };
-
-  return Wrapper;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: getInput,
-  isComponent: false,
-  params: [{onChange() {}}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.nested-hook-in-normal-function.expect.md

@@ -1,59 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDynamicallyCreatedComponentsOrHooks
-import {useState} from 'react';
-
-function createCustomHook(config) {
-  function useConfiguredState() {
-    const [state, setState] = useState(0);
-
-    const increment = () => {
-      setState(state + config.step);
-    };
-
-    return [state, increment];
-  }
-
-  return useConfiguredState;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: createCustomHook,
-  isComponent: false,
-  params: [{step: 1}],
-};
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: Components and hooks cannot be created dynamically
-
-The function `useConfiguredState` appears to be a React hook, but it's defined inside `createCustomHook`. Components and Hooks should always be declared at module scope
-
-error.nested-hook-in-normal-function.ts:4:9
-  2 | import {useState} from 'react';
-  3 |
-> 4 | function createCustomHook(config) {
-    |          ^^^^^^^^^^^^^^^^ this function dynamically created a component/hook
-  5 |   function useConfiguredState() {
-  6 |     const [state, setState] = useState(0);
-  7 |
-
-error.nested-hook-in-normal-function.ts:5:11
-  3 |
-  4 | function createCustomHook(config) {
-> 5 |   function useConfiguredState() {
-    |            ^^^^^^^^^^^^^^^^^^ the component is created here
-  6 |     const [state, setState] = useState(0);
-  7 |
-  8 |     const increment = () => {
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.nested-hook-in-normal-function.js

@@ -1,22 +0,0 @@
-// @validateNoDynamicallyCreatedComponentsOrHooks
-import {useState} from 'react';
-
-function createCustomHook(config) {
-  function useConfiguredState() {
-    const [state, setState] = useState(0);
-
-    const increment = () => {
-      setState(state + config.step);
-    };
-
-    return [state, increment];
-  }
-
-  return useConfiguredState;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: createCustomHook,
-  isComponent: false,
-  params: [{step: 1}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.object-capture-global-mutation.expect.md

@@ -0,0 +1,39 @@
+
+## Input
+
+```javascript
+// @enableNewMutationAliasingModel:false
+function Foo() {
+  const x = () => {
+    window.href = 'foo';
+  };
+  const y = {x};
+  return <Bar y={y} />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Foo,
+  params: [],
+};
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Error: Modifying a variable defined outside a component or hook is not allowed. Consider using an effect
+
+error.object-capture-global-mutation.ts:4:4
+  2 | function Foo() {
+  3 |   const x = () => {
+> 4 |     window.href = 'foo';
+    |     ^^^^^^ Modifying a variable defined outside a component or hook is not allowed. Consider using an effect
+  5 |   };
+  6 |   const y = {x};
+  7 |   return <Bar y={y} />;
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.object-capture-global-mutation.js

@@ -1,3 +1,4 @@
+// @enableNewMutationAliasingModel:false
 function Foo() {
   const x = () => {
     window.href = 'foo';

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.unconditional-set-state-in-render-after-loop-break.expect.md

@@ -32,7 +32,7 @@ error.unconditional-set-state-in-render-after-loop-break.ts:11:2
    9 |     }
   10 |   }
 > 11 |   setState(true);
-     |   ^^^^^^^^ Found setState() in render
+     |   ^^^^^^^^ Found setState() within useMemo()
   12 |   return state;
   13 | }
   14 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.unconditional-set-state-in-render-after-loop.expect.md

@@ -27,7 +27,7 @@ error.unconditional-set-state-in-render-after-loop.ts:6:2
   4 |   for (const _ of props) {
   5 |   }
 > 6 |   setState(true);
-    |   ^^^^^^^^ Found setState() in render
+    |   ^^^^^^^^ Found setState() within useMemo()
   7 |   return state;
   8 | }
   9 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.unconditional-set-state-in-render-with-loop-throw.expect.md

@@ -32,7 +32,7 @@ error.unconditional-set-state-in-render-with-loop-throw.ts:11:2
    9 |     }
   10 |   }
 > 11 |   setState(true);
-     |   ^^^^^^^^ Found setState() in render
+     |   ^^^^^^^^ Found setState() within useMemo()
   12 |   return state;
   13 | }
   14 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.unconditional-set-state-lambda.expect.md

@@ -30,7 +30,7 @@ error.unconditional-set-state-lambda.ts:8:2
    6 |     setX(1);
    7 |   };
 >  8 |   foo();
-     |   ^^^ Found setState() in render
+     |   ^^^ Found setState() within useMemo()
    9 |
   10 |   return [x];
   11 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.unconditional-set-state-nested-function-expressions.expect.md

@@ -38,7 +38,7 @@ error.unconditional-set-state-nested-function-expressions.ts:16:2
   14 |     bar();
   15 |   };
 > 16 |   baz();
-     |   ^^^ Found setState() in render
+     |   ^^^ Found setState() within useMemo()
   17 |
   18 |   return [x];
   19 | }

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

@@ -58,7 +58,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":206},"end":{"line":16,"column":1,"index":433},"filename":"dynamic-gating-bailout-nopanic.ts"},"detail":{"options":{"category":"PreserveManualMemo","severity":"CannotPreserveMemoization","reason":"Compilation skipped because 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":288},"end":{"line":9,"column":52,"index":309},"filename":"dynamic-gating-bailout-nopanic.ts"},"message":"Could not preserve existing manual memoization"}]}}}
+{"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":206},"end":{"line":16,"column":1,"index":433},"filename":"dynamic-gating-bailout-nopanic.ts"},"detail":{"options":{"severity":"CannotPreserveMemoization","category":"Compilation skipped because 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":288},"end":{"line":9,"column":52,"index":309},"filename":"dynamic-gating-bailout-nopanic.ts"},"message":"Could not preserve existing manual memoization"}]}}}
 ```
       
 ### Eval output

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-invalid-multiple.expect.md

@@ -38,7 +38,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","fnLoc":{"start":{"line":3,"column":0,"index":86},"end":{"line":7,"column":1,"index":190},"filename":"dynamic-gating-invalid-multiple.ts"},"detail":{"options":{"category":"Gating","reason":"Multiple dynamic gating directives found","description":"Expected a single directive but found [use memo if(getTrue), use memo if(getFalse)]","severity":"InvalidReact","suggestions":null,"loc":{"start":{"line":4,"column":2,"index":105},"end":{"line":4,"column":25,"index":128},"filename":"dynamic-gating-invalid-multiple.ts"}}}}
+{"kind":"CompileError","fnLoc":{"start":{"line":3,"column":0,"index":86},"end":{"line":7,"column":1,"index":190},"filename":"dynamic-gating-invalid-multiple.ts"},"detail":{"options":{"reason":"Multiple dynamic gating directives found","description":"Expected a single directive but found [use memo if(getTrue), use memo if(getFalse)]","severity":"InvalidReact","suggestions":null,"loc":{"start":{"line":4,"column":2,"index":105},"end":{"line":4,"column":25,"index":128},"filename":"dynamic-gating-invalid-multiple.ts"}}}}
 ```
       
 ### Eval output

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/mutate-after-useeffect-optional-chain.expect.md

@@ -48,7 +48,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","fnLoc":{"start":{"line":5,"column":0,"index":149},"end":{"line":12,"column":1,"index":404},"filename":"mutate-after-useeffect-optional-chain.ts"},"detail":{"options":{"category":"Immutability","severity":"InvalidReact","reason":"This value cannot be modified","description":"Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect().","details":[{"kind":"error","loc":{"start":{"line":10,"column":2,"index":365},"end":{"line":10,"column":5,"index":368},"filename":"mutate-after-useeffect-optional-chain.ts","identifierName":"arr"},"message":"value cannot be modified"}]}}}
+{"kind":"CompileError","fnLoc":{"start":{"line":5,"column":0,"index":149},"end":{"line":12,"column":1,"index":404},"filename":"mutate-after-useeffect-optional-chain.ts"},"detail":{"options":{"severity":"InvalidReact","category":"This value cannot be modified","description":"Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect().","details":[{"kind":"error","loc":{"start":{"line":10,"column":2,"index":365},"end":{"line":10,"column":5,"index":368},"filename":"mutate-after-useeffect-optional-chain.ts","identifierName":"arr"},"message":"value cannot be modified"}]}}}
 {"kind":"AutoDepsDecorations","fnLoc":{"start":{"line":9,"column":2,"index":314},"end":{"line":9,"column":49,"index":361},"filename":"mutate-after-useeffect-optional-chain.ts"},"decorations":[{"start":{"line":9,"column":24,"index":336},"end":{"line":9,"column":27,"index":339},"filename":"mutate-after-useeffect-optional-chain.ts","identifierName":"arr"}]}
 {"kind":"CompileSuccess","fnLoc":{"start":{"line":5,"column":0,"index":149},"end":{"line":12,"column":1,"index":404},"filename":"mutate-after-useeffect-optional-chain.ts"},"fnName":"Component","memoSlots":0,"memoBlocks":0,"memoValues":0,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/mutate-after-useeffect-ref-access.expect.md

@@ -47,7 +47,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":158},"end":{"line":11,"column":1,"index":331},"filename":"mutate-after-useeffect-ref-access.ts"},"detail":{"options":{"category":"Refs","severity":"InvalidReact","reason":"Cannot access refs during render","description":"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)","details":[{"kind":"error","loc":{"start":{"line":9,"column":2,"index":289},"end":{"line":9,"column":16,"index":303},"filename":"mutate-after-useeffect-ref-access.ts"},"message":"Cannot update ref during render"}]}}}
+{"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":158},"end":{"line":11,"column":1,"index":331},"filename":"mutate-after-useeffect-ref-access.ts"},"detail":{"options":{"severity":"InvalidReact","category":"Cannot access refs during render","description":"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)","details":[{"kind":"error","loc":{"start":{"line":9,"column":2,"index":289},"end":{"line":9,"column":16,"index":303},"filename":"mutate-after-useeffect-ref-access.ts"},"message":"Cannot update ref during render"}]}}}
 {"kind":"AutoDepsDecorations","fnLoc":{"start":{"line":8,"column":2,"index":237},"end":{"line":8,"column":50,"index":285},"filename":"mutate-after-useeffect-ref-access.ts"},"decorations":[{"start":{"line":8,"column":24,"index":259},"end":{"line":8,"column":30,"index":265},"filename":"mutate-after-useeffect-ref-access.ts","identifierName":"arrRef"}]}
 {"kind":"CompileSuccess","fnLoc":{"start":{"line":6,"column":0,"index":158},"end":{"line":11,"column":1,"index":331},"filename":"mutate-after-useeffect-ref-access.ts"},"fnName":"Component","memoSlots":0,"memoBlocks":0,"memoValues":0,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/mutate-after-useeffect.expect.md

@@ -47,7 +47,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","fnLoc":{"start":{"line":4,"column":0,"index":111},"end":{"line":11,"column":1,"index":242},"filename":"mutate-after-useeffect.ts"},"detail":{"options":{"category":"Immutability","severity":"InvalidReact","reason":"This value cannot be modified","description":"Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect().","details":[{"kind":"error","loc":{"start":{"line":9,"column":2,"index":214},"end":{"line":9,"column":5,"index":217},"filename":"mutate-after-useeffect.ts","identifierName":"arr"},"message":"value cannot be modified"}]}}}
+{"kind":"CompileError","fnLoc":{"start":{"line":4,"column":0,"index":111},"end":{"line":11,"column":1,"index":242},"filename":"mutate-after-useeffect.ts"},"detail":{"options":{"severity":"InvalidReact","category":"This value cannot be modified","description":"Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect().","details":[{"kind":"error","loc":{"start":{"line":9,"column":2,"index":214},"end":{"line":9,"column":5,"index":217},"filename":"mutate-after-useeffect.ts","identifierName":"arr"},"message":"value cannot be modified"}]}}}
 {"kind":"AutoDepsDecorations","fnLoc":{"start":{"line":6,"column":2,"index":159},"end":{"line":8,"column":14,"index":210},"filename":"mutate-after-useeffect.ts"},"decorations":[{"start":{"line":7,"column":4,"index":181},"end":{"line":7,"column":7,"index":184},"filename":"mutate-after-useeffect.ts","identifierName":"arr"},{"start":{"line":7,"column":4,"index":181},"end":{"line":7,"column":7,"index":184},"filename":"mutate-after-useeffect.ts","identifierName":"arr"},{"start":{"line":7,"column":13,"index":190},"end":{"line":7,"column":16,"index":193},"filename":"mutate-after-useeffect.ts","identifierName":"foo"}]}
 {"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":111},"end":{"line":11,"column":1,"index":242},"filename":"mutate-after-useeffect.ts"},"fnName":"Component","memoSlots":0,"memoBlocks":0,"memoValues":0,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```