Updated: Only auto-import from package.json

src/compiler/checker.ts

@@ -3682,7 +3682,8 @@ namespace ts {
                     tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: noop, moduleResolverHost: flags! & NodeBuilderFlags.DoNotIncludeSymbolChain ? {
                         getCommonSourceDirectory: (host as Program).getCommonSourceDirectory ? () => (host as Program).getCommonSourceDirectory() : () => "",
                         getSourceFiles: () => host.getSourceFiles(),
-                        getCurrentDirectory: host.getCurrentDirectory && (() => host.getCurrentDirectory!())
+                        getCurrentDirectory: maybeBind(host, host.getCurrentDirectory),
+                        getProbableSymlinks: maybeBind(host, host.getProbableSymlinks),
                     } : undefined },
                     encounteredError: false,
                     visitedTypes: undefined,

src/compiler/moduleSpecifiers.ts

@@ -64,6 +64,20 @@ namespace ts.moduleSpecifiers {
         return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, getPreferences(preferences, compilerOptions, importingSourceFile));
     }
 
+    export function getNodeModulesPackageName(
+        compilerOptions: CompilerOptions,
+        importingSourceFileName: Path,
+        nodeModulesFileName: string,
+        host: ModuleSpecifierResolutionHost,
+        files: readonly SourceFile[],
+        redirectTargetsMap: RedirectTargetsMap,
+    ): string | undefined {
+        const info = getInfo(importingSourceFileName, host);
+        const modulePaths = getAllModulePaths(files, importingSourceFileName, nodeModulesFileName, info.getCanonicalFileName, host, redirectTargetsMap);
+        return firstDefined(modulePaths,
+            moduleFileName => tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions, /*packageNameOnly*/ true));
+    }
+
     function getModuleSpecifierWorker(
         compilerOptions: CompilerOptions,
         importingSourceFileName: Path,
@@ -79,7 +93,7 @@ namespace ts.moduleSpecifiers {
             getLocalModuleSpecifier(toFileName, info, compilerOptions, preferences);
     }
 
-    // Returns an import for each symlink and for the realpath.
+    /** Returns an import for each symlink and for the realpath. */
     export function getModuleSpecifiers(
         moduleSymbol: Symbol,
         compilerOptions: CompilerOptions,
@@ -152,40 +166,6 @@ namespace ts.moduleSpecifiers {
         return firstDefined(imports, ({ text }) => pathIsRelative(text) ? hasJSOrJsonFileExtension(text) : undefined) || false;
     }
 
-    function stringsEqual(a: string, b: string, getCanonicalFileName: GetCanonicalFileName): boolean {
-        return getCanonicalFileName(a) === getCanonicalFileName(b);
-    }
-
-    // KLUDGE: Don't assume one 'node_modules' links to another. More likely a single directory inside the node_modules is the symlink.
-    // ALso, don't assume that an `@foo` directory is linked. More likely the contents of that are linked.
-    function isNodeModulesOrScopedPackageDirectory(s: string, getCanonicalFileName: GetCanonicalFileName): boolean {
-        return getCanonicalFileName(s) === "node_modules" || startsWith(s, "@");
-    }
-
-    function guessDirectorySymlink(a: string, b: string, cwd: string, getCanonicalFileName: GetCanonicalFileName): [string, string] {
-        const aParts = getPathComponents(toPath(a, cwd, getCanonicalFileName));
-        const bParts = getPathComponents(toPath(b, cwd, getCanonicalFileName));
-        while (!isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) &&
-            !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) &&
-            stringsEqual(aParts[aParts.length - 1], bParts[bParts.length - 1], getCanonicalFileName)) {
-            aParts.pop();
-            bParts.pop();
-        }
-        return [getPathFromPathComponents(aParts), getPathFromPathComponents(bParts)];
-    }
-
-    function discoverProbableSymlinks(files: readonly SourceFile[], getCanonicalFileName: GetCanonicalFileName, cwd: string): ReadonlyMap<string> {
-        const result = createMap<string>();
-        const symlinks = flatten<readonly [string, string]>(mapDefined(files, sf =>
-            sf.resolvedModules && compact(arrayFrom(mapIterator(sf.resolvedModules.values(), res =>
-                res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] as const : undefined)))));
-        for (const [resolvedPath, originalPath] of symlinks) {
-            const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedPath, originalPath, cwd, getCanonicalFileName);
-            result.set(commonOriginal, commonResolved);
-        }
-        return result;
-    }
-
     function numberOfDirectorySeparators(str: string) {
         const match = str.match(/\//g);
         return match ? match.length : 0;
@@ -207,7 +187,9 @@ namespace ts.moduleSpecifiers {
         const importedFileNames = redirects ? [...redirects, importedFileName] : [importedFileName];
         const cwd = host.getCurrentDirectory ? host.getCurrentDirectory() : "";
         const targets = importedFileNames.map(f => getNormalizedAbsolutePath(f, cwd));
-        const links = discoverProbableSymlinks(files, getCanonicalFileName, cwd);
+        const links = host.getProbableSymlinks
+            ? host.getProbableSymlinks(files)
+            : discoverProbableSymlinks(files, getCanonicalFileName, cwd);
 
         const result: string[] = [];
         const compareStrings = (!host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames()) ? compareStringsCaseSensitive : compareStringsCaseInsensitive;
@@ -299,7 +281,7 @@ namespace ts.moduleSpecifiers {
             : removeFileExtension(relativePath);
     }
 
-    function tryGetModuleNameAsNodeModule(moduleFileName: string, { getCanonicalFileName, sourceDirectory }: Info, host: ModuleSpecifierResolutionHost, options: CompilerOptions): string | undefined {
+    function tryGetModuleNameAsNodeModule(moduleFileName: string, { getCanonicalFileName, sourceDirectory }: Info, host: ModuleSpecifierResolutionHost, options: CompilerOptions, packageNameOnly?: boolean): string | undefined {
         if (!host.fileExists || !host.readFile) {
             return undefined;
         }
@@ -308,30 +290,33 @@ namespace ts.moduleSpecifiers {
             return undefined;
         }
 
+        let packageJsonContent: any | undefined;
         const packageRootPath = moduleFileName.substring(0, parts.packageRootIndex);
-        const packageJsonPath = combinePaths(packageRootPath, "package.json");
-        const packageJsonContent = host.fileExists(packageJsonPath)
-            ? JSON.parse(host.readFile(packageJsonPath)!)
-            : undefined;
-        const versionPaths = packageJsonContent && packageJsonContent.typesVersions
-            ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)
-            : undefined;
-        if (versionPaths) {
-            const subModuleName = moduleFileName.slice(parts.packageRootIndex + 1);
-            const fromPaths = tryGetModuleNameFromPaths(
-                removeFileExtension(subModuleName),
-                removeExtensionAndIndexPostFix(subModuleName, Ending.Minimal, options),
-                versionPaths.paths
-            );
-            if (fromPaths !== undefined) {
-                moduleFileName = combinePaths(moduleFileName.slice(0, parts.packageRootIndex), fromPaths);
+        if (!packageNameOnly) {
+            const packageJsonPath = combinePaths(packageRootPath, "package.json");
+            packageJsonContent = host.fileExists(packageJsonPath)
+                ? JSON.parse(host.readFile(packageJsonPath)!)
+                : undefined;
+            const versionPaths = packageJsonContent && packageJsonContent.typesVersions
+                ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)
+                : undefined;
+            if (versionPaths) {
+                const subModuleName = moduleFileName.slice(parts.packageRootIndex + 1);
+                const fromPaths = tryGetModuleNameFromPaths(
+                    removeFileExtension(subModuleName),
+                    removeExtensionAndIndexPostFix(subModuleName, Ending.Minimal, options),
+                    versionPaths.paths
+                );
+                if (fromPaths !== undefined) {
+                    moduleFileName = combinePaths(moduleFileName.slice(0, parts.packageRootIndex), fromPaths);
+                }
             }
         }
 
         // Simplify the full file path to something that can be resolved by Node.
 
         // If the module could be imported by a directory name, use that directory's name
-        const moduleSpecifier = getDirectoryOrExtensionlessFileName(moduleFileName);
+        const moduleSpecifier = packageNameOnly ? moduleFileName : getDirectoryOrExtensionlessFileName(moduleFileName);
         // Get a path that's relative to node_modules or the importing file's path
         // if node_modules folder is in this folder or any of its parent folders, no need to keep it.
         if (!startsWith(sourceDirectory, getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)))) return undefined;

src/compiler/program.ts

@@ -715,6 +715,7 @@ namespace ts {
         let processingDefaultLibFiles: SourceFile[] | undefined;
         let processingOtherFiles: SourceFile[] | undefined;
         let files: SourceFile[];
+        let symlinks: ReadonlyMap<string> | undefined;
         let commonSourceDirectory: string;
         let diagnosticsProducingTypeChecker: TypeChecker;
         let noDiagnosticsTypeChecker: TypeChecker;
@@ -973,7 +974,8 @@ namespace ts {
             getResolvedProjectReferenceByPath,
             forEachResolvedProjectReference,
             isSourceOfProjectReferenceRedirect,
-            emitBuildInfo
+            emitBuildInfo,
+            getProbableSymlinks
         };
 
         verifyCompilerOptions();
@@ -1472,6 +1474,7 @@ namespace ts {
                 getLibFileFromReference: program.getLibFileFromReference,
                 isSourceFileFromExternalLibrary,
                 getResolvedProjectReferenceToRedirect,
+                getProbableSymlinks,
                 writeFile: writeFileCallback || (
                     (fileName, data, writeByteOrderMark, onError, sourceFiles) => host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles)),
                 isEmitBlocked,
@@ -3357,6 +3360,16 @@ namespace ts {
         function isSameFile(file1: string, file2: string) {
             return comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
         }
+
+        function getProbableSymlinks(): ReadonlyMap<string> {
+            if (host.getSymlinks) {
+                return host.getSymlinks();
+            }
+            return symlinks || (symlinks = discoverProbableSymlinks(
+                files,
+                getCanonicalFileName,
+                host.getCurrentDirectory()));
+        }
     }
 
     /*@internal*/

src/compiler/types.ts

@@ -3068,6 +3068,7 @@ namespace ts {
         /*@internal*/ isSourceOfProjectReferenceRedirect(fileName: string): boolean;
         /*@internal*/ getProgramBuildInfo?(): ProgramBuildInfo | undefined;
         /*@internal*/ emitBuildInfo(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult;
+        /*@internal*/ getProbableSymlinks(): ReadonlyMap<string>;
     }
 
     /* @internal */
@@ -4884,7 +4885,8 @@ namespace ts {
     }
 
     export interface TypeAcquisition {
-        /* @deprecated typingOptions.enableAutoDiscovery
+        /**
+         * @deprecated typingOptions.enableAutoDiscovery
          * Use typeAcquisition.enable instead.
          */
         enableAutoDiscovery?: boolean;
@@ -5334,6 +5336,7 @@ namespace ts {
 
         // TODO: later handle this in better way in builder host instead once the api for tsbuild finalizes and doesn't use compilerHost as base
         /*@internal*/createDirectory?(directory: string): void;
+        /*@internal*/getSymlinks?(): ReadonlyMap<string>;
     }
 
     /** true if --out otherwise source file name */
@@ -6019,11 +6022,13 @@ namespace ts {
         directoryExists?(directoryName: string): boolean;
         getCurrentDirectory?(): string;
     }
-    /** @internal */
+
     export interface ModuleSpecifierResolutionHost extends GetEffectiveTypeRootsHost {
         useCaseSensitiveFileNames?(): boolean;
         fileExists?(path: string): boolean;
         readFile?(path: string): string | undefined;
+        /* @internal */
+        getProbableSymlinks?(files: readonly SourceFile[]): ReadonlyMap<string>;
     }
 
     // Note: this used to be deprecated in our public API, but is still used internally

src/compiler/utilities.ts

@@ -4621,7 +4621,9 @@ namespace ts {
     }
 
     /** Calls `callback` on `directory` and every ancestor directory it has, returning the first defined result. */
-    export function forEachAncestorDirectory<T>(directory: string, callback: (directory: string) => T | undefined): T | undefined {
+    export function forEachAncestorDirectory<T>(directory: Path, callback: (directory: Path) => T | undefined): T | undefined;
+    export function forEachAncestorDirectory<T>(directory: string, callback: (directory: string) => T | undefined): T | undefined;
+    export function forEachAncestorDirectory<T>(directory: Path, callback: (directory: Path) => T | undefined): T | undefined {
         while (true) {
             const result = callback(directory);
             if (result !== undefined) {
@@ -7624,7 +7626,7 @@ namespace ts {
 
     /**
      * Returns the path except for its basename. Semantics align with NodeJS's `path.dirname`
-     * except that we support URL's as well.
+     * except that we support URLs as well.
      *
      * ```ts
      * getDirectoryPath("/path/to/file.ext") === "/path/to"
@@ -7635,7 +7637,7 @@ namespace ts {
     export function getDirectoryPath(path: Path): Path;
     /**
      * Returns the path except for its basename. Semantics align with NodeJS's `path.dirname`
-     * except that we support URL's as well.
+     * except that we support URLs as well.
      *
      * ```ts
      * getDirectoryPath("/path/to/file.ext") === "/path/to"
@@ -7770,6 +7772,36 @@ namespace ts {
         if (pathComponents.length === 0) return "";
         return pathComponents.slice(1).join(directorySeparator);
     }
+
+    export function discoverProbableSymlinks(files: readonly SourceFile[], getCanonicalFileName: GetCanonicalFileName, cwd: string): ReadonlyMap<string> {
+        const result = createMap<string>();
+        const symlinks = flatten<readonly [string, string]>(mapDefined(files, sf =>
+            sf.resolvedModules && compact(arrayFrom(mapIterator(sf.resolvedModules.values(), res =>
+                res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] as const : undefined)))));
+        for (const [resolvedPath, originalPath] of symlinks) {
+            const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedPath, originalPath, cwd, getCanonicalFileName);
+            result.set(commonOriginal, commonResolved);
+        }
+        return result;
+    }
+
+    function guessDirectorySymlink(a: string, b: string, cwd: string, getCanonicalFileName: GetCanonicalFileName): [string, string] {
+        const aParts = getPathComponents(toPath(a, cwd, getCanonicalFileName));
+        const bParts = getPathComponents(toPath(b, cwd, getCanonicalFileName));
+        while (!isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) &&
+            !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) &&
+            getCanonicalFileName(aParts[aParts.length - 1]) === getCanonicalFileName(bParts[bParts.length - 1])) {
+            aParts.pop();
+            bParts.pop();
+        }
+        return [getPathFromPathComponents(aParts), getPathFromPathComponents(bParts)];
+    }
+
+    // KLUDGE: Don't assume one 'node_modules' links to another. More likely a single directory inside the node_modules is the symlink.
+    // ALso, don't assume that an `@foo` directory is linked. More likely the contents of that are linked.
+    function isNodeModulesOrScopedPackageDirectory(s: string, getCanonicalFileName: GetCanonicalFileName): boolean {
+        return getCanonicalFileName(s) === "node_modules" || startsWith(s, "@");
+    }
 }
 
 /* @internal */

src/harness/client.ts

@@ -124,6 +124,13 @@ namespace ts.server {
             return response;
         }
 
+        /*@internal*/
+        configure(preferences: UserPreferences) {
+            const args: protocol.ConfigureRequestArguments = { preferences };
+            const request = this.processRequest(CommandNames.Configure, args);
+            this.processResponse(request, /*expectEmptyBody*/ true);
+        }
+
         openFile(file: string, fileContent?: string, scriptKindName?: "TS" | "JS" | "TSX" | "JSX"): void {
             const args: protocol.OpenRequestArgs = { file, fileContent, scriptKindName };
             this.processRequest(CommandNames.Open, args);