Ensure auto-imports don’t suggest ./node_modules;

microsoft · andrewbranch · Dec 13, 2022 · Jul 28, 2022 · Jul 29, 2022 · Jul 29, 2022
commit 0249e0a93e08a4365764a0ff92b2b0dfd0daacc0
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3598,6 +3598,7 @@ namespace ts {
                     (isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : undefined)?.name ||
                     (isLiteralImportTypeNode(location) ? location : undefined)?.argument.literal;
             const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
+            const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
             const resolvedModule = getResolvedModule(currentSourceFile, moduleReference, mode);
             const resolutionDiagnostic = resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule);
             const sourceFile = resolvedModule
@@ -3609,7 +3610,22 @@ namespace ts {
                     error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
                 }
 
-                if (resolvedModule.resolvedUsingTsExtension && isDeclarationFileName(moduleReference)) {
+                if (moduleResolutionKind === ModuleResolutionKind.Minimal && pathContainsNodeModules(moduleReference)) {
+                    // A relative import into node_modules is a problem for a few reasons:
+                    //   1. Portability - if the code gets published as a library, it will very likely break
+                    //   2. It's unclear how we should resolve types. By typical relative import rules, we
+                    //      would ignore package.json fields that tell us where to find types and would have
+                    //      no special behavior linking up node_modules/@types with their implementations -
+                    //      we would only find .d.ts files as siblings of .js files. Any package that puts
+                    //      their types in a separate directory, or is typed by @types, would be broken.
+                    //      Some of these redirections would be safe to do, but others might reflect
+                    //      Node-specific resolution features that would only work with non-relative imports.
+                    // The module resolver still returns a result, because it's possible for a module in
+                    // node_modules to end up in the program, and module specifier generation assumes that it
+                    // is always possible to generate a module specifier, even if it also generates a diagnostic.
+                    error(errorNode, Diagnostics.Relative_imports_into_node_modules_are_not_allowed);
+                }
+                else if (resolvedModule.resolvedUsingTsExtension && isDeclarationFileName(moduleReference)) {
                     const importOrExport =
                         findAncestor(location, isImportDeclaration)?.importClause ||
                         findAncestor(location, or(isImportEqualsDeclaration, isExportDeclaration)) as ImportEqualsDeclaration | ExportDeclaration | undefined;
@@ -3629,7 +3645,7 @@ namespace ts {
                     if (resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
                         errorOnImplicitAnyModule(/*isError*/ false, errorNode, resolvedModule, moduleReference);
                     }
-                    if (getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.Node16 || getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.NodeNext) {
+                    if (moduleResolutionKind === ModuleResolutionKind.Node16 || moduleResolutionKind === ModuleResolutionKind.NodeNext) {
                         const isSyncImport = (currentSourceFile.impliedNodeFormat === ModuleKind.CommonJS && !findAncestor(location, isImportCall)) || !!findAncestor(location, isImportEqualsDeclaration);
                         const overrideClauseHost = findAncestor(location, l => isImportTypeNode(l) || isExportDeclaration(l) || isImportDeclaration(l)) as ImportTypeNode | ImportDeclaration | ExportDeclaration | undefined;
                         const overrideClause = overrideClauseHost && isImportTypeNode(overrideClauseHost) ? overrideClauseHost.assertions?.assertClause : overrideClauseHost?.assertClause;
@@ -3737,7 +3753,6 @@ namespace ts {
                 else {
                     const tsExtension = tryExtractTSExtension(moduleReference);
                     const isExtensionlessRelativePathImport = pathIsRelative(moduleReference) && !hasExtension(moduleReference);
-                    const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
                     const resolutionIsNode16OrNext = moduleResolutionKind === ModuleResolutionKind.Node16 ||
                         moduleResolutionKind === ModuleResolutionKind.NodeNext;
                     if (moduleResolutionKind === ModuleResolutionKind.Minimal && pathContainsNodeModules(moduleReference)) {
@@ -3748,7 +3763,7 @@ namespace ts {
                     }
                     else if (!compilerOptions.resolveJsonModule &&
                         fileExtensionIs(moduleReference, Extension.Json) &&
-                        getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.Classic &&
+                        moduleResolutionKind !== ModuleResolutionKind.Classic &&
                         hasJsonModuleEmitEnabled(compilerOptions)) {
                         error(errorNode, Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
                     }

diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
@@ -2705,19 +2705,6 @@ namespace ts {
             if (resolvedUsingSettings) {
                 return resolvedUsingSettings;
             }
-            if (isExternalModuleNameRelative(moduleName) && pathContainsNodeModules(moduleName)) {
-                // A relative import into node_modules is a problem for a few reasons:
-                //   1. Portability - if the code gets published as a library, it will very likely break
-                //   2. It's unclear how we should resolve types. By typical relative import rules, we
-                //      would ignore package.json fields that tell us where to find types and would have
-                //      no special behavior linking up node_modules/@types with their implementations -
-                //      we would only find .d.ts files as siblings of .js files. Any package that puts
-                //      their types in a separate directory, or is typed by @types, would be broken.
-                //      Some of these redirections would be safe to do, but others might reflect
-                //      Node-specific resolution features that would only work with non-relative imports.
-                // There's a diagnostic issued for this case in the checker.
-                return noPackageId(/*resolved*/ undefined);
-            }
             const resolvedRelative = loadModuleFromFileNoImplicitExtensions(extensions, candidate, /*onlyRecordFailures*/ false, state);
             if (resolvedRelative) {
                 return noPackageId(resolvedRelative);

diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
@@ -662,7 +662,8 @@ namespace ts.codefix {
         const compilerOptions = program.getCompilerOptions();
         const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host);
         const getChecker = createGetChecker(program, host);
-        const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(getEmitModuleResolutionKind(compilerOptions));
+        const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
+        const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(moduleResolution) || moduleResolution === ModuleResolutionKind.Minimal;
         const getModuleSpecifiers = fromCacheOnly
             ? (moduleSymbol: Symbol) => ({ moduleSpecifiers: moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false })
             : (moduleSymbol: Symbol, checker: TypeChecker) => moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences);

diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -169,7 +169,7 @@ namespace ts.Completions {
 
     const enum GlobalsSearch { Continue, Success, Fail }
 
-    interface ModuleSpecifierResolutioContext {
+    interface ModuleSpecifierResolutionContext {
         tryResolve: (exportInfo: readonly SymbolExportInfo[], symbolName: string, isFromAmbientModule: boolean) => ModuleSpecifierResolutionResult;
         resolvedAny: () => boolean;
         skippedAny: () => boolean;
@@ -190,15 +190,20 @@ namespace ts.Completions {
         preferences: UserPreferences,
         isForImportStatementCompletion: boolean,
         isValidTypeOnlyUseSite: boolean,
-        cb: (context: ModuleSpecifierResolutioContext) => TReturn,
+        cb: (context: ModuleSpecifierResolutionContext) => TReturn,
     ): TReturn {
         const start = timestamp();
+        const moduleResolution = getEmitModuleResolutionKind(program.getCompilerOptions());
         // Under `--moduleResolution nodenext`, we have to resolve module specifiers up front, because
         // package.json exports can mean we *can't* resolve a module specifier (that doesn't include a
         // relative path into node_modules), and we want to filter those completions out entirely.
+        // Under `--moduleResolution minimal`, we want to reject relative module specifiers into
+        // node_modules, so need to exhaust any other possibilities for how those can be referenced.
         // Import statement completions always need specifier resolution because the module specifier is
         // part of their `insertText`, not the `codeActions` creating edits away from the cursor.
-        const needsFullResolution = isForImportStatementCompletion || moduleResolutionRespectsExports(getEmitModuleResolutionKind(program.getCompilerOptions()));
+        const needsFullResolution = isForImportStatementCompletion
+            || moduleResolutionRespectsExports(moduleResolution)
+            || moduleResolution === ModuleResolutionKind.Minimal;
         let skippedAny = false;
         let ambientCount = 0;
         let resolvedCount = 0;

diff --git a/tests/baselines/reference/autoImportsMinimal1.baseline.md b/tests/baselines/reference/autoImportsMinimal1.baseline.md
@@ -0,0 +1,15 @@
+```ts
+// @Filename: /main.ts
+/*|*/
+```
+
+## From completions
+
+- `fromLocal` from `"./local.js"`
+
+```ts
+import { fromLocal } from "./local.js";
+
+fromLocal
+```
+
diff --git a/tests/baselines/reference/autoImportsMinimal2.baseline.md b/tests/baselines/reference/autoImportsMinimal2.baseline.md
@@ -0,0 +1,15 @@
+```ts
+// @Filename: /main.ts
+/*|*/
+```
+
+## From completions
+
+- `fromLocal` from `"./local.ts"`
+
+```ts
+import { fromLocal } from "./local.ts";
+
+fromLocal
+```
+