diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index c2af8b9dc2a54..25320a192c0e6 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3895,13 +3895,22 @@ namespace ts {
                 const links = getSymbolLinks(symbol);
                 let specifier = links.specifierCache && links.specifierCache.get(contextFile.path);
                 if (!specifier) {
-                    specifier = moduleSpecifiers.getModuleSpecifierForDeclarationFile(
+                    const isBundle = (compilerOptions.out || compilerOptions.outFile);
+                    // For declaration bundles, we need to generate absolute paths relative to the common source dir for imports,
+                    // just like how the declaration emitter does for the ambient module declarations - we can easily accomplish this
+                    // using the `baseUrl` compiler option (which we would otherwise never use in declaration emit) and a non-relative
+                    // specifier preference
+                    const { moduleResolverHost } = context.tracker;
+                    const specifierCompilerOptions = isBundle ? { ...compilerOptions, baseUrl: moduleResolverHost.getCommonSourceDirectory() } : compilerOptions;
+                    specifier = first(first(moduleSpecifiers.getModuleSpecifiers(
                         symbol,
-                        compilerOptions,
+                        specifierCompilerOptions,
                         contextFile,
-                        context.tracker.moduleResolverHost,
+                        moduleResolverHost,
+                        host.getSourceFiles(),
+                        { importModuleSpecifierPreference: isBundle ? "non-relative" : "relative" },
                         host.redirectTargetsMap,
-                    );
+                    )));
                     links.specifierCache = links.specifierCache || createMap();
                     links.specifierCache.set(contextFile.path, specifier);
                 }
diff --git a/src/compiler/moduleSpecifiers.ts b/src/compiler/moduleSpecifiers.ts
index e56951cb5078c..6602a3e70dad2 100644
--- a/src/compiler/moduleSpecifiers.ts
+++ b/src/compiler/moduleSpecifiers.ts
@@ -1,8 +1,52 @@
 // Used by importFixes, getEditsForFileRename, and declaration emit to synthesize import module specifiers.
 /* @internal */
 namespace ts.moduleSpecifiers {
-    export interface ModuleSpecifierPreferences {
-        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
+    const enum RelativePreference { Relative, NonRelative, Auto }
+    // See UserPreferences#importPathEnding
+    const enum Ending { Minimal, Index, JsExtension }
+
+    // Processed preferences
+    interface Preferences {
+        readonly relativePreference: RelativePreference;
+        readonly ending: Ending;
+    }
+
+    function getPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }: UserPreferences, compilerOptions: CompilerOptions, importingSourceFile: SourceFile): Preferences {
+        return {
+            relativePreference: importModuleSpecifierPreference === "relative" ? RelativePreference.Relative : importModuleSpecifierPreference === "non-relative" ? RelativePreference.NonRelative : RelativePreference.Auto,
+            ending: getEnding(),
+        };
+        function getEnding(): Ending {
+            switch (importModuleSpecifierEnding) {
+                case "minimal": return Ending.Minimal;
+                case "index": return Ending.Index;
+                case "js": return Ending.JsExtension;
+                default: return usesJsExtensionOnImports(importingSourceFile) ? Ending.JsExtension
+                    : getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.NodeJs ? Ending.Index : Ending.Minimal;
+            }
+        }
+    }
+
+    function getPreferencesForUpdate(compilerOptions: CompilerOptions, oldImportSpecifier: string): Preferences {
+        return {
+            relativePreference: isExternalModuleNameRelative(oldImportSpecifier) ? RelativePreference.Relative : RelativePreference.NonRelative,
+            ending: hasJavaScriptOrJsonFileExtension(oldImportSpecifier) ? Ending.JsExtension
+                : getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.NodeJs || endsWith(oldImportSpecifier, "index") ? Ending.Index : Ending.Minimal,
+        };
+    }
+
+    export function updateModuleSpecifier(
+        compilerOptions: CompilerOptions,
+        importingSourceFileName: Path,
+        toFileName: string,
+        host: ModuleSpecifierResolutionHost,
+        files: ReadonlyArray<SourceFile>,
+        redirectTargetsMap: RedirectTargetsMap,
+        oldImportSpecifier: string,
+    ): string | undefined {
+        const res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, getPreferencesForUpdate(compilerOptions, oldImportSpecifier));
+        if (res === oldImportSpecifier) return undefined;
+        return res;
     }
 
     // Note: importingSourceFile is just for usesJsExtensionOnImports
@@ -13,35 +57,25 @@ namespace ts.moduleSpecifiers {
         toFileName: string,
         host: ModuleSpecifierResolutionHost,
         files: ReadonlyArray<SourceFile>,
-        preferences: ModuleSpecifierPreferences = {},
+        preferences: UserPreferences = {},
         redirectTargetsMap: RedirectTargetsMap,
     ): string {
-        const info = getInfo(compilerOptions, importingSourceFile, importingSourceFileName, host);
-        const modulePaths = getAllModulePaths(files, importingSourceFileName, toFileName, info.getCanonicalFileName, host, redirectTargetsMap);
-        return firstDefined(modulePaths, moduleFileName => getGlobalModuleSpecifier(moduleFileName, info, host, compilerOptions)) ||
-            first(getLocalModuleSpecifiers(toFileName, info, compilerOptions, preferences));
+        return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, files, redirectTargetsMap, getPreferences(preferences, compilerOptions, importingSourceFile));
     }
 
-    export function getModuleSpecifierForDeclarationFile(
-        moduleSymbol: Symbol,
+    function getModuleSpecifierWorker(
         compilerOptions: CompilerOptions,
-        importingSourceFile: SourceFile,
+        importingSourceFileName: Path,
+        toFileName: string,
         host: ModuleSpecifierResolutionHost,
+        files: ReadonlyArray<SourceFile>,
         redirectTargetsMap: RedirectTargetsMap,
+        preferences: Preferences
     ): string {
-        const isBundle = (compilerOptions.out || compilerOptions.outFile);
-        if (isBundle && host.getCommonSourceDirectory) {
-            // For declaration bundles, we need to generate absolute paths relative to the common source dir for imports,
-            // just like how the declaration emitter does for the ambient module declarations - we can easily accomplish this
-            // using the `baseUrl` compiler option (which we would otherwise never use in declaration emit) and a non-relative
-            // specifier preference
-            compilerOptions = {
-                ...compilerOptions,
-                baseUrl: host.getCommonSourceDirectory(),
-            };
-        }
-        const preferences: ModuleSpecifierPreferences = { importModuleSpecifierPreference: isBundle ? "non-relative" : "relative" };
-        return first(first(getModuleSpecifiers(moduleSymbol, compilerOptions, importingSourceFile, host, host.getSourceFiles ? host.getSourceFiles() : [importingSourceFile], preferences, redirectTargetsMap)));
+        const info = getInfo(importingSourceFileName, host);
+        const modulePaths = getAllModulePaths(files, importingSourceFileName, toFileName, info.getCanonicalFileName, host, redirectTargetsMap);
+        return firstDefined(modulePaths, moduleFileName => tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions)) ||
+            first(getLocalModuleSpecifiers(toFileName, info, compilerOptions, preferences));
     }
 
     // For each symlink/original for a module, returns a list of ways to import that file.
@@ -51,60 +85,39 @@ namespace ts.moduleSpecifiers {
         importingSourceFile: SourceFile,
         host: ModuleSpecifierResolutionHost,
         files: ReadonlyArray<SourceFile>,
-        preferences: ModuleSpecifierPreferences,
+        userPreferences: UserPreferences,
         redirectTargetsMap: RedirectTargetsMap,
     ): ReadonlyArray<ReadonlyArray<string>> {
         const ambient = tryGetModuleNameFromAmbientModule(moduleSymbol);
         if (ambient) return [[ambient]];
 
-        const info = getInfo(compilerOptions, importingSourceFile, importingSourceFile.path, host);
-        if (!files) {
-            return Debug.fail("Files list must be present to resolve symlinks in specifier resolution");
-        }
+        const info = getInfo(importingSourceFile.path, host);
         const moduleSourceFile = getSourceFileOfNode(moduleSymbol.valueDeclaration || getNonAugmentationDeclaration(moduleSymbol));
         const modulePaths = getAllModulePaths(files, importingSourceFile.path, moduleSourceFile.fileName, info.getCanonicalFileName, host, redirectTargetsMap);
 
-        const global = mapDefined(modulePaths, moduleFileName => getGlobalModuleSpecifier(moduleFileName, info, host, compilerOptions));
+        const preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile);
+        const global = mapDefined(modulePaths, moduleFileName => tryGetModuleNameAsNodeModule(moduleFileName, info, host, compilerOptions));
         return global.length ? global.map(g => [g]) : modulePaths.map(moduleFileName =>
             getLocalModuleSpecifiers(moduleFileName, info, compilerOptions, preferences));
     }
 
     interface Info {
-        readonly moduleResolutionKind: ModuleResolutionKind;
-        readonly addJsExtension: boolean;
         readonly getCanonicalFileName: GetCanonicalFileName;
         readonly sourceDirectory: Path;
     }
     // importingSourceFileName is separate because getEditsForFileRename may need to specify an updated path
-    function getInfo(compilerOptions: CompilerOptions, importingSourceFile: SourceFile, importingSourceFileName: Path, host: ModuleSpecifierResolutionHost): Info {
-        const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
-        const addJsExtension = usesJsExtensionOnImports(importingSourceFile);
+    function getInfo(importingSourceFileName: Path, host: ModuleSpecifierResolutionHost): Info {
         const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true);
         const sourceDirectory = getDirectoryPath(importingSourceFileName);
-        return { moduleResolutionKind, addJsExtension, getCanonicalFileName, sourceDirectory };
-    }
-
-    function getGlobalModuleSpecifier(
-        moduleFileName: string,
-        { addJsExtension, getCanonicalFileName, sourceDirectory }: Info,
-        host: ModuleSpecifierResolutionHost,
-        compilerOptions: CompilerOptions,
-    ) {
-        return tryGetModuleNameFromTypeRoots(compilerOptions, host, getCanonicalFileName, moduleFileName, addJsExtension)
-            || tryGetModuleNameAsNodeModule(compilerOptions, moduleFileName, host, getCanonicalFileName, sourceDirectory);
+        return { getCanonicalFileName, sourceDirectory };
     }
 
-    function getLocalModuleSpecifiers(
-        moduleFileName: string,
-        { moduleResolutionKind, addJsExtension, getCanonicalFileName, sourceDirectory }: Info,
-        compilerOptions: CompilerOptions,
-        preferences: ModuleSpecifierPreferences,
-    ): ReadonlyArray<string> {
+    function getLocalModuleSpecifiers(moduleFileName: string, { getCanonicalFileName, sourceDirectory }: Info, compilerOptions: CompilerOptions, { ending, relativePreference }: Preferences): ReadonlyArray<string> {
         const { baseUrl, paths, rootDirs } = compilerOptions;
 
         const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName) ||
-            removeExtensionAndIndexPostFix(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), moduleResolutionKind, addJsExtension);
-        if (!baseUrl || preferences.importModuleSpecifierPreference === "relative") {
+            removeExtensionAndIndexPostFix(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions);
+        if (!baseUrl || relativePreference === RelativePreference.Relative) {
             return [relativePath];
         }
 
@@ -113,7 +126,7 @@ namespace ts.moduleSpecifiers {
             return [relativePath];
         }
 
-        const importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, moduleResolutionKind, addJsExtension);
+        const importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions);
         if (paths) {
             const fromPaths = tryGetModuleNameFromPaths(removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths);
             if (fromPaths) {
@@ -121,11 +134,11 @@ namespace ts.moduleSpecifiers {
             }
         }
 
-        if (preferences.importModuleSpecifierPreference === "non-relative") {
+        if (relativePreference === RelativePreference.NonRelative) {
             return [importRelativeToBaseUrl];
         }
 
-        if (preferences.importModuleSpecifierPreference !== undefined) Debug.assertNever(preferences.importModuleSpecifierPreference);
+        if (relativePreference !== RelativePreference.Auto) Debug.assertNever(relativePreference);
 
         if (isPathRelativeToParent(relativeToBaseUrl)) {
             return [relativePath];
@@ -164,7 +177,7 @@ namespace ts.moduleSpecifiers {
     }
 
     function usesJsExtensionOnImports({ imports }: SourceFile): boolean {
-        return firstDefined(imports, ({ text }) => pathIsRelative(text) ? fileExtensionIs(text, Extension.Js) : undefined) || false;
+        return firstDefined(imports, ({ text }) => pathIsRelative(text) ? hasJavaScriptOrJsonFileExtension(text) : undefined) || false;
     }
 
     function stringsEqual(a: string, b: string, getCanonicalFileName: GetCanonicalFileName): boolean {
@@ -283,37 +296,8 @@ namespace ts.moduleSpecifiers {
         return removeFileExtension(relativePath);
     }
 
-    function tryGetModuleNameFromTypeRoots(
-        options: CompilerOptions,
-        host: GetEffectiveTypeRootsHost,
-        getCanonicalFileName: (file: string) => string,
-        moduleFileName: string,
-        addJsExtension: boolean,
-    ): string | undefined {
-        const roots = getEffectiveTypeRoots(options, host);
-        return firstDefined(roots, unNormalizedTypeRoot => {
-            const typeRoot = toPath(unNormalizedTypeRoot, /*basePath*/ undefined, getCanonicalFileName);
-            if (startsWith(moduleFileName, typeRoot)) {
-                // For a type definition, we can strip `/index` even with classic resolution.
-                return removeExtensionAndIndexPostFix(moduleFileName.substring(typeRoot.length + 1), ModuleResolutionKind.NodeJs, addJsExtension);
-            }
-        });
-    }
-
-    function tryGetModuleNameAsNodeModule(
-        options: CompilerOptions,
-        moduleFileName: string,
-        host: ModuleSpecifierResolutionHost,
-        getCanonicalFileName: (file: string) => string,
-        sourceDirectory: Path,
-    ): string | undefined {
-        if (getEmitModuleResolutionKind(options) !== ModuleResolutionKind.NodeJs) {
-            // nothing to do here
-            return undefined;
-        }
-
+    function tryGetModuleNameAsNodeModule(moduleFileName: string, { getCanonicalFileName, sourceDirectory }: Info, host: ModuleSpecifierResolutionHost, options: CompilerOptions): string | undefined {
         const parts: NodeModulePathParts = getNodeModulePathParts(moduleFileName)!;
-
         if (!parts) {
             return undefined;
         }
@@ -325,8 +309,12 @@ namespace ts.moduleSpecifiers {
         // Get a path that's relative to node_modules or the importing file's path
         // if node_modules folder is in this folder or any of its parent folders, no need to keep it.
         if (!startsWith(sourceDirectory, getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)))) return undefined;
+
         // If the module was found in @types, get the actual Node package name
-        return getPackageNameFromAtTypesDirectory(moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1));
+        const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
+        const packageName = getPackageNameFromAtTypesDirectory(nodeModulesDirectoryName);
+        // For classic resolution, only allow importing from node_modules/@types, not other node_modules
+        return getEmitModuleResolutionKind(options) !== ModuleResolutionKind.NodeJs && packageName === nodeModulesDirectoryName ? undefined : packageName;
 
         function getDirectoryOrExtensionlessFileName(path: string): string {
             // If the file is the main module, it can be imported by the package name
@@ -440,13 +428,35 @@ namespace ts.moduleSpecifiers {
         });
     }
 
-    function removeExtensionAndIndexPostFix(fileName: string, moduleResolutionKind: ModuleResolutionKind, addJsExtension: boolean): string {
+    function removeExtensionAndIndexPostFix(fileName: string, ending: Ending, options: CompilerOptions): string {
         const noExtension = removeFileExtension(fileName);
-        return addJsExtension
-            ? noExtension + ".js"
-            : moduleResolutionKind === ModuleResolutionKind.NodeJs
-                ? removeSuffix(noExtension, "/index")
-                : noExtension;
+        switch (ending) {
+            case Ending.Minimal:
+                return removeSuffix(noExtension, "/index");
+            case Ending.Index:
+                return noExtension;
+            case Ending.JsExtension:
+                return noExtension + getJavaScriptExtensionForFile(fileName, options);
+            default:
+                return Debug.assertNever(ending);
+        }
+    }
+
+    function getJavaScriptExtensionForFile(fileName: string, options: CompilerOptions): Extension {
+        const ext = extensionFromPath(fileName);
+        switch (ext) {
+            case Extension.Ts:
+            case Extension.Dts:
+                return Extension.Js;
+            case Extension.Tsx:
+                return options.jsx === JsxEmit.Preserve ? Extension.Jsx : Extension.Js;
+            case Extension.Js:
+            case Extension.Jsx:
+            case Extension.Json:
+                return ext;
+            default:
+                return Debug.assertNever(ext);
+        }
     }
 
     function getRelativePathIfInDirectory(path: string, directoryPath: string, getCanonicalFileName: GetCanonicalFileName): string | undefined {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 1b3e19f3ad6bb..83a934090364e 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -5335,8 +5335,6 @@ namespace ts {
         useCaseSensitiveFileNames?(): boolean;
         fileExists?(path: string): boolean;
         readFile?(path: string): string | undefined;
-        getSourceFiles?(): ReadonlyArray<SourceFile>; // Used for cached resolutions to find symlinks without traversing the fs (again)
-        getCommonSourceDirectory?(): string;
     }
 
     // Note: this used to be deprecated in our public API, but is still used internally
@@ -5349,7 +5347,7 @@ namespace ts {
         reportInaccessibleThisError?(): void;
         reportPrivateInBaseOfClassExpression?(propertyName: string): void;
         reportInaccessibleUniqueSymbolError?(): void;
-        moduleResolverHost?: ModuleSpecifierResolutionHost;
+        moduleResolverHost?: EmitHost;
         trackReferencedAmbientModule?(decl: ModuleDeclaration, symbol: Symbol): void;
         trackExternalModuleSymbolOfImportTypeNode?(symbol: Symbol): void;
     }
@@ -5599,4 +5597,15 @@ namespace ts {
         get<TKey extends keyof PragmaPsuedoMap>(key: TKey): PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][];
         forEach(action: <TKey extends keyof PragmaPsuedoMap>(value: PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][], key: TKey) => void): void;
     }
+
+    export interface UserPreferences {
+        readonly disableSuggestions?: boolean;
+        readonly quotePreference?: "double" | "single";
+        readonly includeCompletionsForModuleExports?: boolean;
+        readonly includeCompletionsWithInsertText?: boolean;
+        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
+        /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
+        readonly importModuleSpecifierEnding?: "minimal" | "index" | "js";
+        readonly allowTextChangesInNewFiles?: boolean;
+    }
 }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 388dbda709126..ad000bdecd2f2 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -7877,6 +7877,7 @@ namespace ts {
     /** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */
     export const supportedTypescriptExtensionsForExtractExtension: ReadonlyArray<Extension> = [Extension.Dts, Extension.Ts, Extension.Tsx];
     export const supportedJavascriptExtensions: ReadonlyArray<Extension> = [Extension.Js, Extension.Jsx];
+    export const supportedJavaScriptAndJsonExtensions: ReadonlyArray<Extension> = [Extension.Js, Extension.Jsx, Extension.Json];
     const allSupportedExtensions: ReadonlyArray<Extension> = [...supportedTypeScriptExtensions, ...supportedJavascriptExtensions];
 
     export function getSupportedExtensions(options?: CompilerOptions, extraFileExtensions?: ReadonlyArray<FileExtensionInfo>): ReadonlyArray<string> {
@@ -7902,6 +7903,10 @@ namespace ts {
         return some(supportedJavascriptExtensions, extension => fileExtensionIs(fileName, extension));
     }
 
+    export function hasJavaScriptOrJsonFileExtension(fileName: string): boolean {
+        return supportedJavaScriptAndJsonExtensions.some(ext => fileExtensionIs(fileName, ext));
+    }
+
     export function hasTypeScriptFileExtension(fileName: string): boolean {
         return some(supportedTypeScriptExtensions, extension => fileExtensionIs(fileName, extension));
     }
diff --git a/src/services/getEditsForFileRename.ts b/src/services/getEditsForFileRename.ts
index bd00ce5dd9e23..4fe024787f38f 100644
--- a/src/services/getEditsForFileRename.ts
+++ b/src/services/getEditsForFileRename.ts
@@ -6,7 +6,7 @@ namespace ts {
         newFileOrDirPath: string,
         host: LanguageServiceHost,
         formatContext: formatting.FormatContext,
-        preferences: UserPreferences,
+        _preferences: UserPreferences,
         sourceMapper: SourceMapper,
     ): ReadonlyArray<FileTextChanges> {
         const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
@@ -15,7 +15,7 @@ namespace ts {
         const newToOld = getPathUpdater(newFileOrDirPath, oldFileOrDirPath, getCanonicalFileName, sourceMapper);
         return textChanges.ChangeTracker.with({ host, formatContext }, changeTracker => {
             updateTsconfigFiles(program, changeTracker, oldToNew, newFileOrDirPath, host.getCurrentDirectory(), useCaseSensitiveFileNames);
-            updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName, preferences);
+            updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName);
         });
     }
 
@@ -122,7 +122,6 @@ namespace ts {
         newToOld: PathUpdater,
         host: LanguageServiceHost,
         getCanonicalFileName: GetCanonicalFileName,
-        preferences: UserPreferences,
     ): void {
         const allFiles = program.getSourceFiles();
         for (const sourceFile of allFiles) {
@@ -156,7 +155,7 @@ namespace ts {
 
                     // Need an update if the imported file moved, or the importing file moved and was using a relative path.
                     return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && pathIsRelative(importLiteral.text)))
-                        ? moduleSpecifiers.getModuleSpecifier(program.getCompilerOptions(), sourceFile, newImportFromPath, toImport.newFileName, host, allFiles, preferences, program.redirectTargetsMap)
+                        ? moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), newImportFromPath, toImport.newFileName, host, allFiles, program.redirectTargetsMap, importLiteral.text)
                         : undefined;
                 });
         }
@@ -210,7 +209,7 @@ namespace ts {
     }
 
     function updateImportsWorker(sourceFile: SourceFile, changeTracker: textChanges.ChangeTracker, updateRef: (refText: string) => string | undefined, updateImport: (importLiteral: StringLiteralLike) => string | undefined) {
-        for (const ref of sourceFile.referencedFiles) {
+        for (const ref of sourceFile.referencedFiles || emptyArray) { // TODO: GH#26162
             const updated = updateRef(ref.fileName);
             if (updated !== undefined && updated !== sourceFile.text.slice(ref.pos, ref.end)) changeTracker.replaceRangeWithText(sourceFile, ref, updated);
         }
diff --git a/src/services/types.ts b/src/services/types.ts
index 51c98724c0957..9bf0edf31508e 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -233,14 +233,6 @@ namespace ts {
         installPackage?(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult>;
     }
 
-    export interface UserPreferences {
-        readonly disableSuggestions?: boolean;
-        readonly quotePreference?: "double" | "single";
-        readonly includeCompletionsForModuleExports?: boolean;
-        readonly includeCompletionsWithInsertText?: boolean;
-        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
-        readonly allowTextChangesInNewFiles?: boolean;
-    }
     /* @internal */
     export const emptyOptions = {};
 
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index c08e8bf9b5cd9..a03dfe40edbd4 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -3001,6 +3001,16 @@ declare namespace ts {
         Parameters = 1296,
         IndexSignatureParameters = 4432
     }
+    interface UserPreferences {
+        readonly disableSuggestions?: boolean;
+        readonly quotePreference?: "double" | "single";
+        readonly includeCompletionsForModuleExports?: boolean;
+        readonly includeCompletionsWithInsertText?: boolean;
+        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
+        /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
+        readonly importModuleSpecifierEnding?: "minimal" | "index" | "js";
+        readonly allowTextChangesInNewFiles?: boolean;
+    }
 }
 declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any;
 declare function clearTimeout(handle: any): void;
@@ -4818,14 +4828,6 @@ declare namespace ts {
         isKnownTypesPackageName?(name: string): boolean;
         installPackage?(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult>;
     }
-    interface UserPreferences {
-        readonly disableSuggestions?: boolean;
-        readonly quotePreference?: "double" | "single";
-        readonly includeCompletionsForModuleExports?: boolean;
-        readonly includeCompletionsWithInsertText?: boolean;
-        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
-        readonly allowTextChangesInNewFiles?: boolean;
-    }
     interface LanguageService {
         cleanupSemanticCache(): void;
         getSyntacticDiagnostics(fileName: string): DiagnosticWithLocation[];
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 7d00fa8aff849..3d204560281b8 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -3001,6 +3001,16 @@ declare namespace ts {
         Parameters = 1296,
         IndexSignatureParameters = 4432
     }
+    interface UserPreferences {
+        readonly disableSuggestions?: boolean;
+        readonly quotePreference?: "double" | "single";
+        readonly includeCompletionsForModuleExports?: boolean;
+        readonly includeCompletionsWithInsertText?: boolean;
+        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
+        /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
+        readonly importModuleSpecifierEnding?: "minimal" | "index" | "js";
+        readonly allowTextChangesInNewFiles?: boolean;
+    }
 }
 declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any;
 declare function clearTimeout(handle: any): void;
@@ -4818,14 +4828,6 @@ declare namespace ts {
         isKnownTypesPackageName?(name: string): boolean;
         installPackage?(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult>;
     }
-    interface UserPreferences {
-        readonly disableSuggestions?: boolean;
-        readonly quotePreference?: "double" | "single";
-        readonly includeCompletionsForModuleExports?: boolean;
-        readonly includeCompletionsWithInsertText?: boolean;
-        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
-        readonly allowTextChangesInNewFiles?: boolean;
-    }
     interface LanguageService {
         cleanupSemanticCache(): void;
         getSyntacticDiagnostics(fileName: string): DiagnosticWithLocation[];
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index 900ae172ab88f..3f09d48490ec3 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -526,10 +526,11 @@ declare namespace FourSlashInterface {
         filesToSearch?: ReadonlyArray<string>;
     }
     interface UserPreferences {
-        quotePreference?: "double" | "single";
-        includeCompletionsForModuleExports?: boolean;
-        includeInsertTextCompletions?: boolean;
-        importModuleSpecifierPreference?: "relative" | "non-relative";
+        readonly quotePreference?: "double" | "single";
+        readonly includeCompletionsForModuleExports?: boolean;
+        readonly includeInsertTextCompletions?: boolean;
+        readonly importModuleSpecifierPreference?: "relative" | "non-relative";
+        readonly importModuleSpecifierEnding?: "minimal" | "index" | "js";
     }
     interface CompletionsAtOptions extends UserPreferences {
         triggerCharacter?: string;
diff --git a/tests/cases/fourslash/getEditsForFileRename_preservePathEnding.ts b/tests/cases/fourslash/getEditsForFileRename_preservePathEnding.ts
new file mode 100644
index 0000000000000..54b3e0e061272
--- /dev/null
+++ b/tests/cases/fourslash/getEditsForFileRename_preservePathEnding.ts
@@ -0,0 +1,44 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+// @checkJs: true
+// @strict: true
+// @jsx: preserve
+// @resolveJsonModule: true
+
+// @Filename: /index.js
+////export const x = 0;
+
+// @Filename: /jsx.jsx
+////export const y = 0;
+
+// @Filename: /j.jonah.json
+////{ "j": 0 }
+
+// @Filename: /a.js
+////import { x as x0 } from ".";
+////import { x as x1 } from "./index";
+////import { x as x2 } from "./index.js";
+////import { y } from "./jsx.jsx";
+////import { j } from "./j.jonah.json";
+
+verify.noErrors();
+
+verify.getEditsForFileRename({
+    oldPath: "/a.js",
+    newPath: "/b.js",
+    newFileContents: {}, // No change
+});
+
+verify.getEditsForFileRename({
+    oldPath: "/b.js",
+    newPath: "/src/b.js",
+    newFileContents: {
+        "/b.js":
+`import { x as x0 } from "..";
+import { x as x1 } from "../index";
+import { x as x2 } from "../index.js";
+import { y } from "../jsx.jsx";
+import { j } from "../j.jonah.json";`,
+    },
+});
diff --git a/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots0.ts b/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots0.ts
index cb7ef465affe8..ddc6d1790c726 100644
--- a/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots0.ts
+++ b/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots0.ts
@@ -1,22 +1,23 @@
-/// <reference path="fourslash.ts" />
-
-// @Filename: a/f1.ts
-//// [|foo/*0*/();|]
-
-// @Filename: types/random/index.ts
-//// export function foo() {};
-
-// @Filename: tsconfig.json
-//// {
-////     "compilerOptions": {
-////         "typeRoots": [
-////             "./types"
-////         ]
-////     }
-//// }
-
-verify.importFixAtPosition([
-`import { foo } from "random";
-
-foo();`
-]);
+/// <reference path="fourslash.ts" />
+
+// @Filename: a/f1.ts
+//// [|foo/*0*/();|]
+
+// @Filename: types/random/index.ts
+//// export function foo() {};
+
+// @Filename: tsconfig.json
+//// {
+////     "compilerOptions": {
+////         "typeRoots": [
+////             "./types"
+////         ]
+////     }
+//// }
+
+// "typeRoots" does not affect module resolution. Importing from "random" would be a compile error.
+verify.importFixAtPosition([
+`import { foo } from "../types/random";
+
+foo();`
+]);
diff --git a/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots1.ts b/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots1.ts
index 1398a5d786614..9743d164a9c51 100644
--- a/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots1.ts
+++ b/tests/cases/fourslash/importNameCodeFixNewImportTypeRoots1.ts
@@ -1,23 +1,27 @@
-/// <reference path="fourslash.ts" />
-
-// @Filename: a/f1.ts
-//// [|foo/*0*/();|]
-
-// @Filename: types/random/index.ts
-//// export function foo() {};
-
-// @Filename: tsconfig.json
-//// {
-////     "compilerOptions": {
-////         "baseUrl": ".",
-////         "typeRoots": [
-////             "./types"
-////         ]
-////     }
-//// }
-
-verify.importFixAtPosition([
-`import { foo } from "random";
-
-foo();`
-]);
+/// <reference path="fourslash.ts" />
+
+// @Filename: a/f1.ts
+//// [|foo/*0*/();|]
+
+// @Filename: types/random/index.ts
+//// export function foo() {};
+
+// @Filename: tsconfig.json
+//// {
+////     "compilerOptions": {
+////         "baseUrl": ".",
+////         "typeRoots": [
+////             "./types"
+////         ]
+////     }
+//// }
+
+// "typeRoots" does not affect module resolution. Importing from "random" would be a compile error.
+verify.importFixAtPosition([
+`import { foo } from "types/random";
+
+foo();`,
+`import { foo } from "../types/random";
+
+foo();`
+]);
diff --git a/tests/cases/fourslash/importNameCodeFix_endingPreference.ts b/tests/cases/fourslash/importNameCodeFix_endingPreference.ts
new file mode 100644
index 0000000000000..41a96e9cf0633
--- /dev/null
+++ b/tests/cases/fourslash/importNameCodeFix_endingPreference.ts
@@ -0,0 +1,26 @@
+/// <reference path="fourslash.ts" />
+
+// @moduleResolution: node
+
+// @Filename: /foo/index.ts
+////export const foo = 0;
+
+// @Filename: /a.ts
+////foo;
+
+// @Filename: /b.ts
+////foo;
+
+// @Filename: /c.ts
+////foo;
+
+const tests: ReadonlyArray<[string, FourSlashInterface.UserPreferences["importModuleSpecifierEnding"], string]> = [
+    ["/a.ts", "js", "./foo/index.js"],
+    ["/b.ts", "index", "./foo/index"],
+    ["/c.ts", "minimal", "./foo"],
+];
+
+for (const [fileName, importModuleSpecifierEnding, specifier] of tests) {
+    goTo.file(fileName);
+    verify.importFixAtPosition([`import { foo } from "${specifier}";\n\nfoo;`,], /*errorCode*/ undefined, { importModuleSpecifierEnding });
+}
diff --git a/tests/cases/fourslash/importNameCodeFix_jsExtension.ts b/tests/cases/fourslash/importNameCodeFix_jsExtension.ts
index e719f1aeee889..b47e67d82b23b 100644
--- a/tests/cases/fourslash/importNameCodeFix_jsExtension.ts
+++ b/tests/cases/fourslash/importNameCodeFix_jsExtension.ts
@@ -2,6 +2,7 @@
 
 // @moduleResolution: node
 // @noLib: true
+// @jsx: preserve
 
 // @Filename: /a.ts
 ////export function a() {}
@@ -9,17 +10,24 @@
 // @Filename: /b.ts
 ////export function b() {}
 
+// @Filename: /c.tsx
+////export function c() {}
+
 // @Filename: /c.ts
 ////import * as g from "global"; // Global imports skipped
 ////import { a } from "./a.js";
 ////import { a as a2 } from "./a"; // Ignored, only the first relative import is considered
-////b;
+////b; c;
 
 goTo.file("/c.ts");
-verify.importFixAtPosition([
+verify.codeFixAll({
+    fixId: "fixMissingImport",
+    fixAllDescription: "Add all missing imports",
+    newFileContent:
 `import * as g from "global"; // Global imports skipped
 import { a } from "./a.js";
 import { a as a2 } from "./a"; // Ignored, only the first relative import is considered
 import { b } from "./b.js";
-b;`,
-]);
+import { c } from "./c.jsx";
+b; c;`,
+});
diff --git a/tests/cases/fourslash/importNameCodeFix_types_classic.ts b/tests/cases/fourslash/importNameCodeFix_types_classic.ts
index b9ba463fada80..4d3bdda4d3142 100644
--- a/tests/cases/fourslash/importNameCodeFix_types_classic.ts
+++ b/tests/cases/fourslash/importNameCodeFix_types_classic.ts
@@ -5,12 +5,22 @@
 // @Filename: /node_modules/@types/foo/index.d.ts
 ////export const xyz: number;
 
+// @Filename: /node_modules/bar/index.d.ts
+////export const qrs: number;
+
 // @Filename: /a.ts
-////[|xyz|]
+////xyz;
+////qrs;
 
 goTo.file("/a.ts");
-verify.importFixAtPosition([
+verify.codeFixAll({
+    fixId: "fixMissingImport",
+    fixAllDescription: "Add all missing imports",
+    newFileContent:
 `import { xyz } from "foo";
 
-xyz`
-]);
+import { qrs } from "./node_modules/bar/index";
+
+xyz;
+qrs;`,
+});