perf(fmt): use empty cache hash sentinel

Author: chenjiahan

packages/rstack/src/fmt/cacheStore.ts

@@ -20,10 +20,8 @@ const fmtCacheStateIds = {
   unsupported: 2,
 } as const satisfies Record<FmtCacheState, FmtCacheStateId>;
 
-type FmtCacheFileValue = string | number | null;
-type FmtCacheEntry =
-  | readonly [contentHash: string, optionsHash: string, state: 'clean' | 'dirty']
-  | readonly [contentHash: string | null, optionsHash: string, state: 'unsupported'];
+type FmtCacheFileValue = string | number;
+type FmtCacheEntry = readonly [contentHash: string, optionsHash: string, state: FmtCacheState];
 
 interface FmtCacheFile {
   version: typeof fmtCacheVersion;
@@ -147,12 +145,10 @@ class FmtCacheStoreImpl implements FmtCacheStore {
     }
 
     const { files, options } = this.#cache;
-    const contentHash = files[offset + contentHashOffset] as string | null;
+    const contentHash = files[offset + contentHashOffset] as string;
     const optionsHash = options[files[offset + optionsIndexOffset] as number];
     const state = fmtCacheStates[files[offset + stateOffset] as FmtCacheStateId];
-    return state === 'unsupported'
-      ? [contentHash, optionsHash, state]
-      : [contentHash as string, optionsHash, state];
+    return [contentHash, optionsHash, state];
   }
 
   set(filePath: string, entry: FmtCacheEntry): void {

packages/rstack/src/fmt/runner.ts

@@ -116,7 +116,7 @@ const isCachedUnsupported = ({ file, cache }: FmtFileRunTask): boolean => {
     return false;
   }
   return (
-    cache.entry[0] === null &&
+    cache.entry[0] === '' &&
     cache.entry[1] === cache.optionsHash &&
     cache.entry[2] === 'unsupported' &&
     hasDottedBasename(file.path)

packages/rstack/src/fmt/worker.ts

@@ -42,7 +42,7 @@ const formatFile = async ({
   if (cache?.entry && cache.entry[1] === cache.optionsHash) {
     const { entry } = cache;
     if (entry[2] === 'unsupported') {
-      if (entry[0] === null) {
+      if (entry[0] === '') {
         if (hasDottedBasename(file.path)) {
           return { status: 'unsupported' };
         }
@@ -70,7 +70,7 @@ const formatFile = async ({
           status: 'unsupported',
           cacheEntry: [
             hasDottedBasename(file.path)
-              ? null
+              ? ''
               : (contentHash ?? createCacheHash(sourceBuffer ?? readFileSync(file.path))),
             cache.optionsHash,
             'unsupported',

packages/rstack/tests/cli/fmt/cache.test.ts

@@ -8,7 +8,7 @@ interface SerializedFmtCache {
   version: number;
   namespace: string;
   options: string[];
-  files: (string | number | null)[];
+  files: (string | number)[];
 }
 
 const readFmtCache = (filePath: string): SerializedFmtCache =>

packages/rstack/tests/fmt/cacheStore.test.ts

@@ -19,7 +19,7 @@ const optionsB = createCacheHash('options-b');
 const optionsC = createCacheHash('options-c');
 const firstEntry = [contentA, optionsA, 'clean'] as const;
 const secondEntry = [contentB, optionsB, 'dirty'] as const;
-const unsupportedEntry = [null, optionsC, 'unsupported'] as const;
+const unsupportedEntry = ['', optionsC, 'unsupported'] as const;
 const hashedUnsupportedEntry = [contentC, optionsC, 'unsupported'] as const;
 
 const readCache = (filePath: string): FmtCacheFile =>
@@ -48,7 +48,7 @@ test('writes flat entries that can be loaded by another store', async () => {
         0,
         0,
         'src/unknown.fixture',
-        null,
+        '',
         1,
         2,
         'script',

packages/rstack/tests/fmt/runnerCache.test.ts

@@ -126,7 +126,7 @@ test('caches unsupported parser results until final options change', async () =>
       processedFileCount: 0,
     });
     expect((await loadFmtCacheStore(cache.filePath, cacheNamespace)).get('data.unknown')).toEqual([
-      null,
+      '',
       createOptionsHasher()(unsupported.options),
       'unsupported',
     ]);

packages/rstack/tests/fmt/runnerWorkerPreflight.test.ts

@@ -34,7 +34,7 @@ const createCachedUnsupportedFile = async (rootPath: string, fileName: string) =
   }
 
   const store = await loadFmtCacheStore(cache.filePath, cacheNamespace);
-  store.set(fileName, [null, optionsHash, 'unsupported']);
+  store.set(fileName, ['', optionsHash, 'unsupported']);
   await expect(store.save()).resolves.toBe(true);
 
   return { cache, file };

packages/rstack/tests/fmt/worker.test.ts

@@ -20,8 +20,8 @@ test('returns cached states before resolving the parser', async () => {
       [[contentHash, optionsHash, 'clean'], filePath, true, 'unchanged'],
       [[contentHash, optionsHash, 'unsupported'], noExtensionPath, false, 'unsupported'],
       [[contentHash, optionsHash, 'unsupported'], noExtensionPath, true, 'unsupported'],
-      [[null, optionsHash, 'unsupported'], missingPath, false, 'unsupported'],
-      [[null, optionsHash, 'unsupported'], missingPath, true, 'unsupported'],
+      [['', optionsHash, 'unsupported'], missingPath, false, 'unsupported'],
+      [['', optionsHash, 'unsupported'], missingPath, true, 'unsupported'],
     ] as const) {
       await expect(
         formatFile({
@@ -54,7 +54,7 @@ test('does not trust path-only unsupported entries for files without extensions'
         },
         shouldWrite: false,
         cache: {
-          entry: [null, 'options', 'unsupported'],
+          entry: ['', 'options', 'unsupported'],
           optionsHash: 'options',
         },
       }),
@@ -81,7 +81,7 @@ test('resolves parser support before reading on a cache miss', async () => {
       }),
     ).resolves.toEqual({
       status: 'unsupported',
-      cacheEntry: [null, 'options', 'unsupported'],
+      cacheEntry: ['', 'options', 'unsupported'],
     });
   });
 });