Andrew Branch (andrewbranch) · Dec 13, 2022 · Jul 28, 2022 · Jul 29, 2022 · Jul 29, 2022 · Jul 29, 2022
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
diff --git a/src/compiler/moduleSpecifiers.ts b/src/compiler/moduleSpecifiers.ts
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts
diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
@@ -499,235 +499,21 @@ function getImportFixes(
     };
 }
 
-    function getTargetModuleFromNamespaceLikeImport(declaration: AnyImportOrRequire, checker: TypeChecker) {
-        switch (declaration.kind) {
-            case SyntaxKind.VariableDeclaration:
-                return checker.resolveExternalModuleName(declaration.initializer.arguments[0]);
-            case SyntaxKind.ImportEqualsDeclaration:
-                return checker.getAliasedSymbol(declaration.symbol);
-            case SyntaxKind.ImportDeclaration:
-                const namespaceImport = tryCast(declaration.importClause?.namedBindings, isNamespaceImport);
-                return namespaceImport && checker.getAliasedSymbol(namespaceImport.symbol);
-            default:
-                return Debug.assertNever(declaration);
-        }
-    }
-
-    function getNamespaceLikeImportText(declaration: AnyImportOrRequire) {
-        switch (declaration.kind) {
-            case SyntaxKind.VariableDeclaration:
-                return tryCast(declaration.name, isIdentifier)?.text;
-            case SyntaxKind.ImportEqualsDeclaration:
-                return declaration.name.text;
-            case SyntaxKind.ImportDeclaration:
-                return tryCast(declaration.importClause?.namedBindings, isNamespaceImport)?.name.text;
-            default:
-                return Debug.assertNever(declaration);
-        }
-    }
-
-    function getAddAsTypeOnly(
-        isValidTypeOnlyUseSite: boolean,
-        isForNewImportDeclaration: boolean,
-        symbol: Symbol,
-        targetFlags: SymbolFlags,
-        checker: TypeChecker,
-        compilerOptions: CompilerOptions
-    ) {
-        if (!isValidTypeOnlyUseSite) {
-            // Can't use a type-only import if the usage is an emitting position
-            return AddAsTypeOnly.NotAllowed;
-        }
-        if (isForNewImportDeclaration && compilerOptions.importsNotUsedAsValues === ImportsNotUsedAsValues.Error) {
-            // Not writing a (top-level) type-only import here would create an error because the runtime dependency is unnecessary
-            return AddAsTypeOnly.Required;
-        }
-        if (compilerOptions.isolatedModules && compilerOptions.preserveValueImports &&
-            (!(targetFlags & SymbolFlags.Value) || !!checker.getTypeOnlyAliasDeclaration(symbol))
-        ) {
-            // A type-only import is required for this symbol if under these settings if the symbol will
-            // be erased, which will happen if the target symbol is purely a type or if it was exported/imported
-            // as type-only already somewhere between this import and the target.
-            return AddAsTypeOnly.Required;
-        }
-        return AddAsTypeOnly.Allowed;
-    }
-
-    function tryAddToExistingImport(existingImports: readonly FixAddToExistingImportInfo[], isValidTypeOnlyUseSite: boolean, checker: TypeChecker, compilerOptions: CompilerOptions): FixAddToExistingImport | undefined {
-        return firstDefined(existingImports, ({ declaration, importKind, symbol, targetFlags }): FixAddToExistingImport | undefined => {
-            if (importKind === ImportKind.CommonJS || importKind === ImportKind.Namespace || declaration.kind === SyntaxKind.ImportEqualsDeclaration) {
-                // These kinds of imports are not combinable with anything
-                return undefined;
-            }
-
-            if (declaration.kind === SyntaxKind.VariableDeclaration) {
-                return (importKind === ImportKind.Named || importKind === ImportKind.Default) && declaration.name.kind === SyntaxKind.ObjectBindingPattern
-                    ? { kind: ImportFixKind.AddToExisting, importClauseOrBindingPattern: declaration.name, importKind, moduleSpecifier: declaration.initializer.arguments[0].text, addAsTypeOnly: AddAsTypeOnly.NotAllowed }
-                    : undefined;
-            }
-
-            const { importClause } = declaration;
-            if (!importClause || !isStringLiteralLike(declaration.moduleSpecifier)) return undefined;
-            const { name, namedBindings } = importClause;
-            // A type-only import may not have both a default and named imports, so the only way a name can
-            // be added to an existing type-only import is adding a named import to existing named bindings.
-            if (importClause.isTypeOnly && !(importKind === ImportKind.Named && namedBindings)) return undefined;
-
-            // N.B. we don't have to figure out whether to use the main program checker
-            // or the AutoImportProvider checker because we're adding to an existing import; the existence of
-            // the import guarantees the symbol came from the main program.
-            const addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ false, symbol, targetFlags, checker, compilerOptions);
-
-            if (importKind === ImportKind.Default && (
-                name ||                                                   // Cannot add a default import to a declaration that already has one
-                addAsTypeOnly === AddAsTypeOnly.Required && namedBindings // Cannot add a default import as type-only if the import already has named bindings
-            )) return undefined;
-            if (
-                importKind === ImportKind.Named &&
-                namedBindings?.kind === SyntaxKind.NamespaceImport        // Cannot add a named import to a declaration that has a namespace import
-            ) return undefined;
-
-            return {
-                kind: ImportFixKind.AddToExisting,
-                importClauseOrBindingPattern: importClause,
-                importKind,
-                moduleSpecifier: declaration.moduleSpecifier.text,
-                addAsTypeOnly,
-            };
-        });
-    }
-
-    function createExistingImportMap(checker: TypeChecker, importingFile: SourceFile, compilerOptions: CompilerOptions) {
-        let importMap: MultiMap<SymbolId, AnyImportOrRequire> | undefined;
-        for (const moduleSpecifier of importingFile.imports) {
-            const i = importFromModuleSpecifier(moduleSpecifier);
-            if (isVariableDeclarationInitializedToRequire(i.parent)) {
-                const moduleSymbol = checker.resolveExternalModuleName(moduleSpecifier);
-                if (moduleSymbol) {
-                    (importMap ||= createMultiMap()).add(getSymbolId(moduleSymbol), i.parent);
-                }
-            }
-            else if (i.kind === SyntaxKind.ImportDeclaration || i.kind === SyntaxKind.ImportEqualsDeclaration) {
-                const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
-                if (moduleSymbol) {
-                    (importMap ||= createMultiMap()).add(getSymbolId(moduleSymbol), i);
-                }
-            }
-        }
-
-        return {
-            getImportsForExportInfo: ({ moduleSymbol, exportKind, targetFlags, symbol }: SymbolExportInfo): readonly FixAddToExistingImportInfo[] => {
-                // Can't use an es6 import for a type in JS.
-                if (!(targetFlags & SymbolFlags.Value) && isSourceFileJS(importingFile)) return emptyArray;
-                const matchingDeclarations = importMap?.get(getSymbolId(moduleSymbol));
-                if (!matchingDeclarations) return emptyArray;
-                const importKind = getImportKind(importingFile, exportKind, compilerOptions);
-                return matchingDeclarations.map(declaration => ({ declaration, importKind, symbol, targetFlags }));
-            }
-        };
-    }
-
-    function shouldUseRequire(sourceFile: SourceFile, program: Program): boolean {
-        // 1. TypeScript files don't use require variable declarations
-        if (!isSourceFileJS(sourceFile)) {
-            return false;
-        }
-
-        // 2. If the current source file is unambiguously CJS or ESM, go with that
-        if (sourceFile.commonJsModuleIndicator && !sourceFile.externalModuleIndicator) return true;
-        if (sourceFile.externalModuleIndicator && !sourceFile.commonJsModuleIndicator) return false;
-
-        // 3. If there's a tsconfig/jsconfig, use its module setting
-        const compilerOptions = program.getCompilerOptions();
-        if (compilerOptions.configFile) {
-            return getEmitModuleKind(compilerOptions) < ModuleKind.ES2015;
-        }
-
-        // 4. Match the first other JS file in the program that's unambiguously CJS or ESM
-        for (const otherFile of program.getSourceFiles()) {
-            if (otherFile === sourceFile || !isSourceFileJS(otherFile) || program.isSourceFileFromExternalLibrary(otherFile)) continue;
-            if (otherFile.commonJsModuleIndicator && !otherFile.externalModuleIndicator) return true;
-            if (otherFile.externalModuleIndicator && !otherFile.commonJsModuleIndicator) return false;
-        }
-
-        // 5. Literally nothing to go on
-        return true;
-    }
-
-    function createGetChecker(program: Program, host: LanguageServiceHost) {
-        return memoizeOne((isFromPackageJson: boolean) => isFromPackageJson ? host.getPackageJsonAutoImportProvider!()!.getTypeChecker() : program.getTypeChecker());
-    }
-
-    function getNewImportFixes(
-        program: Program,
-        sourceFile: SourceFile,
-        position: number | undefined,
-        isValidTypeOnlyUseSite: boolean,
-        useRequire: boolean,
-        exportInfo: readonly SymbolExportInfo[],
-        host: LanguageServiceHost,
-        preferences: UserPreferences,
-        fromCacheOnly?: boolean,
-    ): { computedWithoutCacheCount: number, fixes: readonly (FixAddNewImport | FixAddJsdocTypeImport)[] } {
-        const isJs = isSourceFileJS(sourceFile);
-        const compilerOptions = program.getCompilerOptions();
-        const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host);
-        const getChecker = createGetChecker(program, host);
-        const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-        const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(moduleResolution);
-        const getModuleSpecifiers = fromCacheOnly
-            ? (moduleSymbol: Symbol) => ({ moduleSpecifiers: moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false })
-            : (moduleSymbol: Symbol, checker: TypeChecker) => moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences);
-
-        let computedWithoutCacheCount = 0;
-        const fixes = flatMap(exportInfo, (exportInfo, i) => {
-            const checker = getChecker(exportInfo.isFromPackageJson);
-            const { computedWithoutCache, moduleSpecifiers } = getModuleSpecifiers(exportInfo.moduleSymbol, checker);
-            const importedSymbolHasValueMeaning = !!(exportInfo.targetFlags & SymbolFlags.Value);
-            const addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, exportInfo.symbol, exportInfo.targetFlags, checker, compilerOptions);
-            computedWithoutCacheCount += computedWithoutCache ? 1 : 0;
-            return mapDefined(moduleSpecifiers, (moduleSpecifier): FixAddNewImport | FixAddJsdocTypeImport | undefined =>
-                rejectNodeModulesRelativePaths && pathContainsNodeModules(moduleSpecifier) ? undefined :
-                // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
-                !importedSymbolHasValueMeaning && isJs && position !== undefined ? { kind: ImportFixKind.JsdocTypeImport, moduleSpecifier, position, exportInfo, isReExport: i > 0 } :
-                {
-                    kind: ImportFixKind.AddNew,
-                    moduleSpecifier,
-                    importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions),
-                    useRequire,
-                    addAsTypeOnly,
-                    exportInfo,
-                    isReExport: i > 0,
-                }
-            );
-        });
-
-        return { computedWithoutCacheCount, fixes };
-    }
-
-    function getFixesForAddImport(
-        exportInfos: readonly SymbolExportInfo[],
-        existingImports: readonly FixAddToExistingImportInfo[],
-        program: Program,
-        sourceFile: SourceFile,
-        position: number | undefined,
-        isValidTypeOnlyUseSite: boolean,
-        useRequire: boolean,
-        host: LanguageServiceHost,
-        preferences: UserPreferences,
-        fromCacheOnly?: boolean,
-    ): { computedWithoutCacheCount?: number, fixes: readonly (FixAddNewImport | FixAddJsdocTypeImport)[] } {
-        const existingDeclaration = firstDefined(existingImports, info => newImportInfoFromExistingSpecifier(info, isValidTypeOnlyUseSite, useRequire, program.getTypeChecker(), program.getCompilerOptions()));
-        return existingDeclaration ? { fixes: [existingDeclaration] } : getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfos, host, preferences, fromCacheOnly);
-    }
-
-    function newImportInfoFromExistingSpecifier(
-        { declaration, importKind, symbol, targetFlags }: FixAddToExistingImportInfo,
-        isValidTypeOnlyUseSite: boolean,
-        useRequire: boolean,
-        checker: TypeChecker,
-        compilerOptions: CompilerOptions
-    ): FixAddNewImport | undefined {
+function tryUseExistingNamespaceImport(existingImports: readonly FixAddToExistingImportInfo[], symbolName: string, position: number, checker: TypeChecker): FixUseNamespaceImport | undefined {
+    // It is possible that multiple import statements with the same specifier exist in the file.
+    // e.g.
+    //
+    //     import * as ns from "foo";
+    //     import { member1, member2 } from "foo";
+    //
+    //     member3/**/ <-- cusor here
+    //
+    // in this case we should provie 2 actions:
+    //     1. change "member3" to "ns.member3"
+    //     2. add "member3" to the second import statement's import list
+    // and it is up to the user to decide which one fits best.
+    return firstDefined(existingImports, ({ declaration }): FixUseNamespaceImport | undefined => {
+        const namespacePrefix = getNamespaceLikeImportText(declaration);
         const moduleSpecifier = tryGetModuleSpecifierFromDeclaration(declaration)?.text;
         if (namespacePrefix && moduleSpecifier) {
             const moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker);
@@ -912,7 +698,8 @@ function getNewImportFixes(
     const compilerOptions = program.getCompilerOptions();
     const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host);
     const getChecker = createGetChecker(program, host);
-    const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(getEmitModuleResolutionKind(compilerOptions));
+    const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
+    const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(moduleResolution);
     const getModuleSpecifiers = fromCacheOnly
         ? (moduleSymbol: Symbol) => ({ moduleSpecifiers: moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false })
         : (moduleSymbol: Symbol, checker: TypeChecker) => moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences);