diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 4cb55f0fe30..52a7b5f5a7a 100644
--- 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
index 12a42b6899c..e4edfe68dfa 100644
--- 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
index 7ca57c2a69f..53ec99fac81 100644
--- 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
index 58de3ec8137..c36ad7ab50b 100644
--- a/src/services/pathCompletions.ts
+++ b/src/services/pathCompletions.ts
@@ -245,18 +245,15 @@ 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);
             });
         }
 
@@ -264,7 +261,7 @@ namespace ts.Completions.PathCompletions {
         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*/ ["./*"]);
@@ -272,14 +269,14 @@ namespace ts.Completions.PathCompletions {
                         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
new file mode 100644
index 00000000000..bca8f716200
--- /dev/null
+++ 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();`
+]);
\ No newline at end of file
diff --git a/tests/cases/fourslash/importNameCodeFixNewImportFromAtTypesScopedPackage.ts b/tests/cases/fourslash/importNameCodeFixNewImportFromAtTypesScopedPackage.ts
new file mode 100644
index 00000000000..3cf6cf8a32e
--- /dev/null
+++ 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();`
+]);
\ No newline at end of file