Import completions with rootdirs compiler option

Author: riknoll

src/harness/harnessLanguageService.ts

@@ -219,7 +219,22 @@ namespace Harness.LanguageService {
             return snapshot.getText(0, snapshot.getLength());
         }
         resolvePath(path: string): string {
-            return ts.normalizePath(ts.isRootedDiskPath(path) ? path : ts.combinePaths(this.getCurrentDirectory(), path));
+            if (!ts.isRootedDiskPath(path)) {
+                // An "absolute" path for fourslash is one that is contained within the tests directory
+                const components = ts.getNormalizedPathComponents(path, this.getCurrentDirectory());
+                if (components.length) {
+                    // If this is still a relative path after normalization (i.e. currentDirectory is relative), the root will be the empty string
+                    if (!components[0]) {
+                        components.splice(0, 1);
+                        if (components[0] !== "tests") {
+                            // If not contained within test, assume its relative to the directory containing the test files
+                            return ts.normalizePath(ts.combinePaths("tests/cases/fourslash", components.join(ts.directorySeparator)));
+                        }
+                    }
+                    return ts.normalizePath(components.join(ts.directorySeparator));
+                }
+            }
+            return ts.normalizePath(path);
         }
 
 

src/services/services.ts

@@ -4379,7 +4379,15 @@ namespace ts {
                 const isRelativePath = startsWith(literalValue, ".");
                 const scriptDir = getDirectoryPath(node.getSourceFile().path);
                 if (isRelativePath || isRootedDiskPath(literalValue)) {
-                    result = getCompletionEntriesForDirectoryFragment(literalValue, scriptDir, getSupportedExtensions(program.getCompilerOptions()), /*includeExtensions*/false);
+                    const compilerOptions = program.getCompilerOptions();
+                    if (compilerOptions.rootDirs) {
+                        result = getCompletionEntriesForDirectoryFragmentWithRootDirs(
+                            compilerOptions.rootDirs, literalValue, scriptDir, getSupportedExtensions(program.getCompilerOptions()), /*includeExtensions*/false);
+                    }
+                    else {
+                        result = getCompletionEntriesForDirectoryFragment(
+                            literalValue, scriptDir, getSupportedExtensions(program.getCompilerOptions()), /*includeExtensions*/false);
+                    }
                 }
                 else {
                     // Check for node modules
@@ -4393,10 +4401,42 @@ namespace ts {
                 };
             }
 
-            function getCompletionEntriesForDirectoryFragment(fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean): CompletionEntry[] {
-                // Complete the path by looking for source files and directories
+            /**
+             * Takes a script path and returns paths for all potential folders that could be merged with its
+             * containing folder via the "rootDirs" compiler option
+             */
+            function getBaseDirectoriesFromRootDirs(rootDirs: string[], basePath: string, scriptPath: string, ignoreCase: boolean) {
+                // Make all paths absolute/normalized if they are not already
+                rootDirs = map(rootDirs, rootDirectory => normalizePath(isRootedDiskPath(rootDirectory) ? rootDirectory : combinePaths(basePath, rootDirectory)));
+
+                // Determine the path to the directory containing the script relative to the root directory it is contained within
+                let relativeDirectory: string;
+                forEach(rootDirs, rootDirectory => {
+                    if (containsPath(rootDirectory, scriptPath, basePath, ignoreCase)) {
+                        relativeDirectory = scriptPath.substr(rootDirectory.length);
+                        return true;
+                    }
+                });
+
+                // Now find a path for each potential directory that is to be merged with the one containing the script
+                return deduplicate(map(rootDirs, rootDirectory => combinePaths(rootDirectory, relativeDirectory)));
+            }
+
+            function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs: string[], fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean): CompletionEntry[] {
+                const basePath = program.getCompilerOptions().project || host.getCurrentDirectory();
+
+                const baseDirectories = getBaseDirectoriesFromRootDirs(
+                    rootDirs, basePath, scriptPath, host.useCaseSensitiveFileNames && !host.useCaseSensitiveFileNames());
                 const result: CompletionEntry[] = [];
 
+                for (const baseDirectory of baseDirectories) {
+                    getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensions, includeExtensions, result);
+                }
+
+                return result;
+            }
+
+            function getCompletionEntriesForDirectoryFragment(fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean, result: CompletionEntry[] = []): CompletionEntry[] {
                 const toComplete = getBaseFileName(fragment);
                 const absolutePath = normalizeSlashes(host.resolvePath(isRootedDiskPath(fragment) ? fragment : combinePaths(scriptPath, fragment)));
                 const baseDirectory = toComplete ? getDirectoryPath(absolutePath) : absolutePath;
@@ -4456,7 +4496,8 @@ namespace ts {
 
                 if (baseUrl) {
                     const fileExtensions = getSupportedExtensions(options);
-                    const absolute = isRootedDiskPath(baseUrl) ? baseUrl : combinePaths(host.getCurrentDirectory(), baseUrl)
+                    const projectDir = options.project || host.getCurrentDirectory();
+                    const absolute = isRootedDiskPath(baseUrl) ? baseUrl : combinePaths(projectDir, baseUrl);
                     result = getCompletionEntriesForDirectoryFragment(fragment, normalizePath(absolute), fileExtensions, /*includeExtensions*/false);
 
                     if (paths) {

tests/cases/fourslash/completionForStringLiteralRelativeImport4.ts

@@ -0,0 +1,48 @@
+/// <reference path='fourslash.ts' />
+
+// @rootDirs: sub/src1,src2
+
+// @Filename: src2/test0.ts
+//// import * as foo1 from "./mo/*import_as0*/
+//// import foo2 = require("./mo/*import_equals0*/
+//// var foo3 = require("./mo/*require0*/
+
+// @Filename: src2/module0.ts
+//// export var w = 0;
+
+// @Filename: sub/src1/module1.ts
+//// export var x = 0;
+
+// @Filename: sub/src1/module2.ts
+//// export var y = 0;
+
+// @Filename: sub/src1/more/module3.ts
+//// export var z = 0;
+
+
+// @Filename: f1.ts
+//// /*f1*/
+// @Filename: f2.tsx
+//// /*f2*/
+// @Filename: folder/f1.ts
+//// /*subf1*/
+// @Filename: f3.js
+//// /*f3*/
+// @Filename: f4.jsx
+//// /*f4*/
+// @Filename: e1.ts
+//// /*e1*/
+// @Filename: e2.js
+//// /*e2*/
+
+const kinds = ["import_as", "import_equals", "require"];
+
+for (const kind of kinds) {
+    goTo.marker(kind + "0");
+
+    verify.completionListContains("module0");
+    verify.completionListContains("module1");
+    verify.completionListContains("module2");
+    verify.completionListContains("more/");
+    verify.not.completionListItemsCountIsGreaterThan(4);
+}