Merge pull request microsoft#15545 from aozgaa/atTypesPrefixAndImportSuffix

aozgaa · web-flow · commit 567b10d71c09 · 2017-05-22T16:53:04.000-07:00
At types prefix and import suffix
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -1783,7 +1783,8 @@ namespace ts {
         return path.length > extension.length && endsWith(path, extension);
     }
 
-    export function fileExtensionIsAny(path: string, extensions: string[]): boolean {
+    /* @internal */
+    export function fileExtensionIsOneOf(path: string, extensions: string[]): boolean {
         for (const extension of extensions) {
             if (fileExtensionIs(path, extension)) {
                 return true;
@@ -1983,7 +1984,7 @@ namespace ts {
             for (const current of files) {
                 const name = combinePaths(path, current);
                 const absoluteName = combinePaths(absolutePath, current);
-                if (extensions && !fileExtensionIsAny(name, extensions)) continue;
+                if (extensions && !fileExtensionIsOneOf(name, extensions)) continue;
                 if (excludeRegex && excludeRegex.test(absoluteName)) continue;
                 if (!includeFileRegexes) {
                     results[0].push(name);
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
@@ -971,10 +971,13 @@ namespace ts {
         }
     }
 
+    /** Double underscores are used in DefinitelyTyped to delimit scoped packages. */
+    const mangledScopedPackageSeparator = "__";
+
     /** For a scoped package, we must look in `@types/foo__bar` instead of `@types/@foo/bar`. */
     function mangleScopedPackage(moduleName: string, state: ModuleResolutionState): string {
         if (startsWith(moduleName, "@")) {
-            const replaceSlash = moduleName.replace(ts.directorySeparator, "__");
+            const replaceSlash = moduleName.replace(ts.directorySeparator, mangledScopedPackageSeparator);
             if (replaceSlash !== moduleName) {
                 const mangled = replaceSlash.slice(1); // Take off the "@"
                 if (state.traceEnabled) {
@@ -986,6 +989,17 @@ namespace ts {
         return moduleName;
     }
 
+    /* @internal */
+    export function getPackageNameFromAtTypesDirectory(mangledName: string): string {
+        const withoutAtTypePrefix = removePrefix(mangledName, "@types/");
+        if (withoutAtTypePrefix !== mangledName) {
+            return withoutAtTypePrefix.indexOf("__") !== -1 ?
+                "@" + withoutAtTypePrefix.replace(mangledScopedPackageSeparator, ts.directorySeparator) :
+                withoutAtTypePrefix;
+        }
+        return mangledName;
+    }
+
     function tryFindNonRelativeModuleNameInCache(cache: PerModuleNameCache | undefined, moduleName: string, containingDirectory: string, traceEnabled: boolean, host: ModuleResolutionHost): SearchResult<Resolved> {
         const result = cache && cache.get(containingDirectory);
         if (result) {
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
@@ -523,7 +523,7 @@ namespace ts.codefix {
                             catch (e) { }
                         }
 
-                        return relativeFileName;
+                        return getPackageNameFromAtTypesDirectory(relativeFileName);
                     }
                 }
 
diff --git a/src/services/pathCompletions.ts b/src/services/pathCompletions.ts
@@ -245,41 +245,38 @@ namespace ts.Completions.PathCompletions {
 
         // Get modules that the type checker picked up
         const ambientModules = map(typeChecker.getAmbientModules(), sym => stripQuotes(sym.name));
-        let nonRelativeModules = filter(ambientModules, moduleName => startsWith(moduleName, fragment));
+        let nonRelativeModuleNames = filter(ambientModules, moduleName => startsWith(moduleName, fragment));
 
         // Nested modules of the form "module-name/sub" need to be adjusted to only return the string
         // after the last '/' that appears in the fragment because that's where the replacement span
         // starts
         if (isNestedModule) {
             const moduleNameWithSeperator = ensureTrailingDirectorySeparator(moduleNameFragment);
-            nonRelativeModules = map(nonRelativeModules, moduleName => {
-                if (startsWith(fragment, moduleNameWithSeperator)) {
-                    return moduleName.substr(moduleNameWithSeperator.length);
-                }
-                return moduleName;
+            nonRelativeModuleNames = map(nonRelativeModuleNames, nonRelativeModuleName => {
+                return removePrefix(nonRelativeModuleName, moduleNameWithSeperator);
             });
         }
 
 
         if (!options.moduleResolution || options.moduleResolution === ModuleResolutionKind.NodeJs) {
             for (const visibleModule of enumerateNodeModulesVisibleToScript(host, scriptPath)) {
                 if (!isNestedModule) {
-                    nonRelativeModules.push(visibleModule.moduleName);
+                    nonRelativeModuleNames.push(visibleModule.moduleName);
                 }
                 else if (startsWith(visibleModule.moduleName, moduleNameFragment)) {
                     const nestedFiles = tryReadDirectory(host, visibleModule.moduleDir, supportedTypeScriptExtensions, /*exclude*/ undefined, /*include*/ ["./*"]);
                     if (nestedFiles) {
                         for (let f of nestedFiles) {
                             f = normalizePath(f);
                             const nestedModule = removeFileExtension(getBaseFileName(f));
-                            nonRelativeModules.push(nestedModule);
+                            nonRelativeModuleNames.push(nestedModule);
                         }
                     }
                 }
             }
         }
 
-        return deduplicate(nonRelativeModules);
+        return deduplicate(nonRelativeModuleNames);
     }
 
     export function getTripleSlashReferenceCompletion(sourceFile: SourceFile, position: number, compilerOptions: CompilerOptions, host: LanguageServiceHost): CompletionInfo {
diff --git a/tests/cases/fourslash/importNameCodeFixNewImportFromAtTypes.ts b/tests/cases/fourslash/importNameCodeFixNewImportFromAtTypes.ts
@@ -0,0 +1,13 @@
+/// <reference path="fourslash.ts" />
+
+//// [|f1/*0*/();|]
+
+// @Filename: node_modules/@types/myLib/index.d.ts
+//// export function f1() {}
+//// export var v1 = 5;
+
+verify.importFixAtPosition([
+`import { f1 } from "myLib";
+
+f1();`
+]);
diff --git a/tests/cases/fourslash/importNameCodeFixNewImportFromAtTypesScopedPackage.ts b/tests/cases/fourslash/importNameCodeFixNewImportFromAtTypesScopedPackage.ts
@@ -0,0 +1,13 @@
+/// <reference path="fourslash.ts" />
+
+//// [|f1/*0*/();|]
+
+// @Filename: node_modules/@types/myLib__scoped/index.d.ts
+//// export function f1() {}
+//// export var v1 = 5;
+
+verify.importFixAtPosition([
+`import { f1 } from "@myLib/scoped";
+
+f1();`
+]);

Original file line number	Diff line number	Diff line change
`@@ -523,7 +523,7 @@ namespace ts.codefix {`
`523`	`523`	`catch (e) { }`
`524`	`524`	`}`
`525`	`525`
`526`		`- return relativeFileName;`
	`526`	`+ return getPackageNameFromAtTypesDirectory(relativeFileName);`
`527`	`527`	`}`
`528`	`528`	`}`
`529`	`529`
Original file line number	Diff line number	Diff line change
`@@ -245,41 +245,38 @@ namespace ts.Completions.PathCompletions {`
`245`	`245`
`246`	`246`	`// Get modules that the type checker picked up`
`247`	`247`	`const ambientModules = map(typeChecker.getAmbientModules(), sym => stripQuotes(sym.name));`
`248`		`- let nonRelativeModules = filter(ambientModules, moduleName => startsWith(moduleName, fragment));`
	`248`	`+ let nonRelativeModuleNames = filter(ambientModules, moduleName => startsWith(moduleName, fragment));`
`249`	`249`
`250`	`250`	`// Nested modules of the form "module-name/sub" need to be adjusted to only return the string`
`251`	`251`	`// after the last '/' that appears in the fragment because that's where the replacement span`
`252`	`252`	`// starts`
`253`	`253`	`if (isNestedModule) {`
`254`	`254`	`const moduleNameWithSeperator = ensureTrailingDirectorySeparator(moduleNameFragment);`
`255`		`- nonRelativeModules = map(nonRelativeModules, moduleName => {`
`256`		`- if (startsWith(fragment, moduleNameWithSeperator)) {`
`257`		`- return moduleName.substr(moduleNameWithSeperator.length);`
`258`		`- }`
`259`		`- return moduleName;`
	`255`	`+ nonRelativeModuleNames = map(nonRelativeModuleNames, nonRelativeModuleName => {`
	`256`	`+ return removePrefix(nonRelativeModuleName, moduleNameWithSeperator);`
`260`	`257`	`});`
`261`	`258`	`}`
`262`	`259`
`263`	`260`
`264`	`261`	`if (!options.moduleResolution \|\| options.moduleResolution === ModuleResolutionKind.NodeJs) {`
`265`	`262`	`for (const visibleModule of enumerateNodeModulesVisibleToScript(host, scriptPath)) {`
`266`	`263`	`if (!isNestedModule) {`
`267`		`- nonRelativeModules.push(visibleModule.moduleName);`
	`264`	`+ nonRelativeModuleNames.push(visibleModule.moduleName);`
`268`	`265`	`}`
`269`	`266`	`else if (startsWith(visibleModule.moduleName, moduleNameFragment)) {`
`270`	`267`	`const nestedFiles = tryReadDirectory(host, visibleModule.moduleDir, supportedTypeScriptExtensions, /exclude/ undefined, /include/ ["./*"]);`
`271`	`268`	`if (nestedFiles) {`
`272`	`269`	`for (let f of nestedFiles) {`
`273`	`270`	`f = normalizePath(f);`
`274`	`271`	`const nestedModule = removeFileExtension(getBaseFileName(f));`
`275`		`- nonRelativeModules.push(nestedModule);`
	`272`	`+ nonRelativeModuleNames.push(nestedModule);`
`276`	`273`	`}`
`277`	`274`	`}`
`278`	`275`	`}`
`279`	`276`	`}`
`280`	`277`	`}`
`281`	`278`
`282`		`- return deduplicate(nonRelativeModules);`
	`279`	`+ return deduplicate(nonRelativeModuleNames);`
`283`	`280`	`}`
`284`	`281`
`285`	`282`	`export function getTripleSlashReferenceCompletion(sourceFile: SourceFile, position: number, compilerOptions: CompilerOptions, host: LanguageServiceHost): CompletionInfo {`