@typescript-eslint/typescript-estree 8.70.1-alpha.9 → 8.70.1

package/dist/check-syntax-errors.js

@@ -229,6 +229,13 @@ function checkSyntaxError(tsNode, parent, allowPattern) {
             }
             break;
         }
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        case SyntaxKind.AssertEntry:
+        case SyntaxKind.ImportAttribute:
+            if (node.value.kind !== SyntaxKind.StringLiteral) {
+                throw (0, node_utils_1.createError)(node.value, 'String literal expected.');
+            }
+            break;
         case SyntaxKind.ExternalModuleReference:
             if (node.expression.kind !== SyntaxKind.StringLiteral) {
                 throw (0, node_utils_1.createError)(node.expression, 'String literal expected.');

package/dist/clear-caches.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearProgramCache = void 0;
 exports.clearCaches = clearCaches;
 const getWatchProgramsForProjects_1 = require("./create-program/getWatchProgramsForProjects");
+const shared_1 = require("./create-program/shared");
 const parser_1 = require("./parser");
 const candidateTSConfigRootDirs_1 = require("./parseSettings/candidateTSConfigRootDirs");
 const createParseSettings_1 = require("./parseSettings/createParseSettings");
@@ -18,6 +19,7 @@ function clearCaches() {
     (0, candidateTSConfigRootDirs_1.clearCandidateTSConfigRootDirs)();
     (0, parser_1.clearDefaultProjectMatchedFiles)();
     (0, parser_1.clearProgramCache)();
+    (0, shared_1.clearRealPathCache)();
     (0, getWatchProgramsForProjects_1.clearWatchCaches)();
     (0, createParseSettings_1.clearTSConfigMatchCache)();
     (0, createParseSettings_1.clearTSServerProjectService)();

package/dist/convert.d.ts

@@ -35,7 +35,7 @@ export declare class Converter {
     constructor(ast: ts.SourceFile, options?: ConverterOptions);
     private convertBindingNameWithTypeAnnotation;
     /**
-     * Coverts body Nodes and add a directive field to StringLiterals
+     * Converts body Nodes and add a directive field to StringLiterals
      * @param nodes of ts.Node
      * @param parent parentNode
      * @returns Array of body statements

package/dist/convert.js

@@ -155,7 +155,7 @@ class Converter {
         return id;
     }
     /**
-     * Coverts body Nodes and add a directive field to StringLiterals
+     * Converts body Nodes and add a directive field to StringLiterals
      * @param nodes of ts.Node
      * @param parent parentNode
      * @returns Array of body statements

package/dist/create-program/getWatchProgramsForProjects.js

@@ -113,6 +113,13 @@ function updateCachedFileList(tsconfigPath, program) {
     programFileListCache.set(tsconfigPath, fileList);
     return fileList;
 }
+/**
+ * Checks a program's known files for a path, including when the program knows
+ * the file by a path that resolves to the same file on disk.
+ */
+function fileListIncludes(fileList, filePath) {
+    return fileList.has(filePath) || fileList.has((0, shared_1.getCanonicalRealPath)(filePath));
+}
 /**
  * Calculate project environments using options provided by consumer and paths from config
  * @param parseSettings Internal settings for parsing the file
@@ -152,7 +159,7 @@ function getWatchProgramsForProjects(parseSettings) {
             updatedProgram = existingWatch.getProgram().getProgram();
             fileList = updateCachedFileList(tsconfigPath, updatedProgram);
         }
-        if (fileList.has(filePath)) {
+        if (fileListIncludes(fileList, filePath)) {
             log('Found existing program for file. %s', filePath);
             updatedProgram ??= existingWatch.getProgram().getProgram();
             // sets parent pointers in source files
@@ -177,7 +184,7 @@ function getWatchProgramsForProjects(parseSettings) {
             updatedProgram.getTypeChecker();
             // cache and check the file list
             const fileList = updateCachedFileList(tsconfigPath[0], updatedProgram);
-            if (fileList.has(filePath)) {
+            if (fileListIncludes(fileList, filePath)) {
                 log('Found updated program for file. %s', filePath);
                 // we can return early because we know this program contains the file
                 return [updatedProgram];
@@ -192,7 +199,7 @@ function getWatchProgramsForProjects(parseSettings) {
         program.getTypeChecker();
         // cache and check the file list
         const fileList = updateCachedFileList(tsconfigPath[0], program);
-        if (fileList.has(filePath)) {
+        if (fileListIncludes(fileList, filePath)) {
             log('Found program for file. %s', filePath);
             // we can return early because we know this program contains the file
             return [program];
@@ -301,7 +308,7 @@ function maybeInvalidateProgram(existingWatch, filePath, tsconfigPath) {
         // tsconfig change means that the file list more than likely changed, so clear the cache
         programFileListCache.delete(tsconfigPath);
     }
-    let sourceFile = updatedProgram.getSourceFile(filePath);
+    let sourceFile = (0, shared_1.getSourceFileFromProgram)(updatedProgram, filePath);
     if (sourceFile) {
         return updatedProgram;
     }
@@ -341,7 +348,7 @@ function maybeInvalidateProgram(existingWatch, filePath, tsconfigPath) {
     programFileListCache.delete(tsconfigPath);
     // force the immediate resync
     updatedProgram = existingWatch.getProgram().getProgram();
-    sourceFile = updatedProgram.getSourceFile(filePath);
+    sourceFile = (0, shared_1.getSourceFileFromProgram)(updatedProgram, filePath);
     if (sourceFile) {
         return updatedProgram;
     }
@@ -371,7 +378,7 @@ function maybeInvalidateProgram(existingWatch, filePath, tsconfigPath) {
     // deleted files means that the file list _has_ changed, so clear the cache
     programFileListCache.delete(tsconfigPath);
     updatedProgram = existingWatch.getProgram().getProgram();
-    sourceFile = updatedProgram.getSourceFile(filePath);
+    sourceFile = (0, shared_1.getSourceFileFromProgram)(updatedProgram, filePath);
     if (sourceFile) {
         return updatedProgram;
     }

package/dist/create-program/shared.d.ts

@@ -18,6 +18,29 @@ export type CanonicalPath = {
 export declare function getCanonicalFileName(filePath: string): CanonicalPath;
 export declare function ensureAbsolutePath(p: string, tsconfigRootDir: string): string;
 export declare function canonicalDirname(p: CanonicalPath): CanonicalPath;
+export declare function clearRealPathCache(): void;
+export declare function getCanonicalRealPath(filePath: string): CanonicalPath;
+/**
+ * Maps the canonical real path of each directory that is only reachable through
+ * a symlink to the path it's referred to by.
+ *
+ * TypeScript de-duplicates directories by real path when it expands a TSConfig's
+ * `include`s, so a directory reachable both directly and through a symlink is
+ * only visited once. Files under it then exist in the project solely under
+ * whichever of the two paths was visited first.
+ * https://github.com/typescript-eslint/typescript-eslint/issues/2987
+ */
+export declare function createSymlinkedDirectories(fileNames: Iterable<string>): ReadonlyMap<CanonicalPath, string>;
+/**
+ * Resolves the path a symlinked directory's files are referred to by, for a path
+ * that refers to the same file on disk.
+ */
+export declare function getPathToSameFile(symlinkedDirectories: ReadonlyMap<CanonicalPath, string>, filePath: string): string | undefined;
+/**
+ * Retrieves a program's source file for a path, including when the program knows
+ * the file by a different path that resolves to the same file on disk.
+ */
+export declare function getSourceFileFromProgram(program: ts.Program, filePath: string): ts.SourceFile | undefined;
 export declare function getAstFromProgram(currentProgram: Program, filePath: string): ASTAndDefiniteProgram | undefined;
 /**
  * Hash content for compare content.

package/dist/create-program/shared.js

@@ -41,6 +41,11 @@ exports.createDefaultCompilerOptionsFromExtra = createDefaultCompilerOptionsFrom
 exports.getCanonicalFileName = getCanonicalFileName;
 exports.ensureAbsolutePath = ensureAbsolutePath;
 exports.canonicalDirname = canonicalDirname;
+exports.clearRealPathCache = clearRealPathCache;
+exports.getCanonicalRealPath = getCanonicalRealPath;
+exports.createSymlinkedDirectories = createSymlinkedDirectories;
+exports.getPathToSameFile = getPathToSameFile;
+exports.getSourceFileFromProgram = getSourceFileFromProgram;
 exports.getAstFromProgram = getAstFromProgram;
 exports.createHash = createHash;
 const tsconfig_utils_1 = require("@typescript-eslint/tsconfig-utils");
@@ -94,6 +99,85 @@ function ensureAbsolutePath(p, tsconfigRootDir) {
 function canonicalDirname(p) {
     return node_path_1.default.dirname(p);
 }
+const realPathCache = new Map();
+function clearRealPathCache() {
+    realPathCache.clear();
+}
+function getRealPath(filePath) {
+    let realPath = realPathCache.get(filePath);
+    if (realPath == null) {
+        // ts.sys doesn't exist in browser environments and isn't required to
+        // implement realpath. It returns the given path when it can't resolve one.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        realPath = ts.sys?.realpath?.(filePath) ?? filePath;
+        realPathCache.set(filePath, realPath);
+    }
+    return realPath;
+}
+function getCanonicalRealPath(filePath) {
+    return getCanonicalFileName(getRealPath(filePath));
+}
+/**
+ * Maps the canonical real path of each directory that is only reachable through
+ * a symlink to the path it's referred to by.
+ *
+ * TypeScript de-duplicates directories by real path when it expands a TSConfig's
+ * `include`s, so a directory reachable both directly and through a symlink is
+ * only visited once. Files under it then exist in the project solely under
+ * whichever of the two paths was visited first.
+ * https://github.com/typescript-eslint/typescript-eslint/issues/2987
+ */
+function createSymlinkedDirectories(fileNames) {
+    const directories = new Set([...fileNames].map(fileName => node_path_1.default.dirname(fileName)));
+    return new Map([...directories]
+        .map(directory => [directory, getRealPath(directory)])
+        .filter(([directory, realPath]) => directory !== realPath)
+        .map(([directory, realPath]) => [
+        getCanonicalFileName(realPath),
+        directory,
+    ]));
+}
+/**
+ * Resolves the path a symlinked directory's files are referred to by, for a path
+ * that refers to the same file on disk.
+ */
+function getPathToSameFile(symlinkedDirectories, filePath) {
+    const realPath = getRealPath(filePath);
+    const directory = symlinkedDirectories.get(getCanonicalFileName(node_path_1.default.dirname(realPath)));
+    return directory == null
+        ? undefined
+        : node_path_1.default.join(directory, node_path_1.default.basename(realPath));
+}
+const programSymlinkedDirectories = new WeakMap();
+function getSymlinkedDirectories(program) {
+    let symlinkedDirectories = programSymlinkedDirectories.get(program);
+    if (!symlinkedDirectories) {
+        // Only a project's root files can be under a directory it knows by a
+        // symlinked path: files pulled in by imports resolve to their real path.
+        symlinkedDirectories = createSymlinkedDirectories(program.getRootFileNames());
+        programSymlinkedDirectories.set(program, symlinkedDirectories);
+    }
+    return symlinkedDirectories;
+}
+/**
+ * Retrieves a program's source file for a path, including when the program knows
+ * the file by a different path that resolves to the same file on disk.
+ */
+function getSourceFileFromProgram(program, filePath) {
+    const sourceFile = program.getSourceFile(filePath);
+    if (sourceFile) {
+        return sourceFile;
+    }
+    const realPath = getRealPath(filePath);
+    const fromRealPath = realPath === filePath ? undefined : program.getSourceFile(realPath);
+    if (fromRealPath) {
+        return fromRealPath;
+    }
+    const symlinkedFilePath = getPathToSameFile(getSymlinkedDirectories(program), filePath);
+    return symlinkedFilePath == null
+        ? undefined
+        : program.getSourceFile(symlinkedFilePath);
+}
 const DEFINITION_EXTENSIONS = [
     ts.Extension.Dts,
     ts.Extension.Dcts,
@@ -106,7 +190,7 @@ function getExtension(fileName) {
     return (DEFINITION_EXTENSIONS.find(definitionExt => fileName.endsWith(definitionExt)) ?? node_path_1.default.extname(fileName));
 }
 function getAstFromProgram(currentProgram, filePath) {
-    const ast = currentProgram.getSourceFile(filePath);
+    const ast = getSourceFileFromProgram(currentProgram, filePath);
     // working around https://github.com/typescript-eslint/typescript-eslint/issues/1573
     const expectedExt = getExtension(filePath);
     const returnedExt = getExtension(ast?.fileName);

package/dist/node-utils.js

@@ -521,8 +521,16 @@ function convertTokens(ast) {
         if (isComment(node) || isJSDocComment(node)) {
             return;
         }
-        if (isToken(node) && node.kind !== SyntaxKind.EndOfFileToken) {
-            result.push(convertToken(node, ast));
+        const { kind } = node;
+        if (isToken(node) && kind !== SyntaxKind.EndOfFileToken) {
+            const token = convertToken(node, ast);
+            // TypeScript drops first half of a `<<` in some cases.
+            // Gating on `kind` (a cheap check) keeps the rest of the check,
+            // which has to look at the text, off the hot path.
+            if (kind === SyntaxKind.LessThanToken) {
+                addMissingLessThanToken(result, token, ast);
+            }
+            result.push(token);
         }
         else {
             node.getChildren(ast).forEach(walk);
@@ -531,6 +539,43 @@ function convertTokens(ast) {
     walk(ast);
     return result;
 }
+/**
+ * TypeScript recovers the tokens its parser did not keep as children of a node
+ * (`<` and `>` of a type argument list, for instance) by re-scanning the source
+ * text in the gaps between the children it did keep, and discards any token
+ * that runs past the end of the gap being filled.
+ *
+ * Its scanner produces `<<` as a single token, which the parser splits back
+ * apart when the second `<` opens a type parameter list, as in
+ * `ReturnType<<T>(x: T) => number>`. The re-scan is not aware of that split,
+ * so the `<<` it scans overruns the gap left by the first `<`, and that token
+ * is dropped from `getChildren()` entirely.
+ *
+ * Text skipped in front of a token can otherwise only be trivia, and no trivia
+ * can end in a `<`: line comments, shebangs and conflict markers all run to the
+ * end of a line, and block comments all end in `*` + `/`. So a `<` sitting
+ * directly in front of a token, with anything at all skipped before it,
+ * is unambiguously a token TypeScript lost.
+ *
+ * Only ever called for a `<` token — see the caller.
+ */
+function addMissingLessThanToken(result, token, ast) {
+    if (result.length === 0) {
+        return;
+    }
+    const currentTokenStart = token.range[0];
+    const previousTokenEnd = result[result.length - 1].range[1];
+    if (currentTokenStart > previousTokenEnd &&
+        ast.text[currentTokenStart - 1] === '<') {
+        const range = [currentTokenStart - 1, currentTokenStart];
+        result.push({
+            type: ts_estree_1.AST_TOKEN_TYPES.Punctuator,
+            loc: getLocFor(range, ast),
+            range,
+            value: '<',
+        });
+    }
+}
 class TSError extends Error {
     fileName;
     location;

package/dist/useProgramFromProjectService.js

@@ -74,6 +74,10 @@ function openClientFileFromProjectService(defaultProjectMatchedFiles, isDefaultP
         }
     }
     else {
+        const fromSymlinkedPath = openFromSymlinkedPath();
+        if (fromSymlinkedPath) {
+            return fromSymlinkedPath;
+        }
         const wasNotFound = `${parseSettings.filePath} was not found by the project service`;
         const fileExtension = node_path_1.default.extname(parseSettings.filePath);
         const extraFileExtensions = parseSettings.extraFileExtensions;
@@ -117,11 +121,31 @@ If you absolutely need more files included, set parserOptions.projectService.max
 `);
         }
     }
-    return opened;
-    function openClientFile() {
-        return serviceAndSettings.service.openClientFile(filePathAbsolute, parseSettings.codeFullText, 
+    return { filePathAbsolute, opened };
+    function openClientFile(fileName = filePathAbsolute) {
+        return serviceAndSettings.service.openClientFile(fileName, parseSettings.codeFullText, 
         /* scriptKind */ undefined, parseSettings.tsconfigRootDir);
     }
+    /**
+     * A file reachable through a symlink can be in a project only under the
+     * symlinked path, in which case the project service doesn't know it by the
+     * path it's being linted under.
+     * @see https://github.com/typescript-eslint/typescript-eslint/issues/2987
+     */
+    function openFromSymlinkedPath() {
+        if (isDefaultProjectAllowed) {
+            return undefined;
+        }
+        const symlinkedFilePath = getSymlinkedFilePathInProjects(serviceAndSettings.service, filePathAbsolute);
+        if (symlinkedFilePath == null) {
+            return undefined;
+        }
+        log('Retrying with the path a project knows the file by: %s', symlinkedFilePath);
+        const reopened = openClientFile(symlinkedFilePath);
+        return reopened.configFileName
+            ? { filePathAbsolute: symlinkedFilePath, opened: reopened }
+            : undefined;
+    }
     function openClientFileAndMaybeReload() {
         log('Opening project service client file at path: %s', filePathAbsolute);
         let opened = openClientFile();
@@ -142,6 +166,22 @@ If you absolutely need more files included, set parserOptions.projectService.max
         return opened;
     }
 }
+/**
+ * Searches the loaded projects for a path that refers to the same file on disk
+ * as `filePathAbsolute`, but that a project knows the file by.
+ */
+function getSymlinkedFilePathInProjects(service, filePathAbsolute) {
+    for (const project of service.configuredProjects.values()) {
+        const symlinkedDirectories = (0, shared_1.createSymlinkedDirectories)(project.getFileNames(
+        /* excludeFilesFromExternalLibraries */ true, 
+        /* excludeConfigFiles */ true));
+        const symlinkedFilePath = (0, shared_1.getPathToSameFile)(symlinkedDirectories, filePathAbsolute);
+        if (symlinkedFilePath != null) {
+            return symlinkedFilePath;
+        }
+    }
+    return undefined;
+}
 function createNoProgramWithProjectService(filePathAbsolute, parseSettings, service) {
     log('No project service information available. Creating no program.');
     // If the project service knows about this file, this informs if of changes.
@@ -193,7 +233,7 @@ function useProgramFromProjectService(serviceAndSettings, parseSettings, hasFull
     const opened = hasFullTypeInformation &&
         openClientFileFromProjectService(defaultProjectMatchedFiles, isDefaultProjectAllowed, filePathAbsolute, parseSettings, serviceAndSettings);
     log('Opened project service file: %o', opened);
-    return retrieveASTAndProgramFor(filePathAbsolute, parseSettings, serviceAndSettings);
+    return retrieveASTAndProgramFor(opened ? opened.filePathAbsolute : filePathAbsolute, parseSettings, serviceAndSettings);
 }
 function absolutify(filePath, serviceAndSettings) {
     return node_path_1.default.isAbsolute(filePath)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.70.1-alpha.9",
+  "version": "8.70.1",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -43,10 +43,10 @@
     "syntax"
   ],
   "dependencies": {
-    "@typescript-eslint/project-service": "8.70.1-alpha.9",
-    "@typescript-eslint/tsconfig-utils": "8.70.1-alpha.9",
-    "@typescript-eslint/types": "8.70.1-alpha.9",
-    "@typescript-eslint/visitor-keys": "8.70.1-alpha.9",
+    "@typescript-eslint/project-service": "8.70.1",
+    "@typescript-eslint/tsconfig-utils": "8.70.1",
+    "@typescript-eslint/types": "8.70.1",
+    "@typescript-eslint/visitor-keys": "8.70.1",
     "debug": "^4.4.3",
     "minimatch": "^10.2.2",
     "semver": "^7.7.3",