[eprh] Move to compiler directory

Moves the plugin into the compiler directory.

- Remove eslint-plugin-react-hooks from bundles.js
- Remove eslint-plugin-react-hooks from ReactVersions.js
- Remove jest.config.js
- Remove babel.config-react-compiler.js
- Replace babel.config.js with copy from eslint-plugin-react-compiler
- Add tsup.config.ts to eslint-plugin-react-hooks
- Add eslint-plugin-react-hooks to compiler release scripts

.eslintrc.js

@@ -336,11 +336,11 @@ module.exports = {
         'packages/react-devtools-extensions/**/*.js',
         'packages/react-devtools-timeline/**/*.js',
         'packages/react-native-renderer/**/*.js',
-        'packages/eslint-plugin-react-hooks/**/*.js',
         'packages/jest-react/**/*.js',
         'packages/internal-test-utils/**/*.js',
         'packages/**/__tests__/*.js',
         'packages/**/npm/*.js',
+        'compiler/packages/eslint-plugin-react-hooks/**/*.js',
       ],
       rules: {
         'react-internal/prod-error-codes': OFF,
@@ -515,7 +515,7 @@ module.exports = {
       },
     },
     {
-      files: ['packages/eslint-plugin-react-hooks/src/**/*'],
+      files: ['compiler/packages/eslint-plugin-react-hooks/src/**/*'],
       extends: ['plugin:@typescript-eslint/recommended'],
       parser: '@typescript-eslint/parser',
       plugins: ['@typescript-eslint', 'eslint-plugin'],

.github/workflows/compiler_discord_notify.yml

@@ -7,14 +7,9 @@ on:
       - compiler/**
       - .github/workflows/compiler_**.yml
 
-permissions: {}
-
 jobs:
   check_maintainer:
     uses: facebook/react/.github/workflows/shared_check_maintainer.yml@main
-    permissions:
-      # Used by check_maintainer
-      contents: read
     with:
       actor: ${{ github.event.pull_request.user.login }}
 

.github/workflows/compiler_playground.yml

@@ -8,8 +8,6 @@ on:
       - compiler/**
       - .github/workflows/compiler_playground.yml
 
-permissions: {}
-
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
   cancel-in-progress: true
@@ -40,25 +38,9 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: compiler-and-playground-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-        working-directory: compiler
-      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
       - run: npx playwright install --with-deps chromium
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-      - run: npx playwright install-deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit == 'true'
       - run: CI=true yarn test
       - run: ls -R test-results
         if: '!cancelled()'
@@ -68,4 +50,3 @@ jobs:
         with:
           name: test-results
           path: compiler/apps/playground/test-results
-          if-no-files-found: ignore

.github/workflows/compiler_prereleases.yml

@@ -20,12 +20,11 @@ on:
       NPM_TOKEN:
         required: true
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+  GH_TOKEN: ${{ github.token }}
   NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
 defaults:
@@ -49,9 +48,8 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Publish packages to npm
         run: |
           cp ./scripts/release/ci-npmrc ~/.npmrc

.github/workflows/compiler_prereleases_manual.yml

@@ -15,8 +15,6 @@ on:
         required: true
         type: string
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 

.github/workflows/compiler_prereleases_nightly.yml

@@ -5,8 +5,6 @@ on:
     # At 10 minutes past 16:00 on Mon, Tue, Wed, Thu, and Fri
     - cron: 10 16 * * 1,2,3,4,5
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 

.github/workflows/compiler_prereleases_weekly.yml

@@ -5,8 +5,6 @@ on:
     # At 10 minutes past 9:00 on Mon
     - cron: 10 9 * * 1
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 

.github/workflows/compiler_typescript.yml

@@ -8,8 +8,6 @@ on:
       - compiler/**
       - .github/workflows/compiler_typescript.yml
 
-permissions: {}
-
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
   cancel-in-progress: true
@@ -47,13 +45,11 @@ jobs:
           cache-dependency-path: compiler/yarn.lock
       - name: Restore cached node_modules
         uses: actions/cache@v4
-        id: node_modules
         with:
           path: |
             **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn workspace babel-plugin-react-compiler lint
 
   # Hardcoded to improve parallelism
@@ -73,9 +69,8 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn workspace babel-plugin-react-compiler jest
 
   test:
@@ -99,9 +94,8 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: xvfb-run -a yarn workspace ${{ matrix.workspace_name }} test
         if: runner.os == 'Linux' && matrix.workspace_name == 'react-forgive'
       - run: yarn workspace ${{ matrix.workspace_name }} test

.github/workflows/devtools_regression_tests.yml

@@ -9,8 +9,6 @@ on:
         required: false
         type: string
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -20,9 +18,6 @@ jobs:
   download_build:
     name: Download base build
     runs-on: ubuntu-latest
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -40,9 +35,7 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn --cwd scripts/release install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Download react-devtools artifacts for base revision
         run: |
           git fetch origin main
@@ -54,7 +47,6 @@ jobs:
         with:
           name: build
           path: build
-          if-no-files-found: error
 
   build_devtools_and_process_artifacts:
     name: Build DevTools and process artifacts
@@ -77,7 +69,6 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Restore archived build
         uses: actions/download-artifact@v4
         with:
@@ -93,20 +84,17 @@ jobs:
         with:
           name: react-devtools
           path: build/devtools.tgz
-          if-no-files-found: error
       # Simplifies getting the extension for local testing
       - name: Archive chrome extension
         uses: actions/upload-artifact@v4
         with:
           name: react-devtools-chrome-extension
           path: build/devtools/chrome-extension.zip
-          if-no-files-found: error
       - name: Archive firefox extension
         uses: actions/upload-artifact@v4
         with:
           name: react-devtools-firefox-extension
           path: build/devtools/firefox-extension.zip
-          if-no-files-found: error
 
   run_devtools_tests_for_versions:
     name: Run DevTools tests for versions
@@ -137,7 +125,6 @@ jobs:
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Restore all archived build artifacts
         uses: actions/download-artifact@v4
       - name: Display structure of build
@@ -173,24 +160,14 @@ jobs:
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Restore all archived build artifacts
         uses: actions/download-artifact@v4
       - name: Display structure of build
         run: ls -R build
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
-      - run: npx playwright install --with-deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-      - run: npx playwright install-deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit == 'true'
+      - name: Playwright install deps
+        run: |
+          npx playwright install
+          sudo npx playwright install-deps
       - run: ./scripts/ci/download_devtools_regression_build.js ${{ matrix.version }}
       - run: ls -R build-regression
       - run: ./scripts/ci/run_devtools_e2e_tests.js ${{ matrix.version }}
@@ -202,4 +179,3 @@ jobs:
         with:
           name: screenshots
           path: ./tmp/screenshots
-          if-no-files-found: warn

.github/workflows/runtime_build_and_test.yml

@@ -7,8 +7,6 @@ on:
     paths-ignore:
       - compiler/**
 
-permissions: {}
-
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
   cancel-in-progress: true
@@ -43,16 +41,6 @@ jobs:
           node-version-file: '.nvmrc'
           cache: yarn
           cache-dependency-path: yarn.lock
-      - name: Warm with old cache
-        if: steps.node_modules.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            **/node_modules
-          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - run: yarn install --frozen-lockfile
         if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Save cache
@@ -86,16 +74,6 @@ jobs:
           cache-dependency-path: |
             yarn.lock
             compiler/yarn.lock
-      - name: Warm with old cache
-        if: steps.node_modules.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@v4
-        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: yarn --cwd compiler install --frozen-lockfile
@@ -149,9 +127,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -179,9 +154,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -269,9 +241,6 @@ jobs:
           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-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -313,9 +282,6 @@ jobs:
           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-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -336,7 +302,6 @@ jobs:
         with:
           name: _build_${{ matrix.worker_id }}_${{ matrix.release_channel }}
           path: build
-          if-no-files-found: error
 
   test_build:
     name: yarn test-build
@@ -375,16 +340,9 @@ jobs:
           # TODO: Test more persistent configurations?
         ]
         shard:
-          - 1/10
-          - 2/10
-          - 3/10
-          - 4/10
-          - 5/10
-          - 6/10
-          - 7/10
-          - 8/10
-          - 9/10
-          - 10/10
+          - 1/3
+          - 2/3
+          - 3/3
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -404,9 +362,6 @@ jobs:
           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-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -426,10 +381,6 @@ jobs:
   process_artifacts_combined:
     name: Process artifacts combined
     needs: [build_and_lint, runtime_node_modules_cache]
-    permissions:
-      # https://github.com/actions/attest-build-provenance
-      id-token: write
-      attestations: write
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -447,9 +398,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -472,25 +420,12 @@ jobs:
         # TODO: Migrate scripts to use `build` directory instead of `build2`
       - run: cp ./build.tgz ./build2.tgz
       - name: Archive build artifacts
-        id: upload_artifacts_combined
         uses: actions/upload-artifact@v4
         with:
           name: artifacts_combined
           path: |
             ./build.tgz
             ./build2.tgz
-          if-no-files-found: error
-      - uses: actions/attest-build-provenance@v2
-        # We don't verify builds generated from pull requests not originating from facebook/react.
-        # However, if the PR lands, the run on `main` will generate the attestation which can then
-        # be used to download a build via scripts/release/download-experimental-build.js.
-        #
-        # Note that this means that scripts/release/download-experimental-build.js must be run with
-        # --no-verify when downloading a build from a fork.
-        if: github.event_name == 'push' && github.ref_name == 'main' || github.event.pull_request.head.repo.full_name == github.repository
-        with:
-          subject-name: artifacts_combined.zip
-          subject-digest: sha256:${{ steps.upload_artifacts_combined.outputs.artifact-digest }}
 
   check_error_codes:
     name: Search build artifacts for unminified errors
@@ -512,9 +447,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -552,9 +484,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -588,7 +517,7 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: fixtures_dom-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'fixtures/dom/yarn.lock') }}
+          key: fixtures_dom-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn --cwd fixtures/dom install --frozen-lockfile
@@ -632,26 +561,11 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: fixtures_flight-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'fixtures/flight/yarn.lock') }}
+          key: fixtures_flight-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
         if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: yarn --cwd fixtures/flight install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
-      - name: Playwright install deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-        working-directory: fixtures/flight
-        run: npx playwright install --with-deps chromium
       - name: Restore archived build
         uses: actions/download-artifact@v4
         with:
@@ -660,6 +574,16 @@ jobs:
           merge-multiple: true
       - name: Display structure of build
         run: ls -R build
+      - name: Install fixture dependencies
+        working-directory: fixtures/flight
+        run: |
+          yarn install --frozen-lockfile --cache-folder ~/.cache/yarn
+          if [ $? -ne 0 ]; then
+            yarn install --frozen-lockfile --cache-folder ~/.cache/yarn
+          fi
+      - name: Playwright install deps
+        working-directory: fixtures/flight
+        run: npx playwright install --with-deps chromium
       - name: Run tests
         working-directory: fixtures/flight
         run: yarn test
@@ -671,13 +595,11 @@ jobs:
         with:
           name: flight-playwright-report
           path: fixtures/flight/playwright-report
-          if-no-files-found: warn
       - name: Archive Flight fixture artifacts
         uses: actions/upload-artifact@v4
         with:
           name: flight-test-results
           path: fixtures/flight/test-results
-          if-no-files-found: ignore
 
   # ----- DEVTOOLS -----
   build_devtools_and_process_artifacts:
@@ -704,9 +626,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -728,7 +647,6 @@ jobs:
         with:
           name: react-devtools-${{ matrix.browser }}-extension
           path: build/devtools/${{ matrix.browser }}-extension.zip
-          if-no-files-found: error
 
   merge_devtools_artifacts:
     name: Merge DevTools artifacts
@@ -761,9 +679,6 @@ jobs:
           path: |
             **/node_modules
           key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          restore-keys: |
-            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
-            runtime-node_modules-v6-
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
@@ -785,10 +700,7 @@ jobs:
   sizebot:
     if: ${{ github.event_name == 'pull_request' && github.ref_name != 'main' && github.event.pull_request.base.ref == 'main' }}
     name: Run sizebot
-    needs: [build_and_lint]
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
+    needs: [build_and_lint, runtime_node_modules_cache]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -800,7 +712,7 @@ jobs:
           cache: yarn
           cache-dependency-path: yarn.lock
       - name: Restore cached node_modules
-        uses: actions/cache@v4 # note: this does not reuse centralized cache since it has unique cache key
+        uses: actions/cache/restore@v4
         id: node_modules
         with:
           path: |
@@ -813,23 +725,21 @@ jobs:
       - run: yarn --cwd scripts/release install --frozen-lockfile
         if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Download artifacts for base revision
-        # The build could have been generated from a fork, so we must download the build without
-        # any verification. This is safe since we only use this for sizebot calculation and the
-        # unverified artifact is not used. Additionally this workflow runs in the pull_request
-        # trigger so only restricted permissions are available.
         run: |
-          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=$(git rev-parse ${{ github.event.pull_request.base.sha }}) ${{ (github.event.pull_request.head.repo.full_name != github.repository && '--noVerify') || ''}}
+          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=$(git rev-parse ${{ github.event.pull_request.base.sha }})
           mv ./build ./base-build
+      # TODO: The `download-experimental-build` script copies the npm
+      # packages into the `node_modules` directory. This is a historical
+      # quirk of how the release script works. Let's pretend they
+      # don't exist.
       - name: Delete extraneous files
-        # TODO: The `download-experimental-build` script copies the npm
-        # packages into the `node_modules` directory. This is a historical
-        # quirk of how the release script works. Let's pretend they
-        # don't exist.
         run: rm -rf ./base-build/node_modules
       - name: Display structure of base-build from origin/main
         run: ls -R base-build
       - name: Ensure clean build directory
         run: rm -rf build
+      - run: yarn install --frozen-lockfile
+        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Restore archived build for PR
         uses: actions/download-artifact@v4
         with:
@@ -849,4 +759,3 @@ jobs:
         with:
           name: sizebot-message
           path: sizebot-message.md
-          if-no-files-found: ignore

.github/workflows/runtime_commit_artifacts.yml

@@ -22,8 +22,6 @@ on:
         default: false
         type: boolean
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -32,40 +30,6 @@ env:
 jobs:
   download_artifacts:
     runs-on: ubuntu-latest
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
-    steps:
-      - uses: actions/checkout@v4
-      - name: Restore cached node_modules
-        uses: actions/cache@v4
-        id: node_modules
-        with:
-          path: |
-            **/node_modules
-          key: runtime-release-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'scripts/release/yarn.lock') }}
-      - name: Ensure clean build directory
-        run: rm -rf build
-      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: yarn --cwd scripts/release install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Download artifacts for base revision
-        run: |
-          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }}
-      - name: Display structure of build
-        run: ls -R build
-      - name: Archive build
-        uses: actions/upload-artifact@v4
-        with:
-          name: build
-          path: build/
-          if-no-files-found: error
-
-
-  process_artifacts:
-    runs-on: ubuntu-latest
-    needs: [download_artifacts]
     outputs:
       www_branch_count: ${{ steps.check_branches.outputs.www_branch_count }}
       fbsource_branch_count: ${{ steps.check_branches.outputs.fbsource_branch_count }}
@@ -105,11 +69,25 @@ jobs:
         run: |
           echo "www_branch_count=$(git ls-remote --heads origin "refs/heads/meta-www" | wc -l)" >> "$GITHUB_OUTPUT"
           echo "fbsource_branch_count=$(git ls-remote --heads origin "refs/heads/meta-fbsource" | wc -l)" >> "$GITHUB_OUTPUT"
-      - name: Restore downloaded build
-        uses: actions/download-artifact@v4
+      - uses: actions/setup-node@v4
         with:
-          name: build
-          path: build
+          node-version-file: '.nvmrc'
+          cache: yarn
+          cache-dependency-path: yarn.lock
+      - name: Restore cached node_modules
+        uses: actions/cache@v4
+        id: node_modules
+        with:
+          path: |
+            **/node_modules
+          key: runtime-release-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'scripts/release/yarn.lock') }}
+      - name: Ensure clean build directory
+        run: rm -rf build
+      - run: yarn install --frozen-lockfile
+      - run: yarn --cwd scripts/release install --frozen-lockfile
+      - name: Download artifacts for base revision
+        run: |
+          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }}
       - name: Display structure of build
         run: ls -R build
       - name: Strip @license from eslint plugin and react-refresh
@@ -173,9 +151,9 @@ jobs:
           ls -R ./compiled-rn
       - name: Add REVISION files
         run: |
-          echo ${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }} >> ./compiled/facebook-www/REVISION
+          echo ${{ github.sha }} >> ./compiled/facebook-www/REVISION
           cp ./compiled/facebook-www/REVISION ./compiled/facebook-www/REVISION_TRANSFORMS
-          echo ${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }} >> ./compiled-rn/facebook-fbsource/xplat/js/react-native-github/Libraries/Renderer/REVISION
+          echo ${{ github.sha}} >> ./compiled-rn/facebook-fbsource/xplat/js/react-native-github/Libraries/Renderer/REVISION
       - name: "Get current version string"
         id: get_current_version
         run: |
@@ -192,20 +170,15 @@ jobs:
         with:
           name: compiled
           path: compiled/
-          if-no-files-found: error
       - uses: actions/upload-artifact@v4
         with:
           name: compiled-rn
           path: compiled-rn/
-          if-no-files-found: error
 
   commit_www_artifacts:
-    needs: [download_artifacts, process_artifacts]
-    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.process_artifacts.outputs.www_branch_count == '0')
+    needs: download_artifacts
+    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.download_artifacts.outputs.www_branch_count == '0')
     runs-on: ubuntu-latest
-    permissions:
-      # Used to push a commit to builds/facebook-www
-      contents: write
     steps:
       - uses: actions/checkout@v4
         with:
@@ -217,12 +190,12 @@ jobs:
           name: compiled
           path: compiled/
       - name: Revert version changes
-        if: needs.process_artifacts.outputs.last_version_classic != '' && needs.process_artifacts.outputs.last_version_modern != ''
+        if: needs.download_artifacts.outputs.last_version_classic != '' && needs.download_artifacts.outputs.last_version_modern != ''
         env:
-          CURRENT_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.current_version_classic }}
-          CURRENT_VERSION_MODERN: ${{ needs.process_artifacts.outputs.current_version_modern }}
-          LAST_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.last_version_classic }}
-          LAST_VERSION_MODERN: ${{ needs.process_artifacts.outputs.last_version_modern }}
+          CURRENT_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.current_version_classic }}
+          CURRENT_VERSION_MODERN: ${{ needs.download_artifacts.outputs.current_version_modern }}
+          LAST_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.last_version_classic }}
+          LAST_VERSION_MODERN: ${{ needs.download_artifacts.outputs.last_version_modern }}
         run: |
           echo "Reverting $CURRENT_VERSION_CLASSIC to $LAST_VERSION_CLASSIC"
           grep -rl "$CURRENT_VERSION_CLASSIC" ./compiled || echo "No files found with $CURRENT_VERSION_CLASSIC"
@@ -252,12 +225,12 @@ jobs:
             echo "should_commit=false" >> "$GITHUB_OUTPUT"
           fi
       - name: Re-apply version changes
-        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.process_artifacts.outputs.last_version_classic != '' && needs.process_artifacts.outputs.last_version_modern != '')
+        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.download_artifacts.outputs.last_version_classic != '' && needs.download_artifacts.outputs.last_version_modern != '')
         env:
-          CURRENT_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.current_version_classic }}
-          CURRENT_VERSION_MODERN: ${{ needs.process_artifacts.outputs.current_version_modern }}
-          LAST_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.last_version_classic }}
-          LAST_VERSION_MODERN: ${{ needs.process_artifacts.outputs.last_version_modern }}
+          CURRENT_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.current_version_classic }}
+          CURRENT_VERSION_MODERN: ${{ needs.download_artifacts.outputs.current_version_modern }}
+          LAST_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.last_version_classic }}
+          LAST_VERSION_MODERN: ${{ needs.download_artifacts.outputs.last_version_modern }}
         run: |
           echo "Re-applying $LAST_VERSION_CLASSIC to $CURRENT_VERSION_CLASSIC"
           grep -rl "$LAST_VERSION_CLASSIC" ./compiled || echo "No files found with $LAST_VERSION_CLASSIC"
@@ -271,8 +244,8 @@ jobs:
       - name: Will commit these changes
         if: inputs.force == true || steps.check_should_commit.outputs.should_commit == 'true'
         run: |
-          git add .
-          git status
+          echo ":"
+          git status -u
       - name: Check commit message
         if: inputs.dry_run
         run: |
@@ -291,11 +264,8 @@ jobs:
         run: git push
 
   commit_fbsource_artifacts:
-    needs: [download_artifacts, process_artifacts]
-    permissions:
-      # Used to push a commit to builds/facebook-fbsource
-      contents: write
-    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.process_artifacts.outputs.fbsource_branch_count == '0')
+    needs: download_artifacts
+    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.download_artifacts.outputs.fbsource_branch_count == '0')
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -308,10 +278,10 @@ jobs:
           name: compiled-rn
           path: compiled-rn/
       - name: Revert version changes
-        if: needs.process_artifacts.outputs.last_version_rn != ''
+        if: needs.download_artifacts.outputs.last_version_rn != ''
         env:
-          CURRENT_VERSION: ${{ needs.process_artifacts.outputs.current_version_rn }}
-          LAST_VERSION: ${{ needs.process_artifacts.outputs.last_version_rn }}
+          CURRENT_VERSION: ${{ needs.download_artifacts.outputs.current_version_rn }}
+          LAST_VERSION: ${{ needs.download_artifacts.outputs.last_version_rn }}
         run: |
           echo "Reverting $CURRENT_VERSION to $LAST_VERSION"
           grep -rl "$CURRENT_VERSION" ./compiled-rn || echo "No files found with $CURRENT_VERSION"
@@ -337,10 +307,10 @@ jobs:
             echo "should_commit=false" >> "$GITHUB_OUTPUT"
           fi
       - name: Re-apply version changes
-        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.process_artifacts.outputs.last_version_rn != '')
+        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.download_artifacts.outputs.last_version_rn != '')
         env:
-          CURRENT_VERSION: ${{ needs.process_artifacts.outputs.current_version_rn }}
-          LAST_VERSION: ${{ needs.process_artifacts.outputs.last_version_rn }}
+          CURRENT_VERSION: ${{ needs.download_artifacts.outputs.current_version_rn }}
+          LAST_VERSION: ${{ needs.download_artifacts.outputs.last_version_rn }}
         run: |
           echo "Re-applying $LAST_VERSION to $CURRENT_VERSION"
           grep -rl "$LAST_VERSION" ./compiled-rn || echo "No files found with $LAST_VERSION"

.github/workflows/runtime_discord_notify.yml

@@ -7,14 +7,9 @@ on:
       - compiler/**
       - .github/workflows/compiler_**.yml
 
-permissions: {}
-
 jobs:
   check_maintainer:
     uses: facebook/react/.github/workflows/shared_check_maintainer.yml@main
-    permissions:
-      # Used by check_maintainer
-      contents: read
     with:
       actor: ${{ github.event.pull_request.user.login }}
 

.github/workflows/runtime_eslint_plugin_e2e.yml

@@ -7,8 +7,6 @@ on:
     paths-ignore:
       - compiler/**
 
-permissions: {}
-
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
   cancel-in-progress: true
@@ -46,20 +44,17 @@ jobs:
         with:
           path: |
             **/node_modules
-          key: runtime-and-compiler-eslint_e2e-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock', 'fixtures/eslint-v*/yarn.lock') }}
+          key: runtime-and-compiler-eslint_e2e-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn --cwd compiler install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Install fixture dependencies
-        working-directory: ./fixtures/eslint-v${{ matrix.eslint_major }}
-        run: yarn --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - name: Build plugin
         working-directory: fixtures/eslint-v${{ matrix.eslint_major }}
         run: node build.mjs
+      - name: Install fixture dependencies
+        working-directory: ./fixtures/eslint-v${{ matrix.eslint_major }}
+        run: yarn --frozen-lockfile
       - name: Run lint test
         working-directory: ./fixtures/eslint-v${{ matrix.eslint_major }}
         run: yarn lint

.github/workflows/runtime_fuzz_tests.yml

@@ -8,8 +8,6 @@ on:
       - main
   workflow_dispatch:
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 

.github/workflows/runtime_prereleases.yml

@@ -14,26 +14,20 @@ on:
         required: true
         type: string
     secrets:
-      GH_TOKEN:
-        required: true
       NPM_TOKEN:
         required: true
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+  GH_TOKEN: ${{ github.token }}
   NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
 jobs:
   publish_prerelease:
     name: Publish prelease (${{ inputs.release_channel }}) ${{ inputs.commit_sha }} @${{ inputs.dist_tag }}
     runs-on: ubuntu-latest
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -51,10 +45,8 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        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: |
-          GH_TOKEN=${{ secrets.GH_TOKEN }} scripts/release/prepare-release-from-ci.js --skipTests -r ${{ inputs.release_channel }} --commit=${{ inputs.commit_sha }}
+          scripts/release/prepare-release-from-ci.js --skipTests -r ${{ inputs.release_channel }} --commit=${{ inputs.commit_sha }}
           cp ./scripts/release/ci-npmrc ~/.npmrc
           scripts/release/publish.js --ci --tags ${{ inputs.dist_tag }}

.github/workflows/runtime_prereleases_manual.yml

@@ -6,8 +6,6 @@ on:
       prerelease_commit_sha:
         required: true
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 
@@ -16,9 +14,6 @@ jobs:
   publish_prerelease_canary:
     name: Publish to Canary channel
     uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
     with:
       commit_sha: ${{ inputs.prerelease_commit_sha }}
       release_channel: stable
@@ -35,14 +30,10 @@ jobs:
       dist_tag: canary,next
     secrets:
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   publish_prerelease_experimental:
     name: Publish to Experimental channel
     uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
     # NOTE: Intentionally running these jobs sequentially because npm
     # will sometimes fail if you try to concurrently publish two
     # different versions of the same package, even if they use different
@@ -54,4 +45,3 @@ jobs:
       dist_tag: experimental
     secrets:
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/runtime_prereleases_nightly.yml

@@ -5,8 +5,6 @@ on:
     # At 10 minutes past 16:00 on Mon, Tue, Wed, Thu, and Fri
     - cron: 10 16 * * 1,2,3,4,5
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 
@@ -14,23 +12,16 @@ jobs:
   publish_prerelease_canary:
     name: Publish to Canary channel
     uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
     with:
       commit_sha: ${{ github.sha }}
       release_channel: stable
       dist_tag: canary,next
     secrets:
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   publish_prerelease_experimental:
     name: Publish to Experimental channel
     uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
     # NOTE: Intentionally running these jobs sequentially because npm
     # will sometimes fail if you try to concurrently publish two
     # different versions of the same package, even if they use different
@@ -42,4 +33,3 @@ jobs:
       dist_tag: experimental
     secrets:
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/runtime_releases_from_npm_manual.yml

@@ -31,12 +31,11 @@ on:
         type: boolean
         default: false
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+  GH_TOKEN: ${{ github.token }}
   NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
 jobs:
@@ -78,9 +77,7 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        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
       - if: '${{ inputs.only_packages }}'
         name: 'Prepare ${{ inputs.only_packages }} from NPM'

.github/workflows/shared_check_maintainer.yml

@@ -6,12 +6,14 @@ on:
       actor:
         required: true
         type: string
+      is_remote:
+        required: false
+        type: boolean
+        default: false
     outputs:
       is_core_team:
         value: ${{ jobs.check_maintainer.outputs.is_core_team }}
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -20,12 +22,10 @@ env:
 jobs:
   check_maintainer:
     runs-on: ubuntu-latest
-    permissions:
-      # We fetch the contents of the MAINTAINERS file
-      contents: read
     outputs:
       is_core_team: ${{ steps.check_if_actor_is_maintainer.outputs.result }}
     steps:
+      - uses: actions/checkout@v4
       - name: Check if actor is maintainer
         id: check_if_actor_is_maintainer
         uses: actions/github-script@v7
@@ -33,20 +33,33 @@ jobs:
           script: |
             const fs = require('fs');
             const actor = '${{ inputs.actor }}';
-            const res = await github.rest.repos.getContent({
-              owner: 'facebook',
-              repo: 'react',
-              path: 'MAINTAINERS',
-              ref: 'main',
-              headers: { Accept: 'application/vnd.github+json' }
-            });
-            if (res.status !== 200) {
-              console.error(res);
-              throw new Error('Unable to fetch MAINTAINERS file');
+            let isRemote = ${{ inputs.is_remote }};
+            if (typeof isRemote === 'string') {
+              isRemote = isRemote === 'true';
             }
-            content = Buffer.from(res.data.content, 'base64').toString();
-            if (content == null || typeof content !== 'string') {
-              throw new Error('Unable to retrieve MAINTAINERS file');
+            if (typeof isRemote !== 'boolean') {
+              throw new Error(`Invalid \`isRemote\` input. Expected a boolean, got: ${isRemote}`);
+            }
+
+            let content = null;
+            if (isRemote === true) {
+              const res = await github.rest.repos.getContent({
+                owner: 'facebook',
+                repo: 'react',
+                path: 'MAINTAINERS',
+                ref: 'main',
+                headers: { Accept: 'application/vnd.github+json' }
+              });
+              if (res.status !== 200) {
+                console.error(res);
+                throw new Error('Unable to fetch MAINTAINERS file');
+              }
+              content = Buffer.from(res.data.content, 'base64').toString();
+            } else {
+              content = await fs.readFileSync('./MAINTAINERS', { encoding: 'utf8' });
+            }
+            if (content === null) {
+              throw new Error('Unable to retrieve local or http MAINTAINERS file');
             }
 
             const maintainers = new Set(content.split('\n'));

.github/workflows/shared_cleanup_branch_caches.yml

@@ -1,17 +1,11 @@
 # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#force-deletion-of-caches-overriding-default-cache-eviction-policy
 
-name: (Shared) Cleanup Merged Branch Caches
+name: (Shared) Cleanup Branch Caches
 on:
   pull_request:
     types:
       - closed
   workflow_dispatch:
-    inputs:
-      pr_number:
-        required: true
-        type: string
-
-permissions: {}
 
 jobs:
   cleanup:
@@ -29,13 +23,13 @@ jobs:
 
           ## Setting this to not fail the workflow while deleting cache keys.
           set +e
+          echo "Deleting caches..."
           for cacheKey in $cacheKeysForPR
           do
               gh cache delete $cacheKey
-              echo "Deleting $cacheKey"
           done
           echo "Done"
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           GH_REPO: ${{ github.repository }}
-          BRANCH: refs/pull/${{ inputs.pr_number || github.event.pull_request.number }}/merge
+          BRANCH: refs/pull/${{ github.event.pull_request.number }}/merge

.github/workflows/shared_cleanup_stale_branch_caches.yml

@@ -1,36 +0,0 @@
-# https://github.com/actions/cache/blob/main/tips-and-workarounds.md#force-deletion-of-caches-overriding-default-cache-eviction-policy
-
-name: (Shared) Cleanup Stale Branch Caches
-on:
-  schedule:
-    # Every 6 hours
-    - cron: 0 */6 * * *
-  workflow_dispatch:
-
-permissions: {}
-
-jobs:
-  cleanup:
-    runs-on: ubuntu-latest
-    permissions:
-      # `actions:write` permission is required to delete caches
-      #   See also: https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28#delete-a-github-actions-cache-for-a-repository-using-a-cache-id
-      actions: write
-      contents: read
-    steps:
-      - name: Cleanup
-        run: |
-          echo "Fetching list of cache keys"
-          cacheKeysForPR=$(gh cache list --limit 100 --json id,ref --jq '.[] | select(.ref != "refs/heads/main") | .id')
-
-          ## Setting this to not fail the workflow while deleting cache keys.
-          set +e
-          for cacheKey in $cacheKeysForPR
-          do
-              gh cache delete $cacheKey
-              echo "Deleting $cacheKey"
-          done
-          echo "Done"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}

.github/workflows/shared_close_direct_sync_branch_prs.yml

@@ -5,8 +5,6 @@ on:
     branches:
       - 'builds/facebook-**'
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -15,9 +13,6 @@ env:
 jobs:
   close_pr:
     runs-on: ubuntu-latest
-    permissions:
-      # Used to create a review and close PRs
-      pull-requests: write
     steps:
       - name: Close PR
         uses: actions/github-script@v7

.github/workflows/shared_label_core_team_prs.yml

@@ -3,8 +3,6 @@ name: (Shared) Label Core Team PRs
 on:
   pull_request_target:
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
   # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -13,9 +11,6 @@ env:
 jobs:
   check_maintainer:
     uses: facebook/react/.github/workflows/shared_check_maintainer.yml@main
-    permissions:
-      # Used by check_maintainer
-      contents: read
     with:
       actor: ${{ github.event.pull_request.user.login }}
 
@@ -23,11 +18,6 @@ jobs:
     if: ${{ needs.check_maintainer.outputs.is_core_team == 'true' }}
     runs-on: ubuntu-latest
     needs: check_maintainer
-    permissions:
-      # Used to add labels on issues
-      issues: write
-      # Used to add labels on PRs
-      pull-requests: write
     steps:
       - name: Label PR as React Core Team
         uses: actions/github-script@v7

.github/workflows/shared_lint.yml

@@ -5,8 +5,6 @@ on:
     branches: [main]
   pull_request:
 
-permissions: {}
-
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
   cancel-in-progress: true
@@ -29,7 +27,6 @@ jobs:
           cache-dependency-path: yarn.lock
       - name: Restore cached node_modules
         uses: actions/cache@v4
-        id: node_modules
         with:
           path: |
             **/node_modules
@@ -37,7 +34,6 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: yarn prettier-check
 
   eslint:
@@ -52,7 +48,6 @@ jobs:
           cache-dependency-path: yarn.lock
       - name: Restore cached node_modules
         uses: actions/cache@v4
-        id: node_modules
         with:
           path: |
             **/node_modules
@@ -60,7 +55,6 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: node ./scripts/tasks/eslint
 
   check_license:
@@ -75,7 +69,6 @@ jobs:
           cache-dependency-path: yarn.lock
       - name: Restore cached node_modules
         uses: actions/cache@v4
-        id: node_modules
         with:
           path: |
             **/node_modules
@@ -83,7 +76,6 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: ./scripts/ci/check_license.sh
 
   test_print_warnings:
@@ -98,7 +90,6 @@ jobs:
           cache-dependency-path: yarn.lock
       - name: Restore cached node_modules
         uses: actions/cache@v4
-        id: node_modules
         with:
           path: |
             **/node_modules
@@ -106,5 +97,4 @@ jobs:
       - name: Ensure clean build directory
         run: rm -rf build
       - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
       - run: ./scripts/ci/test_print_warnings.sh

.github/workflows/shared_stale.yml

@@ -6,8 +6,6 @@ on:
     - cron: '0 * * * *'
   workflow_dispatch:
 
-permissions: {}
-
 env:
   TZ: /usr/share/zoneinfo/America/Los_Angeles
 

ReactVersions.js

@@ -33,7 +33,6 @@ const canaryChannelLabel = 'canary';
 const rcNumber = 0;
 
 const stablePackages = {
-  'eslint-plugin-react-hooks': '5.2.0',
   'jest-react': '0.17.0',
   react: ReactVersion,
   'react-art': ReactVersion,

babel.config-react-compiler.js

@@ -1,19 +0,0 @@
-'use strict';
-
-/**
- * HACK: @poteto React Compiler inlines Zod in its build artifact. Zod spreads values passed to .map
- * which causes issues in @babel/plugin-transform-spread in loose mode, as it will result in
- * {undefined: undefined} which fails to parse.
- *
- * [@babel/plugin-transform-block-scoping', {throwIfClosureRequired: true}] also causes issues with
- * the built version of the compiler. The minimal set of plugins needed for this file is reexported
- * from babel.config-ts.
- *
- * I will remove this hack later when we move eslint-plugin-react-hooks into the compiler directory.
- **/
-
-const baseConfig = require('./babel.config-ts');
-
-module.exports = {
-  plugins: baseConfig.plugins,
-};

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

@@ -19,9 +19,7 @@ import BabelPluginReactCompiler, {
   PluginOptions,
   CompilerPipelineValue,
   parsePluginOptions,
-  printReactiveFunctionWithOutlined,
-  printFunctionWithOutlined,
-} from 'babel-plugin-react-compiler';
+} from 'babel-plugin-react-compiler/src';
 import clsx from 'clsx';
 import invariant from 'invariant';
 import {useSnackbar} from 'notistack';
@@ -43,6 +41,8 @@ import {
   default as Output,
   PrintedCompilerPipelineValue,
 } from './Output';
+import {printFunctionWithOutlined} from 'babel-plugin-react-compiler/src/HIR/PrintHIR';
+import {printReactiveFunctionWithOutlined} from 'babel-plugin-react-compiler/src/ReactiveScopes/PrintReactiveFunction';
 import {transformFromAstSync} from '@babel/core';
 
 function parseInput(

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

@@ -6,7 +6,7 @@
  */
 
 import MonacoEditor, {loader, type Monaco} from '@monaco-editor/react';
-import {CompilerErrorDetail} from 'babel-plugin-react-compiler';
+import {CompilerErrorDetail} from 'babel-plugin-react-compiler/src';
 import invariant from 'invariant';
 import type {editor} from 'monaco-editor';
 import * as monaco from 'monaco-editor';

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

@@ -11,7 +11,7 @@ import {
   InformationCircleIcon,
 } from '@heroicons/react/outline';
 import MonacoEditor, {DiffEditor} from '@monaco-editor/react';
-import {type CompilerError} from 'babel-plugin-react-compiler';
+import {type CompilerError} from 'babel-plugin-react-compiler/src';
 import parserBabel from 'prettier/plugins/babel';
 import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettier from 'prettier/standalone';

compiler/apps/playground/lib/reactCompilerMonacoDiagnostics.ts

@@ -6,7 +6,10 @@
  */
 
 import {Monaco} from '@monaco-editor/react';
-import {CompilerErrorDetail, ErrorSeverity} from 'babel-plugin-react-compiler';
+import {
+  CompilerErrorDetail,
+  ErrorSeverity,
+} from 'babel-plugin-react-compiler/src';
 import {MarkerSeverity, type editor} from 'monaco-editor';
 
 function mapReactCompilerSeverityToMonaco(
@@ -51,7 +54,7 @@ export function renderReactCompilerMarkers({
   model,
   details,
 }: ReactCompilerMarkerConfig): void {
-  const markers: Array<editor.IMarkerData> = [];
+  let markers = [];
   for (const detail of details) {
     const marker = mapReactCompilerDiagnosticToMonacoMarker(detail, monaco);
     if (marker == null) {

compiler/apps/playground/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "scripts": {
     "dev": "cd ../.. && concurrently --kill-others -n compiler,runtime,playground \"yarn workspace babel-plugin-react-compiler run watch\" \"yarn workspace react-compiler-runtime run watch\" \"wait-on packages/babel-plugin-react-compiler/dist/index.js && cd apps/playground && NODE_ENV=development next dev\"",
-    "build:compiler": "cd ../.. && concurrently -n compiler,runtime \"yarn workspace babel-plugin-react-compiler run build --dts\" \"yarn workspace react-compiler-runtime run build\"",
+    "build:compiler": "cd ../.. && concurrently -n compiler,runtime \"yarn workspace babel-plugin-react-compiler run build\" \"yarn workspace react-compiler-runtime run build\"",
     "build": "yarn build:compiler && next build",
     "postbuild": "node ./scripts/downloadFonts.js",
     "preinstall": "cd ../.. && yarn install --frozen-lockfile",

compiler/packages/babel-plugin-react-compiler/package.json

@@ -12,12 +12,12 @@
     "build": "rimraf dist && tsup",
     "test": "./scripts/link-react-compiler-runtime.sh && yarn snap:ci",
     "jest": "yarn build && ts-node node_modules/.bin/jest",
-    "snap": "yarn workspace snap run snap",
+    "snap": "node ../snap/dist/main.js",
     "snap:build": "yarn workspace snap run build",
     "snap:ci": "yarn snap:build && yarn snap",
     "ts:analyze-trace": "scripts/ts-analyze-trace.sh",
-    "lint": "yarn eslint src",
-    "watch": "yarn build --dts --watch"
+    "lint": "../../node_modules/eslint-v8/bin/eslint.js src",
+    "watch": "yarn build --watch"
   },
   "dependencies": {
     "@babel/types": "^7.26.0"
@@ -43,7 +43,7 @@
     "babel-jest": "^29.0.3",
     "babel-plugin-fbt": "^1.0.0",
     "babel-plugin-fbt-runtime": "^1.0.0",
-    "eslint": "^8.57.1",
+    "eslint-v8": "npm:eslint@^8.57.1",
     "invariant": "^2.2.4",
     "jest": "^29.0.3",
     "jest-environment-jsdom": "^29.0.3",

compiler/packages/babel-plugin-react-compiler/scripts/jest/e2e-forget.config.js

@@ -7,4 +7,7 @@
 
 const makeE2EConfig = require('../jest/makeE2EConfig');
 
-module.exports = makeE2EConfig('e2e with forget', true);
+const config = makeE2EConfig('e2e with forget', true);
+config.setupFilesAfterEnv = ['<rootDir>/../scripts/jest/setupEnvE2E.js'];
+
+module.exports = config;

compiler/packages/babel-plugin-react-compiler/scripts/jest/makeTransform.ts

@@ -5,16 +5,19 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+import {jsx} from '@babel/plugin-syntax-jsx';
 import babelJest from 'babel-jest';
-import {
-  validateEnvironmentConfig,
-  EnvironmentConfig,
-} from 'babel-plugin-react-compiler';
+import {compile} from 'babel-plugin-react-compiler';
 import {execSync} from 'child_process';
 
 import type {NodePath, Visitor} from '@babel/traverse';
-import type {CallExpression} from '@babel/types';
-import BabelPluginReactCompiler from 'babel-plugin-react-compiler';
+import type {CallExpression, FunctionDeclaration} from '@babel/types';
+import * as t from '@babel/types';
+import {
+  EnvironmentConfig,
+  validateEnvironmentConfig,
+} from 'babel-plugin-react-compiler';
+import {basename} from 'path';
 
 /**
  * -- IMPORTANT --
@@ -25,19 +28,10 @@ import BabelPluginReactCompiler from 'babel-plugin-react-compiler';
 const e2eTransformerCacheKey = 1;
 const forgetOptions: EnvironmentConfig = validateEnvironmentConfig({
   enableAssumeHooksFollowRulesOfReact: true,
+  enableFunctionOutlining: false,
 });
 const debugMode = process.env['DEBUG_FORGET_COMPILER'] != null;
 
-const compilerCacheKey = execSync(
-  'yarn --silent --cwd ../.. hash packages/babel-plugin-react-compiler/dist',
-)
-  .toString()
-  .trim();
-
-if (debugMode) {
-  console.log('cachebreaker', compilerCacheKey);
-}
-
 module.exports = (useForget: boolean) => {
   function createTransformer() {
     return babelJest.createTransformer({
@@ -48,14 +42,15 @@ module.exports = (useForget: boolean) => {
           plugins: [
             useForget
               ? [
-                  BabelPluginReactCompiler,
+                  ReactForgetFunctionTransform,
                   {
-                    environment: forgetOptions,
                     /*
                      * Jest hashes the babel config as a cache breaker.
                      * (see https://github.com/jestjs/jest/blob/v29.6.2/packages/babel-jest/src/index.ts#L84)
                      */
-                    compilerCacheKey,
+                    compilerCacheKey: execSync(
+                      'yarn --silent --cwd ../.. hash packages/babel-plugin-react-compiler/dist',
+                    ).toString(),
                     transformOptionsCacheKey: forgetOptions,
                     e2eTransformerCacheKey,
                   },
@@ -110,3 +105,104 @@ module.exports = (useForget: boolean) => {
     createTransformer,
   };
 };
+
+// Mostly copied from react/scripts/babel/transform-forget.js
+function isReactComponentLike(fn: NodePath<FunctionDeclaration>): boolean {
+  let isReactComponent = false;
+  let hasNoUseForgetDirective = false;
+
+  /*
+   * React components start with an upper case letter,
+   * React hooks start with `use`
+   */
+  if (
+    fn.node.id == null ||
+    (fn.node.id.name[0].toUpperCase() !== fn.node.id.name[0] &&
+      !/^use[A-Z0-9]/.test(fn.node.id.name))
+  ) {
+    return false;
+  }
+
+  fn.traverse({
+    DirectiveLiteral(path) {
+      if (path.node.value === 'use no forget') {
+        hasNoUseForgetDirective = true;
+      }
+    },
+
+    JSX(path) {
+      // Is there is a JSX node created in the current function context?
+      if (path.scope.getFunctionParent()?.path.node === fn.node) {
+        isReactComponent = true;
+      }
+    },
+
+    CallExpression(path) {
+      // Is there hook usage?
+      if (
+        path.node.callee.type === 'Identifier' &&
+        !/^use[A-Z0-9]/.test(path.node.callee.name)
+      ) {
+        isReactComponent = true;
+      }
+    },
+  });
+
+  if (hasNoUseForgetDirective) {
+    return false;
+  }
+
+  return isReactComponent;
+}
+
+function ReactForgetFunctionTransform() {
+  const compiledFns = new Set();
+  const visitor = {
+    FunctionDeclaration(fn: NodePath<FunctionDeclaration>, state: any): void {
+      if (compiledFns.has(fn.node)) {
+        return;
+      }
+
+      if (!isReactComponentLike(fn)) {
+        return;
+      }
+      if (debugMode) {
+        const filename = basename(state.file.opts.filename);
+        if (fn.node.loc && fn.node.id) {
+          console.log(
+            ` Compiling ${filename}:${fn.node.loc.start.line}:${fn.node.loc.start.column}  ${fn.node.id.name}`,
+          );
+        } else {
+          console.log(` Compiling ${filename} ${fn.node.id?.name}`);
+        }
+      }
+
+      const compiled = compile(
+        fn,
+        forgetOptions,
+        'Other',
+        'all_features',
+        '_c',
+        null,
+        null,
+        null,
+      );
+      compiledFns.add(compiled);
+
+      const fun = t.functionDeclaration(
+        compiled.id,
+        compiled.params,
+        compiled.body,
+        compiled.generator,
+        compiled.async,
+      );
+      fn.replaceWith(fun);
+      fn.skip();
+    },
+  };
+  return {
+    name: 'react-forget-e2e',
+    inherits: jsx,
+    visitor,
+  };
+}

compiler/packages/babel-plugin-react-compiler/scripts/jest/setupEnvE2E.js

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+
+const ReactCompilerRuntime = require('react/compiler-runtime');
+
+/*
+ * Our e2e babel transform currently only compiles functions, not programs.
+ * As a result, our e2e transpiled code does not contain an import for the
+ * memo cache function. As a temporary hack, we add a `_c` global, which is
+ * the name that is used for the import by default.
+ */
+globalThis._c = ReactCompilerRuntime.c;

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

@@ -73,7 +73,7 @@ export default function BabelPluginReactCompiler(
             pass.filename ?? null,
             opts.logger,
             opts.environment,
-            result,
+            result?.retryErrors ?? [],
           );
           if (ENABLE_REACT_COMPILER_TIMINGS === true) {
             performance.mark(`${filename}:end`, {

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

@@ -6,7 +6,6 @@
  */
 
 import type {SourceLocation} from './HIR';
-import {Err, Ok, Result} from './Utils/Result';
 import {assertExhaustive} from './Utils/utils';
 
 export enum ErrorSeverity {
@@ -225,10 +224,6 @@ export class CompilerError extends Error {
     return this.details.length > 0;
   }
 
-  asResult(): Result<void, CompilerError> {
-    return this.hasErrors() ? Err(this) : Ok(undefined);
-  }
-
   /*
    * An error is critical if it means the compiler has entered into a broken state and cannot
    * continue safely. Other expected errors such as Todos mean that we can skip over that component

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

@@ -7,9 +7,8 @@
 
 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
+import {PluginOptions} from './Options';
 import {CompilerError} from '../CompilerError';
-import {ProgramContext} from './Imports';
-import {ExternalFunction} from '..';
 
 /**
  * Gating rewrite for function declarations which are referenced before their
@@ -35,8 +34,7 @@ import {ExternalFunction} from '..';
 function insertAdditionalFunctionDeclaration(
   fnPath: NodePath<t.FunctionDeclaration>,
   compiled: t.FunctionDeclaration,
-  programContext: ProgramContext,
-  gatingFunctionIdentifierName: string,
+  gating: NonNullable<PluginOptions['gating']>,
 ): void {
   const originalFnName = fnPath.node.id;
   const originalFnParams = fnPath.node.params;
@@ -59,14 +57,14 @@ function insertAdditionalFunctionDeclaration(
     loc: fnPath.node.loc ?? null,
   });
 
-  const gatingCondition = t.identifier(
-    programContext.newUid(`${gatingFunctionIdentifierName}_result`),
+  const gatingCondition = fnPath.scope.generateUidIdentifier(
+    `${gating.importSpecifierName}_result`,
   );
-  const unoptimizedFnName = t.identifier(
-    programContext.newUid(`${originalFnName.name}_unoptimized`),
+  const unoptimizedFnName = fnPath.scope.generateUidIdentifier(
+    `${originalFnName.name}_unoptimized`,
   );
-  const optimizedFnName = t.identifier(
-    programContext.newUid(`${originalFnName.name}_optimized`),
+  const optimizedFnName = fnPath.scope.generateUidIdentifier(
+    `${originalFnName.name}_optimized`,
   );
   /**
    * Step 1: rename existing functions
@@ -117,7 +115,7 @@ function insertAdditionalFunctionDeclaration(
     t.variableDeclaration('const', [
       t.variableDeclarator(
         gatingCondition,
-        t.callExpression(t.identifier(gatingFunctionIdentifierName), []),
+        t.callExpression(t.identifier(gating.importSpecifierName), []),
       ),
     ]),
   );
@@ -131,26 +129,19 @@ export function insertGatedFunctionDeclaration(
     | t.FunctionDeclaration
     | t.ArrowFunctionExpression
     | t.FunctionExpression,
-  programContext: ProgramContext,
-  gating: ExternalFunction,
+  gating: NonNullable<PluginOptions['gating']>,
   referencedBeforeDeclaration: boolean,
 ): void {
-  const gatingImportedName = programContext.addImportSpecifier(gating).name;
   if (referencedBeforeDeclaration && fnPath.isFunctionDeclaration()) {
     CompilerError.invariant(compiled.type === 'FunctionDeclaration', {
       reason: 'Expected compiled node type to match input type',
       description: `Got ${compiled.type} but expected FunctionDeclaration`,
       loc: fnPath.node.loc ?? null,
     });
-    insertAdditionalFunctionDeclaration(
-      fnPath,
-      compiled,
-      programContext,
-      gatingImportedName,
-    );
+    insertAdditionalFunctionDeclaration(fnPath, compiled, gating);
   } else {
     const gatingExpression = t.conditionalExpression(
-      t.callExpression(t.identifier(gatingImportedName), []),
+      t.callExpression(t.identifier(gating.importSpecifierName), []),
       buildFunctionExpression(compiled),
       buildFunctionExpression(fnPath.node),
     );

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

@@ -7,19 +7,9 @@
 
 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
-import {Scope as BabelScope} from '@babel/traverse';
-
 import {CompilerError, ErrorSeverity} from '../CompilerError';
-import {
-  EnvironmentConfig,
-  GeneratedSource,
-  NonLocalImportSpecifier,
-} from '../HIR';
-import {getOrInsertWith} from '../Utils/utils';
-import {ExternalFunction, isHookName} from '../HIR/Environment';
-import {Err, Ok, Result} from '../Utils/Result';
-import {CompilerReactTarget} from './Options';
-import {getReactCompilerRuntimeModule} from './Program';
+import {EnvironmentConfig, ExternalFunction, GeneratedSource} from '../HIR';
+import {getOrInsertDefault} from '../Utils/utils';
 
 export function validateRestrictedImports(
   path: NodePath<t.Program>,
@@ -52,209 +42,50 @@ export function validateRestrictedImports(
   }
 }
 
-export class ProgramContext {
-  /* Program and environment context */
-  scope: BabelScope;
-  reactRuntimeModule: string;
-  hookPattern: string | null;
-
-  // known generated or referenced identifiers in the program
-  knownReferencedNames: Set<string> = new Set();
-  // generated imports
-  imports: Map<string, Map<string, NonLocalImportSpecifier>> = new Map();
-
-  constructor(
-    program: NodePath<t.Program>,
-    reactRuntimeModule: CompilerReactTarget,
-    hookPattern: string | null,
-  ) {
-    this.hookPattern = hookPattern;
-    this.scope = program.scope;
-    this.reactRuntimeModule = getReactCompilerRuntimeModule(reactRuntimeModule);
-  }
-
-  isHookName(name: string): boolean {
-    if (this.hookPattern == null) {
-      return isHookName(name);
-    } else {
-      const match = new RegExp(this.hookPattern).exec(name);
-      return (
-        match != null && typeof match[1] === 'string' && isHookName(match[1])
-      );
-    }
-  }
-
-  hasReference(name: string): boolean {
-    return (
-      this.knownReferencedNames.has(name) ||
-      this.scope.hasBinding(name) ||
-      this.scope.hasGlobal(name) ||
-      this.scope.hasReference(name)
-    );
-  }
-
-  newUid(name: string): string {
-    /**
-     * Don't call babel's generateUid for known hook imports, as
-     * InferTypes might eventually type `HookKind` based on callee naming
-     * convention and `_useFoo` is not named as a hook.
-     *
-     * Local uid generation is susceptible to check-before-use bugs since we're
-     * checking for naming conflicts / references long before we actually insert
-     * the import. (see similar logic in HIRBuilder:resolveBinding)
-     */
-    let uid;
-    if (this.isHookName(name)) {
-      uid = name;
-      let i = 0;
-      while (this.hasReference(uid)) {
-        this.knownReferencedNames.add(uid);
-        uid = `${name}_${i++}`;
-      }
-    } else if (!this.hasReference(name)) {
-      uid = name;
-    } else {
-      uid = this.scope.generateUid(name);
-    }
-    this.knownReferencedNames.add(uid);
-    return uid;
-  }
-
-  addMemoCacheImport(): NonLocalImportSpecifier {
-    return this.addImportSpecifier(
-      {
-        source: this.reactRuntimeModule,
-        importSpecifierName: 'c',
-      },
-      '_c',
-    );
-  }
-
-  /**
-   *
-   * @param externalFunction
-   * @param nameHint if defined, will be used as the name of the import specifier
-   * @returns
-   */
-  addImportSpecifier(
-    {source: module, importSpecifierName: specifier}: ExternalFunction,
-    nameHint?: string,
-  ): NonLocalImportSpecifier {
-    const maybeBinding = this.imports.get(module)?.get(specifier);
-    if (maybeBinding != null) {
-      return {...maybeBinding};
-    }
-
-    const binding: NonLocalImportSpecifier = {
-      kind: 'ImportSpecifier',
-      name: this.newUid(nameHint ?? specifier),
-      module,
-      imported: specifier,
-    };
-    getOrInsertWith(this.imports, module, () => new Map()).set(specifier, {
-      ...binding,
-    });
-    return binding;
-  }
-
-  addNewReference(name: string): void {
-    this.knownReferencedNames.add(name);
-  }
-
-  assertGlobalBinding(
-    name: string,
-    localScope?: BabelScope,
-  ): Result<void, CompilerError> {
-    const scope = localScope ?? this.scope;
-    if (!scope.hasReference(name) && !scope.hasBinding(name)) {
-      return Ok(undefined);
-    }
-    const error = new CompilerError();
-    error.push({
-      severity: ErrorSeverity.Todo,
-      reason: 'Encountered conflicting global in generated program',
-      description: `Conflict from local binding ${name}`,
-      loc: scope.getBinding(name)?.path.node.loc ?? null,
-      suggestions: null,
-    });
-    return Err(error);
-  }
-}
-
-function getExistingImports(
-  program: NodePath<t.Program>,
-): Map<string, NodePath<t.ImportDeclaration>> {
-  const existingImports = new Map<string, NodePath<t.ImportDeclaration>>();
-  program.traverse({
-    ImportDeclaration(path) {
-      if (isNonNamespacedImport(path)) {
-        existingImports.set(path.node.source.value, path);
-      }
-    },
-  });
-  return existingImports;
-}
-
 export function addImportsToProgram(
   path: NodePath<t.Program>,
-  programContext: ProgramContext,
+  importList: Array<ExternalFunction>,
 ): void {
-  const existingImports = getExistingImports(path);
+  const identifiers: Set<string> = new Set();
+  const sortedImports: Map<string, Array<string>> = new Map();
+  for (const {importSpecifierName, source} of importList) {
+    /*
+     * Codegen currently does not rename import specifiers, so we do additional
+     * validation here
+     */
+    CompilerError.invariant(identifiers.has(importSpecifierName) === false, {
+      reason: `Encountered conflicting import specifier for ${importSpecifierName} in Forget config.`,
+      description: null,
+      loc: GeneratedSource,
+      suggestions: null,
+    });
+    CompilerError.invariant(
+      path.scope.hasBinding(importSpecifierName) === false,
+      {
+        reason: `Encountered conflicting import specifiers for ${importSpecifierName} in generated program.`,
+        description: null,
+        loc: GeneratedSource,
+        suggestions: null,
+      },
+    );
+    identifiers.add(importSpecifierName);
+
+    const importSpecifierNameList = getOrInsertDefault(
+      sortedImports,
+      source,
+      [],
+    );
+    importSpecifierNameList.push(importSpecifierName);
+  }
+
   const stmts: Array<t.ImportDeclaration> = [];
-  const sortedModules = [...programContext.imports.entries()].sort(([a], [b]) =>
-    a.localeCompare(b),
-  );
-  for (const [moduleName, importsMap] of sortedModules) {
-    for (const [specifierName, loweredImport] of importsMap) {
-      /**
-       * Assert that the import identifier hasn't already be declared in the program.
-       * Note: we use getBinding here since `Scope.hasBinding` pessimistically returns true
-       * for all allocated uids (from `Scope.getUid`)
-       */
-      CompilerError.invariant(
-        path.scope.getBinding(loweredImport.name) == null,
-        {
-          reason:
-            'Encountered conflicting import specifiers in generated program',
-          description: `Conflict from import ${loweredImport.module}:(${loweredImport.imported} as ${loweredImport.name}).`,
-          loc: GeneratedSource,
-          suggestions: null,
-        },
-      );
-      CompilerError.invariant(
-        loweredImport.module === moduleName &&
-          loweredImport.imported === specifierName,
-        {
-          reason:
-            'Found inconsistent import specifier. This is an internal bug.',
-          description: `Expected import ${moduleName}:${specifierName} but found ${loweredImport.module}:${loweredImport.imported}`,
-          loc: GeneratedSource,
-        },
-      );
-    }
-    const sortedImport: Array<NonLocalImportSpecifier> = [
-      ...importsMap.values(),
-    ].sort(({imported: a}, {imported: b}) => a.localeCompare(b));
-    const importSpecifiers = sortedImport.map(specifier => {
-      return t.importSpecifier(
-        t.identifier(specifier.name),
-        t.identifier(specifier.imported),
-      );
+  for (const [source, importSpecifierNameList] of sortedImports) {
+    const importSpecifiers = importSpecifierNameList.map(name => {
+      const id = t.identifier(name);
+      return t.importSpecifier(id, id);
     });
 
-    /**
-     * If an existing import of this module exists (ie `import { ... } from
-     * '<moduleName>'`), inject new imported specifiers into the list of
-     * destructured variables.
-     */
-    const maybeExistingImports = existingImports.get(moduleName);
-    if (maybeExistingImports != null) {
-      maybeExistingImports.pushContainer('specifiers', importSpecifiers);
-    } else {
-      stmts.push(
-        t.importDeclaration(importSpecifiers, t.stringLiteral(moduleName)),
-      );
-    }
+    stmts.push(t.importDeclaration(importSpecifiers, t.stringLiteral(source)));
   }
   path.unshiftContainer('body', stmts);
 }
@@ -262,12 +93,13 @@ export function addImportsToProgram(
 /*
  * Matches `import { ... } from <moduleName>;`
  * but not `import * as React from <moduleName>;`
- *         `import type { Foo } from <moduleName>;`
  */
 function isNonNamespacedImport(
   importDeclPath: NodePath<t.ImportDeclaration>,
+  moduleName: string,
 ): boolean {
   return (
+    importDeclPath.get('source').node.value === moduleName &&
     importDeclPath
       .get('specifiers')
       .every(specifier => specifier.isImportSpecifier()) &&
@@ -275,3 +107,94 @@ function isNonNamespacedImport(
     importDeclPath.node.importKind !== 'typeof'
   );
 }
+
+function hasExistingNonNamespacedImportOfModule(
+  program: NodePath<t.Program>,
+  moduleName: string,
+): boolean {
+  let hasExistingImport = false;
+  program.traverse({
+    ImportDeclaration(importDeclPath) {
+      if (isNonNamespacedImport(importDeclPath, moduleName)) {
+        hasExistingImport = true;
+      }
+    },
+  });
+
+  return hasExistingImport;
+}
+
+/*
+ * If an existing import of React exists (ie `import { ... } from '<moduleName>'`), inject useMemoCache
+ * into the list of destructured variables.
+ */
+function addMemoCacheFunctionSpecifierToExistingImport(
+  program: NodePath<t.Program>,
+  moduleName: string,
+  identifierName: string,
+): boolean {
+  let didInsertUseMemoCache = false;
+  program.traverse({
+    ImportDeclaration(importDeclPath) {
+      if (
+        !didInsertUseMemoCache &&
+        isNonNamespacedImport(importDeclPath, moduleName)
+      ) {
+        importDeclPath.pushContainer(
+          'specifiers',
+          t.importSpecifier(t.identifier(identifierName), t.identifier('c')),
+        );
+        didInsertUseMemoCache = true;
+      }
+    },
+  });
+  return didInsertUseMemoCache;
+}
+
+export function updateMemoCacheFunctionImport(
+  program: NodePath<t.Program>,
+  moduleName: string,
+  useMemoCacheIdentifier: string,
+): void {
+  /*
+   * If there isn't already an import of * as React, insert it so useMemoCache doesn't
+   * throw
+   */
+  const hasExistingImport = hasExistingNonNamespacedImportOfModule(
+    program,
+    moduleName,
+  );
+
+  if (hasExistingImport) {
+    const didUpdateImport = addMemoCacheFunctionSpecifierToExistingImport(
+      program,
+      moduleName,
+      useMemoCacheIdentifier,
+    );
+    if (!didUpdateImport) {
+      throw new Error(
+        `Expected an ImportDeclaration of \`${moduleName}\` in order to update ImportSpecifiers with useMemoCache`,
+      );
+    }
+  } else {
+    addMemoCacheFunctionImportDeclaration(
+      program,
+      moduleName,
+      useMemoCacheIdentifier,
+    );
+  }
+}
+
+function addMemoCacheFunctionImportDeclaration(
+  program: NodePath<t.Program>,
+  moduleName: string,
+  localName: string,
+): void {
+  program.unshiftContainer(
+    'body',
+    t.importDeclaration(
+      [t.importSpecifier(t.identifier(localName), t.identifier('c'))],
+      t.stringLiteral(moduleName),
+    ),
+  );
+}

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

@@ -8,7 +8,7 @@
 import {NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
 import prettyFormat from 'pretty-format';
-import {Logger, ProgramContext} from '.';
+import {Logger} from '.';
 import {
   HIRFunction,
   ReactiveFunction,
@@ -100,9 +100,8 @@ import {propagateScopeDependenciesHIR} from '../HIR/PropagateScopeDependenciesHI
 import {outlineJSX} from '../Optimization/OutlineJsx';
 import {optimizePropsMethodCalls} from '../Optimization/OptimizePropsMethodCalls';
 import {transformFire} from '../Transform';
-import {validateNoImpureFunctionsInRender} from '../Validation/ValidateNoImpureFunctionsInRender';
+import {validateNoImpureFunctionsInRender} from '../Validation/ValiateNoImpureFunctionsInRender';
 import {CompilerError} from '..';
-import {validateStaticComponents} from '../Validation/ValidateStaticComponents';
 
 export type CompilerPipelineValue =
   | {kind: 'ast'; name: string; value: CodegenFunction}
@@ -117,7 +116,7 @@ function run(
   config: EnvironmentConfig,
   fnType: ReactFunctionType,
   mode: CompilerMode,
-  programContext: ProgramContext,
+  useMemoCacheIdentifier: string,
   logger: Logger | null,
   filename: string | null,
   code: string | null,
@@ -132,7 +131,7 @@ function run(
     logger,
     filename,
     code,
-    programContext,
+    useMemoCacheIdentifier,
   );
   env.logger?.debugLogIRs?.({
     kind: 'debug',
@@ -162,7 +161,7 @@ function runWithEnvironment(
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
   validateContextVariableLValues(hir);
-  validateUseMemo(hir).unwrap();
+  validateUseMemo(hir);
 
   if (
     env.isInferredMemoEnabled &&
@@ -203,10 +202,10 @@ function runWithEnvironment(
 
   if (env.isInferredMemoEnabled) {
     if (env.config.validateHooksUsage) {
-      validateHooksUsage(hir).unwrap();
+      validateHooksUsage(hir);
     }
     if (env.config.validateNoCapitalizedCalls) {
-      validateNoCapitalizedCalls(hir).unwrap();
+      validateNoCapitalizedCalls(hir);
     }
   }
 
@@ -256,23 +255,23 @@ function runWithEnvironment(
     }
 
     if (env.config.validateRefAccessDuringRender) {
-      validateNoRefAccessInRender(hir).unwrap();
+      validateNoRefAccessInRender(hir);
     }
 
     if (env.config.validateNoSetStateInRender) {
-      validateNoSetStateInRender(hir).unwrap();
+      validateNoSetStateInRender(hir);
     }
 
     if (env.config.validateNoSetStateInPassiveEffects) {
-      env.logErrors(validateNoSetStateInPassiveEffects(hir));
+      validateNoSetStateInPassiveEffects(hir);
     }
 
     if (env.config.validateNoJSXInTryStatements) {
-      env.logErrors(validateNoJSXInTryStatement(hir));
+      validateNoJSXInTryStatement(hir);
     }
 
     if (env.config.validateNoImpureFunctionsInRender) {
-      validateNoImpureFunctionsInRender(hir).unwrap();
+      validateNoImpureFunctionsInRender(hir);
     }
   }
 
@@ -294,10 +293,6 @@ function runWithEnvironment(
   });
 
   if (env.isInferredMemoEnabled) {
-    if (env.config.validateStaticComponents) {
-      env.logErrors(validateStaticComponents(hir));
-    }
-
     /**
      * Only create reactive scopes (which directly map to generated memo blocks)
      * if inferred memoization is enabled. This makes all later passes which
@@ -514,14 +509,14 @@ function runWithEnvironment(
   });
 
   if (env.config.validateMemoizedEffectDependencies) {
-    validateMemoizedEffectDependencies(reactiveFunction).unwrap();
+    validateMemoizedEffectDependencies(reactiveFunction);
   }
 
   if (
     env.config.enablePreserveExistingMemoizationGuarantees ||
     env.config.validatePreserveExistingMemoizationGuarantees
   ) {
-    validatePreservedManualMemoization(reactiveFunction).unwrap();
+    validatePreservedManualMemoization(reactiveFunction);
   }
 
   const ast = codegenFunction(reactiveFunction, {
@@ -552,7 +547,7 @@ export function compileFn(
   config: EnvironmentConfig,
   fnType: ReactFunctionType,
   mode: CompilerMode,
-  programContext: ProgramContext,
+  useMemoCacheIdentifier: string,
   logger: Logger | null,
   filename: string | null,
   code: string | null,
@@ -562,7 +557,7 @@ export function compileFn(
     config,
     fnType,
     mode,
-    programContext,
+    useMemoCacheIdentifier,
     logger,
     filename,
     code,

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

@@ -12,7 +12,11 @@ import {
   CompilerErrorDetail,
   ErrorSeverity,
 } from '../CompilerError';
-import {EnvironmentConfig, ReactFunctionType} from '../HIR/Environment';
+import {
+  EnvironmentConfig,
+  ExternalFunction,
+  ReactFunctionType,
+} from '../HIR/Environment';
 import {CodegenFunction} from '../ReactiveScopes';
 import {isComponentDeclaration} from '../Utils/ComponentDeclaration';
 import {isHookDeclaration} from '../Utils/HookDeclaration';
@@ -20,17 +24,16 @@ import {assertExhaustive} from '../Utils/utils';
 import {insertGatedFunctionDeclaration} from './Gating';
 import {
   addImportsToProgram,
-  ProgramContext,
+  updateMemoCacheFunctionImport,
   validateRestrictedImports,
 } from './Imports';
-import {CompilerReactTarget, PluginOptions} from './Options';
+import {PluginOptions} from './Options';
 import {compileFn} from './Pipeline';
 import {
   filterSuppressionsThatAffectFunction,
   findProgramSuppressions,
   suppressionsToCompilerError,
 } from './Suppression';
-import {GeneratedSource} from '../HIR';
 
 export type CompilerPass = {
   opts: PluginOptions;
@@ -268,9 +271,8 @@ function isFilePartOfSources(
   return false;
 }
 
-export type CompileProgramResult = {
+type CompileProgramResult = {
   retryErrors: Array<{fn: BabelFn; error: CompilerError}>;
-  inferredEffectLocations: Set<t.SourceLocation>;
 };
 /**
  * `compileProgram` is directly invoked by the react-compiler babel plugin, so
@@ -297,12 +299,8 @@ export function compileProgram(
     handleError(restrictedImportsErr, pass, null);
     return null;
   }
+  const useMemoCacheIdentifier = program.scope.generateUidIdentifier('c');
 
-  const programContext = new ProgramContext(
-    program,
-    pass.opts.target,
-    environment.hookPattern,
-  );
   /*
    * Record lint errors and critical errors as depending on Forget's config,
    * we may still need to run Forget's analysis on every function (even if we
@@ -371,7 +369,6 @@ export function compileProgram(
     },
   );
   const retryErrors: Array<{fn: BabelFn; error: CompilerError}> = [];
-  const inferredEffectLocations = new Set<t.SourceLocation>();
   const processFn = (
     fn: BabelFn,
     fnType: ReactFunctionType,
@@ -413,7 +410,7 @@ export function compileProgram(
             environment,
             fnType,
             'all_features',
-            programContext,
+            useMemoCacheIdentifier.name,
             pass.opts.logger,
             pass.filename,
             pass.code,
@@ -448,18 +445,12 @@ export function compileProgram(
             environment,
             fnType,
             'no_inferred_memo',
-            programContext,
+            useMemoCacheIdentifier.name,
             pass.opts.logger,
             pass.filename,
             pass.code,
           ),
         };
-        if (
-          !compileResult.compiledFn.hasFireRewrite &&
-          !compileResult.compiledFn.hasInferredEffect
-        ) {
-          return null;
-        }
       } catch (err) {
         // TODO: we might want to log error here, but this will also result in duplicate logging
         if (err instanceof CompilerError) {
@@ -512,14 +503,6 @@ export function compileProgram(
     if (!pass.opts.noEmit) {
       return compileResult.compiledFn;
     }
-    /**
-     * inferEffectDependencies + noEmit is currently only used for linting. In
-     * this mode, add source locations for where the compiler *can* infer effect
-     * dependencies.
-     */
-    for (const loc of compileResult.compiledFn.inferredEffectLocations) {
-      if (loc !== GeneratedSource) inferredEffectLocations.add(loc);
-    }
     return null;
   };
 
@@ -565,29 +548,79 @@ export function compileProgram(
   if (moduleScopeOptOutDirectives.length > 0) {
     return null;
   }
+  let gating: null | {
+    gatingFn: ExternalFunction;
+    referencedBeforeDeclared: Set<CompileResult>;
+  } = null;
+  if (pass.opts.gating != null) {
+    gating = {
+      gatingFn: pass.opts.gating,
+      referencedBeforeDeclared:
+        getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns),
+    };
+  }
+
+  const hasLoweredContextAccess = compiledFns.some(
+    c => c.compiledFn.hasLoweredContextAccess,
+  );
+  const externalFunctions: Array<ExternalFunction> = [];
+  try {
+    // TODO: check for duplicate import specifiers
+    if (gating != null) {
+      externalFunctions.push(gating.gatingFn);
+    }
+
+    const lowerContextAccess = environment.lowerContextAccess;
+    if (lowerContextAccess && hasLoweredContextAccess) {
+      externalFunctions.push(lowerContextAccess);
+    }
+
+    const enableEmitInstrumentForget = environment.enableEmitInstrumentForget;
+    if (enableEmitInstrumentForget != null) {
+      externalFunctions.push(enableEmitInstrumentForget.fn);
+      if (enableEmitInstrumentForget.gating != null) {
+        externalFunctions.push(enableEmitInstrumentForget.gating);
+      }
+    }
+
+    if (environment.enableEmitFreeze != null) {
+      externalFunctions.push(environment.enableEmitFreeze);
+    }
+
+    if (environment.enableEmitHookGuards != null) {
+      externalFunctions.push(environment.enableEmitHookGuards);
+    }
+
+    if (environment.enableChangeDetectionForDebugging != null) {
+      externalFunctions.push(environment.enableChangeDetectionForDebugging);
+    }
+
+    const hasFireRewrite = compiledFns.some(c => c.compiledFn.hasFireRewrite);
+    if (environment.enableFire && hasFireRewrite) {
+      externalFunctions.push({
+        source: getReactCompilerRuntimeModule(pass.opts),
+        importSpecifierName: 'useFire',
+      });
+    }
+  } catch (err) {
+    handleError(err, pass, null);
+    return null;
+  }
+
   /*
    * Only insert Forget-ified functions if we have not encountered a critical
    * error elsewhere in the file, regardless of bailout mode.
    */
-  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);
 
-    if (referencedBeforeDeclared != null && kind === 'original') {
-      CompilerError.invariant(pass.opts.gating != null, {
-        reason: "Expected 'gating' import to be present",
-        loc: null,
-      });
+    if (gating != null && kind === 'original') {
       insertGatedFunctionDeclaration(
         originalFn,
         transformedFn,
-        programContext,
-        pass.opts.gating,
-        referencedBeforeDeclared.has(result),
+        gating.gatingFn,
+        gating.referencedBeforeDeclared.has(result),
       );
     } else {
       originalFn.replaceWith(transformedFn);
@@ -596,9 +629,24 @@ export function compileProgram(
 
   // Forget compiled the component, we need to update existing imports of useMemoCache
   if (compiledFns.length > 0) {
-    addImportsToProgram(program, programContext);
+    let needsMemoCacheFunctionImport = false;
+    for (const fn of compiledFns) {
+      if (fn.compiledFn.memoSlotsUsed > 0) {
+        needsMemoCacheFunctionImport = true;
+        break;
+      }
+    }
+
+    if (needsMemoCacheFunctionImport) {
+      updateMemoCacheFunctionImport(
+        program,
+        getReactCompilerRuntimeModule(pass.opts),
+        useMemoCacheIdentifier.name,
+      );
+    }
+    addImportsToProgram(program, externalFunctions);
   }
-  return {retryErrors, inferredEffectLocations};
+  return {retryErrors};
 }
 
 function shouldSkipCompilation(
@@ -629,7 +677,7 @@ function shouldSkipCompilation(
   if (
     hasMemoCacheFunctionImport(
       program,
-      getReactCompilerRuntimeModule(pass.opts.target),
+      getReactCompilerRuntimeModule(pass.opts),
     )
   ) {
     return true;
@@ -954,39 +1002,31 @@ function callsHooksOrCreatesJsx(
   return invokesHooks || createsJsx;
 }
 
-function isNonNode(node?: t.Expression | null): boolean {
-  if (!node) {
-    return true;
-  }
-  switch (node.type) {
-    case 'ObjectExpression':
-    case 'ArrowFunctionExpression':
-    case 'FunctionExpression':
-    case 'BigIntLiteral':
-    case 'ClassExpression':
-    case 'NewExpression': // technically `new Array()` is legit, but unlikely
-      return true;
-  }
-  return false;
-}
-
 function returnsNonNode(
   node: NodePath<
     t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression
   >,
 ): boolean {
+  let hasReturn = false;
   let returnsNonNode = false;
-  if (
-    // node.traverse#ArrowFunctionExpression isn't called for the root node
-    node.type === 'ArrowFunctionExpression' &&
-    node.node.body.type !== 'BlockStatement'
-  ) {
-    returnsNonNode = isNonNode(node.node.body);
-  }
 
   node.traverse({
     ReturnStatement(ret) {
-      returnsNonNode = isNonNode(ret.node.argument);
+      hasReturn = true;
+      const argument = ret.node.argument;
+      if (argument == null) {
+        returnsNonNode = true;
+      } else {
+        switch (argument.type) {
+          case 'ObjectExpression':
+          case 'ArrowFunctionExpression':
+          case 'FunctionExpression':
+          case 'BigIntLiteral':
+          case 'ClassExpression':
+          case 'NewExpression': // technically `new Array()` is legit, but unlikely
+            returnsNonNode = true;
+        }
+      }
     },
     // Skip traversing all nested functions and their return statements
     ArrowFunctionExpression: skipNestedFunctions(node),
@@ -995,7 +1035,7 @@ function returnsNonNode(
     ObjectMethod: node => node.skip(),
   });
 
-  return returnsNonNode;
+  return !hasReturn || returnsNonNode;
 }
 
 /*
@@ -1123,18 +1163,16 @@ function getFunctionReferencedBeforeDeclarationAtTopLevel(
   return referencedBeforeDeclaration;
 }
 
-export function getReactCompilerRuntimeModule(
-  target: CompilerReactTarget,
-): string {
-  if (target === '19') {
+function getReactCompilerRuntimeModule(opts: PluginOptions): string {
+  if (opts.target === '19') {
     return 'react/compiler-runtime'; // from react namespace
-  } else if (target === '17' || target === '18') {
+  } else if (opts.target === '17' || opts.target === '18') {
     return 'react-compiler-runtime'; // npm package
   } else {
     CompilerError.invariant(
-      target != null &&
-        target.kind === 'donotuse_meta_internal' &&
-        typeof target.runtimeModule === 'string',
+      opts.target != null &&
+        opts.target.kind === 'donotuse_meta_internal' &&
+        typeof opts.target.runtimeModule === 'string',
       {
         reason: 'Expected target to already be validated',
         description: null,
@@ -1142,6 +1180,6 @@ export function getReactCompilerRuntimeModule(
         suggestions: null,
       },
     );
-    return target.runtimeModule;
+    return opts.target.runtimeModule;
   }
 }

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

@@ -11,7 +11,6 @@ import {
 import {getOrInsertWith} from '../Utils/utils';
 import {Environment} from '../HIR';
 import {DEFAULT_EXPORT} from '../HIR/Environment';
-import {CompileProgramResult} from './Program';
 
 function throwInvalidReact(
   options: Omit<CompilerErrorDetailOptions, 'severity'>,
@@ -37,16 +36,12 @@ function assertValidEffectImportReference(
     const parent = path.parentPath;
     if (parent != null && parent.isCallExpression()) {
       const args = parent.get('arguments');
-      const maybeCalleeLoc = path.node.loc;
-      const hasInferredEffect =
-        maybeCalleeLoc != null &&
-        context.inferredEffectLocations.has(maybeCalleeLoc);
       /**
        * Only error on untransformed references of the form `useMyEffect(...)`
        * or `moduleNamespace.useMyEffect(...)`, with matching argument counts.
        * TODO: do we also want a mode to also hard error on non-call references?
        */
-      if (args.length === numArgs && !hasInferredEffect) {
+      if (args.length === numArgs) {
         const maybeErrorDiagnostic = matchCompilerDiagnostic(
           path,
           context.transformErrors,
@@ -102,7 +97,7 @@ export default function validateNoUntransformedReferences(
   filename: string | null,
   logger: Logger | null,
   env: EnvironmentConfig,
-  compileResult: CompileProgramResult | null,
+  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>,
 ): void {
   const moduleLoadChecks = new Map<
     string,
@@ -131,7 +126,7 @@ export default function validateNoUntransformedReferences(
     }
   }
   if (moduleLoadChecks.size > 0) {
-    transformProgram(path, moduleLoadChecks, filename, logger, compileResult);
+    transformProgram(path, moduleLoadChecks, filename, logger, transformErrors);
   }
 }
 
@@ -141,7 +136,6 @@ type TraversalState = {
   logger: Logger | null;
   filename: string | null;
   transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>;
-  inferredEffectLocations: Set<t.SourceLocation>;
 };
 type CheckInvalidReferenceFn = (
   paths: Array<NodePath<t.Node>>,
@@ -229,16 +223,14 @@ function transformProgram(
   moduleLoadChecks: Map<string, Map<string, CheckInvalidReferenceFn>>,
   filename: string | null,
   logger: Logger | null,
-  compileResult: CompileProgramResult | null,
+  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>,
 ): void {
   const traversalState: TraversalState = {
     shouldInvalidateScopes: true,
     program: path,
     filename,
     logger,
-    transformErrors: compileResult?.retryErrors ?? [],
-    inferredEffectLocations:
-      compileResult?.inferredEffectLocations ?? new Set(),
+    transformErrors,
   };
   path.traverse({
     ImportDeclaration(path: NodePath<t.ImportDeclaration>) {

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

@@ -11,12 +11,10 @@ import {fromZodError} from 'zod-validation-error';
 import {CompilerError} from '../CompilerError';
 import {
   CompilationMode,
-  defaultOptions,
   Logger,
   PanicThresholdOptions,
   parsePluginOptions,
   PluginOptions,
-  ProgramContext,
 } from '../Entrypoint';
 import {Err, Ok, Result} from '../Utils/Result';
 import {
@@ -86,8 +84,6 @@ export const InstrumentationSchema = z
   );
 
 export type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
-export const USE_FIRE_FUNCTION_NAME = 'useFire';
-export const EMIT_FREEZE_GLOBAL_GATING = '__DEV__';
 
 export const MacroMethodSchema = z.union([
   z.object({type: z.literal('wildcard')}),
@@ -334,11 +330,6 @@ const EnvironmentConfigSchema = z.object({
    */
   validateNoJSXInTryStatements: z.boolean().default(false),
 
-  /**
-   * Validates against dynamically creating components during render.
-   */
-  validateStaticComponents: z.boolean().default(false),
-
   /**
    * Validates that the dependencies of all effect hooks are memoized. This helps ensure
    * that Forget does not introduce infinite renders caused by a dependency changing,
@@ -780,7 +771,6 @@ export function parseConfigPragmaForTests(
   const environment = parseConfigPragmaEnvironmentForTest(pragma);
   let compilationMode: CompilationMode = defaults.compilationMode;
   let panicThreshold: PanicThresholdOptions = 'all_errors';
-  let noEmit: boolean = defaultOptions.noEmit;
   for (const token of pragma.split(' ')) {
     if (!token.startsWith('@')) {
       continue;
@@ -806,17 +796,12 @@ export function parseConfigPragmaForTests(
         panicThreshold = 'none';
         break;
       }
-      case '@noEmit': {
-        noEmit = true;
-        break;
-      }
     }
   }
   return parsePluginOptions({
     environment,
     compilationMode,
     panicThreshold,
-    noEmit,
   });
 }
 
@@ -856,10 +841,9 @@ export class Environment {
   config: EnvironmentConfig;
   fnType: ReactFunctionType;
   compilerMode: CompilerMode;
-  programContext: ProgramContext;
+  useMemoCacheIdentifier: string;
+  hasLoweredContextAccess: boolean;
   hasFireRewrite: boolean;
-  hasInferredEffect: boolean;
-  inferredEffectLocations: Set<SourceLocation> = new Set();
 
   #contextIdentifiers: Set<t.Identifier>;
   #hoistedIdentifiers: Set<t.Identifier>;
@@ -873,7 +857,7 @@ export class Environment {
     logger: Logger | null,
     filename: string | null,
     code: string | null,
-    programContext: ProgramContext,
+    useMemoCacheIdentifier: string,
   ) {
     this.#scope = scope;
     this.fnType = fnType;
@@ -882,11 +866,11 @@ export class Environment {
     this.filename = filename;
     this.code = code;
     this.logger = logger;
-    this.programContext = programContext;
+    this.useMemoCacheIdentifier = useMemoCacheIdentifier;
     this.#shapes = new Map(DEFAULT_SHAPES);
     this.#globals = new Map(DEFAULT_GLOBALS);
+    this.hasLoweredContextAccess = false;
     this.hasFireRewrite = false;
-    this.hasInferredEffect = false;
 
     if (
       config.disableMemoizationForDebugging &&
@@ -948,23 +932,6 @@ export class Environment {
     return makeScopeId(this.#nextScope++);
   }
 
-  get scope(): BabelScope {
-    return this.#scope;
-  }
-
-  logErrors(errors: Result<void, CompilerError>): void {
-    if (errors.isOk() || this.logger == null) {
-      return;
-    }
-    for (const error of errors.unwrapErr().details) {
-      this.logger.logEvent(this.filename, {
-        kind: 'CompileError',
-        detail: error,
-        fnLoc: null,
-      });
-    }
-  }
-
   isContextIdentifier(node: t.Identifier): boolean {
     return this.#contextIdentifiers.has(node);
   }

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

@@ -10,10 +10,7 @@ import {
   BUILTIN_SHAPES,
   BuiltInArrayId,
   BuiltInFireId,
-  BuiltInMapId,
   BuiltInMixedReadonlyId,
-  BuiltInObjectId,
-  BuiltInSetId,
   BuiltInUseActionStateId,
   BuiltInUseContextHookId,
   BuiltInUseEffectHookId,
@@ -48,23 +45,29 @@ export const DEFAULT_SHAPES: ShapeRegistry = new Map(BUILTIN_SHAPES);
 
 // Hack until we add ObjectShapes for all globals
 const UNTYPED_GLOBALS: Set<string> = new Set([
+  'String',
   'Object',
   'Function',
+  'Number',
   'RegExp',
   'Date',
   'Error',
+  'Function',
   'TypeError',
   'RangeError',
   'ReferenceError',
   'SyntaxError',
   'URIError',
   'EvalError',
+  'Boolean',
   'DataView',
   'Float32Array',
   'Float64Array',
   'Int8Array',
   'Int16Array',
   'Int32Array',
+  'Map',
+  'Set',
   'WeakMap',
   'Uint8Array',
   'Uint8ClampedArray',
@@ -72,8 +75,16 @@ const UNTYPED_GLOBALS: Set<string> = new Set([
   'Uint32Array',
   'ArrayBuffer',
   'JSON',
+  'parseFloat',
+  'parseInt',
   'console',
+  'isNaN',
   'eval',
+  'isFinite',
+  'encodeURI',
+  'decodeURI',
+  'encodeURIComponent',
+  'decodeURIComponent',
 ]);
 
 const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
@@ -90,23 +101,6 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
           returnValueKind: ValueKind.Mutable,
         }),
       ],
-      [
-        /**
-         * Object.fromEntries(iterable)
-         * iterable: An iterable, such as an Array or Map, containing a list of
-         *           objects. Each object should have two properties.
-         * Returns a new object whose properties are given by the entries of the
-         * iterable.
-         */
-        'fromEntries',
-        addFunction(DEFAULT_SHAPES, [], {
-          positionalParams: [Effect.ConditionallyMutate],
-          restParam: null,
-          returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-          calleeEffect: Effect.Read,
-          returnValueKind: ValueKind.Mutable,
-        }),
-      ],
     ]),
   ],
   [
@@ -138,7 +132,7 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
         'from',
         addFunction(DEFAULT_SHAPES, [], {
           positionalParams: [
-            Effect.ConditionallyMutateIterator,
+            Effect.ConditionallyMutate,
             Effect.ConditionallyMutate,
             Effect.ConditionallyMutate,
           ],
@@ -378,118 +372,6 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
       returnValueKind: ValueKind.Primitive,
     }),
   ],
-  [
-    'parseInt',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'parseFloat',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'isNaN',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'isFinite',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'encodeURI',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'encodeURIComponent',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'decodeURI',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'decodeURIComponent',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'Map',
-    addFunction(
-      DEFAULT_SHAPES,
-      [],
-      {
-        positionalParams: [Effect.ConditionallyMutateIterator],
-        restParam: null,
-        returnType: {kind: 'Object', shapeId: BuiltInMapId},
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Mutable,
-      },
-      null,
-      true,
-    ),
-  ],
-  [
-    'Set',
-    addFunction(
-      DEFAULT_SHAPES,
-      [],
-      {
-        positionalParams: [Effect.ConditionallyMutateIterator],
-        restParam: null,
-        returnType: {kind: 'Object', shapeId: BuiltInSetId},
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Mutable,
-      },
-      null,
-      true,
-    ),
-  ],
   // TODO: rest of Global objects
 ];
 

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

@@ -10,7 +10,7 @@ import * as t from '@babel/types';
 import {CompilerError, CompilerErrorDetailOptions} from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
 import {Environment, ReactFunctionType} from './Environment';
-import type {HookKind} from './ObjectShape';
+import {HookKind} from './ObjectShape';
 import {Type, makeType} from './Types';
 import {z} from 'zod';
 
@@ -829,13 +829,6 @@ export type CallExpression = {
   typeArguments?: Array<t.FlowType>;
 };
 
-export type NewExpression = {
-  kind: 'NewExpression';
-  callee: Place;
-  args: Array<Place | SpreadPattern>;
-  loc: SourceLocation;
-};
-
 export type LoadLocal = {
   kind: 'LoadLocal';
   place: Place;
@@ -901,7 +894,12 @@ export type InstructionValue =
       right: Place;
       loc: SourceLocation;
     }
-  | NewExpression
+  | {
+      kind: 'NewExpression';
+      callee: Place;
+      args: Array<Place | SpreadPattern>;
+      loc: SourceLocation;
+    }
   | CallExpression
   | MethodCall
   | {
@@ -1167,21 +1165,18 @@ export type VariableBinding =
   // bindings declard outside the current component/hook
   | NonLocalBinding;
 
-// `import {bar as baz} from 'foo'`: name=baz, module=foo, imported=bar
-export type NonLocalImportSpecifier = {
-  kind: 'ImportSpecifier';
-  name: string;
-  module: string;
-  imported: string;
-};
-
 export type NonLocalBinding =
   // `import Foo from 'foo'`: name=Foo, module=foo
   | {kind: 'ImportDefault'; name: string; module: string}
   // `import * as Foo from 'foo'`: name=Foo, module=foo
   | {kind: 'ImportNamespace'; name: string; module: string}
-  // `import {bar as baz} from 'foo'`
-  | NonLocalImportSpecifier
+  // `import {bar as baz} from 'foo'`: name=baz, module=foo, imported=bar
+  | {
+      kind: 'ImportSpecifier';
+      name: string;
+      module: string;
+      imported: string;
+    }
   // let, const, function, etc declared in the module but outside the current component/hook
   | {kind: 'ModuleLocal'; name: string}
   // an unresolved binding
@@ -1399,7 +1394,6 @@ export enum Effect {
   Read = 'read',
   // This reference reads and stores the value
   Capture = 'capture',
-  ConditionallyMutateIterator = 'mutate-iterator?',
   /*
    * This reference *may* write to (mutate) the value. This covers two similar cases:
    * - The compiler is being conservative and assuming that a value *may* be mutated
@@ -1418,11 +1412,11 @@ export enum Effect {
   // This reference may alias to (mutate) the value
   Store = 'store',
 }
+
 export const EffectSchema = z.enum([
   Effect.Read,
   Effect.Mutate,
   Effect.ConditionallyMutate,
-  Effect.ConditionallyMutateIterator,
   Effect.Capture,
   Effect.Store,
   Effect.Freeze,
@@ -1436,7 +1430,6 @@ export function isMutableEffect(
     case Effect.Capture:
     case Effect.Store:
     case Effect.ConditionallyMutate:
-    case Effect.ConditionallyMutateIterator:
     case Effect.Mutate: {
       return true;
     }
@@ -1656,14 +1649,6 @@ export function isArrayType(id: Identifier): boolean {
   return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInArray';
 }
 
-export function isMapType(id: Identifier): boolean {
-  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInMap';
-}
-
-export function isSetType(id: Identifier): boolean {
-  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInSet';
-}
-
 export function isPropsType(id: Identifier): boolean {
   return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInProps';
 }

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

@@ -331,7 +331,6 @@ export default class HIRBuilder {
           type: makeType(),
           loc: node.loc ?? GeneratedSource,
         };
-        this.#env.programContext.addNewReference(name);
         this.#bindings.set(name, {node, identifier});
         return identifier;
       } else if (mapping.node === node) {

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

@@ -44,7 +44,6 @@ export function addFunction(
   properties: Iterable<[string, BuiltInType | PolyType]>,
   fn: Omit<FunctionSignature, 'hookKind'>,
   id: string | null = null,
-  isConstructor: boolean = false,
 ): FunctionType {
   const shapeId = id ?? createAnonId();
   addShape(registry, shapeId, properties, {
@@ -55,7 +54,6 @@ export function addFunction(
     kind: 'Function',
     return: fn.returnType,
     shapeId,
-    isConstructor,
   };
 }
 
@@ -75,7 +73,6 @@ export function addHook(
     kind: 'Function',
     return: fn.returnType,
     shapeId,
-    isConstructor: false,
   };
 }
 
@@ -201,8 +198,6 @@ export type ObjectShape = {
 export type ShapeRegistry = Map<string, ObjectShape>;
 export const BuiltInPropsId = 'BuiltInProps';
 export const BuiltInArrayId = 'BuiltInArray';
-export const BuiltInSetId = 'BuiltInSet';
-export const BuiltInMapId = 'BuiltInMap';
 export const BuiltInFunctionId = 'BuiltInFunction';
 export const BuiltInJsxId = 'BuiltInJsx';
 export const BuiltInObjectId = 'BuiltInObject';
@@ -456,313 +451,6 @@ addObject(BUILTIN_SHAPES, BuiltInObjectId, [
    */
 ]);
 
-/* Built-in Set shape */
-addObject(BUILTIN_SHAPES, BuiltInSetId, [
-  [
-    /**
-     * add(value)
-     * Parameters
-     *   value: the value of the element to add to the Set object.
-     * Returns the Set object with added value.
-     */
-    'add',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Store,
-      // returnValueKind is technically dependent on the ValueKind of the set itself
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * clear()
-     * Parameters none
-     * Returns undefined
-     */
-    'clear',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * setInstance.delete(value)
-     * Returns true if value was already in Set; otherwise false.
-     */
-    'delete',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'has',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  ['size', PRIMITIVE_TYPE],
-  [
-    /**
-     * difference(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * Returns a new Set object containing elements in this set but not in the other set.
-     */
-    'difference',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * union(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * Returns a new Set object containing elements in either this set or the other set.
-     */
-    'union',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * symmetricalDifference(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * A new Set object containing elements which are in either this set or the other set, but not in both.
-     */
-    'symmetricalDifference',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * isSubsetOf(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * Returns true if all elements in this set are also in the other set, and false otherwise.
-     */
-    'isSubsetOf',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * isSupersetOf(other)
-     * Parameters
-     *  other: A Set object, or set-like object.
-     * Returns true if all elements in the other set are also in this set, and false otherwise.
-     */
-    'isSupersetOf',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * forEach(callbackFn)
-     * forEach(callbackFn, thisArg)
-     */
-    'forEach',
-    addFunction(BUILTIN_SHAPES, [], {
-      /**
-       * see Array.map explanation for why arguments are marked `ConditionallyMutate`
-       */
-      positionalParams: [],
-      restParam: Effect.ConditionallyMutate,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.ConditionallyMutate,
-      returnValueKind: ValueKind.Primitive,
-      noAlias: true,
-      mutableOnlyIfOperandsAreMutable: true,
-    }),
-  ],
-  /**
-   * Iterators
-   */
-  [
-    'entries',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'keys',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'values',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-addObject(BUILTIN_SHAPES, BuiltInMapId, [
-  [
-    /**
-     * clear()
-     * Parameters none
-     * Returns undefined
-     */
-    'clear',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'delete',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'get',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'has',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * Params
-     *   key: the key of the element to add to the Map object. The key may be
-     *   any JavaScript type (any primitive value or any type of JavaScript
-     *   object).
-     *   value: the value of the element to add to the Map object.
-     * Returns the Map object.
-     */
-    'set',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture, Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInMapId},
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  ['size', PRIMITIVE_TYPE],
-  [
-    'forEach',
-    addFunction(BUILTIN_SHAPES, [], {
-      /**
-       * see Array.map explanation for why arguments are marked `ConditionallyMutate`
-       */
-      positionalParams: [],
-      restParam: Effect.ConditionallyMutate,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.ConditionallyMutate,
-      returnValueKind: ValueKind.Primitive,
-      noAlias: true,
-      mutableOnlyIfOperandsAreMutable: true,
-    }),
-  ],
-  /**
-   * Iterators
-   */
-  [
-    'entries',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'keys',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'values',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
 addObject(BUILTIN_SHAPES, BuiltInUseStateId, [
   ['0', {kind: 'Poly'}],
   [

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

@@ -38,7 +38,6 @@ export type FunctionType = {
   kind: 'Function';
   shapeId: string | null;
   return: Type;
-  isConstructor: boolean;
 };
 
 export type ObjectType = {
@@ -112,7 +111,6 @@ export function duplicateType(type: Type): Type {
         kind: 'Function',
         return: duplicateType(type.return),
         shapeId: type.shapeId,
-        isConstructor: type.isConstructor,
       };
     }
     case 'Object': {

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

@@ -32,5 +32,5 @@ export {
 } from './HIRBuilder';
 export {mergeConsecutiveBlocks} from './MergeConsecutiveBlocks';
 export {mergeOverlappingReactiveScopesHIR} from './MergeOverlappingReactiveScopesHIR';
-export {printFunction, printHIR, printFunctionWithOutlined} from './PrintHIR';
+export {printFunction, printHIR} from './PrintHIR';
 export {pruneUnusedLabelsHIR} from './PruneUnusedLabelsHIR';

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

@@ -217,7 +217,6 @@ export function inferEffectDependencies(fn: HIRFunction): void {
             // 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
             newInstructions.push({
@@ -228,7 +227,6 @@ export function inferEffectDependencies(fn: HIRFunction): void {
             });
             value.args.push({...depsPlace, effect: Effect.Freeze});
             rewriteInstrs.set(instr.id, newInstructions);
-            fn.env.inferredEffectLocations.add(callee.loc);
           }
         }
       }
@@ -251,7 +249,6 @@ export function inferEffectDependencies(fn: HIRFunction): void {
     // Renumber instructions and fix scope ranges
     markInstructionIds(fn.body);
     fixScopeAndIdentifierRanges(fn.body);
-    fn.env.hasInferredEffect = true;
   }
 }
 

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

@@ -11,10 +11,7 @@ import {
   Identifier,
   InstructionId,
   InstructionKind,
-  isArrayType,
-  isMapType,
   isRefOrRefValue,
-  isSetType,
   makeInstructionId,
   Place,
 } from '../HIR/HIR';
@@ -93,17 +90,6 @@ function inferPlace(
         infer(place, instrId);
       }
       return;
-    case Effect.ConditionallyMutateIterator: {
-      const identifier = place.identifier;
-      if (
-        !isArrayType(identifier) &&
-        !isSetType(identifier) &&
-        !isMapType(identifier)
-      ) {
-        infer(place, instrId);
-      }
-      return;
-    }
     case Effect.ConditionallyMutate:
     case Effect.Mutate: {
       infer(place, instrId);

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

@@ -230,7 +230,6 @@ export function inferReactivePlaces(fn: HIRFunction): void {
               case Effect.Capture:
               case Effect.Store:
               case Effect.ConditionallyMutate:
-              case Effect.ConditionallyMutateIterator:
               case Effect.Mutate: {
                 if (isMutable(instruction, operand)) {
                   reactiveIdentifiers.markReactive(operand);

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

@@ -12,7 +12,6 @@ import {
   BasicBlock,
   BlockId,
   CallExpression,
-  NewExpression,
   Effect,
   FunctionEffect,
   GeneratedSource,
@@ -24,15 +23,12 @@ import {
   Phi,
   Place,
   SpreadPattern,
-  TInstruction,
   Type,
   ValueKind,
   ValueReason,
   isArrayType,
-  isMapType,
   isMutableEffect,
   isObjectType,
-  isSetType,
 } from '../HIR/HIR';
 import {FunctionSignature} from '../HIR/ObjectShape';
 import {
@@ -42,6 +38,7 @@ import {
   printSourceLocation,
 } from '../HIR/PrintHIR';
 import {
+  eachCallArgument,
   eachInstructionOperand,
   eachInstructionValueOperand,
   eachPatternOperand,
@@ -254,7 +251,7 @@ type FreezeAction = {values: Set<InstructionValue>; reason: Set<ValueReason>};
 
 // Maintains a mapping of top-level variables to the kind of value they hold
 class InferenceState {
-  env: Environment;
+  #env: Environment;
 
   // The kind of each value, based on its allocation site
   #values: Map<InstructionValue, AbstractValue>;
@@ -270,7 +267,7 @@ class InferenceState {
     values: Map<InstructionValue, AbstractValue>,
     variables: Map<IdentifierId, Set<InstructionValue>>,
   ) {
-    this.env = env;
+    this.#env = env;
     this.#values = values;
     this.#variables = variables;
   }
@@ -412,8 +409,8 @@ class InferenceState {
       });
       if (
         value.kind === 'FunctionExpression' &&
-        (this.env.config.enablePreserveExistingMemoizationGuarantees ||
-          this.env.config.enableTransitivelyFreezeFunctionExpressions)
+        (this.#env.config.enablePreserveExistingMemoizationGuarantees ||
+          this.#env.config.enableTransitivelyFreezeFunctionExpressions)
       ) {
         for (const operand of value.loweredFunc.func.context) {
           const operandValues = this.#variables.get(operand.identifier.id);
@@ -471,25 +468,6 @@ class InferenceState {
         }
         break;
       }
-      case Effect.ConditionallyMutateIterator: {
-        if (
-          valueKind.kind === ValueKind.Mutable ||
-          valueKind.kind === ValueKind.Context
-        ) {
-          if (
-            isArrayType(place.identifier) ||
-            isSetType(place.identifier) ||
-            isMapType(place.identifier)
-          ) {
-            effect = Effect.Capture;
-          } else {
-            effect = Effect.ConditionallyMutate;
-          }
-        } else {
-          effect = Effect.Read;
-        }
-        break;
-      }
       case Effect.Mutate: {
         effect = Effect.Mutate;
         break;
@@ -612,7 +590,7 @@ class InferenceState {
       return null;
     } else {
       return new InferenceState(
-        this.env,
+        this.#env,
         nextValues ?? new Map(this.#values),
         nextVariables ?? new Map(this.#variables),
       );
@@ -626,7 +604,7 @@ class InferenceState {
    */
   clone(): InferenceState {
     return new InferenceState(
-      this.env,
+      this.#env,
       new Map(this.#values),
       new Map(this.#variables),
     );
@@ -901,7 +879,9 @@ function inferBlock(
             state.referenceAndRecordEffects(
               freezeActions,
               element.place,
-              Effect.ConditionallyMutateIterator,
+              isArrayType(element.place.identifier)
+                ? Effect.Capture
+                : Effect.ConditionallyMutate,
               ValueReason.Other,
             );
           } else if (element.kind === 'Identifier') {
@@ -924,12 +904,43 @@ function inferBlock(
         break;
       }
       case 'NewExpression': {
-        inferCallEffects(
-          state,
-          instr as TInstruction<NewExpression>,
+        /**
+         * For new expressions, we infer a `read` effect on the Class / Function type
+         * to avoid extending mutable ranges of locally created classes, e.g.
+         * ```js
+         * const MyClass = getClass();
+         * const value = new MyClass(val1, val2)
+         *                   ^ (read)   ^ (conditionally mutate)
+         * ```
+         *
+         * Risks:
+         * Classes / functions created during render could technically capture and
+         * mutate their enclosing scope, which we currently do not detect.
+         */
+        const valueKind: AbstractValue = {
+          kind: ValueKind.Mutable,
+          reason: new Set([ValueReason.Other]),
+          context: new Set(),
+        };
+        state.referenceAndRecordEffects(
           freezeActions,
-          getFunctionCallSignature(env, instrValue.callee.identifier.type),
+          instrValue.callee,
+          Effect.Read,
+          ValueReason.Other,
         );
+
+        for (const operand of eachCallArgument(instrValue.args)) {
+          state.referenceAndRecordEffects(
+            freezeActions,
+            operand,
+            Effect.ConditionallyMutate,
+            ValueReason.Other,
+          );
+        }
+
+        state.initialize(instrValue, valueKind);
+        state.define(instr.lvalue, instrValue);
+        instr.lvalue.effect = Effect.ConditionallyMutate;
         continuation = {kind: 'funeffects'};
         break;
       }
@@ -1227,12 +1238,62 @@ function inferBlock(
         break;
       }
       case 'CallExpression': {
-        inferCallEffects(
-          state,
-          instr as TInstruction<CallExpression>,
-          freezeActions,
-          getFunctionCallSignature(env, instrValue.callee.identifier.type),
+        const signature = getFunctionCallSignature(
+          env,
+          instrValue.callee.identifier.type,
         );
+
+        const effects =
+          signature !== null ? getFunctionEffects(instrValue, signature) : null;
+        const returnValueKind: AbstractValue =
+          signature !== null
+            ? {
+                kind: signature.returnValueKind,
+                reason: new Set([
+                  signature.returnValueReason ??
+                    ValueReason.KnownReturnSignature,
+                ]),
+                context: new Set(),
+              }
+            : {
+                kind: ValueKind.Mutable,
+                reason: new Set([ValueReason.Other]),
+                context: new Set(),
+              };
+        let hasCaptureArgument = false;
+        for (let i = 0; i < instrValue.args.length; i++) {
+          const arg = instrValue.args[i];
+          const place = arg.kind === 'Identifier' ? arg : arg.place;
+          state.referenceAndRecordEffects(
+            freezeActions,
+            place,
+            getArgumentEffect(effects != null ? effects[i] : null, arg),
+            ValueReason.Other,
+          );
+          hasCaptureArgument ||= place.effect === Effect.Capture;
+        }
+        if (signature !== null) {
+          state.referenceAndRecordEffects(
+            freezeActions,
+            instrValue.callee,
+            signature.calleeEffect,
+            ValueReason.Other,
+          );
+        } else {
+          state.referenceAndRecordEffects(
+            freezeActions,
+            instrValue.callee,
+            Effect.ConditionallyMutate,
+            ValueReason.Other,
+          );
+        }
+        hasCaptureArgument ||= instrValue.callee.effect === Effect.Capture;
+
+        state.initialize(instrValue, returnValueKind);
+        state.define(instr.lvalue, instrValue);
+        instr.lvalue.effect = hasCaptureArgument
+          ? Effect.Store
+          : Effect.ConditionallyMutate;
         continuation = {kind: 'funeffects'};
         break;
       }
@@ -1250,12 +1311,102 @@ function inferBlock(
           Effect.Read,
           ValueReason.Other,
         );
-        inferCallEffects(
-          state,
-          instr as TInstruction<MethodCall>,
-          freezeActions,
-          getFunctionCallSignature(env, instrValue.property.identifier.type),
+
+        const signature = getFunctionCallSignature(
+          env,
+          instrValue.property.identifier.type,
         );
+
+        const returnValueKind: AbstractValue =
+          signature !== null
+            ? {
+                kind: signature.returnValueKind,
+                reason: new Set([
+                  signature.returnValueReason ??
+                    ValueReason.KnownReturnSignature,
+                ]),
+                context: new Set(),
+              }
+            : {
+                kind: ValueKind.Mutable,
+                reason: new Set([ValueReason.Other]),
+                context: new Set(),
+              };
+
+        if (
+          signature !== null &&
+          signature.mutableOnlyIfOperandsAreMutable &&
+          areArgumentsImmutableAndNonMutating(state, instrValue.args)
+        ) {
+          /*
+           * None of the args are mutable or mutate their params, we can downgrade to
+           * treating as all reads (except that the receiver may be captured)
+           */
+          for (const arg of instrValue.args) {
+            const place = arg.kind === 'Identifier' ? arg : arg.place;
+            state.referenceAndRecordEffects(
+              freezeActions,
+              place,
+              Effect.Read,
+              ValueReason.Other,
+            );
+          }
+          state.referenceAndRecordEffects(
+            freezeActions,
+            instrValue.receiver,
+            Effect.Capture,
+            ValueReason.Other,
+          );
+          state.initialize(instrValue, returnValueKind);
+          state.define(instr.lvalue, instrValue);
+          instr.lvalue.effect =
+            instrValue.receiver.effect === Effect.Capture
+              ? Effect.Store
+              : Effect.ConditionallyMutate;
+          continuation = {kind: 'funeffects'};
+          break;
+        }
+
+        const effects =
+          signature !== null ? getFunctionEffects(instrValue, signature) : null;
+        let hasCaptureArgument = false;
+        for (let i = 0; i < instrValue.args.length; i++) {
+          const arg = instrValue.args[i];
+          const place = arg.kind === 'Identifier' ? arg : arg.place;
+          /*
+           * If effects are inferred for an argument, we should fail invalid
+           * mutating effects
+           */
+          state.referenceAndRecordEffects(
+            freezeActions,
+            place,
+            getArgumentEffect(effects != null ? effects[i] : null, arg),
+            ValueReason.Other,
+          );
+          hasCaptureArgument ||= place.effect === Effect.Capture;
+        }
+        if (signature !== null) {
+          state.referenceAndRecordEffects(
+            freezeActions,
+            instrValue.receiver,
+            signature.calleeEffect,
+            ValueReason.Other,
+          );
+        } else {
+          state.referenceAndRecordEffects(
+            freezeActions,
+            instrValue.receiver,
+            Effect.ConditionallyMutate,
+            ValueReason.Other,
+          );
+        }
+        hasCaptureArgument ||= instrValue.receiver.effect === Effect.Capture;
+
+        state.initialize(instrValue, returnValueKind);
+        state.define(instr.lvalue, instrValue);
+        instr.lvalue.effect = hasCaptureArgument
+          ? Effect.Store
+          : Effect.ConditionallyMutate;
         continuation = {kind: 'funeffects'};
         break;
       }
@@ -1662,13 +1813,7 @@ function inferBlock(
           kind === ValueKind.Mutable || kind === ValueKind.Context;
         let effect;
         let valueKind: AbstractValue;
-        const iterator = instrValue.collection.identifier;
-        if (
-          !isMutable ||
-          isArrayType(iterator) ||
-          isMapType(iterator) ||
-          isSetType(iterator)
-        ) {
+        if (!isMutable || isArrayType(instrValue.collection.identifier)) {
           // Case 1, assume iterator is a separate mutable object
           effect = {
             kind: Effect.Read,
@@ -1709,7 +1854,7 @@ function inferBlock(
         state.referenceAndRecordEffects(
           freezeActions,
           instrValue.iterator,
-          Effect.ConditionallyMutateIterator,
+          Effect.ConditionallyMutate,
           ValueReason.Other,
         );
         /**
@@ -1838,7 +1983,7 @@ export function getFunctionCallSignature(
  * @returns Inferred effects of function arguments, or null if inference fails.
  */
 export function getFunctionEffects(
-  fn: MethodCall | CallExpression | NewExpression,
+  fn: MethodCall | CallExpression,
   sig: FunctionSignature,
 ): Array<Effect> | null {
   const results = [];
@@ -1867,33 +2012,6 @@ export function getFunctionEffects(
   return results;
 }
 
-export function isKnownMutableEffect(effect: Effect): boolean {
-  switch (effect) {
-    case Effect.Store:
-    case Effect.ConditionallyMutate:
-    case Effect.ConditionallyMutateIterator:
-    case Effect.Mutate: {
-      return true;
-    }
-
-    case Effect.Unknown: {
-      CompilerError.invariant(false, {
-        reason: 'Unexpected unknown effect',
-        description: null,
-        loc: GeneratedSource,
-        suggestions: null,
-      });
-    }
-    case Effect.Read:
-    case Effect.Capture:
-    case Effect.Freeze: {
-      return false;
-    }
-    default: {
-      assertExhaustive(effect, `Unexpected effect \`${effect}\``);
-    }
-  }
-}
 /**
  * Returns true if all of the arguments are both non-mutable (immutable or frozen)
  * _and_ are not functions which might mutate their arguments. Note that function
@@ -1905,20 +2023,10 @@ function areArgumentsImmutableAndNonMutating(
   args: MethodCall['args'],
 ): boolean {
   for (const arg of args) {
-    if (arg.kind === 'Identifier' && arg.identifier.type.kind === 'Function') {
-      const fnShape = state.env.getFunctionSignature(arg.identifier.type);
-      if (fnShape != null) {
-        return (
-          !fnShape.positionalParams.some(isKnownMutableEffect) &&
-          (fnShape.restParam == null ||
-            !isKnownMutableEffect(fnShape.restParam))
-        );
-      }
-    }
     const place = arg.kind === 'Identifier' ? arg : arg.place;
-
     const kind = state.kind(place).kind;
     switch (kind) {
+      case ValueKind.Global:
       case ValueKind.Primitive:
       case ValueKind.Frozen: {
         /*
@@ -1929,10 +2037,6 @@ function areArgumentsImmutableAndNonMutating(
         break;
       }
       default: {
-        /**
-         * Globals, module locals, and other locally defined functions may
-         * mutate their arguments.
-         */
         return false;
       }
     }
@@ -1975,128 +2079,9 @@ function getArgumentEffect(
         });
       }
       // effects[i] is Effect.Capture | Effect.Read | Effect.Store
-      return Effect.ConditionallyMutateIterator;
+      return Effect.ConditionallyMutate;
     }
   } else {
     return Effect.ConditionallyMutate;
   }
 }
-
-function inferCallEffects(
-  state: InferenceState,
-  instr:
-    | TInstruction<CallExpression>
-    | TInstruction<MethodCall>
-    | TInstruction<NewExpression>,
-  freezeActions: Array<FreezeAction>,
-  signature: FunctionSignature | null,
-): void {
-  const instrValue = instr.value;
-  const returnValueKind: AbstractValue =
-    signature !== null
-      ? {
-          kind: signature.returnValueKind,
-          reason: new Set([
-            signature.returnValueReason ?? ValueReason.KnownReturnSignature,
-          ]),
-          context: new Set(),
-        }
-      : {
-          kind: ValueKind.Mutable,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
-        };
-
-  if (
-    instrValue.kind === 'MethodCall' &&
-    signature !== null &&
-    signature.mutableOnlyIfOperandsAreMutable &&
-    areArgumentsImmutableAndNonMutating(state, instrValue.args)
-  ) {
-    /*
-     * None of the args are mutable or mutate their params, we can downgrade to
-     * treating as all reads (except that the receiver may be captured)
-     */
-    for (const arg of instrValue.args) {
-      const place = arg.kind === 'Identifier' ? arg : arg.place;
-      state.referenceAndRecordEffects(
-        freezeActions,
-        place,
-        Effect.Read,
-        ValueReason.Other,
-      );
-    }
-    state.referenceAndRecordEffects(
-      freezeActions,
-      instrValue.receiver,
-      Effect.Capture,
-      ValueReason.Other,
-    );
-    state.initialize(instrValue, returnValueKind);
-    state.define(instr.lvalue, instrValue);
-    instr.lvalue.effect =
-      instrValue.receiver.effect === Effect.Capture
-        ? Effect.Store
-        : Effect.ConditionallyMutate;
-    return;
-  }
-
-  const effects =
-    signature !== null ? getFunctionEffects(instrValue, signature) : null;
-  let hasCaptureArgument = false;
-  for (let i = 0; i < instrValue.args.length; i++) {
-    const arg = instrValue.args[i];
-    const place = arg.kind === 'Identifier' ? arg : arg.place;
-    /*
-     * If effects are inferred for an argument, we should fail invalid
-     * mutating effects
-     */
-    state.referenceAndRecordEffects(
-      freezeActions,
-      place,
-      getArgumentEffect(effects != null ? effects[i] : null, arg),
-      ValueReason.Other,
-    );
-    hasCaptureArgument ||= place.effect === Effect.Capture;
-  }
-  const callee =
-    instrValue.kind === 'MethodCall' ? instrValue.receiver : instrValue.callee;
-  if (signature !== null) {
-    state.referenceAndRecordEffects(
-      freezeActions,
-      callee,
-      signature.calleeEffect,
-      ValueReason.Other,
-    );
-  } else {
-    /**
-     * For new expressions, we infer a `read` effect on the Class / Function type
-     * to avoid extending mutable ranges of locally created classes, e.g.
-     * ```js
-     * const MyClass = getClass();
-     * const value = new MyClass(val1, val2)
-     *                   ^ (read)   ^ (conditionally mutate)
-     * ```
-     *
-     * Risks:
-     * Classes / functions created during render could technically capture and
-     * mutate their enclosing scope, which we currently do not detect.
-     */
-
-    state.referenceAndRecordEffects(
-      freezeActions,
-      callee,
-      instrValue.kind === 'NewExpression'
-        ? Effect.Read
-        : Effect.ConditionallyMutate,
-      ValueReason.Other,
-    );
-  }
-  hasCaptureArgument ||= callee.effect === Effect.Capture;
-
-  state.initialize(instrValue, returnValueKind);
-  state.define(instr.lvalue, instrValue);
-  instr.lvalue.effect = hasCaptureArgument
-    ? Effect.Store
-    : Effect.ConditionallyMutate;
-}

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

@@ -18,7 +18,6 @@ import {
   Instruction,
   LoadGlobal,
   LoadLocal,
-  NonLocalImportSpecifier,
   Place,
   PropertyLoad,
   isUseContextHookType,
@@ -36,7 +35,7 @@ import {inferTypes} from '../TypeInference';
 
 export function lowerContextAccess(
   fn: HIRFunction,
-  loweredContextCalleeConfig: ExternalFunction,
+  loweredContextCallee: ExternalFunction,
 ): void {
   const contextAccess: Map<IdentifierId, CallExpression> = new Map();
   const contextKeys: Map<IdentifierId, Array<string>> = new Map();
@@ -80,8 +79,6 @@ export function lowerContextAccess(
     }
   }
 
-  let importLoweredContextCallee: NonLocalImportSpecifier | null = null;
-
   if (contextAccess.size > 0 && contextKeys.size > 0) {
     for (const [, block] of fn.body.blocks) {
       let nextInstructions: Array<Instruction> | null = null;
@@ -94,13 +91,9 @@ export function lowerContextAccess(
           isUseContextHookType(value.callee.identifier) &&
           contextKeys.has(lvalue.identifier.id)
         ) {
-          importLoweredContextCallee ??=
-            fn.env.programContext.addImportSpecifier(
-              loweredContextCalleeConfig,
-            );
           const loweredContextCalleeInstr = emitLoadLoweredContextCallee(
             fn.env,
-            importLoweredContextCallee,
+            loweredContextCallee,
           );
 
           if (nextInstructions === null) {
@@ -129,16 +122,21 @@ export function lowerContextAccess(
     }
     markInstructionIds(fn.body);
     inferTypes(fn);
+    fn.env.hasLoweredContextAccess = true;
   }
 }
 
 function emitLoadLoweredContextCallee(
   env: Environment,
-  importedLowerContextCallee: NonLocalImportSpecifier,
+  loweredContextCallee: ExternalFunction,
 ): Instruction {
   const loadGlobal: LoadGlobal = {
     kind: 'LoadGlobal',
-    binding: {...importedLowerContextCallee},
+    binding: {
+      kind: 'ImportNamespace',
+      module: loweredContextCallee.source,
+      name: loweredContextCallee.importSpecifierName,
+    },
     loc: GeneratedSource,
   };
 

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

@@ -196,7 +196,7 @@ function process(
     return null;
   }
 
-  const props = collectProps(fn.env, jsx);
+  const props = collectProps(jsx);
   if (!props) return null;
 
   const outlinedTag = fn.env.generateGloballyUniqueIdentifierName(null).value;
@@ -217,7 +217,6 @@ type OutlinedJsxAttribute = {
 };
 
 function collectProps(
-  env: Environment,
   instructions: Array<JsxInstruction>,
 ): Array<OutlinedJsxAttribute> | null {
   let id = 1;
@@ -228,7 +227,6 @@ function collectProps(
       newName = `${oldName}${id++}`;
     }
     seen.add(newName);
-    env.programContext.addNewReference(newName);
     return newName;
   }
 

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

@@ -14,7 +14,7 @@ import {
   renameVariables,
 } from '.';
 import {CompilerError, ErrorSeverity} from '../CompilerError';
-import {Environment, ExternalFunction} from '../HIR';
+import {Environment, EnvironmentConfig, ExternalFunction} from '../HIR';
 import {
   ArrayPattern,
   BlockId,
@@ -52,8 +52,7 @@ import {assertExhaustive} from '../Utils/utils';
 import {buildReactiveFunction} from './BuildReactiveFunction';
 import {SINGLE_CHILD_FBT_TAGS} from './MemoizeFbtAndMacroOperandsInSameScope';
 import {ReactiveFunctionVisitor, visitReactiveFunction} from './visitors';
-import {EMIT_FREEZE_GLOBAL_GATING, ReactFunctionType} from '../HIR/Environment';
-import {ProgramContext} from '../Entrypoint';
+import {ReactFunctionType} from '../HIR/Environment';
 
 export const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
 export const EARLY_RETURN_SENTINEL = 'react.early_return_sentinel';
@@ -101,10 +100,9 @@ export type CodegenFunction = {
   }>;
 
   /**
-   * This is true if the compiler has compiled inferred effect dependencies
+   * This is true if the compiler has the lowered useContext calls.
    */
-  hasInferredEffect: boolean;
-  inferredEffectLocations: Set<SourceLocation>;
+  hasLoweredContextAccess: boolean;
 
   /**
    * This is true if the compiler has compiled a fire to a useFire call
@@ -158,11 +156,10 @@ export function codegenFunction(
   const compiled = compileResult.unwrap();
 
   const hookGuard = fn.env.config.enableEmitHookGuards;
-  if (hookGuard != null && fn.env.isInferredMemoEnabled) {
+  if (hookGuard != null) {
     compiled.body = t.blockStatement([
       createHookGuard(
         hookGuard,
-        fn.env.programContext,
         compiled.body.body,
         GuardKind.PushHookGuard,
         GuardKind.PopHookGuard,
@@ -173,15 +170,13 @@ export function codegenFunction(
   const cacheCount = compiled.memoSlotsUsed;
   if (cacheCount !== 0) {
     const preface: Array<t.Statement> = [];
-    const useMemoCacheIdentifier =
-      fn.env.programContext.addMemoCacheImport().name;
 
     // The import declaration for `useMemoCache` is inserted in the Babel plugin
     preface.push(
       t.variableDeclaration('const', [
         t.variableDeclarator(
           t.identifier(cx.synthesizeName('$')),
-          t.callExpression(t.identifier(useMemoCacheIdentifier), [
+          t.callExpression(t.identifier(fn.env.useMemoCacheIdentifier), [
             t.numericLiteral(cacheCount),
           ]),
         ),
@@ -255,63 +250,39 @@ export function codegenFunction(
   }
 
   const emitInstrumentForget = fn.env.config.enableEmitInstrumentForget;
-  if (
-    emitInstrumentForget != null &&
-    fn.id != null &&
-    fn.env.isInferredMemoEnabled
-  ) {
+  if (emitInstrumentForget != null && fn.id != null) {
     /*
      * Technically, this is a conditional hook call. However, we expect
      * __DEV__ and gating identifier to be runtime constants
      */
-    const gating =
-      emitInstrumentForget.gating != null
-        ? t.identifier(
-            fn.env.programContext.addImportSpecifier(
-              emitInstrumentForget.gating,
-            ).name,
-          )
-        : null;
-
-    const globalGating =
+    let gating: t.Expression;
+    if (
+      emitInstrumentForget.gating != null &&
       emitInstrumentForget.globalGating != null
-        ? t.identifier(emitInstrumentForget.globalGating)
-        : null;
-
-    if (emitInstrumentForget.globalGating != null) {
-      const assertResult = fn.env.programContext.assertGlobalBinding(
-        emitInstrumentForget.globalGating,
+    ) {
+      gating = t.logicalExpression(
+        '&&',
+        t.identifier(emitInstrumentForget.globalGating),
+        t.identifier(emitInstrumentForget.gating.importSpecifierName),
       );
-      if (assertResult.isErr()) {
-        return assertResult;
-      }
-    }
-
-    let ifTest: t.Expression;
-    if (gating != null && globalGating != null) {
-      ifTest = t.logicalExpression('&&', globalGating, gating);
-    } else if (gating != null) {
-      ifTest = gating;
+    } else if (emitInstrumentForget.gating != null) {
+      gating = t.identifier(emitInstrumentForget.gating.importSpecifierName);
     } else {
-      CompilerError.invariant(globalGating != null, {
+      CompilerError.invariant(emitInstrumentForget.globalGating != null, {
         reason:
           'Bad config not caught! Expected at least one of gating or globalGating',
         loc: null,
         suggestions: null,
       });
-      ifTest = globalGating;
+      gating = t.identifier(emitInstrumentForget.globalGating);
     }
-
-    const instrumentFnIdentifier = fn.env.programContext.addImportSpecifier(
-      emitInstrumentForget.fn,
-    ).name;
     const test: t.IfStatement = t.ifStatement(
-      ifTest,
+      gating,
       t.expressionStatement(
-        t.callExpression(t.identifier(instrumentFnIdentifier), [
-          t.stringLiteral(fn.id),
-          t.stringLiteral(fn.env.filename ?? ''),
-        ]),
+        t.callExpression(
+          t.identifier(emitInstrumentForget.fn.importSpecifierName),
+          [t.stringLiteral(fn.id), t.stringLiteral(fn.env.filename ?? '')],
+        ),
       ),
     );
     compiled.body.body.unshift(test);
@@ -388,9 +359,8 @@ function codegenReactiveFunction(
     prunedMemoBlocks: countMemoBlockVisitor.prunedMemoBlocks,
     prunedMemoValues: countMemoBlockVisitor.prunedMemoValues,
     outlined: [],
+    hasLoweredContextAccess: fn.env.hasLoweredContextAccess,
     hasFireRewrite: fn.env.hasFireRewrite,
-    hasInferredEffect: fn.env.hasInferredEffect,
-    inferredEffectLocations: fn.env.inferredEffectLocations,
   });
 }
 
@@ -578,19 +548,14 @@ function codegenBlockNoReset(
 }
 
 function wrapCacheDep(cx: Context, value: t.Expression): t.Expression {
-  if (cx.env.config.enableEmitFreeze != null && cx.env.isInferredMemoEnabled) {
-    const emitFreezeIdentifier = cx.env.programContext.addImportSpecifier(
-      cx.env.config.enableEmitFreeze,
-    ).name;
-    cx.env.programContext
-      .assertGlobalBinding(EMIT_FREEZE_GLOBAL_GATING, cx.env.scope)
-      .unwrap();
+  if (cx.env.config.enableEmitFreeze != null) {
+    // The import declaration for emitFreeze is inserted in the Babel plugin
     return t.conditionalExpression(
-      t.identifier(EMIT_FREEZE_GLOBAL_GATING),
-      t.callExpression(t.identifier(emitFreezeIdentifier), [
-        value,
-        t.stringLiteral(cx.fnName),
-      ]),
+      t.identifier('__DEV__'),
+      t.callExpression(
+        t.identifier(cx.env.config.enableEmitFreeze.importSpecifierName),
+        [value, t.stringLiteral(cx.fnName)],
+      ),
       value,
     );
   } else {
@@ -744,14 +709,16 @@ function codegenReactiveScope(
   let computationBlock = codegenBlock(cx, block);
 
   let memoStatement;
-  const detectionFunction = cx.env.config.enableChangeDetectionForDebugging;
-  if (detectionFunction != null && changeExpressions.length > 0) {
+  if (
+    cx.env.config.enableChangeDetectionForDebugging != null &&
+    changeExpressions.length > 0
+  ) {
     const loc =
       typeof scope.loc === 'symbol'
         ? 'unknown location'
         : `(${scope.loc.start.line}:${scope.loc.end.line})`;
-    const importedDetectionFunctionIdentifier =
-      cx.env.programContext.addImportSpecifier(detectionFunction).name;
+    const detectionFunction =
+      cx.env.config.enableChangeDetectionForDebugging.importSpecifierName;
     const cacheLoadOldValueStatements: Array<t.Statement> = [];
     const changeDetectionStatements: Array<t.Statement> = [];
     const idempotenceDetectionStatements: Array<t.Statement> = [];
@@ -773,7 +740,7 @@ function codegenReactiveScope(
       );
       changeDetectionStatements.push(
         t.expressionStatement(
-          t.callExpression(t.identifier(importedDetectionFunctionIdentifier), [
+          t.callExpression(t.identifier(detectionFunction), [
             t.identifier(loadName),
             t.cloneNode(name, true),
             t.stringLiteral(name.name),
@@ -785,7 +752,7 @@ function codegenReactiveScope(
       );
       idempotenceDetectionStatements.push(
         t.expressionStatement(
-          t.callExpression(t.identifier(importedDetectionFunctionIdentifier), [
+          t.callExpression(t.identifier(detectionFunction), [
             t.cloneNode(slot, true),
             t.cloneNode(name, true),
             t.stringLiteral(name.name),
@@ -1547,15 +1514,15 @@ const createStringLiteral = withLoc(t.stringLiteral);
 
 function createHookGuard(
   guard: ExternalFunction,
-  context: ProgramContext,
   stmts: Array<t.Statement>,
   before: GuardKind,
   after: GuardKind,
 ): t.TryStatement {
-  const guardFnName = context.addImportSpecifier(guard).name;
   function createHookGuardImpl(kind: number): t.ExpressionStatement {
     return t.expressionStatement(
-      t.callExpression(t.identifier(guardFnName), [t.numericLiteral(kind)]),
+      t.callExpression(t.identifier(guard.importSpecifierName), [
+        t.numericLiteral(kind),
+      ]),
     );
   }
 
@@ -1586,7 +1553,7 @@ function createHookGuard(
  * ```
  */
 function createCallExpression(
-  env: Environment,
+  config: EnvironmentConfig,
   callee: t.Expression,
   args: Array<t.Expression | t.SpreadElement>,
   loc: SourceLocation | null,
@@ -1597,15 +1564,14 @@ function createCallExpression(
     callExpr.loc = loc;
   }
 
-  const hookGuard = env.config.enableEmitHookGuards;
-  if (hookGuard != null && isHook && env.isInferredMemoEnabled) {
+  const hookGuard = config.enableEmitHookGuards;
+  if (hookGuard != null && isHook) {
     const iife = t.functionExpression(
       null,
       [],
       t.blockStatement([
         createHookGuard(
           hookGuard,
-          env.programContext,
           [t.returnStatement(callExpr)],
           GuardKind.AllowHook,
           GuardKind.DisallowHook,
@@ -1735,7 +1701,7 @@ function codegenInstructionValue(
       const callee = codegenPlaceToExpression(cx, instrValue.callee);
       const args = instrValue.args.map(arg => codegenArgument(cx, arg));
       value = createCallExpression(
-        cx.env,
+        cx.env.config,
         callee,
         args,
         instrValue.loc,
@@ -1825,7 +1791,7 @@ function codegenInstructionValue(
       );
       const args = instrValue.args.map(arg => codegenArgument(cx, arg));
       value = createCallExpression(
-        cx.env,
+        cx.env.config,
         memberExpr,
         args,
         instrValue.loc,

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

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError} from '..';
 import {
   DeclarationId,
   InstructionKind,
@@ -28,17 +27,7 @@ export function pruneHoistedContexts(fn: ReactiveFunction): void {
   visitReactiveFunction(fn, new Visitor(), hoistedIdentifiers);
 }
 
-const REWRITTEN_HOISTED_CONST: unique symbol = Symbol(
-  'REWRITTEN_HOISTED_CONST',
-);
-const REWRITTEN_HOISTED_LET: unique symbol = Symbol('REWRITTEN_HOISTED_LET');
-
-type HoistedIdentifiers = Map<
-  DeclarationId,
-  | InstructionKind
-  | typeof REWRITTEN_HOISTED_CONST
-  | typeof REWRITTEN_HOISTED_LET
->;
+type HoistedIdentifiers = Map<DeclarationId, InstructionKind>;
 
 class Visitor extends ReactiveFunctionTransform<HoistedIdentifiers> {
   override transformInstruction(
@@ -46,10 +35,6 @@ class Visitor extends ReactiveFunctionTransform<HoistedIdentifiers> {
     state: HoistedIdentifiers,
   ): Transformed<ReactiveStatement> {
     this.visitInstruction(instruction, state);
-
-    /**
-     * Remove hoisted declarations to preserve TDZ
-     */
     if (
       instruction.value.kind === 'DeclareContext' &&
       instruction.value.lvalue.kind === 'HoistedConst'
@@ -83,75 +68,31 @@ class Visitor extends ReactiveFunctionTransform<HoistedIdentifiers> {
       return {kind: 'remove'};
     }
 
-    if (instruction.value.kind === 'StoreContext') {
+    if (
+      instruction.value.kind === 'StoreContext' &&
+      state.has(instruction.value.lvalue.place.identifier.declarationId)
+    ) {
       const kind = state.get(
         instruction.value.lvalue.place.identifier.declarationId,
-      );
-      if (kind != null) {
-        CompilerError.invariant(kind !== REWRITTEN_HOISTED_CONST, {
-          reason: 'Expected exactly one store to a hoisted const variable',
-          loc: instruction.loc,
-        });
-        if (
-          kind === InstructionKind.Const ||
-          kind === InstructionKind.Function
-        ) {
-          state.set(
-            instruction.value.lvalue.place.identifier.declarationId,
-            REWRITTEN_HOISTED_CONST,
-          );
-          return {
-            kind: 'replace',
+      )!;
+      return {
+        kind: 'replace',
+        value: {
+          kind: 'instruction',
+          instruction: {
+            ...instruction,
             value: {
-              kind: 'instruction',
-              instruction: {
-                ...instruction,
-                value: {
-                  ...instruction.value,
-                  lvalue: {
-                    ...instruction.value.lvalue,
-                    kind,
-                  },
-                  type: null,
-                  kind: 'StoreLocal',
-                },
+              ...instruction.value,
+              lvalue: {
+                ...instruction.value.lvalue,
+                kind,
               },
+              type: null,
+              kind: 'StoreLocal',
             },
-          };
-        } else if (kind !== REWRITTEN_HOISTED_LET) {
-          /**
-           * Context variables declared with let may have reassignments. Only
-           * insert a `DeclareContext` for the first encountered `StoreContext`
-           * instruction.
-           */
-          state.set(
-            instruction.value.lvalue.place.identifier.declarationId,
-            REWRITTEN_HOISTED_LET,
-          );
-          return {
-            kind: 'replace-many',
-            value: [
-              {
-                kind: 'instruction',
-                instruction: {
-                  id: instruction.id,
-                  lvalue: null,
-                  value: {
-                    kind: 'DeclareContext',
-                    lvalue: {
-                      kind: InstructionKind.Let,
-                      place: {...instruction.value.lvalue.place},
-                    },
-                    loc: instruction.value.loc,
-                  },
-                  loc: instruction.loc,
-                },
-              },
-              {kind: 'instruction', instruction},
-            ],
-          };
-        }
-      }
+          },
+        },
+      };
     }
 
     return {kind: 'keep'};

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

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {ProgramContext} from '..';
 import {CompilerError} from '../CompilerError';
 import {
   DeclarationId,
@@ -48,7 +47,7 @@ import {ReactiveFunctionVisitor, visitReactiveFunction} from './visitors';
  */
 export function renameVariables(fn: ReactiveFunction): Set<string> {
   const globals = collectReferencedGlobals(fn);
-  const scopes = new Scopes(globals, fn.env.programContext);
+  const scopes = new Scopes(globals);
   renameVariablesImpl(fn, new Visitor(), scopes);
   return new Set([...scopes.names, ...globals]);
 }
@@ -125,12 +124,10 @@ class Scopes {
   #seen: Map<DeclarationId, IdentifierName> = new Map();
   #stack: Array<Map<string, DeclarationId>> = [new Map()];
   #globals: Set<string>;
-  #programContext: ProgramContext;
   names: Set<ValidIdentifierName> = new Set();
 
-  constructor(globals: Set<string>, programContext: ProgramContext) {
+  constructor(globals: Set<string>) {
     this.#globals = globals;
-    this.#programContext = programContext;
   }
 
   visit(identifier: Identifier): void {
@@ -159,7 +156,6 @@ class Scopes {
         name = `${originalName.value}$${id++}`;
       }
     }
-    this.#programContext.addNewReference(name);
     const identifierName = makeIdentifierName(name);
     identifier.name = identifierName;
     this.#seen.set(identifier.declarationId, identifierName);

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

@@ -14,10 +14,7 @@ export {extractScopeDeclarationsFromDestructuring} from './ExtractScopeDeclarati
 export {inferReactiveScopeVariables} from './InferReactiveScopeVariables';
 export {memoizeFbtAndMacroOperandsInSameScope} from './MemoizeFbtAndMacroOperandsInSameScope';
 export {mergeReactiveScopesThatInvalidateTogether} from './MergeReactiveScopesThatInvalidateTogether';
-export {
-  printReactiveFunction,
-  printReactiveFunctionWithOutlined,
-} from './PrintReactiveFunction';
+export {printReactiveFunction} from './PrintReactiveFunction';
 export {promoteUsedTemporaries} from './PromoteUsedTemporaries';
 export {propagateEarlyReturns} from './PropagateEarlyReturns';
 export {pruneAllReactiveScopes} from './PruneAllReactiveScopes';

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

@@ -28,7 +28,6 @@ import {
   isUseEffectHookType,
   LoadLocal,
   makeInstructionId,
-  NonLocalImportSpecifier,
   Place,
   promoteTemporary,
 } from '../HIR';
@@ -37,7 +36,6 @@ import {getOrInsertWith} from '../Utils/utils';
 import {BuiltInFireId, DefaultNonmutatingHook} from '../HIR/ObjectShape';
 import {eachInstructionOperand} from '../HIR/visitors';
 import {printSourceLocationLine} from '../HIR/PrintHIR';
-import {USE_FIRE_FUNCTION_NAME} from '../HIR/Environment';
 
 /*
  * TODO(jmbrown):
@@ -58,7 +56,6 @@ export function transformFire(fn: HIRFunction): void {
 }
 
 function replaceFireFunctions(fn: HIRFunction, context: Context): void {
-  let importedUseFire: NonLocalImportSpecifier | null = null;
   let hasRewrite = false;
   for (const [, block] of fn.body.blocks) {
     const rewriteInstrs = new Map<InstructionId, Array<Instruction>>();
@@ -90,15 +87,7 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
           ] of capturedCallees.entries()) {
             if (!context.hasCalleeWithInsertedFire(fireCalleePlace)) {
               context.addCalleeWithInsertedFire(fireCalleePlace);
-
-              importedUseFire ??= fn.env.programContext.addImportSpecifier({
-                source: fn.env.programContext.reactRuntimeModule,
-                importSpecifierName: USE_FIRE_FUNCTION_NAME,
-              });
-              const loadUseFireInstr = makeLoadUseFireInstruction(
-                fn.env,
-                importedUseFire,
-              );
+              const loadUseFireInstr = makeLoadUseFireInstruction(fn.env);
               const loadFireCalleeInstr = makeLoadFireCalleeInstruction(
                 fn.env,
                 fireCalleeInfo.capturedCalleeIdentifier,
@@ -415,16 +404,18 @@ function ensureNoMoreFireUses(fn: HIRFunction, context: Context): void {
   }
 }
 
-function makeLoadUseFireInstruction(
-  env: Environment,
-  importedLoadUseFire: NonLocalImportSpecifier,
-): Instruction {
+function makeLoadUseFireInstruction(env: Environment): Instruction {
   const useFirePlace = createTemporaryPlace(env, GeneratedSource);
   useFirePlace.effect = Effect.Read;
   useFirePlace.identifier.type = DefaultNonmutatingHook;
   const instrValue: InstructionValue = {
     kind: 'LoadGlobal',
-    binding: {...importedLoadUseFire},
+    binding: {
+      kind: 'ImportSpecifier',
+      name: 'useFire',
+      module: 'react',
+      imported: 'useFire',
+    },
     loc: GeneratedSource,
   };
   return {

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

@@ -261,7 +261,6 @@ function* generateInstructionTypes(
         kind: 'Function',
         shapeId: null,
         return: returnType,
-        isConstructor: false,
       });
       yield equation(left, returnType);
       break;
@@ -278,7 +277,6 @@ function* generateInstructionTypes(
         kind: 'Function',
         shapeId: null,
         return: returnType,
-        isConstructor: false,
       });
       yield equation(left, returnType);
       break;
@@ -335,7 +333,6 @@ function* generateInstructionTypes(
         kind: 'Function',
         return: returnType,
         shapeId: null,
-        isConstructor: false,
       });
 
       yield equation(left, returnType);
@@ -408,7 +405,6 @@ function* generateInstructionTypes(
         kind: 'Function',
         shapeId: BuiltInFunctionId,
         return: value.loweredFunc.func.returnType,
-        isConstructor: false,
       });
       break;
     }
@@ -429,20 +425,9 @@ function* generateInstructionTypes(
       yield equation(left, {kind: 'Object', shapeId: BuiltInJsxId});
       break;
     }
-    case 'NewExpression': {
-      const returnType = makeType();
-      yield equation(value.callee.identifier.type, {
-        kind: 'Function',
-        return: returnType,
-        shapeId: null,
-        isConstructor: true,
-      });
-
-      yield equation(left, returnType);
-      break;
-    }
     case 'PropertyStore':
     case 'DeclareLocal':
+    case 'NewExpression':
     case 'RegExpLiteral':
     case 'MetaProperty':
     case 'ComputedStore':
@@ -520,11 +505,7 @@ class Unifier {
       return;
     }
 
-    if (
-      tB.kind === 'Function' &&
-      tA.kind === 'Function' &&
-      tA.isConstructor === tB.isConstructor
-    ) {
+    if (tB.kind === 'Function' && tA.kind === 'Function') {
       this.unify(tA.return, tB.return);
       return;
     }
@@ -667,7 +648,6 @@ class Unifier {
           kind: 'Function',
           return: returnType,
           shapeId: type.shapeId,
-          isConstructor: type.isConstructor,
         };
       }
       case 'ObjectMethod':

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

@@ -8,7 +8,6 @@
 import {CompilerError, ErrorSeverity} from '..';
 import {HIRFunction} from '../HIR';
 import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
-import {Result} from '../Utils/Result';
 
 /**
  * Checks that known-impure functions are not called during render. Examples of invalid functions to
@@ -19,9 +18,7 @@ import {Result} from '../Utils/Result';
  * this in several of our validation passes and should unify those analyses into a reusable helper
  * and use it here.
  */
-export function validateNoImpureFunctionsInRender(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
@@ -49,5 +46,7 @@ export function validateNoImpureFunctionsInRender(
       }
     }
   }
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    throw errors;
+  }
 }

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

@@ -26,7 +26,6 @@ import {
   eachTerminalOperand,
 } from '../HIR/visitors';
 import {assertExhaustive} from '../Utils/utils';
-import {Result} from '../Utils/Result';
 
 /**
  * Represents the possible kinds of value which may be stored at a given Place during
@@ -88,9 +87,7 @@ function joinKinds(a: Kind, b: Kind): Kind {
  *   may not appear as the callee of a conditional call.
  *   See the note for Kind.PotentialHook for sources of potential hooks
  */
-export function validateHooksUsage(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateHooksUsage(fn: HIRFunction): void {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
 
   const errors = new CompilerError();
@@ -426,7 +423,9 @@ export function validateHooksUsage(
   for (const [, error] of errorsByPlace) {
     errors.push(error);
   }
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    throw errors;
+  }
 }
 
 function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {

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

@@ -22,7 +22,6 @@ import {
   ReactiveFunctionVisitor,
   visitReactiveFunction,
 } from '../ReactiveScopes/visitors';
-import {Result} from '../Utils/Result';
 
 /**
  * Validates that all known effect dependencies are memoized. The algorithm checks two things:
@@ -48,12 +47,12 @@ import {Result} from '../Utils/Result';
  * mutate(object); // ... mutable range ends here after this mutation
  * ```
  */
-export function validateMemoizedEffectDependencies(
-  fn: ReactiveFunction,
-): Result<void, CompilerError> {
+export function validateMemoizedEffectDependencies(fn: ReactiveFunction): void {
   const errors = new CompilerError();
   visitReactiveFunction(fn, new Visitor(), errors);
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    throw errors;
+  }
 }
 
 class Visitor extends ReactiveFunctionVisitor<CompilerError> {

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

@@ -4,14 +4,11 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import {CompilerError, EnvironmentConfig, ErrorSeverity} from '..';
+import {CompilerError, EnvironmentConfig} from '..';
 import {HIRFunction, IdentifierId} from '../HIR';
 import {DEFAULT_GLOBALS} from '../HIR/Globals';
-import {Result} from '../Utils/Result';
 
-export function validateNoCapitalizedCalls(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoCapitalizedCalls(fn: HIRFunction): void {
   const envConfig: EnvironmentConfig = fn.env.config;
   const ALLOW_LIST = new Set([
     ...DEFAULT_GLOBALS.keys(),
@@ -29,7 +26,6 @@ export function validateNoCapitalizedCalls(
     );
   };
 
-  const errors = new CompilerError();
   const capitalLoadGlobals = new Map<IdentifierId, string>();
   const capitalizedProperties = new Map<IdentifierId, string>();
   const reason =
@@ -77,8 +73,7 @@ export function validateNoCapitalizedCalls(
           const propertyIdentifier = value.property.identifier.id;
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
-            errors.push({
-              severity: ErrorSeverity.InvalidReact,
+            CompilerError.throwInvalidReact({
               reason,
               description: `${propertyName} may be a component.`,
               loc: value.loc,
@@ -90,5 +85,4 @@ export function validateNoCapitalizedCalls(
       }
     }
   }
-  return errors.asResult();
 }

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

@@ -7,7 +7,6 @@
 
 import {CompilerError, ErrorSeverity} from '..';
 import {BlockId, HIRFunction} from '../HIR';
-import {Result} from '../Utils/Result';
 import {retainWhere} from '../Utils/utils';
 
 /**
@@ -20,9 +19,7 @@ import {retainWhere} from '../Utils/utils';
  * created within a try block. JSX is allowed within a catch statement, unless that catch
  * is itself nested inside an outer try.
  */
-export function validateNoJSXInTryStatement(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoJSXInTryStatement(fn: HIRFunction): void {
   const activeTryBlocks: Array<BlockId> = [];
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
@@ -49,5 +46,7 @@ export function validateNoJSXInTryStatement(
       activeTryBlocks.push(block.terminal.handler);
     }
   }
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    throw errors;
+  }
 }

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

@@ -99,11 +99,9 @@ class Env extends Map<IdentifierId, RefAccessType> {
   }
 }
 
-export function validateNoRefAccessInRender(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoRefAccessInRender(fn: HIRFunction): void {
   const env = new Env();
-  return validateNoRefAccessInRenderImpl(fn, env).map(_ => undefined);
+  validateNoRefAccessInRenderImpl(fn, env).unwrap();
 }
 
 function refTypeOfType(place: Place): RefAccessType {

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

@@ -14,7 +14,6 @@ import {
   Place,
 } from '../HIR';
 import {eachInstructionValueOperand} from '../HIR/visitors';
-import {Result} from '../Utils/Result';
 
 /**
  * Validates against calling setState in the body of a *passive* effect (useEffect),
@@ -24,9 +23,7 @@ import {Result} from '../Utils/Result';
  * often bad for performance and frequently has more efficient and straightforward
  * alternatives. See https://react.dev/learn/you-might-not-need-an-effect for examples.
  */
-export function validateNoSetStateInPassiveEffects(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoSetStateInPassiveEffects(fn: HIRFunction): void {
   const setStateFunctions: Map<IdentifierId, Place> = new Map();
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
@@ -101,7 +98,9 @@ export function validateNoSetStateInPassiveEffects(
     }
   }
 
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    throw errors;
+  }
 }
 
 function getSetStateCall(

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

@@ -9,7 +9,7 @@ import {CompilerError, ErrorSeverity} from '../CompilerError';
 import {HIRFunction, IdentifierId, isSetStateType} from '../HIR';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
 import {eachInstructionValueOperand} from '../HIR/visitors';
-import {Result} from '../Utils/Result';
+import {Err, Ok, Result} from '../Utils/Result';
 
 /**
  * Validates that the given function does not have an infinite update loop
@@ -39,11 +39,9 @@ import {Result} from '../Utils/Result';
  * y();
  * ```
  */
-export function validateNoSetStateInRender(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoSetStateInRender(fn: HIRFunction): void {
   const unconditionalSetStateFunctions: Set<IdentifierId> = new Set();
-  return validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions);
+  validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions).unwrap();
 }
 
 function validateNoSetStateInRenderImpl(
@@ -147,5 +145,9 @@ function validateNoSetStateInRenderImpl(
     }
   }
 
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    return Err(errors);
+  } else {
+    return Ok(undefined);
+  }
 }

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

@@ -5,10 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError, ErrorSeverity} from '../CompilerError';
+import {CompilerError, Effect, ErrorSeverity} from '..';
 import {
   DeclarationId,
-  Effect,
   GeneratedSource,
   Identifier,
   IdentifierId,
@@ -31,7 +30,6 @@ import {
   ReactiveFunctionVisitor,
   visitReactiveFunction,
 } from '../ReactiveScopes/visitors';
-import {Result} from '../Utils/Result';
 import {getOrInsertDefault} from '../Utils/utils';
 
 /**
@@ -41,15 +39,15 @@ import {getOrInsertDefault} from '../Utils/utils';
  * This can occur if a value's mutable range somehow extended to include a hook and
  * was pruned.
  */
-export function validatePreservedManualMemoization(
-  fn: ReactiveFunction,
-): Result<void, CompilerError> {
+export function validatePreservedManualMemoization(fn: ReactiveFunction): void {
   const state = {
     errors: new CompilerError(),
     manualMemoState: null,
   };
   visitReactiveFunction(fn, new Visitor(), state);
-  return state.errors.asResult();
+  if (state.errors.hasErrors()) {
+    throw state.errors;
+  }
 }
 
 const DEBUG = false;

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

@@ -1,83 +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 {CompilerError, ErrorSeverity} from '../CompilerError';
-import {HIRFunction, IdentifierId, SourceLocation} from '../HIR';
-import {Result} from '../Utils/Result';
-
-/**
- * Validates against components that are created dynamically and whose identity is not guaranteed
- * to be stable (which would cause the component to reset on each re-render).
- */
-export function validateStaticComponents(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
-  const error = new CompilerError();
-  const knownDynamicComponents = new Map<IdentifierId, SourceLocation>();
-  for (const block of fn.body.blocks.values()) {
-    phis: for (const phi of block.phis) {
-      for (const operand of phi.operands.values()) {
-        const loc = knownDynamicComponents.get(operand.identifier.id);
-        if (loc != null) {
-          knownDynamicComponents.set(phi.place.identifier.id, loc);
-          continue phis;
-        }
-      }
-    }
-    for (const instr of block.instructions) {
-      const {lvalue, value} = instr;
-      switch (value.kind) {
-        case 'FunctionExpression':
-        case 'NewExpression':
-        case 'MethodCall':
-        case 'CallExpression': {
-          knownDynamicComponents.set(lvalue.identifier.id, value.loc);
-          break;
-        }
-        case 'LoadLocal': {
-          const loc = knownDynamicComponents.get(value.place.identifier.id);
-          if (loc != null) {
-            knownDynamicComponents.set(lvalue.identifier.id, loc);
-          }
-          break;
-        }
-        case 'StoreLocal': {
-          const loc = knownDynamicComponents.get(value.value.identifier.id);
-          if (loc != null) {
-            knownDynamicComponents.set(lvalue.identifier.id, loc);
-            knownDynamicComponents.set(value.lvalue.place.identifier.id, loc);
-          }
-          break;
-        }
-        case 'JsxExpression': {
-          if (value.tag.kind === 'Identifier') {
-            const location = knownDynamicComponents.get(
-              value.tag.identifier.id,
-            );
-            if (location != null) {
-              error.push({
-                reason: `Components created during render will reset their state each time they are created. Declare components outside of render. `,
-                severity: ErrorSeverity.InvalidReact,
-                loc: value.tag.loc,
-                description: null,
-                suggestions: null,
-              });
-              error.push({
-                reason: `The component may be created during render`,
-                severity: ErrorSeverity.InvalidReact,
-                loc: location,
-                description: null,
-                suggestions: null,
-              });
-            }
-          }
-        }
-      }
-    }
-  }
-  return error.asResult();
-}

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

@@ -5,12 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError, ErrorSeverity} from '..';
+import {CompilerError} from '..';
 import {FunctionExpression, HIRFunction, IdentifierId} from '../HIR';
-import {Result} from '../Utils/Result';
 
-export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
-  const errors = new CompilerError();
+export function validateUseMemo(fn: HIRFunction): void {
   const useMemos = new Set<IdentifierId>();
   const react = new Set<IdentifierId>();
   const functions = new Map<IdentifierId, FunctionExpression>();
@@ -63,8 +61,7 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
           }
 
           if (body.loweredFunc.func.params.length > 0) {
-            errors.push({
-              severity: ErrorSeverity.InvalidReact,
+            CompilerError.throwInvalidReact({
               reason: 'useMemo callbacks may not accept any arguments',
               description: null,
               loc: body.loc,
@@ -73,8 +70,7 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
           }
 
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
-            errors.push({
-              severity: ErrorSeverity.InvalidReact,
+            CompilerError.throwInvalidReact({
               reason:
                 'useMemo callbacks may not be async or generator functions',
               description: null,
@@ -88,5 +84,4 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
       }
     }
   }
-  return errors.asResult();
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/e2e/constant-prop.e2e.js

@@ -12,7 +12,6 @@ globalThis.constantValue = 'global test value';
 
 test('literal-constant-propagation', () => {
   function Component() {
-    'use memo';
     const x = 'test value 1';
     return <div>{x}</div>;
   }
@@ -39,7 +38,6 @@ test('literal-constant-propagation', () => {
 
 test('global-constant-propagation', () => {
   function Component() {
-    'use memo';
     const x = constantValue;
 
     return <div>{x}</div>;
@@ -67,7 +65,6 @@ test('global-constant-propagation', () => {
 
 test('lambda-constant-propagation', () => {
   function Component() {
-    'use memo';
     const x = 'test value 1';
     const getDiv = () => <div>{x}</div>;
     return getDiv();
@@ -95,7 +92,6 @@ test('lambda-constant-propagation', () => {
 
 test('lambda-constant-propagation-of-phi-node', () => {
   function Component({noopCallback}) {
-    'use memo';
     const x = 'test value 1';
     if (constantValue) {
       noopCallback();

compiler/packages/babel-plugin-react-compiler/src/__tests__/e2e/update-button.e2e.js

@@ -16,7 +16,6 @@ function Button({label}) {
 
 let currentTheme = 'light';
 function useTheme() {
-  'use memo';
   return currentTheme;
 }
 

compiler/packages/babel-plugin-react-compiler/src/__tests__/e2e/update-expressions.e2e.js

@@ -10,7 +10,6 @@ import * as React from 'react';
 import {expectLogsAndClear, log} from './expectLogs';
 
 function Counter(props) {
-  'use memo';
   let value = props.value;
   let a = value++;
   expect(a).toBe(props.value); // postfix

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/array-from-arg1-captures-arg0.expect.md

@@ -50,55 +50,28 @@ import { useIdentity, Stringify } from "shared-runtime";
  * (2) the 1st argument might mutate its callee
  */
 function Component(t0) {
-  const $ = _c(10);
+  const $ = _c(4);
   const { value } = t0;
-  let t1;
-  let t2;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = { value: "foo" };
-    t2 = { value: "bar" };
-    $[0] = t1;
-    $[1] = t2;
-  } else {
-    t1 = $[0];
-    t2 = $[1];
-  }
-  let t3;
-  if ($[2] !== value) {
-    t3 = [t1, t2, { value }];
-    $[2] = value;
-    $[3] = t3;
-  } else {
-    t3 = $[3];
-  }
-  const arr = t3;
+  const arr = [{ value: "foo" }, { value: "bar" }, { value }];
   useIdentity();
-  let t4;
-  if ($[4] !== arr) {
-    t4 = Array.from(arr, _temp);
-    $[4] = arr;
-    $[5] = t4;
+  const derived = Array.from(arr, _temp);
+  let t1;
+  if ($[0] !== derived) {
+    t1 = derived.at(-1);
+    $[0] = derived;
+    $[1] = t1;
   } else {
-    t4 = $[5];
+    t1 = $[1];
   }
-  const derived = t4;
-  let t5;
-  if ($[6] !== derived) {
-    t5 = derived.at(-1);
-    $[6] = derived;
-    $[7] = t5;
+  let t2;
+  if ($[2] !== t1) {
+    t2 = <Stringify>{t1}</Stringify>;
+    $[2] = t1;
+    $[3] = t2;
   } else {
-    t5 = $[7];
+    t2 = $[3];
   }
-  let t6;
-  if ($[8] !== t5) {
-    t6 = <Stringify>{t5}</Stringify>;
-    $[8] = t5;
-    $[9] = t6;
-  } else {
-    t6 = $[9];
-  }
-  return t6;
+  return t2;
 }
 function _temp(x, idx) {
   return { ...x, id: idx };

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/array-from-captures-arg0.expect.md

@@ -50,55 +50,28 @@ import { useIdentity, Stringify } from "shared-runtime";
  * (2) the 1st argument might mutate its callee
  */
 function Component(t0) {
-  const $ = _c(10);
+  const $ = _c(4);
   const { value } = t0;
-  let t1;
-  let t2;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = { value: "foo" };
-    t2 = { value: "bar" };
-    $[0] = t1;
-    $[1] = t2;
-  } else {
-    t1 = $[0];
-    t2 = $[1];
-  }
-  let t3;
-  if ($[2] !== value) {
-    t3 = [t1, t2, { value }];
-    $[2] = value;
-    $[3] = t3;
-  } else {
-    t3 = $[3];
-  }
-  const arr = t3;
+  const arr = [{ value: "foo" }, { value: "bar" }, { value }];
   useIdentity();
-  let t4;
-  if ($[4] !== arr) {
-    t4 = Array.from(arr);
-    $[4] = arr;
-    $[5] = t4;
+  const derived = Array.from(arr);
+  let t1;
+  if ($[0] !== derived) {
+    t1 = derived.at(-1);
+    $[0] = derived;
+    $[1] = t1;
   } else {
-    t4 = $[5];
+    t1 = $[1];
   }
-  const derived = t4;
-  let t5;
-  if ($[6] !== derived) {
-    t5 = derived.at(-1);
-    $[6] = derived;
-    $[7] = t5;
+  let t2;
+  if ($[2] !== t1) {
+    t2 = <Stringify>{t1}</Stringify>;
+    $[2] = t1;
+    $[3] = t2;
   } else {
-    t5 = $[7];
+    t2 = $[3];
   }
-  let t6;
-  if ($[8] !== t5) {
-    t6 = <Stringify>{t5}</Stringify>;
-    $[8] = t5;
-    $[9] = t6;
-  } else {
-    t6 = $[9];
-  }
-  return t6;
+  return t2;
 }
 
 export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/array-from-maybemutates-arg0.expect.md

@@ -7,19 +7,14 @@ import {mutateAndReturn, Stringify, useIdentity} from 'shared-runtime';
 function Component({value}) {
   const arr = [{value: 'foo'}, {value: 'bar'}, {value}];
   useIdentity();
-  const derived = Array.from(arr).map(mutateAndReturn);
-  return (
-    <Stringify>
-      {derived.at(0)}
-      {derived.at(-1)}
-    </Stringify>
-  );
+  const derived = Array.from(arr, mutateAndReturn);
+  return <Stringify>{derived.at(-1)}</Stringify>;
 }
 
 export const FIXTURE_ENTRYPOINT = {
   fn: Component,
   params: [{value: 5}],
-  sequentialRenders: [{value: 5}, {value: 6}, {value: 6}, {value: 7}],
+  sequentialRenders: [{value: 5}, {value: 6}, {value: 6}],
 };
 
 ```
@@ -31,54 +26,39 @@ import { c as _c } from "react/compiler-runtime";
 import { mutateAndReturn, Stringify, useIdentity } from "shared-runtime";
 
 function Component(t0) {
-  const $ = _c(7);
+  const $ = _c(4);
   const { value } = t0;
   const arr = [{ value: "foo" }, { value: "bar" }, { value }];
   useIdentity();
-  const derived = Array.from(arr).map(mutateAndReturn);
+  const derived = Array.from(arr, mutateAndReturn);
   let t1;
   if ($[0] !== derived) {
-    t1 = derived.at(0);
+    t1 = derived.at(-1);
     $[0] = derived;
     $[1] = t1;
   } else {
     t1 = $[1];
   }
   let t2;
-  if ($[2] !== derived) {
-    t2 = derived.at(-1);
-    $[2] = derived;
+  if ($[2] !== t1) {
+    t2 = <Stringify>{t1}</Stringify>;
+    $[2] = t1;
     $[3] = t2;
   } else {
     t2 = $[3];
   }
-  let t3;
-  if ($[4] !== t1 || $[5] !== t2) {
-    t3 = (
-      <Stringify>
-        {t1}
-        {t2}
-      </Stringify>
-    );
-    $[4] = t1;
-    $[5] = t2;
-    $[6] = t3;
-  } else {
-    t3 = $[6];
-  }
-  return t3;
+  return t2;
 }
 
 export const FIXTURE_ENTRYPOINT = {
   fn: Component,
   params: [{ value: 5 }],
-  sequentialRenders: [{ value: 5 }, { value: 6 }, { value: 6 }, { value: 7 }],
+  sequentialRenders: [{ value: 5 }, { value: 6 }, { value: 6 }],
 };
 
 ```
       
 ### Eval output
-(kind: ok) <div>{"children":[{"value":"foo","wat0":"joe"},{"value":5,"wat0":"joe"}]}</div>
-<div>{"children":[{"value":"foo","wat0":"joe"},{"value":6,"wat0":"joe"}]}</div>
-<div>{"children":[{"value":"foo","wat0":"joe"},{"value":6,"wat0":"joe"}]}</div>
-<div>{"children":[{"value":"foo","wat0":"joe"},{"value":7,"wat0":"joe"}]}</div>
+(kind: ok) <div>{"children":{"value":5,"wat0":"joe"}}</div>
+<div>{"children":{"value":6,"wat0":"joe"}}</div>
+<div>{"children":{"value":6,"wat0":"joe"}}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/array-from-maybemutates-arg0.js

@@ -3,17 +3,12 @@ import {mutateAndReturn, Stringify, useIdentity} from 'shared-runtime';
 function Component({value}) {
   const arr = [{value: 'foo'}, {value: 'bar'}, {value}];
   useIdentity();
-  const derived = Array.from(arr).map(mutateAndReturn);
-  return (
-    <Stringify>
-      {derived.at(0)}
-      {derived.at(-1)}
-    </Stringify>
-  );
+  const derived = Array.from(arr, mutateAndReturn);
+  return <Stringify>{derived.at(-1)}</Stringify>;
 }
 
 export const FIXTURE_ENTRYPOINT = {
   fn: Component,
   params: [{value: 5}],
-  sequentialRenders: [{value: 5}, {value: 6}, {value: 6}, {value: 7}],
+  sequentialRenders: [{value: 5}, {value: 6}, {value: 6}],
 };

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/arrow-function-with-implicit-return.expect.md

@@ -1,39 +0,0 @@
-
-## Input
-
-```javascript
-// @compilationMode(infer)
-const Test = () => <div />;
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Test,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @compilationMode(infer)
-const Test = () => {
-  const $ = _c(1);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = <div />;
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return t0;
-};
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Test,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div></div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/arrow-function-with-implicit-return.js

@@ -1,7 +0,0 @@
-// @compilationMode(infer)
-const Test = () => <div />;
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Test,
-  params: [{}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/babel-existing-react-runtime-import.expect.md

@@ -1,73 +0,0 @@
-
-## Input
-
-```javascript
-import * as React from 'react';
-import {someImport} from 'react/compiler-runtime';
-import {calculateExpensiveNumber} from 'shared-runtime';
-
-function Component(props) {
-  const [x] = React.useState(0);
-  const expensiveNumber = React.useMemo(() => calculateExpensiveNumber(x), [x]);
-
-  return (
-    <div>
-      {expensiveNumber}
-      {`${someImport}`}
-    </div>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [],
-};
-
-```
-
-## Code
-
-```javascript
-import * as React from "react";
-import { someImport, c as _c } from "react/compiler-runtime";
-import { calculateExpensiveNumber } from "shared-runtime";
-
-function Component(props) {
-  const $ = _c(4);
-  const [x] = React.useState(0);
-  let t0;
-  let t1;
-  if ($[0] !== x) {
-    t1 = calculateExpensiveNumber(x);
-    $[0] = x;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  t0 = t1;
-  const expensiveNumber = t0;
-  let t2;
-  if ($[2] !== expensiveNumber) {
-    t2 = (
-      <div>
-        {expensiveNumber}
-        {`${someImport}`}
-      </div>
-    );
-    $[2] = expensiveNumber;
-    $[3] = t2;
-  } else {
-    t2 = $[3];
-  }
-  return t2;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>0undefined</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/babel-existing-react-runtime-import.js

@@ -1,20 +0,0 @@
-import * as React from 'react';
-import {someImport} from 'react/compiler-runtime';
-import {calculateExpensiveNumber} from 'shared-runtime';
-
-function Component(props) {
-  const [x] = React.useState(0);
-  const expensiveNumber = React.useMemo(() => calculateExpensiveNumber(x), [x]);
-
-  return (
-    <div>
-      {expensiveNumber}
-      {`${someImport}`}
-    </div>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/codegen-emit-imports-same-source.expect.md

@@ -14,9 +14,9 @@ function useFoo(props) {
 
 ```javascript
 import {
-  makeReadOnly,
-  shouldInstrument,
   useRenderCounter,
+  shouldInstrument,
+  makeReadOnly,
 } from "react-compiler-runtime";
 import { c as _c } from "react/compiler-runtime"; // @enableEmitFreeze @enableEmitInstrumentForget
 

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/codegen-instrument-forget-test.expect.md

@@ -23,7 +23,7 @@ function Foo(props) {
 ## Code
 
 ```javascript
-import { shouldInstrument, useRenderCounter } from "react-compiler-runtime";
+import { useRenderCounter, shouldInstrument } from "react-compiler-runtime";
 import { c as _c } from "react/compiler-runtime"; // @enableEmitInstrumentForget @compilationMode(annotation)
 
 function Bar(props) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/conflict-codegen-instrument-forget.expect.md

@@ -1,97 +0,0 @@
-
-## Input
-
-```javascript
-// @enableEmitInstrumentForget @compilationMode(annotation)
-
-import {identity} from 'shared-runtime';
-
-function Bar(props) {
-  'use forget';
-  const shouldInstrument = identity(null);
-  const _shouldInstrument = identity(null);
-  const _x2 = () => {
-    const _shouldInstrument2 = 'hello world';
-    return identity({_shouldInstrument2});
-  };
-  return (
-    <div style={shouldInstrument} other={_shouldInstrument}>
-      {props.bar}
-    </div>
-  );
-}
-
-function Foo(props) {
-  'use forget';
-  return <Foo>{props.bar}</Foo>;
-}
-
-```
-
-## Code
-
-```javascript
-import {
-  shouldInstrument as _shouldInstrument3,
-  useRenderCounter,
-} from "react-compiler-runtime";
-import { c as _c } from "react/compiler-runtime"; // @enableEmitInstrumentForget @compilationMode(annotation)
-
-import { identity } from "shared-runtime";
-
-function Bar(props) {
-  "use forget";
-  if (DEV && _shouldInstrument3)
-    useRenderCounter("Bar", "/conflict-codegen-instrument-forget.ts");
-  const $ = _c(4);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = identity(null);
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const shouldInstrument = t0;
-  let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = identity(null);
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const _shouldInstrument = t1;
-  let t2;
-  if ($[2] !== props.bar) {
-    t2 = (
-      <div style={shouldInstrument} other={_shouldInstrument}>
-        {props.bar}
-      </div>
-    );
-    $[2] = props.bar;
-    $[3] = t2;
-  } else {
-    t2 = $[3];
-  }
-  return t2;
-}
-
-function Foo(props) {
-  "use forget";
-  if (DEV && _shouldInstrument3)
-    useRenderCounter("Foo", "/conflict-codegen-instrument-forget.ts");
-  const $ = _c(2);
-  let t0;
-  if ($[0] !== props.bar) {
-    t0 = <Foo>{props.bar}</Foo>;
-    $[0] = props.bar;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/conflict-codegen-instrument-forget.js

@@ -1,23 +0,0 @@
-// @enableEmitInstrumentForget @compilationMode(annotation)
-
-import {identity} from 'shared-runtime';
-
-function Bar(props) {
-  'use forget';
-  const shouldInstrument = identity(null);
-  const _shouldInstrument = identity(null);
-  const _x2 = () => {
-    const _shouldInstrument2 = 'hello world';
-    return identity({_shouldInstrument2});
-  };
-  return (
-    <div style={shouldInstrument} other={_shouldInstrument}>
-      {props.bar}
-    </div>
-  );
-}
-
-function Foo(props) {
-  'use forget';
-  return <Foo>{props.bar}</Foo>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/emit-freeze-conflicting-imports.expect.md

@@ -1,37 +0,0 @@
-
-## Input
-
-```javascript
-// @enableEmitFreeze @instrumentForget
-
-let makeReadOnly = 'conflicting identifier';
-function useFoo(props) {
-  return foo(props.x);
-}
-
-```
-
-## Code
-
-```javascript
-import { makeReadOnly as _makeReadOnly } from "react-compiler-runtime";
-import { c as _c } from "react/compiler-runtime"; // @enableEmitFreeze @instrumentForget
-
-let makeReadOnly = "conflicting identifier";
-function useFoo(props) {
-  const $ = _c(2);
-  let t0;
-  if ($[0] !== props.x) {
-    t0 = foo(props.x);
-    $[0] = props.x;
-    $[1] = __DEV__ ? _makeReadOnly(t0, "useFoo") : t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/emit-freeze-nonconflicting-global-reference.expect.md

@@ -1,33 +0,0 @@
-
-## Input
-
-```javascript
-// @enableEmitFreeze @instrumentForget
-function useFoo(props) {
-  return foo(props.x, __DEV__);
-}
-
-```
-
-## Code
-
-```javascript
-import { makeReadOnly } from "react-compiler-runtime";
-import { c as _c } from "react/compiler-runtime"; // @enableEmitFreeze @instrumentForget
-function useFoo(props) {
-  const $ = _c(2);
-  let t0;
-  if ($[0] !== props.x) {
-    t0 = foo(props.x, __DEV__);
-    $[0] = props.x;
-    $[1] = __DEV__ ? makeReadOnly(t0, "useFoo") : t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/emit-freeze-nonconflicting-global-reference.js

@@ -1,4 +0,0 @@
-// @enableEmitFreeze @instrumentForget
-function useFoo(props) {
-  return foo(props.x, __DEV__);
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.codegen-error-on-conflicting-imports.expect.md

@@ -0,0 +1,21 @@
+
+## Input
+
+```javascript
+// @enableEmitFreeze @instrumentForget
+
+let makeReadOnly = 'conflicting identifier';
+function useFoo(props) {
+  return foo(props.x);
+}
+
+```
+
+
+## Error
+
+```
+Invariant: Encountered conflicting import specifiers for makeReadOnly in generated program.
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.emit-freeze-conflicting-global.expect.md

@@ -1,27 +0,0 @@
-
-## Input
-
-```javascript
-// @enableEmitFreeze @instrumentForget
-function useFoo(props) {
-  const __DEV__ = 'conflicting global';
-  console.log(__DEV__);
-  return foo(props.x);
-}
-
-```
-
-
-## Error
-
-```
-  1 | // @enableEmitFreeze @instrumentForget
-  2 | function useFoo(props) {
-> 3 |   const __DEV__ = 'conflicting global';
-    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Todo: Encountered conflicting global in generated program. Conflict from local binding __DEV__ (3:3)
-  4 |   console.log(__DEV__);
-  5 |   return foo(props.x);
-  6 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.emit-freeze-conflicting-global.js

@@ -1,6 +0,0 @@
-// @enableEmitFreeze @instrumentForget
-function useFoo(props) {
-  const __DEV__ = 'conflicting global';
-  console.log(__DEV__);
-  return foo(props.x);
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-jsx-in-catch-in-outer-try-with-catch.expect.md

@@ -0,0 +1,38 @@
+
+## Input
+
+```javascript
+// @validateNoJSXInTryStatements
+import {identity} from 'shared-runtime';
+
+function Component(props) {
+  let el;
+  try {
+    let value;
+    try {
+      value = identity(props.foo);
+    } catch {
+      el = <div value={value} />;
+    }
+  } catch {
+    return null;
+  }
+  return el;
+}
+
+```
+
+
+## Error
+
+```
+   9 |       value = identity(props.foo);
+  10 |     } catch {
+> 11 |       el = <div value={value} />;
+     |            ^^^^^^^^^^^^^^^^^^^^^ InvalidReact: Unexpected JSX element within a try statement. To catch errors in rendering a given component, wrap that component in an error boundary. (https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary) (11:11)
+  12 |     }
+  13 |   } catch {
+  14 |     return null;
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-jsx-in-catch-in-outer-try-with-catch.js

@@ -1,4 +1,4 @@
-// @logger @validateNoJSXInTryStatements
+// @validateNoJSXInTryStatements
 import {identity} from 'shared-runtime';
 
 function Component(props) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-jsx-in-try-with-catch.expect.md

@@ -0,0 +1,31 @@
+
+## Input
+
+```javascript
+// @validateNoJSXInTryStatements
+function Component(props) {
+  let el;
+  try {
+    el = <div />;
+  } catch {
+    return null;
+  }
+  return el;
+}
+
+```
+
+
+## Error
+
+```
+  3 |   let el;
+  4 |   try {
+> 5 |     el = <div />;
+    |          ^^^^^^^ InvalidReact: Unexpected JSX element within a try statement. To catch errors in rendering a given component, wrap that component in an error boundary. (https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary) (5:5)
+  6 |   } catch {
+  7 |     return null;
+  8 |   }
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-jsx-in-try-with-catch.js

@@ -1,4 +1,4 @@
-// @logger @validateNoJSXInTryStatements
+// @validateNoJSXInTryStatements
 function Component(props) {
   let el;
   try {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-setState-in-useEffect-transitive.expect.md

@@ -0,0 +1,37 @@
+
+## Input
+
+```javascript
+// @validateNoSetStateInPassiveEffects
+import {useEffect, useState} from 'react';
+
+function Component() {
+  const [state, setState] = useState(0);
+  const f = () => {
+    setState(s => s + 1);
+  };
+  const g = () => {
+    f();
+  };
+  useEffect(() => {
+    g();
+  });
+  return state;
+}
+
+```
+
+
+## Error
+
+```
+  11 |   };
+  12 |   useEffect(() => {
+> 13 |     g();
+     |     ^ InvalidReact: Calling setState directly within a useEffect causes cascading renders and is not recommended. Consider alternatives to useEffect. (https://react.dev/learn/you-might-not-need-an-effect) (13:13)
+  14 |   });
+  15 |   return state;
+  16 | }
+```
+          
+