moduleSpecifiers: Simpler criteria for preferring relative path vs baseUrl

Author: Andy Hanson

src/compiler/moduleSpecifiers.ts

@@ -89,11 +89,9 @@ namespace ts.moduleSpecifiers {
         }
 
         const importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, moduleResolutionKind, addJsExtension);
-        if (paths) {
-            const fromPaths = tryGetModuleNameFromPaths(removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths);
-            if (fromPaths) {
-                return [fromPaths];
-            }
+        const fromPaths = paths && tryGetModuleNameFromPaths(removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths);
+        if (fromPaths) {
+            return [fromPaths];
         }
 
         if (preferences.importModuleSpecifierPreference === "non-relative") {
@@ -106,38 +104,19 @@ namespace ts.moduleSpecifiers {
             return [relativePath];
         }
 
-        /*
-        Prefer a relative import over a baseUrl import if it doesn't traverse up to baseUrl.
-
-        Suppose we have:
-            baseUrl = /base
-            sourceDirectory = /base/a/b
-            moduleFileName = /base/foo/bar
-        Then:
-            relativePath = ../../foo/bar
-            getRelativePathNParents(relativePath) = 2
-            pathFromSourceToBaseUrl = ../../
-            getRelativePathNParents(pathFromSourceToBaseUrl) = 2
-            2 < 2 = false
-        In this case we should prefer using the baseUrl path "/a/b" instead of the relative path "../../foo/bar".
-
-        Suppose we have:
-            baseUrl = /base
-            sourceDirectory = /base/foo/a
-            moduleFileName = /base/foo/bar
-        Then:
-            relativePath = ../a
-            getRelativePathNParents(relativePath) = 1
-            pathFromSourceToBaseUrl = ../../
-            getRelativePathNParents(pathFromSourceToBaseUrl) = 2
-            1 < 2 = true
-        In this case we should prefer using the relative path "../a" instead of the baseUrl path "foo/a".
-        */
-        const pathFromSourceToBaseUrl = ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, baseUrl, getCanonicalFileName));
-        const relativeFirst = getRelativePathNParents(relativePath) < getRelativePathNParents(pathFromSourceToBaseUrl);
+        // Prefer a relative import over a baseUrl import if it has fewer components.
+        const relativeFirst = countPathComponents(relativePath) < countPathComponents(importRelativeToBaseUrl);
         return relativeFirst ? [relativePath, importRelativeToBaseUrl] : [importRelativeToBaseUrl, relativePath];
     }
 
+    function countPathComponents(path: string): number {
+        let count = 0;
+        for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
+            if (path.charCodeAt(i) === CharacterCodes.slash) count++;
+        }
+        return count;
+    }
+
     function usesJsExtensionOnImports({ imports }: SourceFile): boolean {
         return firstDefined(imports, ({ text }) => pathIsRelative(text) ? fileExtensionIs(text, Extension.Js) : undefined) || false;
     }
@@ -197,15 +176,6 @@ namespace ts.moduleSpecifiers {
         return symlinks.length === 0 ? getAllModulePathsUsingIndirectSymlinks(files, getNormalizedAbsolutePath(importedFileName, host.getCurrentDirectory ? host.getCurrentDirectory() : ""), getCanonicalFileName, host) : symlinks;
     }
 
-    function getRelativePathNParents(relativePath: string): number {
-        const components = getPathComponents(relativePath);
-        if (components[0] || components.length === 1) return 0;
-        for (let i = 1; i < components.length; i++) {
-            if (components[i] !== "..") return i - 1;
-        }
-        return components.length - 1;
-    }
-
     function tryGetModuleNameFromAmbientModule(moduleSymbol: Symbol): string | undefined {
         const decl = moduleSymbol.valueDeclaration;
         if (isModuleDeclaration(decl) && isStringLiteral(decl.name)) {

tests/cases/fourslash/importNameCodeFix_preferBaseUrl.ts

@@ -0,0 +1,20 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /tsconfig.json
+////{ "compilerOptions": { "baseUrl": "./src" } }
+
+// @Filename: /src/d0/d1/d2/file.ts
+////foo/**/;
+
+// @Filename: /src/d0/a.ts
+////export const foo = 0;
+
+goTo.file("/src/d0/d1/d2/file.ts");
+verify.importFixAtPosition([
+`import { foo } from "d0/a";
+
+foo;`,
+`import { foo } from "../../a";
+
+foo;`,
+]);