typescript-eslint · kirkwaiblinger · Aug 6, 2025 · Aug 6, 2025 · Aug 6, 2025 · Aug 6, 2025
diff --git a/packages/typescript-estree/src/create-program/shared.ts b/packages/typescript-estree/src/create-program/shared.ts
@@ -70,9 +70,7 @@ export function getCanonicalFileName(filePath: string): CanonicalPath {
 }
 
 export function ensureAbsolutePath(p: string, tsconfigRootDir: string): string {
-  return path.isAbsolute(p)
-    ? p
-    : path.join(tsconfigRootDir || process.cwd(), p);
+  return path.resolve(tsconfigRootDir, p);
 }
 
 export function canonicalDirname(p: CanonicalPath): CanonicalPath {

diff --git a/packages/typescript-estree/src/parseSettings/createParseSettings.ts b/packages/typescript-estree/src/parseSettings/createParseSettings.ts
@@ -50,10 +50,37 @@ export function createParseSettings(
 ): MutableParseSettings {
   const codeFullText = enforceCodeString(code);
   const singleRun = inferSingleRun(tsestreeOptions);
-  const tsconfigRootDir =
-    typeof tsestreeOptions.tsconfigRootDir === 'string'
-      ? tsestreeOptions.tsconfigRootDir
-      : getInferredTSConfigRootDir();
+  const tsconfigRootDir = (() => {
+    let tsconfigRootDir;
+    if (tsestreeOptions.tsconfigRootDir == null) {
+      tsconfigRootDir = getInferredTSConfigRootDir();
+      if (!path.isAbsolute(tsconfigRootDir)) {
+        throw new Error(
+          `inferred tsconfigRootDir should have be an absolute path, but received: ${JSON.stringify(
+            tsconfigRootDir,
+          )}. This is a bug in typescript-eslint! Please report it to us at https://github.com/typescript-eslint/typescript-eslint/issues/new/choose.`,
+        );
+      }
+    } else if (typeof tsestreeOptions.tsconfigRootDir === 'string') {
+      tsconfigRootDir = tsestreeOptions.tsconfigRootDir;
+      if (!path.isAbsolute(tsconfigRootDir)) {
+        throw new Error(
+          `parserOptions.tsconfigRootDir must be an absolute path, but received: ${JSON.stringify(
+            tsconfigRootDir,
+          )}. This is a bug in your configuration; please supply an absolute path.`,
+        );
+      }
+    } else {
+      throw new Error(
+        `If provided, parserOptions.tsconfigRootDir must be a string, but received a value of type "${typeof tsestreeOptions.tsconfigRootDir}"`,
+      );
+    }
+
+    // Deal with any funny business around trailing path separators (a/b/) or relative path segments (/a/b/../c)
+    // We already know it's absolute, so we can safely use path.resolve
+    return path.resolve(tsconfigRootDir);
+  })();
+
   const passedLoggerFn = typeof tsestreeOptions.loggerFn === 'function';
   const filePath = ensureAbsolutePath(
     typeof tsestreeOptions.filePath === 'string' &&

diff --git a/packages/typescript-estree/tests/lib/createParseSettings.test.ts b/packages/typescript-estree/tests/lib/createParseSettings.test.ts
@@ -1,3 +1,5 @@
+import path from 'node:path';
+
 import {
   addCandidateTSConfigRootDir,
   clearCandidateTSConfigRootDirs,
@@ -71,30 +73,59 @@
       clearCandidateTSConfigRootDirs();
     });
 
+    it('errors on non-absolute path', () => {
+      expect(() =>
+        createParseSettings('', { tsconfigRootDir: 'a/b/c' }),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[Error: parserOptions.tsconfigRootDir must be an absolute path, but received: "a/b/c". This is a bug in your configuration; please supply an absolute path.]`,
+      );
+    });
+
+    it('normalizes crazy tsconfigRootDir', () => {
+      const parseSettings = createParseSettings('', {
+        tsconfigRootDir: '/a/b////..//c///',
+      });
+
+      expect(parseSettings.tsconfigRootDir).toBe(
+        process.platform !== 'win32' ? '/a/c' : '\\a\\c',
+      );
+    });
+
+    it('errors on invalid tsconfigRootDir', () => {
+      expect(() =>
+        createParseSettings('', {
+          // @ts-expect-error -- testing invalid input
+          tsconfigRootDir: 42,
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[Error: If provided, parserOptions.tsconfigRootDir must be a string, but received a value of type "number"]`,
+      );
+    });
+
     it('uses the provided tsconfigRootDir when it exists and no candidates exist', () => {
-      const tsconfigRootDir = 'a/b/c';
+      const tsconfigRootDir = path.normalize('/a/b/c');
 
       const parseSettings = createParseSettings('', { tsconfigRootDir });
 
      expect(parseSettings.tsconfigRootDir).toBe(tsconfigRootDir);
    });
 
     it('uses the provided tsconfigRootDir when it exists and a candidate exists', () => {
       addCandidateTSConfigRootDir('candidate');
-      const tsconfigRootDir = 'a/b/c';
+      const tsconfigRootDir = path.normalize('/a/b/c');
 
       const parseSettings = createParseSettings('', { tsconfigRootDir });
 
       expect(parseSettings.tsconfigRootDir).toBe(tsconfigRootDir);
     });
 
     it('uses the inferred candidate when no tsconfigRootDir is provided and a candidate exists', () => {
-      const tsconfigRootDir = 'a/b/c';
+      const tsconfigRootDir = path.normalize('/a/b/c');
       addCandidateTSConfigRootDir(tsconfigRootDir);
 
       const parseSettings = createParseSettings('');

      expect(parseSettings.tsconfigRootDir).toBe(tsconfigRootDir);
    });
  });
 });
diff --git a/packages/typescript-estree/tests/lib/getProjectConfigFiles.test.ts b/packages/typescript-estree/tests/lib/getProjectConfigFiles.test.ts
@@ -17,15 +17,16 @@ vi.mock(import('node:fs'), async importOriginal => {
 });
 
 const parseSettings = {
-  filePath: './repos/repo/packages/package/file.ts',
+  filePath: path.normalize('/repos/repo/packages/package/file.ts'),
   tsconfigMatchCache: new ExpiringCache<string, string>(1),
-  tsconfigRootDir: './repos/repo',
+  tsconfigRootDir: path.normalize('/repos/repo'),
 };
 
 describe(getProjectConfigFiles, () => {
   beforeEach(() => {
     parseSettings.tsconfigMatchCache.clear();
     vi.clearAllMocks();
+    vi.resetModules();
   });
 
   afterAll(() => {
@@ -66,24 +67,24 @@ describe(getProjectConfigFiles, () => {
       const actual = getProjectConfigFiles(parseSettings, true);
 
       expect(actual).toStrictEqual([
-        path.normalize('repos/repo/packages/package/tsconfig.json'),
+        path.normalize('/repos/repo/packages/package/tsconfig.json'),
       ]);
       expect(mockExistsSync).toHaveBeenCalledOnce();
     });
 
     it('returns a nearby parent tsconfig.json when it was previously cached by a different directory search', () => {
       mockExistsSync.mockImplementation(
-        input => input === path.normalize('a/tsconfig.json'),
+        input => input === path.normalize('/a/tsconfig.json'),
       );
 
       const tsconfigMatchCache = new ExpiringCache<string, string>(1);
 
       // This should call to fs.existsSync three times: c, b, a
       getProjectConfigFiles(
         {
-          filePath: './a/b/c/d.ts',
+          filePath: path.normalize('/a/b/c/d.ts'),
           tsconfigMatchCache,
-          tsconfigRootDir: './a',
+          tsconfigRootDir: path.normalize('/a'),
         },
         true,
       );
@@ -92,30 +93,30 @@ describe(getProjectConfigFiles, () => {
       // Then it should retrieve c from cache, pointing to a
       const actual = getProjectConfigFiles(
         {
-          filePath: './a/b/c/e/f.ts',
+          filePath: path.normalize('/a/b/c/e/f.ts'),
           tsconfigMatchCache,
-          tsconfigRootDir: './a',
+          tsconfigRootDir: path.normalize('/a'),
         },
         true,
       );
 
-      expect(actual).toStrictEqual([path.normalize('a/tsconfig.json')]);
+      expect(actual).toStrictEqual([path.normalize('/a/tsconfig.json')]);
       expect(mockExistsSync).toHaveBeenCalledTimes(4);
     });
 
     it('returns a distant parent tsconfig.json when it was previously cached by a different directory search', () => {
       mockExistsSync.mockImplementation(
-        input => input === path.normalize('a/tsconfig.json'),
+        input => input === path.normalize('/a/tsconfig.json'),
       );
 
       const tsconfigMatchCache = new ExpiringCache<string, string>(1);
 
       // This should call to fs.existsSync 4 times: d, c, b, a
       getProjectConfigFiles(
         {
-          filePath: './a/b/c/d/e.ts',
+          filePath: path.normalize('/a/b/c/d/e.ts'),
           tsconfigMatchCache,
-          tsconfigRootDir: './a',
+          tsconfigRootDir: path.normalize('/a'),
         },
         true,
       );
@@ -124,14 +125,14 @@ describe(getProjectConfigFiles, () => {
       // Then it should retrieve b from cache, pointing to a
       const actual = getProjectConfigFiles(
         {
-          filePath: './a/b/f/g/h.ts',
+          filePath: path.normalize('/a/b/f/g/h.ts'),
           tsconfigMatchCache,
-          tsconfigRootDir: './a',
+          tsconfigRootDir: path.normalize('/a'),
         },
         true,
       );
 
-      expect(actual).toStrictEqual([path.normalize('a/tsconfig.json')]);
+      expect(actual).toStrictEqual([path.normalize('/a/tsconfig.json')]);
       expect(mockExistsSync).toHaveBeenCalledTimes(6);
     });
   });
@@ -143,39 +144,68 @@ describe(getProjectConfigFiles, () => {
       const actual = getProjectConfigFiles(parseSettings, true);
 
       expect(actual).toStrictEqual([
-        path.normalize('repos/repo/packages/package/tsconfig.json'),
+        path.normalize('/repos/repo/packages/package/tsconfig.json'),
       ]);
     });
 
     it('returns a parent tsconfig.json when matched', () => {
       mockExistsSync.mockImplementation(
-        filePath => filePath === path.normalize('repos/repo/tsconfig.json'),
+        filePath => filePath === path.normalize('/repos/repo/tsconfig.json'),
       );
 
       const actual = getProjectConfigFiles(parseSettings, true);
 
       expect(actual).toStrictEqual([
-        path.normalize('repos/repo/tsconfig.json'),
+        path.normalize('/repos/repo/tsconfig.json'),
       ]);
     });
 
-    it('throws when searching hits .', () => {
+    it('throws when searching hits .', async () => {
+      // ensure posix-style paths are used for consistent snapshot.
+      vi.mock('path', async () => {
+        const actual = await vi.importActual<typeof path>('path');
+        return {
+          ...actual.posix,
+          default: actual.posix,
+        };
+      });
+
+      const { getProjectConfigFiles } = await import(
+        '../../src/parseSettings/getProjectConfigFiles.js'
+      );
+
       mockExistsSync.mockReturnValue(false);
 
       expect(() =>
         getProjectConfigFiles(parseSettings, true),
       ).toThrowErrorMatchingInlineSnapshot(
-        `[Error: project was set to \`true\` but couldn't find any tsconfig.json relative to './repos/repo/packages/package/file.ts' within './repos/repo'.]`,
+        `[Error: project was set to \`true\` but couldn't find any tsconfig.json relative to '/repos/repo/packages/package/file.ts' within '/repos/repo'.]`,
       );
     });
 
-    it('throws when searching passes the tsconfigRootDir', () => {
+    it('throws when searching passes the tsconfigRootDir', async () => {
+      // ensure posix-style paths are used for consistent snapshot.
+      vi.mock('path', async () => {
+        const actual = await vi.importActual<typeof path>('path');
+        return {
+          ...actual.posix,
+          default: actual.posix,
+        };
+      });
+
+      const { getProjectConfigFiles } = await import(
+        '../../src/parseSettings/getProjectConfigFiles.js'
+      );
+
       mockExistsSync.mockReturnValue(false);
 
       expect(() =>
-        getProjectConfigFiles({ ...parseSettings, tsconfigRootDir: '/' }, true),
+        getProjectConfigFiles(
+          { ...parseSettings, tsconfigRootDir: path.normalize('/') },
+          true,
+        ),
       ).toThrowErrorMatchingInlineSnapshot(
-        `[Error: project was set to \`true\` but couldn't find any tsconfig.json relative to './repos/repo/packages/package/file.ts' within '/'.]`,
+        `[Error: project was set to \`true\` but couldn't find any tsconfig.json relative to '/repos/repo/packages/package/file.ts' within '/'.]`,
       );
     });
   });