Never show pnpm paths in auto imports, even if there’s no other path

Author: andrewbranch

src/compiler/moduleSpecifiers.ts

@@ -163,7 +163,16 @@ namespace ts.moduleSpecifiers {
 
         return pathsSpecifiers?.length ? pathsSpecifiers :
             nodeModulesSpecifiers?.length ? nodeModulesSpecifiers :
-            Debug.checkDefined(relativeSpecifiers);
+            fallback();
+
+        // Unless 'preferFailureToResultsWithIgnoredPaths' is set, we *must* generate a relative path fallback.
+        // (The declaration emitter must write something, but auto-imports may exclude bad suggestions.)
+        function fallback() {
+            if (host.preferFailureToResultsWithIgnoredPaths?.()) {
+                return relativeSpecifiers || emptyArray;
+            }
+            return Debug.checkDefined(relativeSpecifiers);
+        }
     }
 
     interface Info {
@@ -286,7 +295,7 @@ namespace ts.moduleSpecifiers {
         const redirects = host.redirectTargetsMap.get(importedPath) || emptyArray;
         const importedFileNames = [...(referenceRedirect ? [referenceRedirect] : emptyArray), importedFileName, ...redirects];
         const targets = importedFileNames.map(f => getNormalizedAbsolutePath(f, cwd));
-        let shouldFilterIgnoredPaths = !every(targets, containsIgnoredPath);
+        let shouldFilterIgnoredPaths = host.preferFailureToResultsWithIgnoredPaths?.() || !every(targets, containsIgnoredPath);
 
         if (!preferSymlinks) {
             // Symlinks inside ignored paths are already filtered out of the symlink cache,

src/compiler/types.ts

@@ -8137,6 +8137,7 @@ namespace ts {
         getModuleSpecifierCache?(): ModuleSpecifierCache;
         getGlobalTypingsCacheLocation?(): string | undefined;
         getNearestAncestorDirectoryWithPackageJson?(fileName: string, rootDir?: string): string | undefined;
+        preferFailureToResultsWithIgnoredPaths?(): boolean;
 
         getSourceFiles(): readonly SourceFile[];
         readonly redirectTargetsMap: RedirectTargetsMap;

src/services/codefixes/importFixes.ts

@@ -66,7 +66,9 @@ namespace ts.codefix {
             const preferTypeOnlyImport = !!usageIsTypeOnly && compilerOptions.importsNotUsedAsValues === ImportsNotUsedAsValues.Error;
             const useRequire = shouldUseRequire(sourceFile, program);
             const fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, preferTypeOnlyImport, useRequire, host, preferences);
-            addImport({ fixes: [fix], symbolName });
+            if (fix) {
+                addImport({ fixes: [fix], symbolName });
+            }
         }
 
         function addImport(info: FixesInfo) {
@@ -203,7 +205,7 @@ namespace ts.codefix {
             : getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, host, program, /*useAutoImportProvider*/ true);
         const useRequire = shouldUseRequire(sourceFile, program);
         const preferTypeOnlyImport = compilerOptions.importsNotUsedAsValues === ImportsNotUsedAsValues.Error && !isSourceFileJS(sourceFile) && isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
-        const fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, preferTypeOnlyImport, useRequire, host, preferences);
+        const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, preferTypeOnlyImport, useRequire, host, preferences));
         return { moduleSpecifier: fix.moduleSpecifier, codeAction: codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName, fix, getQuotePreference(sourceFile, preferences))) };
     }
 
@@ -274,7 +276,7 @@ namespace ts.codefix {
         program: Program,
         host: LanguageServiceHost,
         preferences: UserPreferences
-    ): { exportInfo?: SymbolExportInfo, moduleSpecifier: string } {
+    ): { exportInfo?: SymbolExportInfo, moduleSpecifier: string } | undefined {
         return getBestFix(getNewImportFixes(program, importingFile, /*position*/ undefined, /*preferTypeOnlyImport*/ false, /*useRequire*/ false, exportInfo, host, preferences), importingFile, host);
     }
 
@@ -529,7 +531,8 @@ namespace ts.codefix {
         return sort(fixes, (a, b) => compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, allowsImportingSpecifier));
     }
 
-    function getBestFix<T extends ImportFix>(fixes: readonly T[], sourceFile: SourceFile, host: LanguageServiceHost): T {
+    function getBestFix<T extends ImportFix>(fixes: readonly T[], sourceFile: SourceFile, host: LanguageServiceHost): T | undefined {
+        if (!some(fixes)) return;
         // These will always be placed first if available, and are better than other kinds
         if (fixes[0].kind === ImportFixKind.UseNamespace || fixes[0].kind === ImportFixKind.AddToExisting) {
             return fixes[0];

src/services/completions.ts

@@ -1762,7 +1762,7 @@ namespace ts.Completions {
                     // If we don't need to resolve module specifiers, we can use any re-export that is importable at all
                     // (We need to ensure that at least one is importable to show a completion.)
                     const { moduleSpecifier, exportInfo } = resolveModuleSpecifiers
-                        ? codefix.getModuleSpecifierForBestExportInfo(info, sourceFile, program, host, preferences)
+                        ? codefix.getModuleSpecifierForBestExportInfo(info, sourceFile, program, host, preferences) || {}
                         : { moduleSpecifier: undefined, exportInfo: find(info, isImportableExportInfo) };
                     if (!exportInfo) return;
                     const moduleFile = tryCast(exportInfo.moduleSymbol.valueDeclaration, isSourceFile);

src/services/utilities.ts

@@ -1852,6 +1852,7 @@ namespace ts {
             isSourceOfProjectReferenceRedirect: fileName => program.isSourceOfProjectReferenceRedirect(fileName),
             getNearestAncestorDirectoryWithPackageJson: maybeBind(host, host.getNearestAncestorDirectoryWithPackageJson),
             getFileIncludeReasons: () => program.getFileIncludeReasons(),
+            preferFailureToResultsWithIgnoredPaths: returnTrue,
         };
     }
 

tests/cases/fourslash/server/importStatementCompletions_pnpm2.ts

@@ -0,0 +1,28 @@
+/// <reference path="../fourslash.ts" />
+
+// @Filename: /project/tsconfig.json
+//// { "compilerOptions": { "module": "commonjs" } }
+
+// @Filename: /project/node_modules/.pnpm/@[email protected]/node_modules/@types/react/index.d.ts
+//// import "csstype";
+//// export declare function Component(): void;
+
+// @Filename: /project/node_modules/.pnpm/[email protected]/node_modules/csstype/index.d.ts
+//// export interface SvgProperties {}
+
+// @Filename: /project/index.ts
+//// [|import SvgProp/**/|]
+
+// @link: /project/node_modules/.pnpm/@[email protected]/node_modules/@types/react -> /project/node_modules/@types/react
+// @link: /project/node_modules/.pnpm/[email protected]/node_modules/csstype -> /project/node_modules/.pnpm/@[email protected]/node_modules/csstype
+
+goTo.marker("");
+verify.completions({
+  marker: "",
+  exact: [],
+  preferences: {
+    includeCompletionsForImportStatements: true,
+    includeCompletionsWithInsertText: true,
+    includeCompletionsWithSnippetText: true,
+  }
+});