Updated: Only auto-import from package.json

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,
@@ -174,7 +188,7 @@ namespace ts.moduleSpecifiers {
         return [getPathFromPathComponents(aParts), getPathFromPathComponents(bParts)];
     }
 
-    function discoverProbableSymlinks(files: readonly SourceFile[], getCanonicalFileName: GetCanonicalFileName, cwd: string): ReadonlyMap<string> {
+    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 =>
@@ -195,7 +209,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;
@@ -262,7 +278,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;
         }
@@ -271,30 +287,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/types.ts

@@ -4808,7 +4808,8 @@ namespace ts {
     }
 
     export interface TypeAcquisition {
-        /* @deprecated typingOptions.enableAutoDiscovery
+        /**
+         * @deprecated typingOptions.enableAutoDiscovery
          * Use typeAcquisition.enable instead.
          */
         enableAutoDiscovery?: boolean;
@@ -5921,11 +5922,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

@@ -7580,7 +7580,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"
@@ -7591,7 +7591,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"

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);

src/harness/fourslash.ts

@@ -421,7 +421,10 @@ namespace FourSlash {
             })!;
         }
 
-        public goToPosition(pos: number) {
+        public goToPosition(positionOrLineAndCharacter: number | ts.LineAndCharacter) {
+            const pos = typeof positionOrLineAndCharacter === "number"
+                ? positionOrLineAndCharacter
+                : this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, positionOrLineAndCharacter);
             this.currentCaretPosition = pos;
             this.selectionEnd = -1;
         }
@@ -447,6 +450,12 @@ namespace FourSlash {
             this.selectionEnd = range.end;
         }
 
+        public selectLine(index: number) {
+            const lineStart = this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, { line: index, character: 0 });
+            const lineEnd = lineStart + this.getLineContent(index).length;
+            this.selectRange({ fileName: this.activeFile.fileName, pos: lineStart, end: lineEnd });
+        }
+
         public moveCaretRight(count = 1) {
             this.currentCaretPosition += count;
             this.currentCaretPosition = Math.min(this.currentCaretPosition, this.getFileContent(this.activeFile.fileName).length);
@@ -803,7 +812,7 @@ namespace FourSlash {
                         const name = typeof include === "string" ? include : include.name;
                         const found = nameToEntries.get(name);
                         if (!found) throw this.raiseError(`Includes: completion '${name}' not found.`);
-                        assert(found.length === 1); // Must use 'exact' for multiple completions with same name
+                        assert(found.length === 1, `Must use 'exact' for multiple completions with same name: '${name}'`);
                         this.verifyCompletionEntry(ts.first(found), include);
                     }
                 }
@@ -1081,11 +1090,23 @@ namespace FourSlash {
                 TestState.getDisplayPartsJson(expected), this.messageAtLastKnownMarker("referenced symbol definition display parts"));
         }
 
+        private configure(preferences: ts.UserPreferences) {
+            if (this.testType === FourSlashTestType.Server) {
+                (this.languageService as ts.server.SessionClient).configure(preferences);
+            }
+        }
+
         private getCompletionListAtCaret(options?: ts.GetCompletionsAtPositionOptions): ts.CompletionInfo | undefined {
+            if (options) {
+                this.configure(options);
+            }
             return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition, options);
         }
 
         private getCompletionEntryDetails(entryName: string, source?: string, preferences?: ts.UserPreferences): ts.CompletionEntryDetails | undefined {
+            if (preferences) {
+                this.configure(preferences);
+            }
             return this.languageService.getCompletionEntryDetails(this.activeFile.fileName, this.currentCaretPosition, entryName, this.formatCodeSettings, source, preferences);
         }
 
@@ -1696,6 +1717,12 @@ namespace FourSlash {
             this.checkPostEditInvariants();
         }
 
+        public deleteLineRange(startIndex: number, endIndexInclusive: number) {
+            const startPos = this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, { line: startIndex, character: 0 });
+            const endPos = this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, { line: endIndexInclusive + 1, character: 0 });
+            this.replace(startPos, endPos - startPos, "");
+        }
+
         public deleteCharBehindMarker(count = 1) {
             let offset = this.currentCaretPosition;
             const ch = "";
@@ -1721,6 +1748,8 @@ namespace FourSlash {
             let offset = this.currentCaretPosition;
             const prevChar = " ";
             const checkCadence = (text.length >> 2) + 1;
+            const selection = this.getSelection();
+            this.replace(selection.pos, selection.end - selection.pos, "");
 
             for (let i = 0; i < text.length; i++) {
                 const ch = text.charAt(i);
@@ -3059,11 +3088,9 @@ namespace FourSlash {
             Harness.IO.log(stringify(codeFixes));
         }
 
-        // Get the text of the entire line the caret is currently at
-        private getCurrentLineContent() {
+        private getLineContent(index: number) {
             const text = this.getFileContent(this.activeFile.fileName);
-
-            const pos = this.currentCaretPosition;
+            const pos = this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, { line: index, character: 0 });
             let startPos = pos, endPos = pos;
 
             while (startPos > 0) {
@@ -3088,6 +3115,14 @@ namespace FourSlash {
             return text.substring(startPos, endPos);
         }
 
+        // Get the text of the entire line the caret is currently at
+        private getCurrentLineContent() {
+            return this.getLineContent(this.languageServiceAdapterHost.positionToLineAndCharacter(
+                this.activeFile.fileName,
+                this.currentCaretPosition,
+            ).line);
+        }
+
         private findFile(indexOrName: string | number): FourSlashFile {
             if (typeof indexOrName === "number") {
                 const index = indexOrName;
@@ -3822,11 +3857,11 @@ namespace FourSlashInterface {
             this.state.goToImplementation();
         }
 
-        public position(position: number, fileNameOrIndex?: string | number): void {
+        public position(positionOrLineAndCharacter: number | ts.LineAndCharacter, fileNameOrIndex?: string | number): void {
             if (fileNameOrIndex !== undefined) {
                 this.file(fileNameOrIndex);
             }
-            this.state.goToPosition(position);
+            this.state.goToPosition(positionOrLineAndCharacter);
         }
 
         // Opens a file, given either its index as it
@@ -4299,6 +4334,19 @@ namespace FourSlashInterface {
             this.state.type(lines.join("\n"));
         }
 
+        public deleteLine(index: number) {
+            this.deleteLineRange(index, index);
+        }
+
+        public deleteLineRange(startIndex: number, endIndexInclusive: number) {
+            this.state.deleteLineRange(startIndex, endIndexInclusive);
+        }
+
+        public replaceLine(index: number, text: string) {
+            this.state.selectLine(index);
+            this.state.type(text);
+        }
+
         public moveRight(count?: number) {
             this.state.moveCaretRight(count);
         }

src/harness/harnessLanguageService.ts

@@ -203,6 +203,12 @@ namespace Harness.LanguageService {
             return ts.computeLineAndCharacterOfPosition(script.getLineMap(), position);
         }
 
+        public lineAndCharacterToPosition(fileName: string, lineAndCharacter: ts.LineAndCharacter): number {
+            const script: ScriptInfo = this.getScriptInfo(fileName)!;
+            assert.isOk(script);
+            return ts.computePositionOfLineAndCharacter(script.getLineMap(), lineAndCharacter.line, lineAndCharacter.character);
+        }
+
         useCaseSensitiveFileNames() {
             return !this.vfs.ignoreCase;
         }

src/server/editorServices.ts

@@ -1005,7 +1005,7 @@ namespace ts.server {
                 directory,
                 fileOrDirectory => {
                     const fileOrDirectoryPath = this.toPath(fileOrDirectory);
-                    project.getCachedDirectoryStructureHost().addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
+                    const fsResult = project.getCachedDirectoryStructureHost().addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
 
                     // don't trigger callback on open, existing files
                     if (project.fileIsOpen(fileOrDirectoryPath)) {
@@ -1015,6 +1015,13 @@ namespace ts.server {
                     if (isPathIgnored(fileOrDirectoryPath)) return;
                     const configFilename = project.getConfigFilePath();
 
+                    if (getBaseFileName(fileOrDirectoryPath) === "package.json" && !isInsideNodeModules(fileOrDirectoryPath) &&
+                        (fsResult && fsResult.fileExists || !fsResult && this.host.fileExists(fileOrDirectoryPath))
+                    ) {
+                        this.logger.info(`Project: ${configFilename} Detected new package.json: ${fileOrDirectory}`);
+                        project.onAddPackageJson(fileOrDirectoryPath);
+                    }
+
                     // If the the added or created file or directory is not supported file name, ignore the file
                     // But when watched directory is added/removed, we need to reload the file list
                     if (fileOrDirectoryPath !== directory && hasExtension(fileOrDirectoryPath) && !isSupportedSourceFileName(fileOrDirectory, project.getCompilationSettings(), this.hostConfiguration.extraFileExtensions)) {