fix(@jest/transform): skip the code cache write when cache is disabled - #16464

Summary

ScriptTransformer writes the transformed code to cacheDirectory for every module it transforms, even when cache is false (--no-cache). That file is only ever read back behind this._config.cache (both readCodeCacheFile call sites), so with the cache off, each write is thrown away. Skipping it avoids one atomic write per transformed module: a temp-file write plus a rename, from write-file-atomic.

This change guards the single writeCodeCacheFile call with this._config.cache. Nothing else changes:

• Source maps are still written. sourceMapPath is returned to callers and read back by path for stack-trace remapping and coverage, regardless of cache.
• cache: true (the default) behaves exactly as before. Same reads, same writes, same keys.

Why it matters

The general point: writing a file that will never be read is pure overhead. It costs filesystem syscalls, disk I/O and cache-directory churn, and grows with the number of modules a test run transforms.

It matters more in sandboxed or hermetic runners, where cache: false is the norm rather than an escape hatch. For example, aspect_rules_jest for Bazel sets config.cache = false and points cacheDirectory at the test's fresh TEST_TMPDIR, because a transform cache cannot be shared across hermetic test actions. There, every Jest shard pays for one throwaway write per transformed module on every run. Sandbox filesystems (symlink trees, FUSE, network-backed temp dirs) tend to make those small writes and renames more expensive than on a plain local disk.

Benchmarks

All numbers are wall-clock medians of interleaved runs. The order alternates each round, the same checkout is used for both sides, and only this change differs (@jest/transform/build swapped between main and this branch). macOS, Apple M-series, Node 26.

Minimal repro (1,531 small ES modules, 8 test files, babel-jest, jest --no-cache with a fresh --cacheDirectory, 6 runs per side):

A large private repo (a 403-test slice, @swc/jest, 5 runs per side):

In every configuration, this PR was faster in every interleaved pair, and the min/max ranges do not overlap. Test results were identical.

// generate.js: 1,500 leaf modules, 30 barrels of 50, one index, 8 tests importing the index
const fs = require('fs');
fs.mkdirSync('src', {recursive: true});
fs.mkdirSync('__tests__', {recursive: true});
const N = 1500, G = 50;
for (let i = 0; i < N; i++)
  fs.writeFileSync(`src/m${i}.js`, `export const v${i} = x => [1, 2, 3].map(n => n * x).reduce((s, n) => s + n, 0) + ${i};\n`);
const groups = [];
for (let g = 0; g < N / G; g++) {
  const ids = Array.from({length: G}, (_, k) => g * G + k);
  fs.writeFileSync(`src/g${g}.js`, ids.map(i => `import {v${i}} from './m${i}';\n`).join('') +
    `export const sum${g} = x => ${ids.map(i => `v${i}(x)`).join(' + ')};\n`);
  groups.push(g);
}
fs.writeFileSync('src/index.js', groups.map(g => `import {sum${g}} from './g${g}';\n`).join('') +
  `export const total = x => ${groups.map(g => `sum${g}(x)`).join(' + ')};\n`);
for (let t = 0; t < 8; t++)
  fs.writeFileSync(`__tests__/t${t}.test.js`, `import {total} from '../src/index';\ntest('ok', () => { expect(total(1)).toBeGreaterThan(0); });\n`);

Test plan

• Updated the three "reads values from the cache" tests (sync, async, async preprocessor). They already asserted that the code cache is not read with cache: false; they now also assert that it is not written (writeFileAtomic.sync not called with the code-cache path), where before they asserted that some write happened.
• Added writes only the source map when \config.cache` is false`: with a transformer that returns a map, exactly one write happens, and it is the source map.
• Reverting the source change makes those four tests fail. With it, all tests in packages/jest-transform pass:

$ FORCE_COLOR=1 yarn jest packages/jest-transform
Tests:       101 passed, 101 total
Snapshots:   33 passed, 33 total

• Every e2e suite that runs with --no-cache, plus coverageRemapping, stackTrace, transform and clearCache (29 suites; this covers V8/babel coverage and source-mapped stack traces under --no-cache):

$ yarn build:js && FORCE_COLOR=1 yarn jest $(rg -l "'--no-cache'" e2e/__tests__) e2e/__tests__/{coverageRemapping,stackTrace,transform,clearCache}.test.ts
Test Suites: 29 passed, 29 total
Tests:       119 passed, 119 total
Snapshots:   74 passed, 74 total

• yarn build, yarn typecheck:tests, yarn eslint and yarn prettier --check on the changed files, and yarn check-copyright-headers: all pass.

— sent via Glean Tau