[compiler] New mutability/aliasing model

Squashed, review-friendly version of the stack from https://github.com/facebook/react/pull/33488.

This is new version of our mutability and inference model, designed to replace the core algorithm for determining the sets of instructions involved in constructing a given value or set of values. The new model replaces InferReferenceEffects, InferMutableRanges (and all of its subcomponents), and parts of AnalyzeFunctions. The new model does not use per-Place effect values, but in order to make this drop-in the end _result_ of the inference adds these per-Place effects.

I'll write up a larger document on the model, first i'm doing some housekeeping to rebase the PR.

.eslintrc.js

@@ -496,7 +496,6 @@ module.exports = {
         'packages/react-devtools-shared/src/devtools/views/**/*.js',
         'packages/react-devtools-shared/src/hook.js',
         'packages/react-devtools-shared/src/backend/console.js',
-        'packages/react-devtools-shared/src/backend/fiber/renderer.js',
         'packages/react-devtools-shared/src/backend/shared/DevToolsComponentStackFrame.js',
         'packages/react-devtools-shared/src/frontend/utils/withPermissionsCheck.js',
       ],
@@ -505,7 +504,6 @@ module.exports = {
         __IS_FIREFOX__: 'readonly',
         __IS_EDGE__: 'readonly',
         __IS_NATIVE__: 'readonly',
-        __IS_INTERNAL_MCP_BUILD__: 'readonly',
         __IS_INTERNAL_VERSION__: 'readonly',
         chrome: 'readonly',
       },
@@ -561,7 +559,6 @@ module.exports = {
     ConsoleTask: 'readonly', // TOOD: Figure out what the official name of this will be.
     ReturnType: 'readonly',
     AnimationFrameID: 'readonly',
-    WeakRef: 'readonly',
     // For Flow type annotation. Only `BigInt` is valid at runtime.
     bigint: 'readonly',
     BigInt: 'readonly',
@@ -612,7 +609,6 @@ module.exports = {
     TimeoutID: 'readonly',
     WheelEventHandler: 'readonly',
     FinalizationRegistry: 'readonly',
-    Exclude: 'readonly',
     Omit: 'readonly',
     Keyframe: 'readonly',
     PropertyIndexedKeyframes: 'readonly',

.github/workflows/compiler_discord_notify.yml

@@ -11,7 +11,6 @@ permissions: {}
 
 jobs:
   check_access:
-    if: ${{ github.event.pull_request.draft == false }}
     runs-on: ubuntu-latest
     outputs:
       is_member_or_collaborator: ${{ steps.check_is_member_or_collaborator.outputs.is_member_or_collaborator }}

.github/workflows/runtime_build_and_test.yml

@@ -280,35 +280,6 @@ jobs:
         if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn test ${{ matrix.params }} --ci --shard=${{ matrix.shard }}
 
-  # Hardcoded to improve parallelism
-  test-linter:
-    name: Test eslint-plugin-react-hooks
-    needs: [runtime_compiler_node_modules_cache]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-          cache: yarn
-          cache-dependency-path:  |
-            yarn.lock
-            compiler/yarn.lock
-      - name: Restore cached node_modules
-        uses: actions/cache@v4
-        id: node_modules
-        with:
-          path: |
-            **/node_modules
-          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
-          restore-keys: |
-            runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-and-compiler-node_modules-v6-
-      - run: yarn install --frozen-lockfile
-        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

.github/workflows/runtime_discord_notify.yml

@@ -11,7 +11,6 @@ permissions: {}
 
 jobs:
   check_access:
-    if: ${{ github.event.pull_request.draft == false }}
     runs-on: ubuntu-latest
     outputs:
       is_member_or_collaborator: ${{ steps.check_is_member_or_collaborator.outputs.is_member_or_collaborator }}

.github/workflows/runtime_prereleases.yml

@@ -17,17 +17,6 @@ on:
         description: 'Whether to notify the team on Discord when the release fails. Useful if this workflow is called from an automation.'
         required: false
         type: boolean
-      only_packages:
-        description: Packages to publish (space separated)
-        type: string
-      skip_packages:
-        description: Packages to NOT publish (space separated)
-        type: string
-      dry:
-        required: true
-        description: Dry run instead of publish?
-        type: boolean
-        default: true
     secrets:
       DISCORD_WEBHOOK_URL:
         description: 'Discord webhook URL to notify on failure. Only required if enableFailureNotification is true.'
@@ -72,36 +61,10 @@ jobs:
         if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn --cwd scripts/release install --frozen-lockfile
         if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: cp ./scripts/release/ci-npmrc ~/.npmrc
       - run: |
           GH_TOKEN=${{ secrets.GH_TOKEN }} scripts/release/prepare-release-from-ci.js --skipTests -r ${{ inputs.release_channel }} --commit=${{ inputs.commit_sha }}
-      - name: Check prepared files
-        run: ls -R build/node_modules
-      - if: '${{ inputs.only_packages }}'
-        name: 'Publish ${{ inputs.only_packages }}'
-        run: |
-          scripts/release/publish.js \
-            --ci \
-            --skipTests \
-            --tags=${{ inputs.dist_tag }} \
-            --onlyPackages=${{ inputs.only_packages }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry'}}
-      - if: '${{ inputs.skip_packages }}'
-        name: 'Publish all packages EXCEPT ${{ inputs.skip_packages }}'
-        run: |
-          scripts/release/publish.js \
-            --ci \
-            --skipTests \
-            --tags=${{ inputs.dist_tag }} \
-            --skipPackages=${{ inputs.skip_packages }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry'}}
-      - if: '${{ !(inputs.skip_packages && inputs.only_packages) }}'
-        name: 'Publish all packages'
-        run: |
-          scripts/release/publish.js \
-            --ci \
-            --tags=${{ inputs.dist_tag }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry'}}
+          cp ./scripts/release/ci-npmrc ~/.npmrc
+          scripts/release/publish.js --ci --tags ${{ inputs.dist_tag }}
       - name: Notify Discord on failure
         if: failure() && inputs.enableFailureNotification == true
         uses: tsickert/discord-webhook@86dc739f3f165f16dadc5666051c367efa1692f4

.github/workflows/runtime_prereleases_manual.yml

@@ -5,25 +5,6 @@ on:
     inputs:
       prerelease_commit_sha:
         required: true
-      only_packages:
-        description: Packages to publish (space separated)
-        type: string
-      skip_packages:
-        description: Packages to NOT publish (space separated)
-        type: string
-      dry:
-        required: true
-        description: Dry run instead of publish?
-        type: boolean
-        default: true
-      experimental_only:
-        type: boolean
-        description: Only publish to the experimental tag
-        default: false
-      force_notify:
-        description: Force a Discord notification?
-        type: boolean
-        default: false
 
 permissions: {}
 
@@ -31,26 +12,8 @@ env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 
 jobs:
-  notify:
-    if: ${{ inputs.force_notify || inputs.dry == false || inputs.dry == 'false' }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Discord Webhook Action
-        uses: tsickert/discord-webhook@86dc739f3f165f16dadc5666051c367efa1692f4
-        with:
-          webhook-url: ${{ secrets.DISCORD_WEBHOOK_URL }}
-          embed-author-name: ${{ github.event.sender.login }}
-          embed-author-url: ${{ github.event.sender.html_url }}
-          embed-author-icon-url: ${{ github.event.sender.avatar_url }}
-          embed-title: "⚠️ Publishing ${{ inputs.experimental_only && 'EXPERIMENTAL' || 'CANARY & EXPERIMENTAL' }} release ${{ (inputs.dry && ' (dry run)') || '' }}"
-          embed-description: |
-            ```json
-            ${{ toJson(inputs) }}
-            ```
-          embed-url: https://github.com/facebook/react/actions/runs/${{ github.run_id }}
 
   publish_prerelease_canary:
-    if: ${{ !inputs.experimental_only }}
     name: Publish to Canary channel
     uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
     permissions:
@@ -70,9 +33,6 @@ jobs:
       # downstream consumers might still expect that tag. We can remove this
       # after some time has elapsed and the change has been communicated.
       dist_tag: canary,next
-      only_packages: ${{ inputs.only_packages }}
-      skip_packages: ${{ inputs.skip_packages }}
-      dry: ${{ inputs.dry }}
     secrets:
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -88,15 +48,10 @@ jobs:
     # different versions of the same package, even if they use different
     # dist tags.
     needs: publish_prerelease_canary
-    # Ensures the job runs even if canary is skipped
-    if: always()
     with:
       commit_sha: ${{ inputs.prerelease_commit_sha }}
       release_channel: experimental
       dist_tag: experimental
-      only_packages: ${{ inputs.only_packages }}
-      skip_packages: ${{ inputs.skip_packages }}
-      dry: ${{ inputs.dry }}
     secrets:
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/runtime_prereleases_nightly.yml

@@ -22,7 +22,6 @@ jobs:
       release_channel: stable
       dist_tag: canary,next
       enableFailureNotification: true
-      dry: false
     secrets:
       DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
@@ -44,7 +43,6 @@ jobs:
       release_channel: experimental
       dist_tag: experimental
       enableFailureNotification: true
-      dry: false
     secrets:
       DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/shared_stale.yml

@@ -6,10 +6,7 @@ on:
     - cron: '0 * * * *'
   workflow_dispatch:
 
-permissions:
-  # https://github.com/actions/stale/tree/v9/?tab=readme-ov-file#recommended-permissions
-  issues: write
-  pull-requests: write
+permissions: {}
 
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles

.prettierrc.js

@@ -3,12 +3,13 @@
 const {esNextPaths} = require('./scripts/shared/pathsByLanguageVersion');
 
 module.exports = {
+  plugins: ['prettier-plugin-hermes-parser'],
   bracketSpacing: false,
   singleQuote: true,
   bracketSameLine: true,
   trailingComma: 'es5',
   printWidth: 80,
-  parser: 'flow',
+  parser: 'hermes',
   arrowParens: 'avoid',
   overrides: [
     {

compiler/.gitignore

@@ -1,14 +1,28 @@
 .DS_Store
 .spr.yml
 
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
 node_modules
 .watchmanconfig
 .watchman-cookie-*
 dist
 .vscode
 !packages/playground/.vscode
+.spr.yml
 testfilter.txt
 
+bundle-oss.sh
+
 # forgive
 *.vsix
 .vscode-test

compiler/apps/playground/scripts/link-compiler.sh

@@ -8,8 +8,8 @@ set -eo pipefail
 
 HERE=$(pwd)
 
-cd ../../packages/react-compiler-runtime && yarn --silent link && cd "$HERE"
-cd ../../packages/babel-plugin-react-compiler && yarn --silent link && cd "$HERE"
+cd ../../packages/react-compiler-runtime && yarn --silent link && cd $HERE
+cd ../../packages/babel-plugin-react-compiler && yarn --silent link && cd $HERE
 
 yarn --silent link babel-plugin-react-compiler
 yarn --silent link react-compiler-runtime

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

@@ -115,6 +115,14 @@ export class CompilerErrorDetail {
 export class CompilerError extends Error {
   details: Array<CompilerErrorDetail> = [];
 
+  static from(details: Array<CompilerErrorDetailOptions>): CompilerError {
+    const error = new CompilerError();
+    for (const detail of details) {
+      error.push(detail);
+    }
+    return error;
+  }
+
   static invariant(
     condition: unknown,
     options: Omit<CompilerErrorDetailOptions, 'severity'>,

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

@@ -37,14 +37,6 @@ const PanicThresholdOptionsSchema = z.enum([
 ]);
 
 export type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>;
-const DynamicGatingOptionsSchema = z.object({
-  source: z.string(),
-});
-export type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>;
-const CustomOptOutDirectiveSchema = z
-  .nullable(z.array(z.string()))
-  .default(null);
-type CustomOptOutDirective = z.infer<typeof CustomOptOutDirectiveSchema>;
 
 export type PluginOptions = {
   environment: EnvironmentConfig;
@@ -73,28 +65,6 @@ export type PluginOptions = {
    */
   gating: ExternalFunction | null;
 
-  /**
-   * If specified, this enables dynamic gating which matches `use memo if(...)`
-   * directives.
-   *
-   * Example usage:
-   * ```js
-   * // @dynamicGating:{"source":"myModule"}
-   * export function MyComponent() {
-   *   'use memo if(isEnabled)';
-   *    return <div>...</div>;
-   * }
-   * ```
-   * This will emit:
-   * ```js
-   * import {isEnabled} from 'myModule';
-   * export const MyComponent = isEnabled()
-   *   ? <optimized version>
-   *   : <original version>;
-   * ```
-   */
-  dynamicGating: DynamicGatingOptions | null;
-
   panicThreshold: PanicThresholdOptions;
 
   /*
@@ -136,11 +106,6 @@ export type PluginOptions = {
    */
   ignoreUseNoForget: boolean;
 
-  /**
-   * Unstable / do not use
-   */
-  customOptOutDirectives: CustomOptOutDirective;
-
   sources: Array<string> | ((filename: string) => boolean) | null;
 
   /**
@@ -279,7 +244,6 @@ export const defaultOptions: PluginOptions = {
   logger: null,
   gating: null,
   noEmit: false,
-  dynamicGating: null,
   eslintSuppressionRules: null,
   flowSuppressions: true,
   ignoreUseNoForget: false,
@@ -287,7 +251,6 @@ export const defaultOptions: PluginOptions = {
     return filename.indexOf('node_modules') === -1;
   },
   enableReanimatedCheck: true,
-  customOptOutDirectives: null,
   target: '19',
 } as const;
 
@@ -329,40 +292,6 @@ export function parsePluginOptions(obj: unknown): PluginOptions {
           }
           break;
         }
-        case 'dynamicGating': {
-          if (value == null) {
-            parsedOptions[key] = null;
-          } else {
-            const result = DynamicGatingOptionsSchema.safeParse(value);
-            if (result.success) {
-              parsedOptions[key] = result.data;
-            } else {
-              CompilerError.throwInvalidConfig({
-                reason:
-                  'Could not parse dynamic gating. Update React Compiler config to fix the error',
-                description: `${fromZodError(result.error)}`,
-                loc: null,
-                suggestions: null,
-              });
-            }
-          }
-          break;
-        }
-        case 'customOptOutDirectives': {
-          const result = CustomOptOutDirectiveSchema.safeParse(value);
-          if (result.success) {
-            parsedOptions[key] = result.data;
-          } else {
-            CompilerError.throwInvalidConfig({
-              reason:
-                'Could not parse custom opt out directives. Update React Compiler config to fix the error',
-              description: `${fromZodError(result.error)}`,
-              loc: null,
-              suggestions: null,
-            });
-          }
-          break;
-        }
         default: {
           parsedOptions[key] = value;
         }

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

@@ -132,7 +132,6 @@ function run(
     mode,
     config,
     contextIdentifiers,
-    func,
     logger,
     filename,
     code,

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

@@ -12,7 +12,7 @@ import {
   CompilerErrorDetail,
   ErrorSeverity,
 } from '../CompilerError';
-import {ExternalFunction, ReactFunctionType} from '../HIR/Environment';
+import {ReactFunctionType} from '../HIR/Environment';
 import {CodegenFunction} from '../ReactiveScopes';
 import {isComponentDeclaration} from '../Utils/ComponentDeclaration';
 import {isHookDeclaration} from '../Utils/HookDeclaration';
@@ -31,7 +31,6 @@ import {
   suppressionsToCompilerError,
 } from './Suppression';
 import {GeneratedSource} from '../HIR';
-import {Err, Ok, Result} from '../Utils/Result';
 
 export type CompilerPass = {
   opts: PluginOptions;
@@ -41,102 +40,26 @@ export type CompilerPass = {
 };
 export const OPT_IN_DIRECTIVES = new Set(['use forget', 'use memo']);
 export const OPT_OUT_DIRECTIVES = new Set(['use no forget', 'use no memo']);
-const DYNAMIC_GATING_DIRECTIVE = new RegExp('^use memo if\\(([^\\)]*)\\)$');
 
-export function tryFindDirectiveEnablingMemoization(
+export function findDirectiveEnablingMemoization(
   directives: Array<t.Directive>,
-  opts: PluginOptions,
-): Result<t.Directive | null, CompilerError> {
-  const optIn = directives.find(directive =>
-    OPT_IN_DIRECTIVES.has(directive.value.value),
+): t.Directive | null {
+  return (
+    directives.find(directive =>
+      OPT_IN_DIRECTIVES.has(directive.value.value),
+    ) ?? null
   );
-  if (optIn != null) {
-    return Ok(optIn);
-  }
-  const dynamicGating = findDirectivesDynamicGating(directives, opts);
-  if (dynamicGating.isOk()) {
-    return Ok(dynamicGating.unwrap()?.directive ?? null);
-  } else {
-    return Err(dynamicGating.unwrapErr());
-  }
 }
 
 export function findDirectiveDisablingMemoization(
   directives: Array<t.Directive>,
-  {customOptOutDirectives}: PluginOptions,
 ): t.Directive | null {
-  if (customOptOutDirectives != null) {
-    return (
-      directives.find(
-        directive =>
-          customOptOutDirectives.indexOf(directive.value.value) !== -1,
-      ) ?? null
-    );
-  }
   return (
     directives.find(directive =>
       OPT_OUT_DIRECTIVES.has(directive.value.value),
     ) ?? null
   );
 }
-function findDirectivesDynamicGating(
-  directives: Array<t.Directive>,
-  opts: PluginOptions,
-): Result<
-  {
-    gating: ExternalFunction;
-    directive: t.Directive;
-  } | null,
-  CompilerError
-> {
-  if (opts.dynamicGating === null) {
-    return Ok(null);
-  }
-  const errors = new CompilerError();
-  const result: Array<{directive: t.Directive; match: string}> = [];
-
-  for (const directive of directives) {
-    const maybeMatch = DYNAMIC_GATING_DIRECTIVE.exec(directive.value.value);
-    if (maybeMatch != null && maybeMatch[1] != null) {
-      if (t.isValidIdentifier(maybeMatch[1])) {
-        result.push({directive, match: maybeMatch[1]});
-      } else {
-        errors.push({
-          reason: `Dynamic gating directive is not a valid JavaScript identifier`,
-          description: `Found '${directive.value.value}'`,
-          severity: ErrorSeverity.InvalidReact,
-          loc: directive.loc ?? null,
-          suggestions: null,
-        });
-      }
-    }
-  }
-  if (errors.hasErrors()) {
-    return Err(errors);
-  } else if (result.length > 1) {
-    const error = new CompilerError();
-    error.push({
-      reason: `Multiple dynamic gating directives found`,
-      description: `Expected a single directive but found [${result
-        .map(r => r.directive.value.value)
-        .join(', ')}]`,
-      severity: ErrorSeverity.InvalidReact,
-      loc: result[0].directive.loc ?? null,
-      suggestions: null,
-    });
-    return Err(error);
-  } else if (result.length === 1) {
-    return Ok({
-      gating: {
-        source: opts.dynamicGating.source,
-        importSpecifierName: result[0].match,
-      },
-      directive: result[0].directive,
-    });
-  } else {
-    return Ok(null);
-  }
-}
 
 function isCriticalError(err: unknown): boolean {
   return !(err instanceof CompilerError) || err.isCritical();
@@ -403,8 +326,7 @@ export function compileProgram(
     code: pass.code,
     suppressions,
     hasModuleScopeOptOut:
-      findDirectiveDisablingMemoization(program.node.directives, pass.opts) !=
-      null,
+      findDirectiveDisablingMemoization(program.node.directives) != null,
   });
 
   const queue: Array<CompileSource> = findFunctionsToCompile(
@@ -555,36 +477,13 @@ function processFn(
   fnType: ReactFunctionType,
   programContext: ProgramContext,
 ): null | CodegenFunction {
-  let directives: {
-    optIn: t.Directive | null;
-    optOut: t.Directive | null;
-  };
+  let directives;
   if (fn.node.body.type !== 'BlockStatement') {
-    directives = {
-      optIn: null,
-      optOut: null,
-    };
+    directives = {optIn: null, optOut: null};
   } else {
-    const optIn = tryFindDirectiveEnablingMemoization(
-      fn.node.body.directives,
-      programContext.opts,
-    );
-    if (optIn.isErr()) {
-      /**
-       * If parsing opt-in directive fails, it's most likely that React Compiler
-       * was not tested or rolled out on this function. In that case, we handle
-       * the error and fall back to the safest option which is to not optimize
-       * the function.
-       */
-      handleError(optIn.unwrapErr(), programContext, fn.node.loc ?? null);
-      return null;
-    }
     directives = {
-      optIn: optIn.unwrapOr(null),
-      optOut: findDirectiveDisablingMemoization(
-        fn.node.body.directives,
-        programContext.opts,
-      ),
+      optIn: findDirectiveEnablingMemoization(fn.node.body.directives),
+      optOut: findDirectiveDisablingMemoization(fn.node.body.directives),
     };
   }
 
@@ -760,31 +659,25 @@ function applyCompiledFunctions(
   pass: CompilerPass,
   programContext: ProgramContext,
 ): void {
-  let referencedBeforeDeclared = null;
+  const referencedBeforeDeclared =
+    pass.opts.gating != null
+      ? getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns)
+      : null;
   for (const result of compiledFns) {
     const {kind, originalFn, compiledFn} = result;
     const transformedFn = createNewFunctionNode(originalFn, compiledFn);
     programContext.alreadyCompiled.add(transformedFn);
 
-    let dynamicGating: ExternalFunction | null = null;
-    if (originalFn.node.body.type === 'BlockStatement') {
-      const result = findDirectivesDynamicGating(
-        originalFn.node.body.directives,
-        pass.opts,
-      );
-      if (result.isOk()) {
-        dynamicGating = result.unwrap()?.gating ?? null;
-      }
-    }
-    const functionGating = dynamicGating ?? pass.opts.gating;
-    if (kind === 'original' && functionGating != null) {
-      referencedBeforeDeclared ??=
-        getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns);
+    if (referencedBeforeDeclared != null && kind === 'original') {
+      CompilerError.invariant(pass.opts.gating != null, {
+        reason: "Expected 'gating' import to be present",
+        loc: null,
+      });
       insertGatedFunctionDeclaration(
         originalFn,
         transformedFn,
         programContext,
-        functionGating,
+        pass.opts.gating,
         referencedBeforeDeclared.has(result),
       );
     } else {
@@ -840,13 +733,8 @@ function getReactFunctionType(
 ): ReactFunctionType | null {
   const hookPattern = pass.opts.environment.hookPattern;
   if (fn.node.body.type === 'BlockStatement') {
-    const optInDirectives = tryFindDirectiveEnablingMemoization(
-      fn.node.body.directives,
-      pass.opts,
-    );
-    if (optInDirectives.unwrapOr(null) != null) {
+    if (findDirectiveEnablingMemoization(fn.node.body.directives) != null)
       return getComponentOrHookLike(fn, hookPattern) ?? 'Other';
-    }
   }
 
   // Component and hook declarations are known components/hooks

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

@@ -70,23 +70,21 @@ import {BuiltInArrayId} from './ObjectShape';
 export function lower(
   func: NodePath<t.Function>,
   env: Environment,
-  // Bindings captured from the outer function, in case lower() is called recursively (for lambdas)
   bindings: Bindings | null = null,
-  capturedRefs: Map<t.Identifier, SourceLocation> = new Map(),
+  capturedRefs: Array<t.Identifier> = [],
+  // the outermost function being compiled, in case lower() is called recursively (for lambdas)
+  parent: NodePath<t.Function> | null = null,
 ): Result<HIRFunction, CompilerError> {
-  const builder = new HIRBuilder(env, {
-    bindings,
-    context: capturedRefs,
-  });
+  const builder = new HIRBuilder(env, parent ?? func, bindings, capturedRefs);
   const context: HIRFunction['context'] = [];
 
-  for (const [ref, loc] of capturedRefs ?? []) {
+  for (const ref of capturedRefs ?? []) {
     context.push({
       kind: 'Identifier',
       identifier: builder.resolveBinding(ref),
       effect: Effect.Unknown,
       reactive: false,
-      loc,
+      loc: ref.loc ?? GeneratedSource,
     });
   }
 
@@ -219,7 +217,7 @@ export function lower(
   return Ok({
     id,
     params,
-    fnType: bindings == null ? env.fnType : 'Other',
+    fnType: parent == null ? env.fnType : 'Other',
     returnTypeAnnotation: null, // TODO: extract the actual return type node if present
     returnType: makeType(),
     returns: createTemporaryPlace(env, func.node.loc ?? GeneratedSource),
@@ -3428,7 +3426,7 @@ function lowerFunction(
     | t.ObjectMethod
   >,
 ): LoweredFunction | null {
-  const componentScope: Scope = builder.environment.parentFunction.scope;
+  const componentScope: Scope = builder.parentFunction.scope;
   const capturedContext = gatherCapturedContext(expr, componentScope);
 
   /*
@@ -3443,7 +3441,8 @@ function lowerFunction(
     expr,
     builder.environment,
     builder.bindings,
-    new Map([...builder.context, ...capturedContext]),
+    [...builder.context, ...capturedContext],
+    builder.parentFunction,
   );
   let loweredFunc: HIRFunction;
   if (lowering.isErr()) {
@@ -3466,7 +3465,7 @@ function lowerExpressionToTemporary(
   return lowerValueToTemporary(builder, value);
 }
 
-export function lowerValueToTemporary(
+function lowerValueToTemporary(
   builder: HIRBuilder,
   value: InstructionValue,
 ): Place {
@@ -4162,11 +4161,6 @@ function captureScopes({from, to}: {from: Scope; to: Scope}): Set<Scope> {
   return scopes;
 }
 
-/**
- * Returns a mapping of "context" identifiers — references to free variables that
- * will become part of the function expression's `context` array — along with the
- * source location of their first reference within the function.
- */
 function gatherCapturedContext(
   fn: NodePath<
     | t.FunctionExpression
@@ -4175,8 +4169,8 @@ function gatherCapturedContext(
     | t.ObjectMethod
   >,
   componentScope: Scope,
-): Map<t.Identifier, SourceLocation> {
-  const capturedIds = new Map<t.Identifier, SourceLocation>();
+): Array<t.Identifier> {
+  const capturedIds = new Set<t.Identifier>();
 
   /*
    * Capture all the scopes from the parent of this function up to and including
@@ -4219,15 +4213,8 @@ function gatherCapturedContext(
 
     // Add the base identifier binding as a dependency.
     const binding = baseIdentifier.scope.getBinding(baseIdentifier.node.name);
-    if (
-      binding !== undefined &&
-      pureScopes.has(binding.scope) &&
-      !capturedIds.has(binding.identifier)
-    ) {
-      capturedIds.set(
-        binding.identifier,
-        path.node.loc ?? binding.identifier.loc ?? GeneratedSource,
-      );
+    if (binding !== undefined && pureScopes.has(binding.scope)) {
+      capturedIds.add(binding.identifier);
     }
   }
 
@@ -4264,7 +4251,7 @@ function gatherCapturedContext(
     },
   });
 
-  return capturedIds;
+  return [...capturedIds.keys()];
 }
 
 function notNull<T>(value: T | null): value is T {

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

@@ -241,10 +241,7 @@ type PropertyPathNode =
 class PropertyPathRegistry {
   roots: Map<IdentifierId, RootNode> = new Map();
 
-  getOrCreateIdentifier(
-    identifier: Identifier,
-    reactive: boolean,
-  ): PropertyPathNode {
+  getOrCreateIdentifier(identifier: Identifier): PropertyPathNode {
     /**
      * Reads from a statically scoped variable are always safe in JS,
      * with the exception of TDZ (not addressed by this pass).
@@ -258,19 +255,12 @@ class PropertyPathRegistry {
         optionalProperties: new Map(),
         fullPath: {
           identifier,
-          reactive,
           path: [],
         },
         hasOptional: false,
         parent: null,
       };
       this.roots.set(identifier.id, rootNode);
-    } else {
-      CompilerError.invariant(reactive === rootNode.fullPath.reactive, {
-        reason:
-          '[HoistablePropertyLoads] Found inconsistencies in `reactive` flag when deduping identifier reads within the same scope',
-        loc: identifier.loc,
-      });
     }
     return rootNode;
   }
@@ -288,7 +278,6 @@ class PropertyPathRegistry {
         parent: parent,
         fullPath: {
           identifier: parent.fullPath.identifier,
-          reactive: parent.fullPath.reactive,
           path: parent.fullPath.path.concat(entry),
         },
         hasOptional: parent.hasOptional || entry.optional,
@@ -304,7 +293,7 @@ class PropertyPathRegistry {
      * so all subpaths of a PropertyLoad should already exist
      * (e.g. a.b is added before a.b.c),
      */
-    let currNode = this.getOrCreateIdentifier(n.identifier, n.reactive);
+    let currNode = this.getOrCreateIdentifier(n.identifier);
     if (n.path.length === 0) {
       return currNode;
     }
@@ -326,11 +315,10 @@ function getMaybeNonNullInInstruction(
   instr: InstructionValue,
   context: CollectHoistablePropertyLoadsContext,
 ): PropertyPathNode | null {
-  let path: ReactiveScopeDependency | null = null;
+  let path = null;
   if (instr.kind === 'PropertyLoad') {
     path = context.temporaries.get(instr.object.identifier.id) ?? {
       identifier: instr.object.identifier,
-      reactive: instr.object.reactive,
       path: [],
     };
   } else if (instr.kind === 'Destructure') {
@@ -393,7 +381,7 @@ function collectNonNullsInBlocks(
   ) {
     const identifier = fn.params[0].identifier;
     knownNonNullIdentifiers.add(
-      context.registry.getOrCreateIdentifier(identifier, true),
+      context.registry.getOrCreateIdentifier(identifier),
     );
   }
   const nodes = new Map<
@@ -628,11 +616,9 @@ function reduceMaybeOptionalChains(
     changed = false;
 
     for (const original of optionalChainNodes) {
-      let {identifier, path: origPath, reactive} = original.fullPath;
-      let currNode: PropertyPathNode = registry.getOrCreateIdentifier(
-        identifier,
-        reactive,
-      );
+      let {identifier, path: origPath} = original.fullPath;
+      let currNode: PropertyPathNode =
+        registry.getOrCreateIdentifier(identifier);
       for (let i = 0; i < origPath.length; i++) {
         const entry = origPath[i];
         // If the base is known to be non-null, replace with a non-optional load

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

@@ -290,7 +290,6 @@ function traverseOptionalBlock(
     );
     baseObject = {
       identifier: maybeTest.instructions[0].value.place.identifier,
-      reactive: maybeTest.instructions[0].value.place.reactive,
       path,
     };
     test = maybeTest.terminal;
@@ -392,7 +391,6 @@ function traverseOptionalBlock(
   );
   const load = {
     identifier: baseObject.identifier,
-    reactive: baseObject.reactive,
     path: [
       ...baseObject.path,
       {

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

@@ -25,9 +25,8 @@ export class ReactiveScopeDependencyTreeHIR {
    * `identifier.path`, or `identifier?.path` is in this map, it is safe to
    * evaluate (non-optional) PropertyLoads from.
    */
-  #hoistableObjects: Map<Identifier, HoistableNode & {reactive: boolean}> =
-    new Map();
-  #deps: Map<Identifier, DependencyNode & {reactive: boolean}> = new Map();
+  #hoistableObjects: Map<Identifier, HoistableNode> = new Map();
+  #deps: Map<Identifier, DependencyNode> = new Map();
 
   /**
    * @param hoistableObjects a set of paths from which we can safely evaluate
@@ -36,10 +35,9 @@ export class ReactiveScopeDependencyTreeHIR {
    * duplicates when traversing the CFG.
    */
   constructor(hoistableObjects: Iterable<ReactiveScopeDependency>) {
-    for (const {path, identifier, reactive} of hoistableObjects) {
+    for (const {path, identifier} of hoistableObjects) {
       let currNode = ReactiveScopeDependencyTreeHIR.#getOrCreateRoot(
         identifier,
-        reactive,
         this.#hoistableObjects,
         path.length > 0 && path[0].optional ? 'Optional' : 'NonNull',
       );
@@ -72,8 +70,7 @@ export class ReactiveScopeDependencyTreeHIR {
 
   static #getOrCreateRoot<T extends string>(
     identifier: Identifier,
-    reactive: boolean,
-    roots: Map<Identifier, TreeNode<T> & {reactive: boolean}>,
+    roots: Map<Identifier, TreeNode<T>>,
     defaultAccessType: T,
   ): TreeNode<T> {
     // roots can always be accessed unconditionally in JS
@@ -82,16 +79,9 @@ export class ReactiveScopeDependencyTreeHIR {
     if (rootNode === undefined) {
       rootNode = {
         properties: new Map(),
-        reactive,
         accessType: defaultAccessType,
       };
       roots.set(identifier, rootNode);
-    } else {
-      CompilerError.invariant(reactive === rootNode.reactive, {
-        reason: '[DeriveMinimalDependenciesHIR] Conflicting reactive root flag',
-        description: `Identifier ${printIdentifier(identifier)}`,
-        loc: GeneratedSource,
-      });
     }
     return rootNode;
   }
@@ -102,10 +92,9 @@ export class ReactiveScopeDependencyTreeHIR {
    * safe-to-evaluate subpath
    */
   addDependency(dep: ReactiveScopeDependency): void {
-    const {identifier, reactive, path} = dep;
+    const {identifier, path} = dep;
     let depCursor = ReactiveScopeDependencyTreeHIR.#getOrCreateRoot(
       identifier,
-      reactive,
       this.#deps,
       PropertyAccessType.UnconditionalAccess,
     );
@@ -183,13 +172,7 @@ export class ReactiveScopeDependencyTreeHIR {
   deriveMinimalDependencies(): Set<ReactiveScopeDependency> {
     const results = new Set<ReactiveScopeDependency>();
     for (const [rootId, rootNode] of this.#deps.entries()) {
-      collectMinimalDependenciesInSubtree(
-        rootNode,
-        rootNode.reactive,
-        rootId,
-        [],
-        results,
-      );
+      collectMinimalDependenciesInSubtree(rootNode, rootId, [], results);
     }
 
     return results;
@@ -311,24 +294,25 @@ type HoistableNode = TreeNode<'Optional' | 'NonNull'>;
 type DependencyNode = TreeNode<PropertyAccessType>;
 
 /**
+ * TODO: this is directly pasted from DeriveMinimalDependencies. Since we no
+ * longer have conditionally accessed nodes, we can simplify
+ *
  * Recursively calculates minimal dependencies in a subtree.
  * @param node DependencyNode representing a dependency subtree.
  * @returns a minimal list of dependencies in this subtree.
  */
 function collectMinimalDependenciesInSubtree(
   node: DependencyNode,
-  reactive: boolean,
   rootIdentifier: Identifier,
   path: Array<DependencyPathEntry>,
   results: Set<ReactiveScopeDependency>,
 ): void {
   if (isDependency(node.accessType)) {
-    results.add({identifier: rootIdentifier, reactive, path});
+    results.add({identifier: rootIdentifier, path});
   } else {
     for (const [childName, childNode] of node.properties) {
       collectMinimalDependenciesInSubtree(
         childNode,
-        reactive,
         rootIdentifier,
         [
           ...path,

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

@@ -47,7 +47,7 @@ import {
   ShapeRegistry,
   addHook,
 } from './ObjectShape';
-import {Scope as BabelScope, NodePath} from '@babel/traverse';
+import {Scope as BabelScope} from '@babel/traverse';
 import {TypeSchema} from './TypeSchema';
 
 export const ReactElementSymbolSchema = z.object({
@@ -246,7 +246,7 @@ export const EnvironmentConfigSchema = z.object({
   /**
    * Enable a new model for mutability and aliasing inference
    */
-  enableNewMutationAliasingModel: z.boolean().default(true),
+  enableNewMutationAliasingModel: z.boolean().default(false),
 
   /**
    * Enables inference of optional dependency chains. Without this flag
@@ -680,7 +680,6 @@ export class Environment {
 
   #contextIdentifiers: Set<t.Identifier>;
   #hoistedIdentifiers: Set<t.Identifier>;
-  parentFunction: NodePath<t.Function>;
 
   constructor(
     scope: BabelScope,
@@ -688,7 +687,6 @@ export class Environment {
     compilerMode: CompilerMode,
     config: EnvironmentConfig,
     contextIdentifiers: Set<t.Identifier>,
-    parentFunction: NodePath<t.Function>, // the outermost function being compiled
     logger: Logger | null,
     filename: string | null,
     code: string | null,
@@ -747,7 +745,6 @@ export class Environment {
       this.#moduleTypes.set(REANIMATED_MODULE_NAME, reanimatedModuleType);
     }
 
-    this.parentFunction = parentFunction;
     this.#contextIdentifiers = contextIdentifiers;
     this.#hoistedIdentifiers = new Set();
   }

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

@@ -17,7 +17,6 @@ import {
   BuiltInSetId,
   BuiltInUseActionStateId,
   BuiltInUseContextHookId,
-  BuiltInUseEffectEventId,
   BuiltInUseEffectHookId,
   BuiltInUseInsertionEffectHookId,
   BuiltInUseLayoutEffectHookId,
@@ -28,7 +27,6 @@ import {
   BuiltInUseTransitionId,
   BuiltInWeakMapId,
   BuiltInWeakSetId,
-  BuiltinEffectEventId,
   ReanimatedSharedValueId,
   ShapeRegistry,
   addFunction,
@@ -760,27 +758,6 @@ const REACT_APIS: Array<[string, BuiltInType]> = [
       BuiltInFireId,
     ),
   ],
-  [
-    'useEffectEvent',
-    addHook(
-      DEFAULT_SHAPES,
-      {
-        positionalParams: [],
-        restParam: Effect.Freeze,
-        returnType: {
-          kind: 'Function',
-          return: {kind: 'Poly'},
-          shapeId: BuiltinEffectEventId,
-          isConstructor: false,
-        },
-        calleeEffect: Effect.Read,
-        hookKind: 'useEffectEvent',
-        // Frozen because it should not mutate any locally-bound values
-        returnValueKind: ValueKind.Frozen,
-      },
-      BuiltInUseEffectEventId,
-    ),
-  ],
 ];
 
 TYPED_GLOBALS.push(

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

@@ -13,7 +13,7 @@ import {Environment, ReactFunctionType} from './Environment';
 import type {HookKind} from './ObjectShape';
 import {Type, makeType} from './Types';
 import {z} from 'zod';
-import type {AliasingEffect} from '../Inference/AliasingEffects';
+import {AliasingEffect} from '../Inference/InferMutationAliasingEffects';
 
 /*
  * *******************************************************************************************
@@ -654,6 +654,10 @@ export type Instruction = {
   effects: Array<AliasingEffect> | null;
 };
 
+export function todoPopulateAliasingEffects(): Array<AliasingEffect> | null {
+  return null;
+}
+
 export type TInstruction<T extends InstructionValue> = {
   id: InstructionId;
   lvalue: Place;
@@ -1388,16 +1392,6 @@ export enum ValueReason {
    */
   JsxCaptured = 'jsx-captured',
 
-  /**
-   * Argument to a hook
-   */
-  HookCaptured = 'hook-captured',
-
-  /**
-   * Return value of a hook
-   */
-  HookReturn = 'hook-return',
-
   /**
    * Passed to an effect
    */
@@ -1591,18 +1585,6 @@ export type DependencyPathEntry = {
 export type DependencyPath = Array<DependencyPathEntry>;
 export type ReactiveScopeDependency = {
   identifier: Identifier;
-  /**
-   * Reflects whether the base identifier is reactive. Note that some reactive
-   * objects may have non-reactive properties, but we do not currently track
-   * this.
-   *
-   * ```js
-   * // Technically, result[0] is reactive and result[1] is not.
-   * // Currently, both dependencies would be marked as reactive.
-   * const result = useState();
-   * ```
-   */
-  reactive: boolean;
   path: DependencyPath;
 };
 
@@ -1808,13 +1790,6 @@ export function isFireFunctionType(id: Identifier): boolean {
   );
 }
 
-export function isEffectEventFunctionType(id: Identifier): boolean {
-  return (
-    id.type.kind === 'Function' &&
-    id.type.shapeId === 'BuiltInEffectEventFunction'
-  );
-}
-
 export function isStableType(id: Identifier): boolean {
   return (
     isSetStateType(id) ||

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

@@ -106,10 +106,11 @@ export default class HIRBuilder {
   #current: WipBlock;
   #entry: BlockId;
   #scopes: Array<Scope> = [];
-  #context: Map<t.Identifier, SourceLocation>;
+  #context: Array<t.Identifier>;
   #bindings: Bindings;
   #env: Environment;
   #exceptionHandlerStack: Array<BlockId> = [];
+  parentFunction: NodePath<t.Function>;
   errors: CompilerError = new CompilerError();
   /**
    * Traversal context: counts the number of `fbt` tag parents
@@ -121,7 +122,7 @@ export default class HIRBuilder {
     return this.#env.nextIdentifierId;
   }
 
-  get context(): Map<t.Identifier, SourceLocation> {
+  get context(): Array<t.Identifier> {
     return this.#context;
   }
 
@@ -135,17 +136,16 @@ export default class HIRBuilder {
 
   constructor(
     env: Environment,
-    options?: {
-      bindings?: Bindings | null;
-      context?: Map<t.Identifier, SourceLocation>;
-      entryBlockKind?: BlockKind;
-    },
+    parentFunction: NodePath<t.Function>, // the outermost function being compiled
+    bindings: Bindings | null = null,
+    context: Array<t.Identifier> | null = null,
   ) {
     this.#env = env;
-    this.#bindings = options?.bindings ?? new Map();
-    this.#context = options?.context ?? new Map();
+    this.#bindings = bindings ?? new Map();
+    this.parentFunction = parentFunction;
+    this.#context = context ?? [];
     this.#entry = makeBlockId(env.nextBlockId);
-    this.#current = newBlock(this.#entry, options?.entryBlockKind ?? 'block');
+    this.#current = newBlock(this.#entry, 'block');
   }
 
   currentBlockKind(): BlockKind {
@@ -240,7 +240,7 @@ export default class HIRBuilder {
 
     // Check if the binding is from module scope
     const outerBinding =
-      this.#env.parentFunction.scope.parent.getBinding(originalName);
+      this.parentFunction.scope.parent.getBinding(originalName);
     if (babelBinding === outerBinding) {
       const path = babelBinding.path;
       if (path.isImportDefaultSpecifier()) {
@@ -294,7 +294,7 @@ export default class HIRBuilder {
     const binding = this.#resolveBabelBinding(path);
     if (binding) {
       // Check if the binding is from module scope, if so return null
-      const outerBinding = this.#env.parentFunction.scope.parent.getBinding(
+      const outerBinding = this.parentFunction.scope.parent.getBinding(
         path.node.name,
       );
       if (binding === outerBinding) {
@@ -377,7 +377,7 @@ export default class HIRBuilder {
   }
 
   // Terminate the current block w the given terminal, and start a new block
-  terminate(terminal: Terminal, nextBlockKind: BlockKind | null): BlockId {
+  terminate(terminal: Terminal, nextBlockKind: BlockKind | null): void {
     const {id: blockId, kind, instructions} = this.#current;
     this.#completed.set(blockId, {
       kind,
@@ -391,7 +391,6 @@ export default class HIRBuilder {
       const nextId = this.#env.nextBlockId;
       this.#current = newBlock(nextId, nextBlockKind);
     }
-    return blockId;
   }
 
   /*
@@ -748,11 +747,6 @@ function getReversePostorderedBlocks(func: HIR): HIR['blocks'] {
      * (eg bb2 then bb1), we ensure that they get reversed back to the correct order.
      */
     const block = func.blocks.get(blockId)!;
-    CompilerError.invariant(block != null, {
-      reason: '[HIRBuilder] Unexpected null block',
-      description: `expected block ${blockId} to exist`,
-      loc: GeneratedSource,
-    });
     const successors = [...eachTerminalSuccessor(block.terminal)].reverse();
     const fallthrough = terminalFallthrough(block.terminal);
 

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

@@ -6,7 +6,7 @@
  */
 
 import {CompilerError} from '../CompilerError';
-import {AliasingSignature} from '../Inference/AliasingEffects';
+import {AliasingSignature} from '../Inference/InferMutationAliasingEffects';
 import {
   Effect,
   GeneratedSource,
@@ -142,7 +142,6 @@ export type HookKind =
   | 'useCallback'
   | 'useTransition'
   | 'useImperativeHandle'
-  | 'useEffectEvent'
   | 'Custom';
 
 /*
@@ -241,8 +240,6 @@ export const BuiltInUseTransitionId = 'BuiltInUseTransition';
 export const BuiltInStartTransitionId = 'BuiltInStartTransition';
 export const BuiltInFireId = 'BuiltInFire';
 export const BuiltInFireFunctionId = 'BuiltInFireFunction';
-export const BuiltInUseEffectEventId = 'BuiltInUseEffectEvent';
-export const BuiltinEffectEventId = 'BuiltInEffectEventFunction';
 
 // See getReanimatedModuleType() in Globals.ts — this is part of supporting Reanimated's ref-like types
 export const ReanimatedSharedValueId = 'ReanimatedSharedValueId';
@@ -1071,19 +1068,6 @@ addObject(BUILTIN_SHAPES, BuiltInRefValueId, [
   ['*', {kind: 'Object', shapeId: BuiltInRefValueId}],
 ]);
 
-addFunction(
-  BUILTIN_SHAPES,
-  [],
-  {
-    positionalParams: [],
-    restParam: Effect.ConditionallyMutate,
-    returnType: {kind: 'Poly'},
-    calleeEffect: Effect.ConditionallyMutate,
-    returnValueKind: ValueKind.Mutable,
-  },
-  BuiltinEffectEventId,
-);
-
 /**
  * MixedReadOnly =
  *   | primitive
@@ -1302,34 +1286,6 @@ export const DefaultNonmutatingHook = addHook(
     calleeEffect: Effect.Read,
     hookKind: 'Custom',
     returnValueKind: ValueKind.Frozen,
-    aliasing: {
-      receiver: makeIdentifierId(0),
-      params: [],
-      rest: makeIdentifierId(1),
-      returns: makeIdentifierId(2),
-      temporaries: [],
-      effects: [
-        // Freeze the arguments
-        {
-          kind: 'Freeze',
-          value: signatureArgument(1),
-          reason: ValueReason.HookCaptured,
-        },
-        // Returns a frozen value
-        {
-          kind: 'Create',
-          into: signatureArgument(2),
-          value: ValueKind.Frozen,
-          reason: ValueReason.HookReturn,
-        },
-        // May alias any arguments into the return
-        {
-          kind: 'Alias',
-          from: signatureArgument(1),
-          into: signatureArgument(2),
-        },
-      ],
-    },
   },
   'DefaultNonmutatingHook',
 );

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

@@ -35,7 +35,10 @@ import type {
   Type,
 } from './HIR';
 import {GotoVariant, InstructionKind} from './HIR';
-import {AliasingEffect, AliasingSignature} from '../Inference/AliasingEffects';
+import {
+  AliasingEffect,
+  AliasingSignature,
+} from '../Inference/InferMutationAliasingEffects';
 
 export type Options = {
   indent: number;

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

@@ -316,7 +316,6 @@ function collectTemporariesSidemapImpl(
         ) {
           temporaries.set(lvalue.identifier.id, {
             identifier: value.place.identifier,
-            reactive: value.place.reactive,
             path: [],
           });
         }
@@ -370,13 +369,11 @@ function getProperty(
   if (resolvedDependency == null) {
     property = {
       identifier: object.identifier,
-      reactive: object.reactive,
       path: [{property: propertyName, optional}],
     };
   } else {
     property = {
       identifier: resolvedDependency.identifier,
-      reactive: resolvedDependency.reactive,
       path: [...resolvedDependency.path, {property: propertyName, optional}],
     };
   }
@@ -535,7 +532,6 @@ export class DependencyCollectionContext {
     this.visitDependency(
       this.#temporaries.get(place.identifier.id) ?? {
         identifier: place.identifier,
-        reactive: place.reactive,
         path: [],
       },
     );
@@ -600,7 +596,6 @@ export class DependencyCollectionContext {
     ) {
       maybeDependency = {
         identifier: maybeDependency.identifier,
-        reactive: maybeDependency.reactive,
         path: [],
       };
     }
@@ -622,11 +617,7 @@ export class DependencyCollectionContext {
         identifier =>
           identifier.declarationId === place.identifier.declarationId,
       ) &&
-      this.#checkValidDependency({
-        identifier: place.identifier,
-        reactive: place.reactive,
-        path: [],
-      })
+      this.#checkValidDependency({identifier: place.identifier, path: []})
     ) {
       currentScope.reassignments.add(place.identifier);
     }

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

@@ -1,285 +0,0 @@
-import {
-  Place,
-  ReactiveScopeDependency,
-  Identifier,
-  makeInstructionId,
-  InstructionKind,
-  GeneratedSource,
-  BlockId,
-  makeTemporaryIdentifier,
-  Effect,
-  GotoVariant,
-  HIR,
-} from './HIR';
-import {CompilerError} from '../CompilerError';
-import {Environment} from './Environment';
-import HIRBuilder from './HIRBuilder';
-import {lowerValueToTemporary} from './BuildHIR';
-
-type DependencyInstructions = {
-  place: Place;
-  value: HIR;
-  exitBlockId: BlockId;
-};
-
-export function buildDependencyInstructions(
-  dep: ReactiveScopeDependency,
-  env: Environment,
-): DependencyInstructions {
-  const builder = new HIRBuilder(env, {
-    entryBlockKind: 'value',
-  });
-  let dependencyValue: Identifier;
-  if (dep.path.every(path => !path.optional)) {
-    dependencyValue = writeNonOptionalDependency(dep, env, builder);
-  } else {
-    dependencyValue = writeOptionalDependency(dep, builder, null);
-  }
-
-  const exitBlockId = builder.terminate(
-    {
-      kind: 'unsupported',
-      loc: GeneratedSource,
-      id: makeInstructionId(0),
-    },
-    null,
-  );
-  return {
-    place: {
-      kind: 'Identifier',
-      identifier: dependencyValue,
-      effect: Effect.Freeze,
-      reactive: dep.reactive,
-      loc: GeneratedSource,
-    },
-    value: builder.build(),
-    exitBlockId,
-  };
-}
-
-/**
- * Write instructions for a simple dependency (without optional chains)
- */
-function writeNonOptionalDependency(
-  dep: ReactiveScopeDependency,
-  env: Environment,
-  builder: HIRBuilder,
-): Identifier {
-  const loc = dep.identifier.loc;
-  let curr: Identifier = makeTemporaryIdentifier(env.nextIdentifierId, loc);
-  builder.push({
-    lvalue: {
-      identifier: curr,
-      kind: 'Identifier',
-      effect: Effect.Mutate,
-      reactive: dep.reactive,
-      loc,
-    },
-    value: {
-      kind: 'LoadLocal',
-      place: {
-        identifier: dep.identifier,
-        kind: 'Identifier',
-        effect: Effect.Freeze,
-        reactive: dep.reactive,
-        loc,
-      },
-      loc,
-    },
-    id: makeInstructionId(1),
-    loc: loc,
-    effects: null,
-  });
-
-  /**
-   * Iteratively build up dependency instructions by reading from the last written
-   * instruction.
-   */
-  for (const path of dep.path) {
-    const next = makeTemporaryIdentifier(env.nextIdentifierId, loc);
-    builder.push({
-      lvalue: {
-        identifier: next,
-        kind: 'Identifier',
-        effect: Effect.Mutate,
-        reactive: dep.reactive,
-        loc,
-      },
-      value: {
-        kind: 'PropertyLoad',
-        object: {
-          identifier: curr,
-          kind: 'Identifier',
-          effect: Effect.Freeze,
-          reactive: dep.reactive,
-          loc,
-        },
-        property: path.property,
-        loc,
-      },
-      id: makeInstructionId(1),
-      loc: loc,
-      effects: null,
-    });
-    curr = next;
-  }
-  return curr;
-}
-
-/**
- * Write a dependency into optional blocks.
- *
- * e.g. `a.b?.c.d` is written to an optional block that tests `a.b` and
- * conditionally evaluates `c.d`.
- */
-function writeOptionalDependency(
-  dep: ReactiveScopeDependency,
-  builder: HIRBuilder,
-  parentAlternate: BlockId | null,
-): Identifier {
-  const env = builder.environment;
-  /**
-   * Reserve an identifier which will be used to store the result of this
-   * dependency.
-   */
-  const dependencyValue: Place = {
-    kind: 'Identifier',
-    identifier: makeTemporaryIdentifier(env.nextIdentifierId, GeneratedSource),
-    effect: Effect.Mutate,
-    reactive: dep.reactive,
-    loc: GeneratedSource,
-  };
-
-  /**
-   * Reserve a block which is the fallthrough (and transitive successor) of this
-   * optional chain.
-   */
-  const continuationBlock = builder.reserve(builder.currentBlockKind());
-  let alternate;
-  if (parentAlternate != null) {
-    alternate = parentAlternate;
-  } else {
-    /**
-     * If an outermost alternate block has not been reserved, write one
-     *
-     * $N = Primitive undefined
-     * $M = StoreLocal $OptionalResult = $N
-     * goto fallthrough
-     */
-    alternate = builder.enter('value', () => {
-      const temp = lowerValueToTemporary(builder, {
-        kind: 'Primitive',
-        value: undefined,
-        loc: GeneratedSource,
-      });
-      lowerValueToTemporary(builder, {
-        kind: 'StoreLocal',
-        lvalue: {kind: InstructionKind.Const, place: {...dependencyValue}},
-        value: {...temp},
-        type: null,
-        loc: GeneratedSource,
-      });
-      return {
-        kind: 'goto',
-        variant: GotoVariant.Break,
-        block: continuationBlock.id,
-        id: makeInstructionId(0),
-        loc: GeneratedSource,
-      };
-    });
-  }
-
-  // Reserve the consequent block, which is the successor of the test block
-  const consequent = builder.reserve('value');
-
-  let testIdentifier: Identifier | null = null;
-  const testBlock = builder.enter('value', () => {
-    const testDependency = {
-      ...dep,
-      path: dep.path.slice(0, dep.path.length - 1),
-    };
-    const firstOptional = dep.path.findIndex(path => path.optional);
-    CompilerError.invariant(firstOptional !== -1, {
-      reason:
-        '[ScopeDependencyUtils] Internal invariant broken: expected optional path',
-      loc: dep.identifier.loc,
-      description: null,
-      suggestions: null,
-    });
-    if (firstOptional === dep.path.length - 1) {
-      // Base case: the test block is simple
-      testIdentifier = writeNonOptionalDependency(testDependency, env, builder);
-    } else {
-      // Otherwise, the test block is a nested optional chain
-      testIdentifier = writeOptionalDependency(
-        testDependency,
-        builder,
-        alternate,
-      );
-    }
-
-    return {
-      kind: 'branch',
-      test: {
-        identifier: testIdentifier,
-        effect: Effect.Freeze,
-        kind: 'Identifier',
-        loc: GeneratedSource,
-        reactive: dep.reactive,
-      },
-      consequent: consequent.id,
-      alternate,
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-      fallthrough: continuationBlock.id,
-    };
-  });
-
-  builder.enterReserved(consequent, () => {
-    CompilerError.invariant(testIdentifier !== null, {
-      reason: 'Satisfy type checker',
-      description: null,
-      loc: null,
-      suggestions: null,
-    });
-
-    lowerValueToTemporary(builder, {
-      kind: 'StoreLocal',
-      lvalue: {kind: InstructionKind.Const, place: {...dependencyValue}},
-      value: lowerValueToTemporary(builder, {
-        kind: 'PropertyLoad',
-        object: {
-          identifier: testIdentifier,
-          kind: 'Identifier',
-          effect: Effect.Freeze,
-          reactive: dep.reactive,
-          loc: GeneratedSource,
-        },
-        property: dep.path.at(-1)!.property,
-        loc: GeneratedSource,
-      }),
-      type: null,
-      loc: GeneratedSource,
-    });
-    return {
-      kind: 'goto',
-      variant: GotoVariant.Break,
-      block: continuationBlock.id,
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-    };
-  });
-  builder.terminateWithContinuation(
-    {
-      kind: 'optional',
-      optional: dep.path.at(-1)!.optional,
-      test: testBlock,
-      fallthrough: continuationBlock.id,
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-    },
-    continuationBlock,
-  );
-
-  return dependencyValue.identifier;
-}

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

@@ -1,233 +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 {CompilerErrorDetailOptions} from '../CompilerError';
-import {
-  FunctionExpression,
-  Hole,
-  IdentifierId,
-  ObjectMethod,
-  Place,
-  SourceLocation,
-  SpreadPattern,
-  ValueKind,
-  ValueReason,
-} from '../HIR';
-import {FunctionSignature} from '../HIR/ObjectShape';
-
-/**
- * `AliasingEffect` describes a set of "effects" that an instruction/terminal has on one or
- * more values in a program. These effects include mutation of values, freezing values,
- * tracking data flow between values, and other specialized cases.
- */
-export type AliasingEffect =
-  /**
-   * Marks the given value and its direct aliases as frozen.
-   *
-   * Captured values are *not* considered frozen, because we cannot be sure that a previously
-   * captured value will still be captured at the point of the freeze.
-   *
-   * For example:
-   * const x = {};
-   * const y = [x];
-   * y.pop(); // y dosn't contain x anymore!
-   * freeze(y);
-   * mutate(x); // safe to mutate!
-   *
-   * The exception to this is FunctionExpressions - since it is impossible to change which
-   * value a function closes over[1] we can transitively freeze functions and their captures.
-   *
-   * [1] Except for `let` values that are reassigned and closed over by a function, but we
-   * handle this explicitly with StoreContext/LoadContext.
-   */
-  | {kind: 'Freeze'; value: Place; reason: ValueReason}
-  /**
-   * Mutate the value and any direct aliases (not captures). Errors if the value is not mutable.
-   */
-  | {kind: 'Mutate'; value: Place}
-  /**
-   * Mutate the value and any direct aliases (not captures), but only if the value is known mutable.
-   * This should be rare.
-   *
-   * TODO: this is only used for IteratorNext, but even then MutateTransitiveConditionally is more
-   * correct for iterators of unknown types.
-   */
-  | {kind: 'MutateConditionally'; value: Place}
-  /**
-   * Mutate the value, any direct aliases, and any transitive captures. Errors if the value is not mutable.
-   */
-  | {kind: 'MutateTransitive'; value: Place}
-  /**
-   * Mutates any of the value, its direct aliases, and its transitive captures that are mutable.
-   */
-  | {kind: 'MutateTransitiveConditionally'; value: Place}
-  /**
-   * Records information flow from `from` to `into` in cases where local mutation of the destination
-   * will *not* mutate the source:
-   *
-   * - Capture a -> b and Mutate(b) X=> (does not imply) Mutate(a)
-   * - Capture a -> b and MutateTransitive(b) => (does imply) Mutate(a)
-   *
-   * Example: `array.push(item)`. Information from item is captured into array, but there is not a
-   * direct aliasing, and local mutations of array will not modify item.
-   */
-  | {kind: 'Capture'; from: Place; into: Place}
-  /**
-   * Records information flow from `from` to `into` in cases where local mutation of the destination
-   * *will* mutate the source:
-   *
-   * - Alias a -> b and Mutate(b) => (does imply) Mutate(a)
-   * - Alias a -> b and MutateTransitive(b) => (does imply) Mutate(a)
-   *
-   * Example: `c = identity(a)`. We don't know what `identity()` returns so we can't use Assign.
-   * But we have to assume that it _could_ be returning its input, such that a local mutation of
-   * c could be mutating a.
-   */
-  | {kind: 'Alias'; from: Place; into: Place}
-  /**
-   * Records direct assignment: `into = from`.
-   */
-  | {kind: 'Assign'; from: Place; into: Place}
-  /**
-   * Creates a value of the given type at the given place
-   */
-  | {kind: 'Create'; into: Place; value: ValueKind; reason: ValueReason}
-  /**
-   * Creates a new value with the same kind as the starting value.
-   */
-  | {kind: 'CreateFrom'; from: Place; into: Place}
-  /**
-   * Immutable data flow, used for escape analysis. Does not influence mutable range analysis:
-   */
-  | {kind: 'ImmutableCapture'; from: Place; into: Place}
-  /**
-   * Calls the function at the given place with the given arguments either captured or aliased,
-   * and captures/aliases the result into the given place.
-   */
-  | {
-      kind: 'Apply';
-      receiver: Place;
-      function: Place;
-      mutatesFunction: boolean;
-      args: Array<Place | SpreadPattern | Hole>;
-      into: Place;
-      signature: FunctionSignature | null;
-      loc: SourceLocation;
-    }
-  /**
-   * Constructs a function value with the given captures. The mutability of the function
-   * will be determined by the mutability of the capture values when evaluated.
-   */
-  | {
-      kind: 'CreateFunction';
-      captures: Array<Place>;
-      function: FunctionExpression | ObjectMethod;
-      into: Place;
-    }
-  /**
-   * Mutation of a value known to be immutable
-   */
-  | {kind: 'MutateFrozen'; place: Place; error: CompilerErrorDetailOptions}
-  /**
-   * Mutation of a global
-   */
-  | {
-      kind: 'MutateGlobal';
-      place: Place;
-      error: CompilerErrorDetailOptions;
-    }
-  /**
-   * Indicates a side-effect that is not safe during render
-   */
-  | {kind: 'Impure'; place: Place; error: CompilerErrorDetailOptions}
-  /**
-   * Indicates that a given place is accessed during render. Used to distingush
-   * hook arguments that are known to be called immediately vs those used for
-   * event handlers/effects, and for JSX values known to be called during render
-   * (tags, children) vs those that may be events/effect (other props).
-   */
-  | {
-      kind: 'Render';
-      place: Place;
-    };
-
-export function hashEffect(effect: AliasingEffect): string {
-  switch (effect.kind) {
-    case 'Apply': {
-      return [
-        effect.kind,
-        effect.receiver.identifier.id,
-        effect.function.identifier.id,
-        effect.mutatesFunction,
-        effect.args
-          .map(a => {
-            if (a.kind === 'Hole') {
-              return '';
-            } else if (a.kind === 'Identifier') {
-              return a.identifier.id;
-            } else {
-              return `...${a.place.identifier.id}`;
-            }
-          })
-          .join(','),
-        effect.into.identifier.id,
-      ].join(':');
-    }
-    case 'CreateFrom':
-    case 'ImmutableCapture':
-    case 'Assign':
-    case 'Alias':
-    case 'Capture': {
-      return [
-        effect.kind,
-        effect.from.identifier.id,
-        effect.into.identifier.id,
-      ].join(':');
-    }
-    case 'Create': {
-      return [
-        effect.kind,
-        effect.into.identifier.id,
-        effect.value,
-        effect.reason,
-      ].join(':');
-    }
-    case 'Freeze': {
-      return [effect.kind, effect.value.identifier.id, effect.reason].join(':');
-    }
-    case 'Impure':
-    case 'Render':
-    case 'MutateFrozen':
-    case 'MutateGlobal': {
-      return [effect.kind, effect.place.identifier.id].join(':');
-    }
-    case 'Mutate':
-    case 'MutateConditionally':
-    case 'MutateTransitive':
-    case 'MutateTransitiveConditionally': {
-      return [effect.kind, effect.value.identifier.id].join(':');
-    }
-    case 'CreateFunction': {
-      return [
-        effect.kind,
-        effect.into.identifier.id,
-        // return places are a unique way to identify functions themselves
-        effect.function.loweredFunc.func.returns.identifier.id,
-        effect.captures.map(p => p.identifier.id).join(','),
-      ].join(':');
-    }
-  }
-}
-
-export type AliasingSignature = {
-  receiver: IdentifierId;
-  params: Array<IdentifierId>;
-  rest: IdentifierId | null;
-  returns: IdentifierId;
-  effects: Array<AliasingEffect>;
-  temporaries: Array<Place>;
-};

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

@@ -42,16 +42,8 @@ export default function analyseFunctions(func: HIRFunction): void {
            * Reset mutable range for outer inferReferenceEffects
            */
           for (const operand of instr.value.loweredFunc.func.context) {
-            /**
-             * NOTE: inferReactiveScopeVariables makes identifiers in the scope
-             * point to the *same* mutableRange instance. Resetting start/end
-             * here is insufficient, because a later mutation of the range
-             * for any one identifier could affect the range for other identifiers.
-             */
-            operand.identifier.mutableRange = {
-              start: makeInstructionId(0),
-              end: makeInstructionId(0),
-            };
+            operand.identifier.mutableRange.start = makeInstructionId(0);
+            operand.identifier.mutableRange.end = makeInstructionId(0);
             operand.identifier.scope = null;
           }
           break;
@@ -62,9 +54,6 @@ export default function analyseFunctions(func: HIRFunction): void {
 }
 
 function lowerWithMutationAliasing(fn: HIRFunction): void {
-  /**
-   * Phase 1: similar to lower(), but using the new mutation/aliasing inference
-   */
   analyseFunctions(fn);
   inferMutationAliasingEffects(fn, {isFunctionExpression: true});
   deadCodeElimination(fn);
@@ -82,11 +71,6 @@ function lowerWithMutationAliasing(fn: HIRFunction): void {
     fn.aliasingEffects?.push(...effects);
   }
 
-  /**
-   * Phase 2: populate the Effect of each context variable to use in inferring
-   * the outer function. For example, InferMutationAliasingEffects uses context variable
-   * effects to decide if the function may be mutable or not.
-   */
   const capturedOrMutated = new Set<IdentifierId>();
   for (const effect of effects ?? []) {
     switch (effect.kind) {

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

@@ -10,6 +10,7 @@ import {CompilerError, SourceLocation} from '..';
 import {
   ArrayExpression,
   Effect,
+  Environment,
   FunctionExpression,
   GeneratedSource,
   HIRFunction,
@@ -28,10 +29,7 @@ import {
   isSetStateType,
   isFireFunctionType,
   makeScopeId,
-  HIR,
-  BasicBlock,
-  BlockId,
-  isEffectEventFunctionType,
+  todoPopulateAliasingEffects,
 } from '../HIR';
 import {collectHoistablePropertyLoadsInInnerFn} from '../HIR/CollectHoistablePropertyLoads';
 import {collectOptionalChainSidemap} from '../HIR/CollectOptionalChainDependencies';
@@ -41,20 +39,13 @@ import {
   createTemporaryPlace,
   fixScopeAndIdentifierRanges,
   markInstructionIds,
-  markPredecessors,
-  reversePostorderBlocks,
 } from '../HIR/HIRBuilder';
 import {
   collectTemporariesSidemap,
   DependencyCollectionContext,
   handleInstruction,
 } from '../HIR/PropagateScopeDependenciesHIR';
-import {buildDependencyInstructions} from '../HIR/ScopeDependencyUtils';
-import {
-  eachInstructionOperand,
-  eachTerminalOperand,
-  terminalFallthrough,
-} from '../HIR/visitors';
+import {eachInstructionOperand, eachTerminalOperand} from '../HIR/visitors';
 import {empty} from '../Utils/Stack';
 import {getOrInsertWith} from '../Utils/utils';
 
@@ -63,6 +54,7 @@ import {getOrInsertWith} from '../Utils/utils';
  * a second argument to the useEffect call if no dependency array is provided.
  */
 export function inferEffectDependencies(fn: HIRFunction): void {
+  let hasRewrite = false;
   const fnExpressions = new Map<
     IdentifierId,
     TInstruction<FunctionExpression>
@@ -95,7 +87,6 @@ export function inferEffectDependencies(fn: HIRFunction): void {
    * reactive(Identifier i) = Union_{reference of i}(reactive(reference))
    */
   const reactiveIds = inferReactiveIdentifiers(fn);
-  const rewriteBlocks: Array<BasicBlock> = [];
 
   for (const [, block] of fn.body.blocks) {
     if (block.terminal.kind === 'scope') {
@@ -111,7 +102,7 @@ export function inferEffectDependencies(fn: HIRFunction): void {
         );
       }
     }
-    const rewriteInstrs: Array<SpliceInfo> = [];
+    const rewriteInstrs = new Map<InstructionId, Array<Instruction>>();
     for (const instr of block.instructions) {
       const {value, lvalue} = instr;
       if (value.kind === 'FunctionExpression') {
@@ -175,6 +166,7 @@ export function inferEffectDependencies(fn: HIRFunction): void {
         ) {
           // We have a useEffect call with no deps array, so we need to infer the deps
           const effectDeps: Array<Place> = [];
+          const newInstructions: Array<Instruction> = [];
           const deps: ArrayExpression = {
             kind: 'ArrayExpression',
             elements: effectDeps,
@@ -205,29 +197,24 @@ export function inferEffectDependencies(fn: HIRFunction): void {
              */
 
             const usedDeps = [];
-            for (const maybeDep of minimalDeps) {
+            for (const dep of minimalDeps) {
               if (
-                ((isUseRefType(maybeDep.identifier) ||
-                  isSetStateType(maybeDep.identifier)) &&
-                  !reactiveIds.has(maybeDep.identifier.id)) ||
-                isFireFunctionType(maybeDep.identifier) ||
-                isEffectEventFunctionType(maybeDep.identifier)
+                ((isUseRefType(dep.identifier) ||
+                  isSetStateType(dep.identifier)) &&
+                  !reactiveIds.has(dep.identifier.id)) ||
+                isFireFunctionType(dep.identifier)
               ) {
                 // exclude non-reactive hook results, which will never be in a memo block
                 continue;
               }
 
-              const dep = truncateDepAtCurrent(maybeDep);
-              const {place, value, exitBlockId} = buildDependencyInstructions(
+              const {place, instructions} = writeDependencyToInstructions(
                 dep,
+                reactiveIds.has(dep.identifier.id),
                 fn.env,
+                fnExpr.loc,
               );
-              rewriteInstrs.push({
-                kind: 'block',
-                location: instr.id,
-                value,
-                exitBlockId: exitBlockId,
-              });
+              newInstructions.push(...instructions);
               effectDeps.push(place);
               usedDeps.push(dep);
             }
@@ -248,34 +235,29 @@ export function inferEffectDependencies(fn: HIRFunction): void {
               });
             }
 
-            // Step 2: push the inferred deps array as an argument of the useEffect
-            rewriteInstrs.push({
-              kind: 'instr',
-              location: instr.id,
-              value: {
-                id: makeInstructionId(0),
-                loc: GeneratedSource,
-                lvalue: {...depsPlace, effect: Effect.Mutate},
-                value: deps,
-                effects: null,
-              },
+            newInstructions.push({
+              id: makeInstructionId(0),
+              lvalue: {...depsPlace, effect: Effect.Mutate},
+              effects: todoPopulateAliasingEffects(),
+              value: deps,
+              loc: GeneratedSource,
             });
+
+            // Step 2: push the inferred deps array as an argument of the useEffect
             value.args.push({...depsPlace, effect: Effect.Freeze});
+            rewriteInstrs.set(instr.id, newInstructions);
             fn.env.inferredEffectLocations.add(callee.loc);
           } else if (loadGlobals.has(value.args[0].identifier.id)) {
             // Global functions have no reactive dependencies, so we can insert an empty array
-            rewriteInstrs.push({
-              kind: 'instr',
-              location: instr.id,
-              value: {
-                id: makeInstructionId(0),
-                loc: GeneratedSource,
-                lvalue: {...depsPlace, effect: Effect.Mutate},
-                value: deps,
-                effects: null,
-              },
+            newInstructions.push({
+              id: makeInstructionId(0),
+              lvalue: {...depsPlace, effect: Effect.Mutate},
+              effects: todoPopulateAliasingEffects(),
+              value: deps,
+              loc: GeneratedSource,
             });
             value.args.push({...depsPlace, effect: Effect.Freeze});
+            rewriteInstrs.set(instr.id, newInstructions);
             fn.env.inferredEffectLocations.add(callee.loc);
           }
         } else if (
@@ -306,164 +288,90 @@ export function inferEffectDependencies(fn: HIRFunction): void {
         }
       }
     }
-    rewriteSplices(block, rewriteInstrs, rewriteBlocks);
-  }
-
-  if (rewriteBlocks.length > 0) {
-    for (const block of rewriteBlocks) {
-      fn.body.blocks.set(block.id, block);
+    if (rewriteInstrs.size > 0) {
+      hasRewrite = true;
+      const newInstrs = [];
+      for (const instr of block.instructions) {
+        const newInstr = rewriteInstrs.get(instr.id);
+        if (newInstr != null) {
+          newInstrs.push(...newInstr, instr);
+        } else {
+          newInstrs.push(instr);
+        }
+      }
+      block.instructions = newInstrs;
     }
-
-    /**
-     * Fixup the HIR to restore RPO, ensure correct predecessors, and renumber
-     * instructions.
-     */
-    reversePostorderBlocks(fn.body);
-    markPredecessors(fn.body);
+  }
+  if (hasRewrite) {
     // Renumber instructions and fix scope ranges
     markInstructionIds(fn.body);
     fixScopeAndIdentifierRanges(fn.body);
-
     fn.env.hasInferredEffect = true;
   }
 }
 
-function truncateDepAtCurrent(
+function writeDependencyToInstructions(
   dep: ReactiveScopeDependency,
-): ReactiveScopeDependency {
-  const idx = dep.path.findIndex(path => path.property === 'current');
-  if (idx === -1) {
-    return dep;
-  } else {
-    return {...dep, path: dep.path.slice(0, idx)};
-  }
-}
-
-type SpliceInfo =
-  | {kind: 'instr'; location: InstructionId; value: Instruction}
-  | {
-      kind: 'block';
-      location: InstructionId;
-      value: HIR;
-      exitBlockId: BlockId;
-    };
-
-function rewriteSplices(
-  originalBlock: BasicBlock,
-  splices: Array<SpliceInfo>,
-  rewriteBlocks: Array<BasicBlock>,
-): void {
-  if (splices.length === 0) {
-    return;
-  }
-  /**
-   * Splice instructions or value blocks into the original block.
-   * --- original block ---
-   * bb_original
-   *   instr1
-   *   ...
-   *   instr2 <-- splice location
-   *   instr3
-   *   ...
-   *   <original terminal>
-   *
-   * If there is more than one block in the splice, this means that we're
-   * splicing in a set of value-blocks of the following structure:
-   * --- blocks we're splicing in ---
-   * bb_entry:
-   *   instrEntry
-   *   ...
-   *   <splice terminal> fallthrough=bb_exit
-   *
-   * bb1(value):
-   *   ...
-   *
-   * bb_exit:
-   *   instrExit
-   *   ...
-   *   <synthetic terminal>
-   *
-   *
-   * --- rewritten blocks ---
-   * bb_original
-   *   instr1
-   *   ... (original instructions)
-   *   instr2
-   *   instrEntry
-   *   ... (spliced instructions)
-   *   <splice terminal> fallthrough=bb_exit
-   *
-   * bb1(value):
-   *   ...
-   *
-   * bb_exit:
-   *   instrExit
-   *   ... (spliced instructions)
-   *   instr3
-   *   ... (original instructions)
-   *   <original terminal>
-   */
-  const originalInstrs = originalBlock.instructions;
-  let currBlock: BasicBlock = {...originalBlock, instructions: []};
-  rewriteBlocks.push(currBlock);
-
-  let cursor = 0;
-  for (const rewrite of splices) {
-    while (originalInstrs[cursor].id < rewrite.location) {
-      CompilerError.invariant(
-        originalInstrs[cursor].id < originalInstrs[cursor + 1].id,
-        {
-          reason:
-            '[InferEffectDependencies] Internal invariant broken: expected block instructions to be sorted',
-          loc: originalInstrs[cursor].loc,
-        },
-      );
-      currBlock.instructions.push(originalInstrs[cursor]);
-      cursor++;
+  reactive: boolean,
+  env: Environment,
+  loc: SourceLocation,
+): {place: Place; instructions: Array<Instruction>} {
+  const instructions: Array<Instruction> = [];
+  let currValue = createTemporaryPlace(env, GeneratedSource);
+  currValue.reactive = reactive;
+  const dependencyPlace: Place = {
+    kind: 'Identifier',
+    identifier: dep.identifier,
+    effect: Effect.Capture,
+    reactive,
+    loc: loc,
+  };
+  instructions.push({
+    id: makeInstructionId(0),
+    loc: GeneratedSource,
+    lvalue: {...currValue, effect: Effect.Mutate},
+    value: {
+      kind: 'LoadLocal',
+      place: {...dependencyPlace},
+      loc: loc,
+    },
+    effects: [
+      {kind: 'Alias', from: {...dependencyPlace}, into: {...currValue}},
+    ],
+  });
+  for (const path of dep.path) {
+    if (path.optional) {
+      /**
+       * TODO: instead of truncating optional paths, reuse
+       * instructions from hoisted dependencies block(s)
+       */
+      break;
     }
-    CompilerError.invariant(originalInstrs[cursor].id === rewrite.location, {
-      reason:
-        '[InferEffectDependencies] Internal invariant broken: splice location not found',
-      loc: originalInstrs[cursor].loc,
+    if (path.property === 'current') {
+      /*
+       * Prune ref.current accesses. This may over-capture for non-ref values with
+       * a current property, but that's fine.
+       */
+      break;
+    }
+    const nextValue = createTemporaryPlace(env, GeneratedSource);
+    nextValue.reactive = reactive;
+    instructions.push({
+      id: makeInstructionId(0),
+      loc: GeneratedSource,
+      lvalue: {...nextValue, effect: Effect.Mutate},
+      value: {
+        kind: 'PropertyLoad',
+        object: {...currValue, effect: Effect.Capture},
+        property: path.property,
+        loc: loc,
+      },
+      effects: [{kind: 'Capture', from: {...currValue}, into: {...nextValue}}],
     });
-
-    if (rewrite.kind === 'instr') {
-      currBlock.instructions.push(rewrite.value);
-    } else {
-      const {entry, blocks} = rewrite.value;
-      const entryBlock = blocks.get(entry)!;
-      // splice in all instructions from the entry block
-      currBlock.instructions.push(...entryBlock.instructions);
-      if (blocks.size > 1) {
-        /**
-         * We're splicing in a set of value-blocks, which means we need
-         * to push new blocks and update terminals.
-         */
-        CompilerError.invariant(
-          terminalFallthrough(entryBlock.terminal) === rewrite.exitBlockId,
-          {
-            reason:
-              '[InferEffectDependencies] Internal invariant broken: expected entry block to have a fallthrough',
-            loc: entryBlock.terminal.loc,
-          },
-        );
-        const originalTerminal = currBlock.terminal;
-        currBlock.terminal = entryBlock.terminal;
-
-        for (const [id, block] of blocks) {
-          if (id === entry) {
-            continue;
-          }
-          if (id === rewrite.exitBlockId) {
-            block.terminal = originalTerminal;
-            currBlock = block;
-          }
-          rewriteBlocks.push(block);
-        }
-      }
-    }
+    currValue = nextValue;
   }
-  currBlock.instructions.push(...originalInstrs.slice(cursor));
+  currValue.effect = Effect.Freeze;
+  return {place: currValue, instructions};
 }
 
 function inferReactiveIdentifiers(fn: HIRFunction): Set<IdentifierId> {

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

@@ -341,10 +341,6 @@ export function getWriteErrorReason(abstractValue: AbstractValue): string {
     return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
   } else if (abstractValue.reason.has(ValueReason.Effect)) {
     return 'Updating a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the mutation before calling useEffect()';
-  } else if (abstractValue.reason.has(ValueReason.HookCaptured)) {
-    return 'Updating a value previously passed as an argument to a hook is not allowed. Consider moving the mutation before calling the hook';
-  } else if (abstractValue.reason.has(ValueReason.HookReturn)) {
-    return 'Updating a value returned from a hook is not allowed. Consider moving the mutation into the hook where the value is constructed';
   } else {
     return 'This mutates a variable that React considers immutable';
   }

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

@@ -86,7 +86,7 @@ export function inferMutableRanges(ir: HIRFunction): void {
   }
 }
 
-function areEqualMaps<T, U>(a: Map<T, U>, b: Map<T, U>): boolean {
+export function areEqualMaps<T, U>(a: Map<T, U>, b: Map<T, U>): boolean {
   if (a.size !== b.size) {
     return false;
   }

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

@@ -7,6 +7,7 @@
 
 import {
   CompilerError,
+  CompilerErrorDetailOptions,
   Effect,
   ErrorSeverity,
   SourceLocation,
@@ -30,6 +31,7 @@ import {
   isRefOrRefValue,
   isSetType,
   makeIdentifierId,
+  ObjectMethod,
   Phi,
   Place,
   SpreadPattern,
@@ -38,7 +40,6 @@ import {
 import {
   eachInstructionValueLValue,
   eachInstructionValueOperand,
-  eachTerminalOperand,
   eachTerminalSuccessor,
 } from '../HIR/visitors';
 import {Ok, Result} from '../Utils/Result';
@@ -66,32 +67,9 @@ import {FunctionSignature} from '../HIR/ObjectShape';
 import {getWriteErrorReason} from './InferFunctionEffects';
 import prettyFormat from 'pretty-format';
 import {createTemporaryPlace} from '../HIR/HIRBuilder';
-import {AliasingEffect, AliasingSignature, hashEffect} from './AliasingEffects';
 
 const DEBUG = false;
 
-/**
- * Infers the mutation/aliasing effects for instructions and terminals and annotates
- * them on the HIR, making the effects of builtin instructions/functions as well as
- * user-defined functions explicit. These effects then form the basis for subsequent
- * analysis to determine the mutable range of each value in the program — the set of
- * instructions over which the value is created and mutated — as well as validation
- * against invalid code.
- *
- * At a high level the approach is:
- * - Determine a set of candidate effects based purely on the syntax of the instruction
- *   and the types involved. These candidate effects are cached the first time each
- *   instruction is visited. The idea is to reason about the semantics of the instruction
- *   or function in isolation, separately from how those effects may interact with later
- *   abstract interpretation.
- * - Then we do abstract interpretation over the HIR, iterating until reaching a fixpoint.
- *   This phase tracks the abstract kind of each value (mutable, primitive, frozen, etc)
- *   and the set of values pointed to by each identifier. Each candidate effect is "applied"
- *   to the current abtract state, and effects may be dropped or rewritten accordingly.
- *   For example, a "MutateConditionally <x>" effect may be dropped if x is not a mutable
- *   value. A "Mutate <y>" effect may get converted into a "MutateFrozen <error>" effect
- *   if y is mutable, etc.
- */
 export function inferMutationAliasingEffects(
   fn: HIRFunction,
   {isFunctionExpression}: {isFunctionExpression: boolean} = {
@@ -222,19 +200,8 @@ export function inferMutationAliasingEffects(
   return Ok(undefined);
 }
 
-function findHoistedContextDeclarations(
-  fn: HIRFunction,
-): Map<DeclarationId, Place | null> {
-  const hoisted = new Map<DeclarationId, Place | null>();
-  function visit(place: Place): void {
-    if (
-      hoisted.has(place.identifier.declarationId) &&
-      hoisted.get(place.identifier.declarationId) == null
-    ) {
-      // If this is the first load of the value, store the location
-      hoisted.set(place.identifier.declarationId, place);
-    }
-  }
+function findHoistedContextDeclarations(fn: HIRFunction): Set<DeclarationId> {
+  const hoisted = new Set<DeclarationId>();
   for (const block of fn.body.blocks.values()) {
     for (const instr of block.instructions) {
       if (instr.value.kind === 'DeclareContext') {
@@ -244,17 +211,10 @@ function findHoistedContextDeclarations(
           kind == InstructionKind.HoistedFunction ||
           kind == InstructionKind.HoistedLet
         ) {
-          hoisted.set(instr.value.lvalue.place.identifier.declarationId, null);
-        }
-      } else {
-        for (const operand of eachInstructionValueOperand(instr.value)) {
-          visit(operand);
+          hoisted.add(instr.value.lvalue.place.identifier.declarationId);
         }
       }
     }
-    for (const operand of eachTerminalOperand(block.terminal)) {
-      visit(operand);
-    }
   }
   return hoisted;
 }
@@ -267,12 +227,12 @@ class Context {
   catchHandlers: Map<BlockId, Place> = new Map();
   isFuctionExpression: boolean;
   fn: HIRFunction;
-  hoistedContextDeclarations: Map<DeclarationId, Place | null>;
+  hoistedContextDeclarations: Set<DeclarationId>;
 
   constructor(
     isFunctionExpression: boolean,
     fn: HIRFunction,
-    hoistedContextDeclarations: Map<DeclarationId, Place | null>,
+    hoistedContextDeclarations: Set<DeclarationId>,
   ) {
     this.isFuctionExpression = isFunctionExpression;
     this.fn = fn;
@@ -920,69 +880,27 @@ function applyEffect(
           console.log(prettyFormat(state.debugAbstractValue(value)));
         }
 
-        if (
-          mutationKind === 'mutate-frozen' &&
-          context.hoistedContextDeclarations.has(
-            effect.value.identifier.declarationId,
-          )
-        ) {
-          const description =
-            effect.value.identifier.name !== null &&
-            effect.value.identifier.name.kind === 'named'
-              ? `Variable \`${effect.value.identifier.name.value}\` is accessed before it is declared`
-              : null;
-          const hoistedAccess = context.hoistedContextDeclarations.get(
-            effect.value.identifier.declarationId,
-          );
-          if (hoistedAccess != null && hoistedAccess.loc != effect.value.loc) {
-            effects.push({
-              kind: 'MutateFrozen',
-              place: effect.value,
-              error: {
-                severity: ErrorSeverity.InvalidReact,
-                reason: `This variable is accessed before it is declared, which may prevent it from updating as the assigned value changes over time`,
-                description,
-                loc: hoistedAccess.loc,
-                suggestions: null,
-              },
-            });
-          }
-
-          effects.push({
-            kind: 'MutateFrozen',
-            place: effect.value,
-            error: {
-              severity: ErrorSeverity.InvalidReact,
-              reason: `This variable is accessed before it is declared, which prevents the earlier access from updating when this value changes over time`,
-              description,
-              loc: effect.value.loc,
-              suggestions: null,
-            },
-          });
-        } else {
-          const reason = getWriteErrorReason({
-            kind: value.kind,
-            reason: value.reason,
-            context: new Set(),
-          });
-          const description =
-            effect.value.identifier.name !== null &&
-            effect.value.identifier.name.kind === 'named'
-              ? `Found mutation of \`${effect.value.identifier.name.value}\``
-              : null;
-          effects.push({
-            kind:
-              value.kind === ValueKind.Frozen ? 'MutateFrozen' : 'MutateGlobal',
-            place: effect.value,
-            error: {
-              severity: ErrorSeverity.InvalidReact,
-              reason,
-              description,
-              loc: effect.value.loc,
-              suggestions: null,
-            },
-          });
-        }
+        const reason = getWriteErrorReason({
+          kind: value.kind,
+          reason: value.reason,
+          context: new Set(),
+        });
+        effects.push({
+          kind:
+            value.kind === ValueKind.Frozen ? 'MutateFrozen' : 'MutateGlobal',
+          place: effect.value,
+          error: {
+            severity: ErrorSeverity.InvalidReact,
+            reason,
+            description:
+              effect.value.identifier.name !== null &&
+              effect.value.identifier.name.kind === 'named'
+                ? `Found mutation of \`${effect.value.identifier.name.value}\``
+                : null,
+            loc: effect.value.loc,
+            suggestions: null,
+          },
+        });
       }
       break;
     }
@@ -2020,17 +1938,28 @@ function computeEffectsForLegacySignature(
         break;
       }
       case Effect.ConditionallyMutateIterator: {
-        const mutateIterator = conditionallyMutateIterator(place);
-        if (mutateIterator != null) {
-          effects.push(mutateIterator);
-          // TODO: should we always push to captures?
+        if (
+          isArrayType(place.identifier) ||
+          isSetType(place.identifier) ||
+          isMapType(place.identifier)
+        ) {
+          effects.push({
+            kind: 'Capture',
+            from: place,
+            into: lvalue,
+          });
+        } else {
+          effects.push({
+            kind: 'Capture',
+            from: place,
+            into: lvalue,
+          });
           captures.push(place);
+          effects.push({
+            kind: 'MutateTransitiveConditionally',
+            value: place,
+          });
         }
-        effects.push({
-          kind: 'Capture',
-          from: place,
-          into: lvalue,
-        });
         break;
       }
       case Effect.Freeze: {
@@ -2220,7 +2149,6 @@ function computeEffectsForSignature(
     return null;
   }
   // Build substitutions
-  const mutableSpreads = new Set<IdentifierId>();
   const substitutions: Map<IdentifierId, Array<Place>> = new Map();
   substitutions.set(signature.receiver, [receiver]);
   substitutions.set(signature.returns, [lvalue]);
@@ -2238,13 +2166,6 @@ function computeEffectsForSignature(
       }
       const place = arg.kind === 'Identifier' ? arg : arg.place;
       getOrInsertWith(substitutions, signature.rest, () => []).push(place);
-
-      if (arg.kind === 'Spread') {
-        const mutateIterator = conditionallyMutateIterator(arg.place);
-        if (mutateIterator != null) {
-          mutableSpreads.add(arg.place.identifier.id);
-        }
-      }
     } else {
       const param = params[i];
       substitutions.set(param, [arg]);
@@ -2316,12 +2237,6 @@ function computeEffectsForSignature(
       case 'Freeze': {
         const values = substitutions.get(effect.value.identifier.id) ?? [];
         for (const value of values) {
-          if (mutableSpreads.has(value.identifier.id)) {
-            CompilerError.throwTodo({
-              reason: 'Support spread syntax for hook arguments',
-              loc: value.loc,
-            });
-          }
           effects.push({kind: 'Freeze', value, reason: effect.reason});
         }
         break;
@@ -2436,6 +2351,295 @@ function buildSignatureFromFunctionExpression(
   };
 }
 
+/*
+ * array.map(cb)
+ * t3 = t0 .t1 ( t2 )
+ * `t3 = MethodCall t0 . t1 ( t2 )
+ *
+ * ## Signature
+ *
+ * substitutions: [
+ *   @Receiver is t0
+ *   @Property is t1
+ *   @Callback is t2
+ *   @Return is return
+ *   @Item is ( t0 as Array ) . Item
+ *   @FunctionItem is (t2 as Function) . Params[0]
+ *   @FunctionCollection is (t2 as Function) . Params[2]
+ *   @FunctionReturn is (t2 as Function) . Return
+ * ]
+ * effects: [
+ *  Capture @Item => @FunctionItem
+ *  Capture @Receiver => @FunctionCollection
+ *  Mutate? @Callback
+ *  Capture @FunctionReturn => @Return
+ * ]
+ * returns: @Return as Array elements=@FunctionItem
+ *
+ * ## Example values
+ * t0 = @0 Array elements=@0.items
+ * t1 = @1
+ * t2 = @2 Function (f0, f1, f2) => fret
+ *  Capture f0 => fret
+ *  Mutate f2
+ *
+ * apply substitutions and effects:
+ *   Capture @Item => @functionItem
+ *     => Capture @0.items => f0
+ *   Capture @Receiver => @FunctionCollection
+ *     => Capture @0 => f2
+ *   Mutate? @Callback
+ *     => (apply function effects) =>
+ *     Capture f0 => fret
+ *       => Capture @0.items => fret
+ *     Mutate f2
+ *       => Mutate @0
+ *   Capture @FunctionReturn => @Return
+ *     => Capture fret => return
+ */
+
+/**
+ * Another take
+ *
+ * Simplify the representation. We don't need to track which entities store which other entities.
+ * We can consolidate aliasing/capturing down to 2 things: "aliasing a->b means mutate(b) => mutate(a)" and "capturing a->b means mutate(b) != mutate(a)".
+ * For either, we say that "aliasing/capturing a->b implies transitiveMutate(b) => mutate(a)".
+ *
+ * This simplifies at the expense of needing a second InferMutableRanges style pass after. This is because if we capture out of a larger object and then mutate
+ * the captured bit, that still needs to count as a mutation of the larger object:
+ * `x = y.z` is "alias y->x", since mutate(x) mutates y.
+ *
+ * We already have a second pass, so it's not a great loss to have to keep it.
+ *
+ * Then there is the question of function expressions. In general I think we say that function expression effects happen _on consumption of the function_,
+ * (not simple aliasing), unless it's used where we have type information to provide specific information about how the function is called (eg Array.prototype.map).
+ *
+ *
+ * Apply t2 receiver=alias t2, params=[capture t2, alias t2] return=t3
+ *
+ * Note that we say if each argument is capture or alias. The function declaration may say that it aliases the param 0 into the return, but if we've passed
+ * a capture variable that gets translated, e.g. `capture x -> alias y` translates to `capture x -> y`.
+ *
+ * alias (capture x) -> y   ==> capture x -> y
+ * capture (alias x) -> Y   ==> capture x -> y
+ * alias (alias x) -> y     ==> alias x -> y
+ * capture (capture x) -> y ==> capture x -> y
+ *
+ * We could then extend this to explicitly represent captured values within each abstract value. Maybe replacing context values.
+ */
+
+export type AliasedPlace = {place: Place; kind: 'alias' | 'capture'};
+
+export type AliasingEffect =
+  /**
+   * Marks the given value and its direct aliases as frozen.
+   *
+   * Captured values are *not* considered frozen, because we cannot be sure that a previously
+   * captured value will still be captured at the point of the freeze.
+   *
+   * For example:
+   * const x = {};
+   * const y = [x];
+   * y.pop(); // y dosn't contain x anymore!
+   * freeze(y);
+   * mutate(x); // safe to mutate!
+   *
+   * The exception to this is FunctionExpressions - since it is impossible to change which
+   * value a function closes over[1] we can transitively freeze functions and their captures.
+   *
+   * [1] Except for `let` values that are reassigned and closed over by a function, but we
+   * handle this explicitly with StoreContext/LoadContext.
+   */
+  | {kind: 'Freeze'; value: Place; reason: ValueReason}
+  /**
+   * Mutate the value and any direct aliases (not captures). Errors if the value is not mutable.
+   */
+  | {kind: 'Mutate'; value: Place}
+  /**
+   * Mutate the value and any direct aliases (not captures), but only if the value is known mutable.
+   * This should be rare.
+   *
+   * TODO: this is only used for IteratorNext, but even then MutateTransitiveConditionally is more
+   * correct for iterators of unknown types.
+   */
+  | {kind: 'MutateConditionally'; value: Place}
+  /**
+   * Mutate the value, any direct aliases, and any transitive captures. Errors if the value is not mutable.
+   */
+  | {kind: 'MutateTransitive'; value: Place}
+  /**
+   * Mutates any of the value, its direct aliases, and its transitive captures that are mutable.
+   */
+  | {kind: 'MutateTransitiveConditionally'; value: Place}
+  /**
+   * Records information flow from `from` to `into` in cases where local mutation of the destination
+   * will *not* mutate the source:
+   *
+   * - Capture a -> b and Mutate(b) X=> (does not imply) Mutate(a)
+   * - Capture a -> b and MutateTransitive(b) => (does imply) Mutate(a)
+   *
+   * Example: `array.push(item)`. Information from item is captured into array, but there is not a
+   * direct aliasing, and local mutations of array will not modify item.
+   */
+  | {kind: 'Capture'; from: Place; into: Place}
+  /**
+   * Records information flow from `from` to `into` in cases where local mutation of the destination
+   * *will* mutate the source:
+   *
+   * - Alias a -> b and Mutate(b) => (does imply) Mutate(a)
+   * - Alias a -> b and MutateTransitive(b) => (does imply) Mutate(a)
+   *
+   * Example: `c = identity(a)`. We don't know what `identity()` returns so we can't use Assign.
+   * But we have to assume that it _could_ be returning its input, such that a local mutation of
+   * c could be mutating a.
+   */
+  | {kind: 'Alias'; from: Place; into: Place}
+  /**
+   * Records direct assignment: `into = from`.
+   */
+  | {kind: 'Assign'; from: Place; into: Place}
+  /**
+   * Creates a value of the given type at the given place
+   */
+  | {kind: 'Create'; into: Place; value: ValueKind; reason: ValueReason}
+  /**
+   * Creates a new value with the same kind as the starting value.
+   */
+  | {kind: 'CreateFrom'; from: Place; into: Place}
+  /**
+   * Immutable data flow, used for escape analysis. Does not influence mutable range analysis:
+   */
+  | {kind: 'ImmutableCapture'; from: Place; into: Place}
+  /**
+   * Calls the function at the given place with the given arguments either captured or aliased,
+   * and captures/aliases the result into the given place.
+   */
+  | {
+      kind: 'Apply';
+      receiver: Place;
+      function: Place;
+      mutatesFunction: boolean;
+      args: Array<Place | SpreadPattern | Hole>;
+      into: Place;
+      signature: FunctionSignature | null;
+      loc: SourceLocation;
+    }
+  /**
+   * Constructs a function value with the given captures. The mutability of the function
+   * will be determined by the mutability of the capture values when evaluated.
+   */
+  | {
+      kind: 'CreateFunction';
+      captures: Array<Place>;
+      function: FunctionExpression | ObjectMethod;
+      into: Place;
+    }
+  /**
+   * Mutation of a value known to be immutable
+   */
+  | {kind: 'MutateFrozen'; place: Place; error: CompilerErrorDetailOptions}
+  /**
+   * Mutation of a global
+   */
+  | {
+      kind: 'MutateGlobal';
+      place: Place;
+      error: CompilerErrorDetailOptions;
+    }
+  /**
+   * Indicates a side-effect that is not safe during render
+   */
+  | {kind: 'Impure'; place: Place; error: CompilerErrorDetailOptions}
+  /**
+   * Indicates that a given place is accessed during render. Used to distingush
+   * hook arguments that are known to be called immediately vs those used for
+   * event handlers/effects, and for JSX values known to be called during render
+   * (tags, children) vs those that may be events/effect (other props).
+   */
+  | {
+      kind: 'Render';
+      place: Place;
+    };
+
+function hashEffect(effect: AliasingEffect): string {
+  switch (effect.kind) {
+    case 'Apply': {
+      return [
+        effect.kind,
+        effect.receiver.identifier.id,
+        effect.function.identifier.id,
+        effect.mutatesFunction,
+        effect.args
+          .map(a => {
+            if (a.kind === 'Hole') {
+              return '';
+            } else if (a.kind === 'Identifier') {
+              return a.identifier.id;
+            } else {
+              return `...${a.place.identifier.id}`;
+            }
+          })
+          .join(','),
+        effect.into.identifier.id,
+      ].join(':');
+    }
+    case 'CreateFrom':
+    case 'ImmutableCapture':
+    case 'Assign':
+    case 'Alias':
+    case 'Capture': {
+      return [
+        effect.kind,
+        effect.from.identifier.id,
+        effect.into.identifier.id,
+      ].join(':');
+    }
+    case 'Create': {
+      return [
+        effect.kind,
+        effect.into.identifier.id,
+        effect.value,
+        effect.reason,
+      ].join(':');
+    }
+    case 'Freeze': {
+      return [effect.kind, effect.value.identifier.id, effect.reason].join(':');
+    }
+    case 'Impure':
+    case 'Render':
+    case 'MutateFrozen':
+    case 'MutateGlobal': {
+      return [effect.kind, effect.place.identifier.id].join(':');
+    }
+    case 'Mutate':
+    case 'MutateConditionally':
+    case 'MutateTransitive':
+    case 'MutateTransitiveConditionally': {
+      return [effect.kind, effect.value.identifier.id].join(':');
+    }
+    case 'CreateFunction': {
+      return [
+        effect.kind,
+        effect.into.identifier.id,
+        // return places are a unique way to identify functions themselves
+        effect.function.loweredFunc.func.returns.identifier.id,
+        effect.captures.map(p => p.identifier.id).join(','),
+      ].join(':');
+    }
+  }
+}
+
+export type AliasingSignatureEffect = AliasingEffect;
+
+export type AliasingSignature = {
+  receiver: IdentifierId;
+  params: Array<IdentifierId>;
+  rest: IdentifierId | null;
+  returns: IdentifierId;
+  effects: Array<AliasingSignatureEffect>;
+  temporaries: Array<Place>;
+};
+
 export type AbstractValue = {
   kind: ValueKind;
   reason: ReadonlySet<ValueReason>;

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

@@ -7,27 +7,8 @@
 
 import {HIRFunction, IdentifierId, Place, ValueKind, ValueReason} from '../HIR';
 import {getOrInsertDefault} from '../Utils/utils';
-import {AliasingEffect} from './AliasingEffects';
+import {AliasingEffect} from './InferMutationAliasingEffects';
 
-/**
- * This function tracks data flow within an inner function expression in order to
- * compute a set of data-flow aliasing effects describing data flow between the function's
- * params, context variables, and return value.
- *
- * For example, consider the following function expression:
- *
- * ```
- * (x) => { return [x, y] }
- * ```
- *
- * This function captures both param `x` and context variable `y` into the return value.
- * Unlike our previous inference which counted this as a mutation of x and y, we want to
- * build a signature for the function that describes the data flow. We would infer
- * `Capture x -> return, Capture y -> return` effects for this function.
- *
- * This function *also* propagates more ambient-style effects (MutateFrozen, MutateGlobal, Impure, Render)
- * from instructions within the function up to the function itself.
- */
 export function inferMutationAliasingFunctionEffects(
   fn: HIRFunction,
 ): Array<AliasingEffect> | null {

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

@@ -32,25 +32,7 @@ const DEBUG = false;
 const VERBOSE = false;
 
 /**
- * Infers mutable ranges for all values in the program, using previously inferred
- * mutation/aliasing effects. This pass builds a data flow graph using the effects,
- * tracking an abstract notion of "when" each effect occurs relative to the others.
- * It then walks each mutation effect against the graph, updating the range of each
- * node that would be reachable at the "time" that the effect occurred.
- *
- * This pass also validates against invalid effects: any function that is reachable
- * by being called, or via a Render effect, is validated against mutating globals
- * or calling impure code.
- *
- * Note that this function also populates the outer function's aliasing effects with
- * any mutations that apply to its params or context variables. For example, a
- * function expression such as the following:
- *
- * ```
- * (x) => { x.y = true }
- * ```
- *
- * Would populate a `Mutate x` aliasing effect on the outer function.
+ * Infers mutable ranges for all values.
  */
 export function inferMutationAliasingRanges(
   fn: HIRFunction,

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

@@ -26,7 +26,6 @@ import {
 import {PostDominator} from '../HIR/Dominator';
 import {
   eachInstructionLValue,
-  eachInstructionOperand,
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
@@ -293,7 +292,7 @@ export function inferReactivePlaces(fn: HIRFunction): void {
         let hasReactiveInput = false;
         /*
          * NOTE: we want to mark all operands as reactive or not, so we
-         * avoid short-circuiting here
+         * avoid short-circuting here
          */
         for (const operand of eachInstructionValueOperand(value)) {
           const reactive = reactiveIdentifiers.isReactive(operand);
@@ -376,41 +375,6 @@ export function inferReactivePlaces(fn: HIRFunction): void {
       }
     }
   } while (reactiveIdentifiers.snapshot());
-
-  function propagateReactivityToInnerFunctions(
-    fn: HIRFunction,
-    isOutermost: boolean,
-  ): void {
-    for (const [, block] of fn.body.blocks) {
-      for (const instr of block.instructions) {
-        if (!isOutermost) {
-          for (const operand of eachInstructionOperand(instr)) {
-            reactiveIdentifiers.isReactive(operand);
-          }
-        }
-        if (
-          instr.value.kind === 'ObjectMethod' ||
-          instr.value.kind === 'FunctionExpression'
-        ) {
-          propagateReactivityToInnerFunctions(
-            instr.value.loweredFunc.func,
-            false,
-          );
-        }
-      }
-      if (!isOutermost) {
-        for (const operand of eachTerminalOperand(block.terminal)) {
-          reactiveIdentifiers.isReactive(operand);
-        }
-      }
-    }
-  }
-
-  /**
-   * Propagate reactivity for inner functions, as we eventually hoist and dedupe
-   * dependency instructions for scopes.
-   */
-  propagateReactivityToInnerFunctions(fn, true);
 }
 
 /*

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

@@ -17,7 +17,6 @@ import {
   InstructionKind,
   LabelTerminal,
   Place,
-  isStatementBlockKind,
   makeInstructionId,
   promoteTemporary,
   reversePostorderBlocks,
@@ -91,106 +90,100 @@ export function inlineImmediatelyInvokedFunctionExpressions(
    */
   const queue = Array.from(fn.body.blocks.values());
   queue: for (const block of queue) {
-    /*
-     * We can't handle labels inside expressions yet, so we don't inline IIFEs if they are in an
-     * expression block.
-     */
-    if (isStatementBlockKind(block.kind)) {
-      for (let ii = 0; ii < block.instructions.length; ii++) {
-        const instr = block.instructions[ii]!;
-        switch (instr.value.kind) {
-          case 'FunctionExpression': {
-            if (instr.lvalue.identifier.name === null) {
-              functions.set(instr.lvalue.identifier.id, instr.value);
-            }
-            break;
+    for (let ii = 0; ii < block.instructions.length; ii++) {
+      const instr = block.instructions[ii]!;
+      switch (instr.value.kind) {
+        case 'FunctionExpression': {
+          if (instr.lvalue.identifier.name === null) {
+            functions.set(instr.lvalue.identifier.id, instr.value);
           }
-          case 'CallExpression': {
-            if (instr.value.args.length !== 0) {
-              // We don't support inlining when there are arguments
-              continue;
-            }
-            const body = functions.get(instr.value.callee.identifier.id);
-            if (body === undefined) {
-              // Not invoking a local function expression, can't inline
-              continue;
-            }
-
-            if (
-              body.loweredFunc.func.params.length > 0 ||
-              body.loweredFunc.func.async ||
-              body.loweredFunc.func.generator
-            ) {
-              // Can't inline functions with params, or async/generator functions
-              continue;
-            }
-
-            // We know this function is used for an IIFE and can prune it later
-            inlinedFunctions.add(instr.value.callee.identifier.id);
-
-            // Create a new block which will contain code following the IIFE call
-            const continuationBlockId = fn.env.nextBlockId;
-            const continuationBlock: BasicBlock = {
-              id: continuationBlockId,
-              instructions: block.instructions.slice(ii + 1),
-              kind: block.kind,
-              phis: new Set(),
-              preds: new Set(),
-              terminal: block.terminal,
-            };
-            fn.body.blocks.set(continuationBlockId, continuationBlock);
-
-            /*
-             * Trim the original block to contain instructions up to (but not including)
-             * the IIFE
-             */
-            block.instructions.length = ii;
-
-            /*
-             * To account for complex control flow within the lambda, we treat the lambda
-             * as if it were a single labeled statement, and replace all returns with gotos
-             * to the label fallthrough.
-             */
-            const newTerminal: LabelTerminal = {
-              block: body.loweredFunc.func.body.entry,
-              id: makeInstructionId(0),
-              kind: 'label',
-              fallthrough: continuationBlockId,
-              loc: block.terminal.loc,
-            };
-            block.terminal = newTerminal;
-
-            // We store the result in the IIFE temporary
-            const result = instr.lvalue;
-
-            // Declare the IIFE temporary
-            declareTemporary(fn.env, block, result);
-
-            // Promote the temporary with a name as we require this to persist
-            promoteTemporary(result.identifier);
-
-            /*
-             * Rewrite blocks from the lambda to replace any `return` with a
-             * store to the result and `goto` the continuation block
-             */
-            for (const [id, block] of body.loweredFunc.func.body.blocks) {
-              block.preds.clear();
-              rewriteBlock(fn.env, block, continuationBlockId, result);
-              fn.body.blocks.set(id, block);
-            }
-
-            /*
-             * Ensure we visit the continuation block, since there may have been
-             * sequential IIFEs that need to be visited.
-             */
-            queue.push(continuationBlock);
-            continue queue;
+          break;
+        }
+        case 'CallExpression': {
+          if (instr.value.args.length !== 0) {
+            // We don't support inlining when there are arguments
+            continue;
           }
-          default: {
-            for (const place of eachInstructionValueOperand(instr.value)) {
-              // Any other use of a function expression means it isn't an IIFE
-              functions.delete(place.identifier.id);
-            }
+          const body = functions.get(instr.value.callee.identifier.id);
+          if (body === undefined) {
+            // Not invoking a local function expression, can't inline
+            continue;
+          }
+
+          if (
+            body.loweredFunc.func.params.length > 0 ||
+            body.loweredFunc.func.async ||
+            body.loweredFunc.func.generator
+          ) {
+            // Can't inline functions with params, or async/generator functions
+            continue;
+          }
+
+          // We know this function is used for an IIFE and can prune it later
+          inlinedFunctions.add(instr.value.callee.identifier.id);
+
+          // Create a new block which will contain code following the IIFE call
+          const continuationBlockId = fn.env.nextBlockId;
+          const continuationBlock: BasicBlock = {
+            id: continuationBlockId,
+            instructions: block.instructions.slice(ii + 1),
+            kind: block.kind,
+            phis: new Set(),
+            preds: new Set(),
+            terminal: block.terminal,
+          };
+          fn.body.blocks.set(continuationBlockId, continuationBlock);
+
+          /*
+           * Trim the original block to contain instructions up to (but not including)
+           * the IIFE
+           */
+          block.instructions.length = ii;
+
+          /*
+           * To account for complex control flow within the lambda, we treat the lambda
+           * as if it were a single labeled statement, and replace all returns with gotos
+           * to the label fallthrough.
+           */
+          const newTerminal: LabelTerminal = {
+            block: body.loweredFunc.func.body.entry,
+            id: makeInstructionId(0),
+            kind: 'label',
+            fallthrough: continuationBlockId,
+            loc: block.terminal.loc,
+          };
+          block.terminal = newTerminal;
+
+          // We store the result in the IIFE temporary
+          const result = instr.lvalue;
+
+          // Declare the IIFE temporary
+          declareTemporary(fn.env, block, result);
+
+          // Promote the temporary with a name as we require this to persist
+          promoteTemporary(result.identifier);
+
+          /*
+           * Rewrite blocks from the lambda to replace any `return` with a
+           * store to the result and `goto` the continuation block
+           */
+          for (const [id, block] of body.loweredFunc.func.body.blocks) {
+            block.preds.clear();
+            rewriteBlock(fn.env, block, continuationBlockId, result);
+            fn.body.blocks.set(id, block);
+          }
+
+          /*
+           * Ensure we visit the continuation block, since there may have been
+           * sequential IIFEs that need to be visited.
+           */
+          queue.push(continuationBlock);
+          continue queue;
+        }
+        default: {
+          for (const place of eachInstructionValueOperand(instr.value)) {
+            // Any other use of a function expression means it isn't an IIFE
+            functions.delete(place.identifier.id);
           }
         }
       }

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

@@ -27,6 +27,7 @@ import {
   Place,
   promoteTemporary,
   SpreadPattern,
+  todoPopulateAliasingEffects,
 } from '../HIR';
 import {
   createTemporaryPlace,
@@ -151,7 +152,7 @@ export function inlineJsxTransform(
               type: null,
               loc: instr.value.loc,
             },
-            effects: null,
+            effects: todoPopulateAliasingEffects(),
             loc: instr.loc,
           };
           currentBlockInstructions.push(varInstruction);
@@ -168,7 +169,7 @@ export function inlineJsxTransform(
               },
               loc: instr.value.loc,
             },
-            effects: null,
+            effects: todoPopulateAliasingEffects(),
             loc: instr.loc,
           };
           currentBlockInstructions.push(devGlobalInstruction);
@@ -222,7 +223,7 @@ export function inlineJsxTransform(
               type: null,
               loc: instr.value.loc,
             },
-            effects: null,
+            effects: todoPopulateAliasingEffects(),
             loc: instr.loc,
           };
           thenBlockInstructions.push(reassignElseInstruction);
@@ -295,7 +296,7 @@ export function inlineJsxTransform(
               ],
               loc: instr.value.loc,
             },
-            effects: null,
+            effects: todoPopulateAliasingEffects(),
             loc: instr.loc,
           };
           elseBlockInstructions.push(reactElementInstruction);
@@ -313,7 +314,7 @@ export function inlineJsxTransform(
               type: null,
               loc: instr.value.loc,
             },
-            effects: null,
+            effects: todoPopulateAliasingEffects(),
             loc: instr.loc,
           };
           elseBlockInstructions.push(reassignConditionalInstruction);
@@ -441,7 +442,7 @@ function createSymbolProperty(
       binding: {kind: 'Global', name: 'Symbol'},
       loc: instr.value.loc,
     },
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: instr.loc,
   };
   nextInstructions.push(symbolInstruction);
@@ -456,7 +457,7 @@ function createSymbolProperty(
       property: makePropertyLiteral('for'),
       loc: instr.value.loc,
     },
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: instr.loc,
   };
   nextInstructions.push(symbolForInstruction);
@@ -470,7 +471,7 @@ function createSymbolProperty(
       value: symbolName,
       loc: instr.value.loc,
     },
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: instr.loc,
   };
   nextInstructions.push(symbolValueInstruction);
@@ -486,7 +487,7 @@ function createSymbolProperty(
       args: [symbolValueInstruction.lvalue],
       loc: instr.value.loc,
     },
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: instr.loc,
   };
   const $$typeofProperty: ObjectProperty = {
@@ -517,7 +518,7 @@ function createTagProperty(
           value: componentTag.name,
           loc: instr.value.loc,
         },
-        effects: null,
+        effects: todoPopulateAliasingEffects(),
         loc: instr.loc,
       };
       tagProperty = {
@@ -644,7 +645,7 @@ function createPropsProperties(
           elements: [...children],
           loc: instr.value.loc,
         },
-        effects: null,
+        effects: todoPopulateAliasingEffects(),
         loc: instr.loc,
       };
       nextInstructions.push(childrenPropInstruction);
@@ -668,7 +669,7 @@ function createPropsProperties(
         value: null,
         loc: instr.value.loc,
       },
-      effects: null,
+      effects: todoPopulateAliasingEffects(),
       loc: instr.loc,
     };
     refProperty = {
@@ -690,7 +691,7 @@ function createPropsProperties(
         value: null,
         loc: instr.value.loc,
       },
-      effects: null,
+      effects: todoPopulateAliasingEffects(),
       loc: instr.loc,
     };
     keyProperty = {
@@ -724,7 +725,7 @@ function createPropsProperties(
         properties: props,
         loc: instr.value.loc,
       },
-      effects: null,
+      effects: todoPopulateAliasingEffects(),
       loc: instr.loc,
     };
     propsProperty = {

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

@@ -29,6 +29,7 @@ import {
   markInstructionIds,
   promoteTemporary,
   reversePostorderBlocks,
+  todoPopulateAliasingEffects,
 } from '../HIR';
 import {createTemporaryPlace} from '../HIR/HIRBuilder';
 import {enterSSA} from '../SSA';
@@ -146,7 +147,7 @@ function emitLoadLoweredContextCallee(
     id: makeInstructionId(0),
     loc: GeneratedSource,
     lvalue: createTemporaryPlace(env, GeneratedSource),
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     value: loadGlobal,
   };
 }
@@ -193,7 +194,7 @@ function emitPropertyLoad(
     lvalue: object,
     value: loadObj,
     id: makeInstructionId(0),
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: GeneratedSource,
   };
 
@@ -208,7 +209,7 @@ function emitPropertyLoad(
     lvalue: element,
     value: loadProp,
     id: makeInstructionId(0),
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: GeneratedSource,
   };
   return {
@@ -283,7 +284,7 @@ function emitSelectorFn(env: Environment, keys: Array<string>): Instruction {
       loc: GeneratedSource,
     },
     lvalue: createTemporaryPlace(env, GeneratedSource),
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: GeneratedSource,
   };
   return fnInstr;
@@ -300,7 +301,7 @@ function emitArrayInstr(elements: Array<Place>, env: Environment): Instruction {
     id: makeInstructionId(0),
     value: array,
     lvalue: arrayLvalue,
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
     loc: GeneratedSource,
   };
   return arrayInstr;

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

@@ -26,6 +26,7 @@ import {
   Place,
   promoteTemporary,
   promoteTemporaryJsxTag,
+  todoPopulateAliasingEffects,
 } from '../HIR/HIR';
 import {createTemporaryPlace} from '../HIR/HIRBuilder';
 import {printIdentifier} from '../HIR/PrintHIR';
@@ -313,7 +314,7 @@ function emitOutlinedJsx(
       openingLoc: GeneratedSource,
       closingLoc: GeneratedSource,
     },
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
   };
 
   return [loadJsx, jsxExpr];
@@ -521,7 +522,7 @@ function emitDestructureProps(
       loc: GeneratedSource,
       value: propsObj,
     },
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
   };
   return destructurePropsInstr;
 }

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

@@ -1726,7 +1726,7 @@ function codegenInstructionValue(
     }
     case 'UnaryExpression': {
       value = t.unaryExpression(
-        instrValue.operator,
+        instrValue.operator as 'throw', // todo
         codegenPlaceToExpression(cx, instrValue.value),
       );
       break;
@@ -2582,16 +2582,7 @@ function codegenValue(
   value: boolean | number | string | null | undefined,
 ): t.Expression {
   if (typeof value === 'number') {
-    if (value < 0) {
-      /**
-       * Babel's code generator produces invalid JS for negative numbers when
-       * run with { compact: true }.
-       * See repro https://codesandbox.io/p/devbox/5d47fr
-       */
-      return t.unaryExpression('-', t.numericLiteral(-value), false);
-    } else {
-      return t.numericLiteral(value);
-    }
+    return t.numericLiteral(value);
   } else if (typeof value === 'boolean') {
     return t.booleanLiteral(value);
   } else if (typeof value === 'string') {

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

@@ -456,7 +456,6 @@ function canMergeScopes(
       new Set(
         [...current.scope.declarations.values()].map(declaration => ({
           identifier: declaration.identifier,
-          reactive: true,
           path: [],
         })),
       ),

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

@@ -31,6 +31,7 @@ import {
   NonLocalImportSpecifier,
   Place,
   promoteTemporary,
+  todoPopulateAliasingEffects,
 } from '../HIR';
 import {createTemporaryPlace, markInstructionIds} from '../HIR/HIRBuilder';
 import {getOrInsertWith} from '../Utils/utils';
@@ -436,7 +437,7 @@ function makeLoadUseFireInstruction(
     value: instrValue,
     lvalue: {...useFirePlace},
     loc: GeneratedSource,
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
   };
 }
 
@@ -461,7 +462,7 @@ function makeLoadFireCalleeInstruction(
     },
     lvalue: {...loadedFireCallee},
     loc: GeneratedSource,
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
   };
 }
 
@@ -485,7 +486,7 @@ function makeCallUseFireInstruction(
     value: useFireCall,
     lvalue: {...useFireCallResultPlace},
     loc: GeneratedSource,
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
   };
 }
 
@@ -514,7 +515,7 @@ function makeStoreUseFireInstruction(
     },
     lvalue: fireFunctionBindingLValuePlace,
     loc: GeneratedSource,
-    effects: null,
+    effects: todoPopulateAliasingEffects(),
   };
 }
 

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

@@ -93,21 +93,6 @@ const testComplexConfigDefaults: PartialEnvironmentConfig = {
     },
   ],
 };
-
-function* splitPragma(
-  pragma: string,
-): Generator<{key: string; value: string | null}> {
-  for (const entry of pragma.split('@')) {
-    const keyVal = entry.trim();
-    const valIdx = keyVal.indexOf(':');
-    if (valIdx === -1) {
-      yield {key: keyVal.split(' ', 1)[0], value: null};
-    } else {
-      yield {key: keyVal.slice(0, valIdx), value: keyVal.slice(valIdx + 1)};
-    }
-  }
-}
-
 /**
  * For snap test fixtures and playground only.
  */
@@ -116,11 +101,19 @@ function parseConfigPragmaEnvironmentForTest(
 ): EnvironmentConfig {
   const maybeConfig: Partial<Record<keyof EnvironmentConfig, unknown>> = {};
 
-  for (const {key, value: val} of splitPragma(pragma)) {
+  for (const token of pragma.split(' ')) {
+    if (!token.startsWith('@')) {
+      continue;
+    }
+    const keyVal = token.slice(1);
+    const valIdx = keyVal.indexOf(':');
+    const key = valIdx === -1 ? keyVal : keyVal.slice(0, valIdx);
+    const val = valIdx === -1 ? undefined : keyVal.slice(valIdx + 1);
+    const isSet = val === undefined || val === 'true';
     if (!hasOwnProperty(EnvironmentConfigSchema.shape, key)) {
       continue;
     }
-    const isSet = val == null || val === 'true';
+
     if (isSet && key in testComplexConfigDefaults) {
       maybeConfig[key] = testComplexConfigDefaults[key];
     } else if (isSet) {
@@ -183,11 +176,18 @@ export function parseConfigPragmaForTests(
     compilationMode: defaults.compilationMode,
     environment,
   };
-  for (const {key, value: val} of splitPragma(pragma)) {
+  for (const token of pragma.split(' ')) {
+    if (!token.startsWith('@')) {
+      continue;
+    }
+    const keyVal = token.slice(1);
+    const idx = keyVal.indexOf(':');
+    const key = idx === -1 ? keyVal : keyVal.slice(0, idx);
+    const val = idx === -1 ? undefined : keyVal.slice(idx + 1);
     if (!hasOwnProperty(defaultOptions, key)) {
       continue;
     }
-    const isSet = val == null || val === 'true';
+    const isSet = val === undefined || val === 'true';
     if (isSet && key in testComplexPluginOptionDefaults) {
       options[key] = testComplexPluginOptionDefaults[key];
     } else if (isSet) {

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

@@ -148,6 +148,19 @@ export function Iterable_some<T>(
   return false;
 }
 
+export function Iterable_filter<T>(
+  iter: Iterable<T>,
+  pred: (item: T) => boolean,
+): Array<T> {
+  const result: Array<T> = [];
+  for (const item of iter) {
+    if (pred(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
 export function nonNull<T extends NonNullable<U>, U>(
   value: T | null | undefined,
 ): value is T {

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

@@ -452,7 +452,7 @@ function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {
                 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)',
                 loc: callee.loc,
-                description: `Cannot call ${hookKind === 'Custom' ? 'hook' : hookKind} within a function expression`,
+                description: `Cannot call ${hookKind} within a function component`,
                 suggestions: null,
               }),
             );

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

@@ -9,7 +9,7 @@ export {validateContextVariableLValues} from './ValidateContextVariableLValues';
 export {validateHooksUsage} from './ValidateHooksUsage';
 export {validateMemoizedEffectDependencies} from './ValidateMemoizedEffectDependencies';
 export {validateNoCapitalizedCalls} from './ValidateNoCapitalizedCalls';
-export {validateNoRefAccessInRender} from './ValidateNoRefAccessInRender';
+export {validateNoRefAccessInRender} from './ValidateNoRefAccesInRender';
 export {validateNoSetStateInRender} from './ValidateNoSetStateInRender';
 export {validatePreservedManualMemoization} from './ValidatePreservedManualMemoization';
 export {validateUseMemo} from './ValidateUseMemo';

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/aliased-nested-scope-truncated-dep.expect.md

@@ -175,14 +175,21 @@ import {
  * and mutability.
  */
 function Component(t0) {
-  const $ = _c(2);
+  const $ = _c(4);
   const { prop } = t0;
   let t1;
   if ($[0] !== prop) {
     const obj = shallowCopy(prop);
     const aliasedObj = identity(obj);
-
-    const id = [obj.id];
+    let t2;
+    if ($[2] !== obj) {
+      t2 = [obj.id];
+      $[2] = obj;
+      $[3] = t2;
+    } else {
+      t2 = $[3];
+    }
+    const id = t2;
 
     mutate(aliasedObj);
     setPropertyByKey(aliasedObj, "id", prop.id + 1);

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/babel-repro-compact-negative-number.expect.md

@@ -1,56 +0,0 @@
-
-## Input
-
-```javascript
-import {Stringify} from 'shared-runtime';
-
-function Repro(props) {
-  const MY_CONST = -2;
-  return <Stringify>{props.arg - MY_CONST}</Stringify>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Repro,
-  params: [
-    {
-      arg: 3,
-    },
-  ],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { Stringify } from "shared-runtime";
-
-function Repro(props) {
-  const $ = _c(2);
-
-  const t0 = props.arg - -2;
-  let t1;
-  if ($[0] !== t0) {
-    t1 = <Stringify>{t0}</Stringify>;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  return t1;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Repro,
-  params: [
-    {
-      arg: 3,
-    },
-  ],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>{"children":5}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/babel-repro-compact-negative-number.js

@@ -1,15 +0,0 @@
-import {Stringify} from 'shared-runtime';
-
-function Repro(props) {
-  const MY_CONST = -2;
-  return <Stringify>{props.arg - MY_CONST}</Stringify>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Repro,
-  params: [
-    {
-      arg: 3,
-    },
-  ],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-ref-prefix-postfix-operator.expect.md

@@ -1,132 +0,0 @@
-
-## Input
-
-```javascript
-import {useRef, useEffect} from 'react';
-
-/**
- * The postfix increment operator should return the value before incrementing.
- * ```js
- * const id = count.current; // 0
- * count.current = count.current + 1; // 1
- * return id;
- * ```
- * The bug is that we currently increment the value before the expression is evaluated.
- * This bug does not trigger when the incremented value is a plain primitive.
- *
- * Found differences in evaluator results
- * Non-forget (expected):
- * (kind: ok) {"count":{"current":0},"updateCountPostfix":"[[ function params=0 ]]","updateCountPrefix":"[[ function params=0 ]]"}
- * logs: ['id = 0','count = 1']
- * Forget:
- * (kind: ok) {"count":{"current":0},"updateCountPostfix":"[[ function params=0 ]]","updateCountPrefix":"[[ function params=0 ]]"}
- * logs: ['id = 1','count = 1']
- */
-function useFoo() {
-  const count = useRef(0);
-  const updateCountPostfix = () => {
-    const id = count.current++;
-    return id;
-  };
-  const updateCountPrefix = () => {
-    const id = ++count.current;
-    return id;
-  };
-  useEffect(() => {
-    const id = updateCountPostfix();
-    console.log(`id = ${id}`);
-    console.log(`count = ${count.current}`);
-  }, []);
-  return {count, updateCountPostfix, updateCountPrefix};
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { useRef, useEffect } from "react";
-
-/**
- * The postfix increment operator should return the value before incrementing.
- * ```js
- * const id = count.current; // 0
- * count.current = count.current + 1; // 1
- * return id;
- * ```
- * The bug is that we currently increment the value before the expression is evaluated.
- * This bug does not trigger when the incremented value is a plain primitive.
- *
- * Found differences in evaluator results
- * Non-forget (expected):
- * (kind: ok) {"count":{"current":0},"updateCountPostfix":"[[ function params=0 ]]","updateCountPrefix":"[[ function params=0 ]]"}
- * logs: ['id = 0','count = 1']
- * Forget:
- * (kind: ok) {"count":{"current":0},"updateCountPostfix":"[[ function params=0 ]]","updateCountPrefix":"[[ function params=0 ]]"}
- * logs: ['id = 1','count = 1']
- */
-function useFoo() {
-  const $ = _c(5);
-  const count = useRef(0);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = () => {
-      count.current = count.current + 1;
-      const id = count.current;
-      return id;
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const updateCountPostfix = t0;
-  let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = () => {
-      const id_0 = (count.current = count.current + 1);
-      return id_0;
-    };
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const updateCountPrefix = t1;
-  let t2;
-  let t3;
-  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-    t2 = () => {
-      const id_1 = updateCountPostfix();
-      console.log(`id = ${id_1}`);
-      console.log(`count = ${count.current}`);
-    };
-    t3 = [];
-    $[2] = t2;
-    $[3] = t3;
-  } else {
-    t2 = $[2];
-    t3 = $[3];
-  }
-  useEffect(t2, t3);
-  let t4;
-  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
-    t4 = { count, updateCountPostfix, updateCountPrefix };
-    $[4] = t4;
-  } else {
-    t4 = $[4];
-  }
-  return t4;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [],
-};
-
-```
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-ref-prefix-postfix-operator.js

@@ -1,42 +0,0 @@
-import {useRef, useEffect} from 'react';
-
-/**
- * The postfix increment operator should return the value before incrementing.
- * ```js
- * const id = count.current; // 0
- * count.current = count.current + 1; // 1
- * return id;
- * ```
- * The bug is that we currently increment the value before the expression is evaluated.
- * This bug does not trigger when the incremented value is a plain primitive.
- *
- * Found differences in evaluator results
- * Non-forget (expected):
- * (kind: ok) {"count":{"current":0},"updateCountPostfix":"[[ function params=0 ]]","updateCountPrefix":"[[ function params=0 ]]"}
- * logs: ['id = 0','count = 1']
- * Forget:
- * (kind: ok) {"count":{"current":0},"updateCountPostfix":"[[ function params=0 ]]","updateCountPrefix":"[[ function params=0 ]]"}
- * logs: ['id = 1','count = 1']
- */
-function useFoo() {
-  const count = useRef(0);
-  const updateCountPostfix = () => {
-    const id = count.current++;
-    return id;
-  };
-  const updateCountPrefix = () => {
-    const id = ++count.current;
-    return id;
-  };
-  useEffect(() => {
-    const id = updateCountPostfix();
-    console.log(`id = ${id}`);
-    console.log(`count = ${count.current}`);
-  }, []);
-  return {count, updateCountPostfix, updateCountPrefix};
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2-iife.expect.md

@@ -25,25 +25,17 @@ export const FIXTURE_ENTRYPOINT = {
 ```javascript
 import { c as _c } from "react/compiler-runtime";
 function bar(a) {
-  const $ = _c(4);
-  let t0;
-  if ($[0] !== a) {
-    t0 = [a];
-    $[0] = a;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const x = t0;
+  const $ = _c(2);
   let y;
-  if ($[2] !== x[0][1]) {
+  if ($[0] !== a) {
+    const x = [a];
     y = {};
 
     y = x[0][1];
-    $[2] = x[0][1];
-    $[3] = y;
+    $[0] = a;
+    $[1] = y;
   } else {
-    y = $[3];
+    y = $[1];
   }
   return y;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3-iife.expect.md

@@ -29,29 +29,20 @@ export const FIXTURE_ENTRYPOINT = {
 ```javascript
 import { c as _c } from "react/compiler-runtime";
 function bar(a, b) {
-  const $ = _c(6);
-  let t0;
-  if ($[0] !== a || $[1] !== b) {
-    t0 = [a, b];
-    $[0] = a;
-    $[1] = b;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const x = t0;
+  const $ = _c(3);
   let y;
-  if ($[3] !== x[0][1] || $[4] !== x[1][0]) {
+  if ($[0] !== a || $[1] !== b) {
+    const x = [a, b];
     y = {};
     let t = {};
 
     y = x[0][1];
     t = x[1][0];
-    $[3] = x[0][1];
-    $[4] = x[1][0];
-    $[5] = y;
+    $[0] = a;
+    $[1] = b;
+    $[2] = y;
   } else {
-    y = $[5];
+    y = $[2];
   }
   return y;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4-iife.expect.md

@@ -25,25 +25,17 @@ export const FIXTURE_ENTRYPOINT = {
 ```javascript
 import { c as _c } from "react/compiler-runtime";
 function bar(a) {
-  const $ = _c(4);
-  let t0;
-  if ($[0] !== a) {
-    t0 = [a];
-    $[0] = a;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const x = t0;
+  const $ = _c(2);
   let y;
-  if ($[2] !== x[0].a[1]) {
+  if ($[0] !== a) {
+    const x = [a];
     y = {};
 
     y = x[0].a[1];
-    $[2] = x[0].a[1];
-    $[3] = y;
+    $[0] = a;
+    $[1] = y;
   } else {
-    y = $[3];
+    y = $[1];
   }
   return y;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-iife.expect.md

@@ -24,25 +24,17 @@ export const FIXTURE_ENTRYPOINT = {
 ```javascript
 import { c as _c } from "react/compiler-runtime";
 function bar(a) {
-  const $ = _c(4);
-  let t0;
-  if ($[0] !== a) {
-    t0 = [a];
-    $[0] = a;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const x = t0;
+  const $ = _c(2);
   let y;
-  if ($[2] !== x[0]) {
+  if ($[0] !== a) {
+    const x = [a];
     y = {};
 
     y = x[0];
-    $[2] = x[0];
-    $[3] = y;
+    $[0] = a;
+    $[1] = y;
   } else {
-    y = $[3];
+    y = $[1];
   }
   return y;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/custom-opt-out-directive.expect.md

@@ -1,35 +0,0 @@
-
-## Input
-
-```javascript
-// @customOptOutDirectives:["use todo memo"]
-function Component() {
-  'use todo memo';
-  return <div>hello world!</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [],
-};
-
-```
-
-## Code
-
-```javascript
-// @customOptOutDirectives:["use todo memo"]
-function Component() {
-  "use todo memo";
-  return <div>hello world!</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>hello world!</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/custom-opt-out-directive.tsx

@@ -1,10 +0,0 @@
-// @customOptOutDirectives:["use todo memo"]
-function Component() {
-  'use todo memo';
-  return <div>hello world!</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.hook-call-freezes-captured-identifier.expect.md

@@ -32,7 +32,7 @@ export const FIXTURE_ENTRYPOINT = {
   11 |   });
   12 |
 > 13 |   x.value += count;
-     |   ^ InvalidReact: Updating a value previously passed as an argument to a hook is not allowed. Consider moving the mutation before calling the hook (13:13)
+     |   ^ InvalidReact: This mutates a variable that React considers immutable (13:13)
   14 |   return <Stringify x={x} cb={cb} />;
   15 | }
   16 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.hook-call-freezes-captured-memberexpr.expect.md

@@ -32,7 +32,7 @@ export const FIXTURE_ENTRYPOINT = {
   11 |   });
   12 |
 > 13 |   x.value += count;
-     |   ^ InvalidReact: Updating a value previously passed as an argument to a hook is not allowed. Consider moving the mutation before calling the hook (13:13)
+     |   ^ InvalidReact: This mutates a variable that React considers immutable (13:13)
   14 |   return <Stringify x={x} cb={cb} />;
   15 | }
   16 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-hoisting-setstate.expect.md

@@ -38,15 +38,13 @@ export const FIXTURE_ENTRYPOINT = {
 ## Error
 
 ```
-  17 |    * $2 = Function context=setState
-  18 |    */
-> 19 |   useEffect(() => setState(2), []);
-     |                   ^^^^^^^^ InvalidReact: This variable is accessed before it is declared, which may prevent it from updating as the assigned value changes over time. Variable `setState` is accessed before it is declared (19:19)
-
-InvalidReact: This variable is accessed before it is declared, which prevents the earlier access from updating when this value changes over time. Variable `setState` is accessed before it is declared (21:21)
+  19 |   useEffect(() => setState(2), []);
   20 |
-  21 |   const [state, setState] = useState(0);
+> 21 |   const [state, setState] = useState(0);
+     |                 ^^^^^^^^ InvalidReact: Updating a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the mutation before calling useEffect(). Found mutation of `setState` (21:21)
   22 |   return <Stringify state={state} />;
+  23 | }
+  24 |
 ```
           
       

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

@@ -20,7 +20,7 @@ function Component() {
   2 |
   3 | function Component() {
 > 4 |   const date = Date.now();
-    |                ^^^^^^^^^^ InvalidReact: Calling an impure function can produce unstable results. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent). `Date.now` is an impure function whose results may change on every call (4:4)
+    |                ^^^^^^^^ InvalidReact: Calling an impure function can produce unstable results. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent). `Date.now` is an impure function whose results may change on every call (4:4)
 
 InvalidReact: Calling an impure function can produce unstable results. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent). `performance.now` is an impure function whose results may change on every call (5:5)
 

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-non-imported-reanimated-shared-value-writes.expect.md

@@ -27,7 +27,7 @@ function SomeComponent() {
    9 |   return (
   10 |     <Button
 > 11 |       onPress={() => (sharedVal.value = Math.random())}
-     |                       ^^^^^^^^^ InvalidReact: Updating a value returned from a hook is not allowed. Consider moving the mutation into the hook where the value is constructed. Found mutation of `sharedVal` (11:11)
+     |                       ^^^^^^^^^ InvalidReact: Mutating a value returned from a function whose return value should not be mutated. Found mutation of `sharedVal` (11:11)
   12 |       title="Randomize"
   13 |     />
   14 |   );

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.mutate-hook-argument.expect.md

@@ -16,8 +16,6 @@ function useHook(a, b) {
   1 | function useHook(a, b) {
 > 2 |   b.test = 1;
     |   ^ InvalidReact: Mutating component props or hook arguments is not allowed. Consider using a local variable instead (2:2)
-
-InvalidReact: Mutating component props or hook arguments is not allowed. Consider using a local variable instead (3:3)
   3 |   a.test = 2;
   4 | }
   5 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.not-useEffect-external-mutate.expect.md

@@ -21,8 +21,6 @@ function Component(props) {
   4 |   foo(() => {
 > 5 |     x.a = 10;
     |     ^ InvalidReact: Writing to a variable defined outside a component or hook is not allowed. Consider using an effect (5:5)
-
-InvalidReact: Writing to a variable defined outside a component or hook is not allowed. Consider using an effect (6:6)
   6 |     x.a = 20;
   7 |   });
   8 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.reassignment-to-global-indirect.expect.md

@@ -21,8 +21,6 @@ function Component() {
   3 |     // Cannot assign to globals
 > 4 |     someUnknownGlobal = true;
     |     ^^^^^^^^^^^^^^^^^ InvalidReact: 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) (4:4)
-
-InvalidReact: 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:5)
   5 |     moduleLocal = true;
   6 |   };
   7 |   foo();

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.reassignment-to-global.expect.md

@@ -18,8 +18,6 @@ function Component() {
   2 |   // Cannot assign to globals
 > 3 |   someUnknownGlobal = true;
     |   ^^^^^^^^^^^^^^^^^ InvalidReact: 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) (3:3)
-
-InvalidReact: 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) (4:4)
   4 |   moduleLocal = true;
   5 | }
   6 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-repro-named-function-with-shadowed-local-same-name.expect.md

@@ -22,7 +22,7 @@ function Component(props) {
    7 |     return hasErrors;
    8 |   }
 >  9 |   return hasErrors();
-     |          ^^^^^^^^^ Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized. <unknown> hasErrors_0$15:TFunction (9:9)
+     |          ^^^^^^^^^ Invariant: [hoisting] Expected value for identifier to be initialized. hasErrors_0$15 (9:9)
   10 | }
   11 |
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-useMemo-with-optional.expect.md

@@ -0,0 +1,32 @@
+
+## Input
+
+```javascript
+function Component(props) {
+  return (
+    useMemo(() => {
+      return [props.value];
+    }) || []
+  );
+}
+
+```
+
+
+## Error
+
+```
+  1 | function Component(props) {
+  2 |   return (
+> 3 |     useMemo(() => {
+    |     ^^^^^^^^^^^^^^^
+> 4 |       return [props.value];
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> 5 |     }) || []
+    | ^^^^^^^^^^^^^ Todo: Support labeled statements combined with value blocks (conditional, logical, optional chaining, etc) (3:5)
+  6 |   );
+  7 | }
+  8 |
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-useMemo-with-optional.js

@@ -0,0 +1,7 @@
+function Component(props) {
+  return (
+    useMemo(() => {
+      return [props.value];
+    }) || []
+  );
+}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-valid-functiondecl-hoisting.expect.md

@@ -34,13 +34,13 @@ export const FIXTURE_ENTRYPOINT = {
 ## Error
 
 ```
-  11 |
-  12 |   function foo() {
-> 13 |     return bar();
-     |            ^^^ Todo: [PruneHoistedContexts] Rewrite hoisted function references (13:13)
+  13 |     return bar();
   14 |   }
-  15 |   function bar() {
+> 15 |   function bar() {
+     |            ^^^ Todo: [PruneHoistedContexts] Rewrite hoisted function references (15:15)
   16 |     return 42;
+  17 |   }
+  18 |
 ```
           
       

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

@@ -1,50 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @compilationMode:"annotation"
-
-function Foo() {
-  'use memo if(getTrue)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { getTrue } from "shared-runtime"; // @dynamicGating:{"source":"shared-runtime"} @compilationMode:"annotation"
-const Foo = getTrue()
-  ? function Foo() {
-      "use memo if(getTrue)";
-      const $ = _c(1);
-      let t0;
-      if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-        t0 = <div>hello world</div>;
-        $[0] = t0;
-      } else {
-        t0 = $[0];
-      }
-      return t0;
-    }
-  : function Foo() {
-      "use memo if(getTrue)";
-      return <div>hello world</div>;
-    };
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>hello world</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-annotation.js

@@ -1,11 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @compilationMode:"annotation"
-
-function Foo() {
-  'use memo if(getTrue)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

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

@@ -1,66 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @validatePreserveExistingMemoizationGuarantees @panicThreshold:"none" @loggerTestOnly
-
-import {useMemo} from 'react';
-import {identity} from 'shared-runtime';
-
-function Foo({value}) {
-  'use memo if(getTrue)';
-
-  const initialValue = useMemo(() => identity(value), []);
-  return (
-    <>
-      <div>initial value {initialValue}</div>
-      <div>current value {value}</div>
-    </>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{value: 1}],
-  sequentialRenders: [{value: 1}, {value: 2}],
-};
-
-```
-
-## Code
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @validatePreserveExistingMemoizationGuarantees @panicThreshold:"none" @loggerTestOnly
-
-import { useMemo } from "react";
-import { identity } from "shared-runtime";
-
-function Foo({ value }) {
-  "use memo if(getTrue)";
-
-  const initialValue = useMemo(() => identity(value), []);
-  return (
-    <>
-      <div>initial value {initialValue}</div>
-      <div>current value {value}</div>
-    </>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{ value: 1 }],
-  sequentialRenders: [{ value: 1 }, { value: 2 }],
-};
-
-```
-
-## 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":{"reason":"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","description":"The inferred dependency was `value`, but the source dependencies were []. Inferred dependency not present in source","severity":"CannotPreserveMemoization","suggestions":null,"loc":{"start":{"line":9,"column":31,"index":288},"end":{"line":9,"column":52,"index":309},"filename":"dynamic-gating-bailout-nopanic.ts"}}}
-```
-      
-### Eval output
-(kind: ok) <div>initial value 1</div><div>current value 1</div>
-<div>initial value 1</div><div>current value 2</div>

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

@@ -1,22 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @validatePreserveExistingMemoizationGuarantees @panicThreshold:"none" @loggerTestOnly
-
-import {useMemo} from 'react';
-import {identity} from 'shared-runtime';
-
-function Foo({value}) {
-  'use memo if(getTrue)';
-
-  const initialValue = useMemo(() => identity(value), []);
-  return (
-    <>
-      <div>initial value {initialValue}</div>
-      <div>current value {value}</div>
-    </>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{value: 1}],
-  sequentialRenders: [{value: 1}, {value: 2}],
-};

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

@@ -1,50 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"}
-
-function Foo() {
-  'use memo if(getFalse)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { getFalse } from "shared-runtime"; // @dynamicGating:{"source":"shared-runtime"}
-const Foo = getFalse()
-  ? function Foo() {
-      "use memo if(getFalse)";
-      const $ = _c(1);
-      let t0;
-      if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-        t0 = <div>hello world</div>;
-        $[0] = t0;
-      } else {
-        t0 = $[0];
-      }
-      return t0;
-    }
-  : function Foo() {
-      "use memo if(getFalse)";
-      return <div>hello world</div>;
-    };
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>hello world</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-disabled.js

@@ -1,11 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"}
-
-function Foo() {
-  'use memo if(getFalse)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

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

@@ -1,50 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"}
-
-function Foo() {
-  'use memo if(getTrue)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { getTrue } from "shared-runtime"; // @dynamicGating:{"source":"shared-runtime"}
-const Foo = getTrue()
-  ? function Foo() {
-      "use memo if(getTrue)";
-      const $ = _c(1);
-      let t0;
-      if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-        t0 = <div>hello world</div>;
-        $[0] = t0;
-      } else {
-        t0 = $[0];
-      }
-      return t0;
-    }
-  : function Foo() {
-      "use memo if(getTrue)";
-      return <div>hello world</div>;
-    };
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>hello world</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-enabled.js

@@ -1,11 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"}
-
-function Foo() {
-  'use memo if(getTrue)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

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

@@ -1,37 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none"
-
-function Foo() {
-  'use memo if(true)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none"
-
-function Foo() {
-  "use memo if(true)";
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>hello world</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-invalid-identifier-nopanic.js

@@ -1,11 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none"
-
-function Foo() {
-  'use memo if(true)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

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

@@ -1,45 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none" @loggerTestOnly
-
-function Foo() {
-  'use memo if(getTrue)';
-  'use memo if(getFalse)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none" @loggerTestOnly
-
-function Foo() {
-  "use memo if(getTrue)";
-  "use memo if(getFalse)";
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## 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":{"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
-(kind: ok) <div>hello world</div>

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

@@ -1,12 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none" @loggerTestOnly
-
-function Foo() {
-  'use memo if(getTrue)';
-  'use memo if(getFalse)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

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

@@ -1,37 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @noEmit
-
-function Foo() {
-  'use memo if(getTrue)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @noEmit
-
-function Foo() {
-  "use memo if(getTrue)";
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>hello world</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/dynamic-gating-noemit.js

@@ -1,11 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @noEmit
-
-function Foo() {
-  'use memo if(getTrue)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/error.dynamic-gating-invalid-identifier-nopanic-required-feature.expect.md

@@ -1,35 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none" @inferEffectDependencies
-import {useEffect} from 'react';
-import {print} from 'shared-runtime';
-
-function ReactiveVariable({propVal}) {
-  'use memo if(invalid identifier)';
-  const arr = [propVal];
-  useEffect(() => print(arr));
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: ReactiveVariable,
-  params: [{}],
-};
-
-```
-
-
-## Error
-
-```
-   6 |   'use memo if(invalid identifier)';
-   7 |   const arr = [propVal];
->  8 |   useEffect(() => print(arr));
-     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ InvalidReact: [InferEffectDependencies] React Compiler is unable to infer dependencies of this effect. This will break your build! To resolve, either pass your own dependency array or fix reported compiler bailout diagnostics. (8:8)
-   9 | }
-  10 |
-  11 | export const FIXTURE_ENTRYPOINT = {
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/error.dynamic-gating-invalid-identifier-nopanic-required-feature.js

@@ -1,14 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @panicThreshold:"none" @inferEffectDependencies
-import {useEffect} from 'react';
-import {print} from 'shared-runtime';
-
-function ReactiveVariable({propVal}) {
-  'use memo if(invalid identifier)';
-  const arr = [propVal];
-  useEffect(() => print(arr));
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: ReactiveVariable,
-  params: [{}],
-};

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

@@ -1,32 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"}
-
-function Foo() {
-  'use memo if(true)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};
-
-```
-
-
-## Error
-
-```
-  2 |
-  3 | function Foo() {
-> 4 |   'use memo if(true)';
-    |   ^^^^^^^^^^^^^^^^^^^^ InvalidReact: Dynamic gating directive is not a valid JavaScript identifier. Found 'use memo if(true)' (4:4)
-  5 |   return <div>hello world</div>;
-  6 | }
-  7 |
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/gating/error.dynamic-gating-invalid-identifier.js

@@ -1,11 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"}
-
-function Foo() {
-  'use memo if(true)';
-  return <div>hello world</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Foo,
-  params: [{}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/iife-inline-ternary.expect.md

@@ -1,40 +0,0 @@
-
-## Input
-
-```javascript
-function Component(props) {
-  const x = props.foo
-    ? 1
-    : (() => {
-        throw new Error('Did not receive 1');
-      })();
-  return items;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: true}],
-};
-
-```
-
-## Code
-
-```javascript
-function Component(props) {
-  props.foo ? 1 : _temp();
-  return items;
-}
-function _temp() {
-  throw new Error("Did not receive 1");
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ foo: true }],
-};
-
-```
-      
-### Eval output
-(kind: exception) items is not defined

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/iife-inline-ternary.js

@@ -1,13 +0,0 @@
-function Component(props) {
-  const x = props.foo
-    ? 1
-    : (() => {
-        throw new Error('Did not receive 1');
-      })();
-  return items;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: true}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/error.todo-dynamic-gating.expect.md

@@ -1,42 +0,0 @@
-
-## Input
-
-```javascript
-// @dynamicGating:{"source":"shared-runtime"} @inferEffectDependencies @panicThreshold:"none"
-
-import useEffectWrapper from 'useEffectWrapper';
-
-/**
- * TODO: run the non-forget enabled version through the effect inference
- * pipeline.
- */
-function Component({foo}) {
-  'use memo if(getTrue)';
-  const arr = [];
-  useEffectWrapper(() => arr.push(foo));
-  arr.push(2);
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: 1}],
-  sequentialRenders: [{foo: 1}, {foo: 2}],
-};
-
-```
-
-
-## Error
-
-```
-  10 |   'use memo if(getTrue)';
-  11 |   const arr = [];
-> 12 |   useEffectWrapper(() => arr.push(foo));
-     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ InvalidReact: [InferEffectDependencies] React Compiler is unable to infer dependencies of this effect. This will break your build! To resolve, either pass your own dependency array or fix reported compiler bailout diagnostics. (12:12)
-  13 |   arr.push(2);
-  14 |   return arr;
-  15 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/error.todo-dynamic-gating.js

@@ -1,21 +0,0 @@
-// @dynamicGating:{"source":"shared-runtime"} @inferEffectDependencies @panicThreshold:"none"
-
-import useEffectWrapper from 'useEffectWrapper';
-
-/**
- * TODO: run the non-forget enabled version through the effect inference
- * pipeline.
- */
-function Component({foo}) {
-  'use memo if(getTrue)';
-  const arr = [];
-  useEffectWrapper(() => arr.push(foo));
-  arr.push(2);
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: 1}],
-  sequentialRenders: [{foo: 1}, {foo: 2}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/error.todo-gating.expect.md

@@ -1,40 +0,0 @@
-
-## Input
-
-```javascript
-// @gating @inferEffectDependencies @panicThreshold:"none"
-import useEffectWrapper from 'useEffectWrapper';
-
-/**
- * TODO: run the non-forget enabled version through the effect inference
- * pipeline.
- */
-function Component({foo}) {
-  const arr = [];
-  useEffectWrapper(() => arr.push(foo));
-  arr.push(2);
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: 1}],
-  sequentialRenders: [{foo: 1}, {foo: 2}],
-};
-
-```
-
-
-## Error
-
-```
-   8 | function Component({foo}) {
-   9 |   const arr = [];
-> 10 |   useEffectWrapper(() => arr.push(foo));
-     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ InvalidReact: [InferEffectDependencies] React Compiler is unable to infer dependencies of this effect. This will break your build! To resolve, either pass your own dependency array or fix reported compiler bailout diagnostics. (10:10)
-  11 |   arr.push(2);
-  12 |   return arr;
-  13 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/bailout-retry/error.todo-gating.js

@@ -1,19 +0,0 @@
-// @gating @inferEffectDependencies @panicThreshold:"none"
-import useEffectWrapper from 'useEffectWrapper';
-
-/**
- * TODO: run the non-forget enabled version through the effect inference
- * pipeline.
- */
-function Component({foo}) {
-  const arr = [];
-  useEffectWrapper(() => arr.push(foo));
-  arr.push(2);
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: 1}],
-  sequentialRenders: [{foo: 1}, {foo: 2}],
-};

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

@@ -1,58 +0,0 @@
-
-## Input
-
-```javascript
-// @inferEffectDependencies @panicThreshold:"none" @loggerTestOnly
-import {useEffect} from 'react';
-import {print} from 'shared-runtime';
-
-function Component({foo}) {
-  const arr = [];
-  // Taking either arr[0].value or arr as a dependency is reasonable
-  // as long as developers know what to expect.
-  useEffect(() => print(arr[0]?.value));
-  arr.push({value: foo});
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: 1}],
-};
-
-```
-
-## Code
-
-```javascript
-// @inferEffectDependencies @panicThreshold:"none" @loggerTestOnly
-import { useEffect } from "react";
-import { print } from "shared-runtime";
-
-function Component(t0) {
-  const { foo } = t0;
-  const arr = [];
-
-  useEffect(() => print(arr[0]?.value), [arr[0]?.value]);
-  arr.push({ value: foo });
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ foo: 1 }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","fnLoc":{"start":{"line":5,"column":0,"index":139},"end":{"line":12,"column":1,"index":384},"filename":"mutate-after-useeffect-optional-chain.ts"},"detail":{"reason":"Updating a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the mutation before calling useEffect()","description":null,"severity":"InvalidReact","suggestions":null,"loc":{"start":{"line":10,"column":2,"index":345},"end":{"line":10,"column":5,"index":348},"filename":"mutate-after-useeffect-optional-chain.ts","identifierName":"arr"}}}
-{"kind":"AutoDepsDecorations","fnLoc":{"start":{"line":9,"column":2,"index":304},"end":{"line":9,"column":39,"index":341},"filename":"mutate-after-useeffect-optional-chain.ts"},"decorations":[{"start":{"line":9,"column":24,"index":326},"end":{"line":9,"column":27,"index":329},"filename":"mutate-after-useeffect-optional-chain.ts","identifierName":"arr"}]}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":5,"column":0,"index":139},"end":{"line":12,"column":1,"index":384},"filename":"mutate-after-useeffect-optional-chain.ts"},"fnName":"Component","memoSlots":0,"memoBlocks":0,"memoValues":0,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: ok) [{"value":1}]
-logs: [1]

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

@@ -1,17 +0,0 @@
-// @inferEffectDependencies @panicThreshold:"none" @loggerTestOnly
-import {useEffect} from 'react';
-import {print} from 'shared-runtime';
-
-function Component({foo}) {
-  const arr = [];
-  // Taking either arr[0].value or arr as a dependency is reasonable
-  // as long as developers know what to expect.
-  useEffect(() => print(arr[0]?.value));
-  arr.push({value: foo});
-  return arr;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{foo: 1}],
-};

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

@@ -2,7 +2,7 @@
 ## Input
 
 ```javascript
-// @inferEffectDependencies @panicThreshold:"none" @loggerTestOnly
+// @inferEffectDependencies @panicThreshold:"none"
 
 import {useEffect, useRef} from 'react';
 import {print} from 'shared-runtime';
@@ -14,17 +14,12 @@ function Component({arrRef}) {
   return arrRef;
 }
 
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{arrRef: {current: {val: 'initial ref value'}}}],
-};
-
 ```
 
 ## Code
 
 ```javascript
-// @inferEffectDependencies @panicThreshold:"none" @loggerTestOnly
+// @inferEffectDependencies @panicThreshold:"none"
 
 import { useEffect, useRef } from "react";
 import { print } from "shared-runtime";
@@ -37,21 +32,7 @@ function Component(t0) {
   return arrRef;
 }
 
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ arrRef: { current: { val: "initial ref value" } } }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":148},"end":{"line":11,"column":1,"index":311},"filename":"mutate-after-useeffect-ref-access.ts"},"detail":{"reason":"Mutating component props or hook arguments is not allowed. Consider using a local variable instead","description":null,"severity":"InvalidReact","suggestions":null,"loc":{"start":{"line":9,"column":2,"index":269},"end":{"line":9,"column":16,"index":283},"filename":"mutate-after-useeffect-ref-access.ts"}}}
-{"kind":"AutoDepsDecorations","fnLoc":{"start":{"line":8,"column":2,"index":227},"end":{"line":8,"column":40,"index":265},"filename":"mutate-after-useeffect-ref-access.ts"},"decorations":[{"start":{"line":8,"column":24,"index":249},"end":{"line":8,"column":30,"index":255},"filename":"mutate-after-useeffect-ref-access.ts","identifierName":"arrRef"}]}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":6,"column":0,"index":148},"end":{"line":11,"column":1,"index":311},"filename":"mutate-after-useeffect-ref-access.ts"},"fnName":"Component","memoSlots":0,"memoBlocks":0,"memoValues":0,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```
       
 ### Eval output
-(kind: ok) {"current":{"val":2}}
-logs: [{ val: 2 }]
+(kind: exception) Fixture not implemented

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

@@ -1,4 +1,4 @@
-// @inferEffectDependencies @panicThreshold:"none" @loggerTestOnly
+// @inferEffectDependencies @panicThreshold:"none"
 
 import {useEffect, useRef} from 'react';
 import {print} from 'shared-runtime';
@@ -9,8 +9,3 @@ function Component({arrRef}) {
   arrRef.current.val = 2;
   return arrRef;
 }
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{arrRef: {current: {val: 'initial ref value'}}}],
-};