@tslite/services 0.0.0-stage → 1.13.0

package/dist/codefixes/importFixes.d.ts

@@ -0,0 +1,14 @@
+import { formatting, textChanges } from "../_namespaces/edit.js";
+import type { CheckResult, CodeAction, CodeFixContextBase, DiagnosticWithLocation, LanguageServiceHost, SourceFile, Symbol, UserPreferences } from "../_namespaces/edit.js";
+export declare const importFixName = "import";
+export interface ImportAdder {
+    addImportFromDiagnostic: (diagnostic: DiagnosticWithLocation, context: CodeFixContextBase) => void;
+    addImportFromExportedSymbol: (exportedSymbol: Symbol, usageIsTypeOnly?: boolean) => void;
+    writeFixes: (changeTracker: textChanges.ChangeTracker) => void;
+}
+export declare function createImportAdder(sourceFile: SourceFile, program: CheckResult, preferences: UserPreferences, host: LanguageServiceHost): ImportAdder;
+export declare function getImportCompletionAction(exportedSymbol: Symbol, moduleSymbol: Symbol, sourceFile: SourceFile, symbolName: string, host: LanguageServiceHost, program: CheckResult, formatContext: formatting.FormatContext, position: number, preferences: UserPreferences): {
+    readonly moduleSpecifier: string;
+    readonly codeAction: CodeAction;
+};
+export declare function forEachExternalModuleToImportFrom(program: CheckResult, _host: LanguageServiceHost, from: SourceFile, cb: (module: Symbol) => void): void;

package/dist/codefixes/importFixes.js

@@ -0,0 +1,441 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/importFixes.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Completions, Debug, Diagnostics, InternalSymbolName, ScriptTarget, SymbolFlags, SyntaxKind, arrayFrom, cast, combine, createIdentifier, createImportSpecifier, createMap, createModuleSpecifierResolutionHost, createMultiMap, createNamedImports, emptyArray, escapeLeadingUnderscores, first, firstDefined, flatMap, flatMapIterator, formatting, getDirectoryPath, getMeaningFromDeclaration, getMeaningFromLocation, getNameForExportedSymbol, getNodeId, getQuotePreference, getTokenAtPosition, getTypeKeywordOfTypeOnlyImport, getUniqueSymbolId, importFromModuleSpecifier, insertImports, isExportAssignment, isExportSpecifier, isExternalOrCommonJsModule, isIdentifier, isNamedImports, isNamespaceImport, isStringLiteral, isValidTypeOnlyAliasUseSite, last, makeImport, mapDefined, moduleSymbolToValidIdentifier, moduleSpecifiers, pushIfUnique, skipAlias, some, sort, startsWith, stripQuotes, textChanges, tryCast, } from "../_namespaces/edit.js";
+import { createCodeFixAction, createCombinedCodeActions, eachDiagnostic, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+export const importFixName = "import";
+const importFixId = "fixMissingImport";
+// Na tag, também o nome que seria um membro do `this` ou um membro estático (CK-02), e o global de um UMD num módulo
+// (CK-03): a cópia não acusa esses erros.
+const errorCodes = [
+    Diagnostics.Cannot_find_name_0.code,
+    Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
+    Diagnostics.Cannot_find_namespace_0.code,
+    Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code,
+];
+// O alvo da configuração fixa (CK-24): o do nome que se importa.
+const languageVersion = ScriptTarget.ES2020;
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const { preferences, sourceFile, span } = context;
+        const info = getFixesInfo(context, span.start);
+        if (!info)
+            return undefined;
+        const { fixes, symbolName } = info;
+        const quotePreference = getQuotePreference(sourceFile, preferences);
+        return fixes.map(fix => codeActionForFix(context, sourceFile, symbolName, fix, quotePreference));
+    },
+    fixIds: [importFixId],
+    getAllCodeActions: context => {
+        const { sourceFile, program, preferences, host } = context;
+        const importAdder = createImportAdder(sourceFile, program, preferences, host);
+        eachDiagnostic(context, errorCodes, diag => importAdder.addImportFromDiagnostic(diag, context));
+        return createCombinedCodeActions(textChanges.ChangeTracker.with(context, importAdder.writeFixes));
+    },
+});
+export function createImportAdder(sourceFile, program, preferences, host) {
+    // Namespace fixes don't conflict, so just build a list.
+    const addToNamespace = [];
+    // Keys are import clause node IDs.
+    const addToExisting = createMap();
+    const newImports = createMap();
+    return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes };
+    function addImportFromDiagnostic(diagnostic, context) {
+        const info = getFixesInfo(context, diagnostic.start);
+        if (!info || !info.fixes.length)
+            return;
+        addImport(info);
+    }
+    // Na tag, o uso só de tipo pedia um import de tipo quando o `importsNotUsedAsValues` era `error`; a configuração
+    // fixa o deixa no padrão (CK-24).
+    function addImportFromExportedSymbol(exportedSymbol) {
+        const moduleSymbol = Debug.checkDefined(exportedSymbol.parent);
+        const symbolName = getNameForExportedSymbol(exportedSymbol, languageVersion);
+        const checker = program.getTypeChecker();
+        const symbol = checker.getMergedSymbol(skipAlias(exportedSymbol, checker));
+        const exportInfos = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, checker, program.getSourceFiles());
+        const fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, host, preferences);
+        addImport({ fixes: [fix], symbolName });
+    }
+    function addImport(info) {
+        const { fixes, symbolName } = info;
+        const fix = first(fixes);
+        switch (fix.kind) {
+            case 0 /* ImportFixKind.UseNamespace */:
+                addToNamespace.push(fix);
+                break;
+            case 1 /* ImportFixKind.AddToExisting */: {
+                const { importClauseOrBindingPattern, importKind, canUseTypeOnlyImport } = fix;
+                const key = String(getNodeId(importClauseOrBindingPattern));
+                let entry = addToExisting.get(key);
+                if (!entry) {
+                    addToExisting.set(key, entry = { importClauseOrBindingPattern, defaultImport: undefined, namedImports: [], canUseTypeOnlyImport });
+                }
+                if (importKind === 0 /* ImportKind.Named */) {
+                    pushIfUnique(entry.namedImports, symbolName);
+                }
+                else {
+                    Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName, "(Add to Existing) Default import should be missing or match symbolName");
+                    entry.defaultImport = symbolName;
+                }
+                break;
+            }
+            case 2 /* ImportFixKind.AddNew */: {
+                const { moduleSpecifier, importKind } = fix;
+                let entry = newImports.get(moduleSpecifier);
+                if (!entry) {
+                    newImports.set(moduleSpecifier, entry = { namedImports: [] });
+                }
+                switch (importKind) {
+                    case 1 /* ImportKind.Default */:
+                        Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName, "(Add new) Default import should be missing or match symbolName");
+                        entry.defaultImport = symbolName;
+                        break;
+                    case 0 /* ImportKind.Named */:
+                        pushIfUnique(entry.namedImports || (entry.namedImports = []), symbolName);
+                        break;
+                }
+                break;
+            }
+            default:
+                Debug.assertNever(fix, `fix wasn't never - got kind ${fix.kind}`);
+        }
+    }
+    function writeFixes(changeTracker) {
+        const quotePreference = getQuotePreference(sourceFile, preferences);
+        for (const fix of addToNamespace) {
+            addNamespaceQualifier(changeTracker, sourceFile, fix);
+        }
+        addToExisting.forEach(({ importClauseOrBindingPattern, defaultImport, namedImports, canUseTypeOnlyImport }) => {
+            doAddExistingFix(changeTracker, sourceFile, importClauseOrBindingPattern, defaultImport, namedImports, canUseTypeOnlyImport);
+        });
+        let newDeclarations;
+        newImports.forEach((imports, moduleSpecifier) => {
+            newDeclarations = combine(newDeclarations, getNewImports(moduleSpecifier, quotePreference, imports));
+        });
+        if (newDeclarations) {
+            insertImports(changeTracker, sourceFile, newDeclarations, /*blankLineBetween*/ true);
+        }
+    }
+}
+// Sorted with the preferred fix coming first.
+// Na tag, também o `import("./a").T` no lugar do nome, que só um arquivo JavaScript pedia (CK-03).
+var ImportFixKind;
+(function (ImportFixKind) {
+    ImportFixKind[ImportFixKind["UseNamespace"] = 0] = "UseNamespace";
+    ImportFixKind[ImportFixKind["AddToExisting"] = 1] = "AddToExisting";
+    ImportFixKind[ImportFixKind["AddNew"] = 2] = "AddNew";
+})(ImportFixKind || (ImportFixKind = {}));
+// Na tag, também o import de namespace e o `import x = require(…)`, que só o global de um UMD e o valor de um
+// `export =` pediam (CK-03).
+var ImportKind;
+(function (ImportKind) {
+    ImportKind[ImportKind["Named"] = 0] = "Named";
+    ImportKind[ImportKind["Default"] = 1] = "Default";
+})(ImportKind || (ImportKind = {}));
+export function getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) {
+    const exportInfos = getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, program.getTypeChecker(), program.getSourceFiles());
+    const moduleSpecifier = first(getNewImportInfos(sourceFile, exportInfos, host, preferences)).moduleSpecifier;
+    const fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, host, preferences);
+    return { moduleSpecifier, codeAction: codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName, fix, getQuotePreference(sourceFile, preferences))) };
+}
+function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, host, preferences) {
+    Debug.assert(exportInfos.some(info => info.moduleSymbol === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
+    // We sort the best codefixes first, so taking `first` is best.
+    return first(getFixForImport(exportInfos, symbolName, position, program, sourceFile, host, preferences));
+}
+// Na tag, também os `commands` da ação (CK-47).
+function codeFixActionToCodeAction({ description, changes }) {
+    return { description, changes };
+}
+function getAllReExportingModules(importingFile, exportedSymbol, exportingModuleSymbol, symbolName, checker, allSourceFiles) {
+    const result = [];
+    forEachExternalModule(checker, allSourceFiles, (moduleSymbol, moduleFile) => {
+        // Don't import from a re-export when looking "up" like to `./index` or `../index`.
+        if (moduleSymbol !== exportingModuleSymbol && startsWith(importingFile.fileName, getDirectoryPath(moduleFile.fileName))) {
+            return;
+        }
+        const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
+        if (defaultInfo && defaultInfo.name === symbolName && skipAlias(defaultInfo.symbol, checker) === exportedSymbol) {
+            result.push({ moduleSymbol, importKind: defaultInfo.kind });
+        }
+        for (const exported of checker.getExportsAndPropertiesOfModule(moduleSymbol)) {
+            if (exported.name === symbolName && skipAlias(exported, checker) === exportedSymbol) {
+                result.push({ moduleSymbol, importKind: 0 /* ImportKind.Named */ });
+            }
+        }
+    });
+    return result;
+}
+function isTypeOnlyPosition(sourceFile, position) {
+    return isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
+}
+function getFixForImport(exportInfos, symbolName, 
+/** undefined only for missing JSX namespace */
+position, program, sourceFile, host, preferences) {
+    const checker = program.getTypeChecker();
+    const existingImports = flatMap(exportInfos, info => getExistingImportDeclarations(info, checker, sourceFile));
+    const useNamespace = position === undefined ? undefined : tryUseExistingNamespaceImport(existingImports, symbolName, position, checker);
+    const addToExisting = tryAddToExistingImport(existingImports, position !== undefined && isTypeOnlyPosition(sourceFile, position));
+    // Don't bother providing an action to add a new import if we can add to an existing one.
+    const addImport = addToExisting ? [addToExisting] : getFixesForAddImport(exportInfos, existingImports, sourceFile, host, preferences);
+    return [...(useNamespace ? [useNamespace] : emptyArray), ...addImport];
+}
+function tryUseExistingNamespaceImport(existingImports, symbolName, position, checker) {
+    // 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 }) => {
+        const namespacePrefix = getNamespaceLikeImportText(declaration);
+        if (namespacePrefix) {
+            const moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker);
+            if (moduleSymbol && moduleSymbol.exports.has(escapeLeadingUnderscores(symbolName))) {
+                return { kind: 0 /* ImportFixKind.UseNamespace */, namespacePrefix, position };
+            }
+        }
+    });
+}
+// Na tag, também o `const x = require(…)` e o `import x = require(…)` (CK-03).
+function getTargetModuleFromNamespaceLikeImport(declaration, checker) {
+    const namespaceImport = tryCast(declaration.importClause?.namedBindings, isNamespaceImport);
+    return namespaceImport && checker.getAliasedSymbol(namespaceImport.symbol);
+}
+// Na tag, também o `const x = require(…)` e o `import x = require(…)` (CK-03).
+function getNamespaceLikeImportText(declaration) {
+    return tryCast(declaration.importClause?.namedBindings, isNamespaceImport)?.name.text;
+}
+function tryAddToExistingImport(existingImports, canUseTypeOnlyImport) {
+    return firstDefined(existingImports, ({ declaration, importKind }) => {
+        // Na tag, o `import =` não recebia mais nada, e o padrão de um `const { … } = require(…)` recebia o nome (CK-03).
+        const { importClause } = declaration;
+        if (!importClause)
+            return undefined;
+        const { name, namedBindings } = importClause;
+        return importKind === 1 /* ImportKind.Default */ && !name || importKind === 0 /* ImportKind.Named */ && (!namedBindings || namedBindings.kind === SyntaxKind.NamedImports)
+            ? { kind: 1 /* ImportFixKind.AddToExisting */, importClauseOrBindingPattern: importClause, importKind, moduleSpecifier: declaration.moduleSpecifier.getText(), canUseTypeOnlyImport }
+            : undefined;
+    });
+}
+function getExistingImportDeclarations({ moduleSymbol, importKind }, checker, sourceFile) {
+    // Na tag, também o `const x = require(…)` e o `import x = require(…)`, e, num arquivo JavaScript, nenhum import ES
+    // para um tipo (CK-03).
+    return mapDefined(sourceFile.imports, (moduleSpecifier) => {
+        const i = importFromModuleSpecifier(moduleSpecifier);
+        if (i.kind === SyntaxKind.ImportDeclaration) {
+            return checker.getSymbolAtLocation(moduleSpecifier) === moduleSymbol ? { declaration: i, importKind } : undefined;
+        }
+    });
+}
+// Na tag, também o `import("./a").T` que um arquivo JavaScript pedia para um tipo (CK-03), e, à frente dos specifiers
+// mais curtos, os que o `package.json` cobria (CK-47). Recebia também o programa, pelas opções e pelo host do specifier.
+function getNewImportInfos(sourceFile, moduleSymbols, host, preferences) {
+    const choicesForEachExportingModule = flatMap(moduleSymbols, ({ moduleSymbol, importKind }) => moduleSpecifiers.getModuleSpecifiers(moduleSymbol, sourceFile, createModuleSpecifierResolutionHost(host), preferences)
+        .map((moduleSpecifier) => ({ kind: 2 /* ImportFixKind.AddNew */, moduleSpecifier, importKind })));
+    // Shortest paths first
+    return sort(choicesForEachExportingModule, (a, b) => a.moduleSpecifier.length - b.moduleSpecifier.length);
+}
+// Na tag, recebia também o programa, que só repassava.
+function getFixesForAddImport(exportInfos, existingImports, sourceFile, host, preferences) {
+    const existingDeclaration = firstDefined(existingImports, info => newImportInfoFromExistingSpecifier(info));
+    return existingDeclaration ? [existingDeclaration] : getNewImportInfos(sourceFile, exportInfos, host, preferences);
+}
+// Na tag, também o specifier de um `const x = require(…)` e de um `import x = require(…)` (CK-03).
+function newImportInfoFromExistingSpecifier({ declaration, importKind }) {
+    const moduleSpecifier = declaration.moduleSpecifier;
+    return isStringLiteral(moduleSpecifier)
+        ? { kind: 2 /* ImportFixKind.AddNew */, moduleSpecifier: moduleSpecifier.text, importKind }
+        : undefined;
+}
+// Na tag, recebia também o código do erro, e o do global de um UMD num módulo ia ao import do UMD (CK-03).
+function getFixesInfo(context, pos) {
+    const symbolToken = getTokenAtPosition(context.sourceFile, pos);
+    const info = isIdentifier(symbolToken) ? getFixesInfoForNonUMDImport(context, symbolToken) : undefined;
+    return info && { ...info, fixes: sort(info.fixes, (a, b) => a.kind - b.kind) };
+}
+function getFixesInfoForNonUMDImport({ sourceFile, program, cancellationToken, host, preferences }, symbolToken) {
+    const checker = program.getTypeChecker();
+    // Na tag, a tag de um elemento JSX que já estava em escopo pedia o import da fábrica do JSX (o `React`), que é do
+    // emit (CK-19).
+    const symbolName = symbolToken.text;
+    // "default" is a keyword and not a legal identifier for the import, so we don't expect it here
+    Debug.assert(symbolName !== InternalSymbolName.Default, "'default' isn't a legal identifier and couldn't occur here");
+    const exportInfos = getExportInfos(symbolName, getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, checker, program, host);
+    const fixes = arrayFrom(flatMapIterator(exportInfos.entries(), ([_, exportInfos]) => getFixForImport(exportInfos, symbolName, symbolToken.getStart(sourceFile), program, sourceFile, host, preferences)));
+    return { fixes, symbolName };
+}
+// Returns a map from an exported symbol's ID to a list of every way it's (re-)exported.
+function getExportInfos(symbolName, currentTokenMeaning, cancellationToken, sourceFile, checker, program, host) {
+    // For each original symbol, keep all re-exports of that symbol together so we can call `getCodeActionsForImport` on the whole group at once.
+    // Maps symbol id to info for modules providing that symbol (original export + re-exports).
+    const originalSymbolToExportInfos = createMultiMap();
+    function addSymbol(moduleSymbol, exportedSymbol, importKind) {
+        originalSymbolToExportInfos.add(getUniqueSymbolId(exportedSymbol, checker).toString(), { moduleSymbol, importKind });
+    }
+    forEachExternalModuleToImportFrom(program, host, sourceFile, moduleSymbol => {
+        cancellationToken.throwIfCancellationRequested();
+        const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
+        if (defaultInfo && defaultInfo.name === symbolName && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) {
+            addSymbol(moduleSymbol, defaultInfo.symbol, defaultInfo.kind);
+        }
+        // check exports with the same name
+        const exportSymbolWithIdenticalName = checker.tryGetMemberInModuleExportsAndProperties(symbolName, moduleSymbol);
+        if (exportSymbolWithIdenticalName && symbolHasMeaning(exportSymbolWithIdenticalName, currentTokenMeaning)) {
+            addSymbol(moduleSymbol, exportSymbolWithIdenticalName, 0 /* ImportKind.Named */);
+        }
+    });
+    return originalSymbolToExportInfos;
+}
+// Na tag, recebia também o arquivo que importa e as opções, que decidiam o import do valor de um `export =` (CK-03).
+function getDefaultLikeExportInfo(moduleSymbol, checker) {
+    const exported = getDefaultLikeExportWorker(moduleSymbol, checker);
+    if (!exported)
+        return undefined;
+    const { symbol, kind } = exported;
+    const info = getDefaultExportInfoWorker(symbol, moduleSymbol, checker);
+    return info && { symbol, kind, ...info };
+}
+// Na tag, também o valor do `export =` do módulo, importado como default, como namespace ou pelo `import =` (CK-03).
+function getDefaultLikeExportWorker(moduleSymbol, checker) {
+    const defaultExport = checker.tryGetMemberInModuleExports(InternalSymbolName.Default, moduleSymbol);
+    if (defaultExport)
+        return { symbol: defaultExport, kind: 1 /* ImportKind.Default */ };
+    return undefined;
+}
+// Na tag, primeiro o símbolo local de uma declaração com o modificador `default`, que só vinha diante da `function` e da
+// classe (CK-02); o `export default` que fica é de expressão, e não tem símbolo local (CK-46).
+function getDefaultExportInfoWorker(defaultExport, moduleSymbol, checker) {
+    const name = getNameForExportDefault(defaultExport);
+    if (name !== undefined)
+        return { symbolForMeaning: defaultExport, name };
+    if (defaultExport.flags & SymbolFlags.Alias) {
+        const aliased = checker.getImmediateAliasedSymbol(defaultExport);
+        return aliased && getDefaultExportInfoWorker(aliased, Debug.checkDefined(aliased.parent, "Alias targets of default exports must have a parent"), checker);
+    }
+    // Na tag, também o nome `export=` (CK-03).
+    if (defaultExport.escapedName !== InternalSymbolName.Default) {
+        return { symbolForMeaning: defaultExport, name: defaultExport.getName() };
+    }
+    return { symbolForMeaning: defaultExport, name: moduleSymbolToValidIdentifier(moduleSymbol, languageVersion) };
+}
+function getNameForExportDefault(symbol) {
+    return symbol.declarations && firstDefined(symbol.declarations, declaration => {
+        if (isExportAssignment(declaration)) {
+            if (isIdentifier(declaration.expression)) {
+                return declaration.expression.text;
+            }
+        }
+        else if (isExportSpecifier(declaration)) {
+            Debug.assert(declaration.name.text === InternalSymbolName.Default, "Expected the specifier to be a default export");
+            return declaration.propertyName && declaration.propertyName.text;
+        }
+    });
+}
+function codeActionForFix(context, sourceFile, symbolName, fix, quotePreference) {
+    let diag;
+    const changes = textChanges.ChangeTracker.with(context, tracker => {
+        diag = codeActionForFixWorker(tracker, sourceFile, symbolName, fix, quotePreference);
+    });
+    return createCodeFixAction(importFixName, changes, diag, importFixId, Diagnostics.Add_all_missing_imports);
+}
+function codeActionForFixWorker(changes, sourceFile, symbolName, fix, quotePreference) {
+    switch (fix.kind) {
+        case 0 /* ImportFixKind.UseNamespace */:
+            addNamespaceQualifier(changes, sourceFile, fix);
+            return [Diagnostics.Change_0_to_1, symbolName, `${fix.namespacePrefix}.${symbolName}`];
+        case 1 /* ImportFixKind.AddToExisting */: {
+            const { importClauseOrBindingPattern, importKind, canUseTypeOnlyImport, moduleSpecifier } = fix;
+            doAddExistingFix(changes, sourceFile, importClauseOrBindingPattern, importKind === 1 /* ImportKind.Default */ ? symbolName : undefined, importKind === 0 /* ImportKind.Named */ ? [symbolName] : emptyArray, canUseTypeOnlyImport);
+            const moduleSpecifierWithoutQuotes = stripQuotes(moduleSpecifier);
+            return [importKind === 1 /* ImportKind.Default */ ? Diagnostics.Add_default_import_0_to_existing_import_declaration_from_1 : Diagnostics.Add_0_to_existing_import_declaration_from_1, symbolName, moduleSpecifierWithoutQuotes]; // you too!
+        }
+        case 2 /* ImportFixKind.AddNew */: {
+            const { importKind, moduleSpecifier } = fix;
+            const importsCollection = importKind === 1 /* ImportKind.Default */ ? { defaultImport: symbolName } : { namedImports: [symbolName] };
+            insertImports(changes, sourceFile, getNewImports(moduleSpecifier, quotePreference, importsCollection), /*blankLineBetween*/ true);
+            return [importKind === 1 /* ImportKind.Default */ ? Diagnostics.Import_default_0_from_module_1 : Diagnostics.Import_0_from_module_1, symbolName, moduleSpecifier];
+        }
+        default:
+            return Debug.assertNever(fix, `Unexpected fix kind ${fix.kind}`);
+    }
+}
+// Na tag, o import existente podia ser também o padrão de um `const { … } = require(…)`, que recebia os nomes (CK-03).
+function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, canUseTypeOnlyImport) {
+    const convertTypeOnlyToRegular = !canUseTypeOnlyImport && clause.isTypeOnly;
+    if (defaultImport) {
+        Debug.assert(!clause.name, "Cannot add a default import to an import clause that already has one");
+        changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), createIdentifier(defaultImport), { suffix: ", " });
+    }
+    if (namedImports.length) {
+        const specifiers = namedImports.map(name => createImportSpecifier(/*propertyName*/ undefined, createIdentifier(name)));
+        if (clause.namedBindings && cast(clause.namedBindings, isNamedImports).elements.length) {
+            for (const spec of specifiers) {
+                changes.insertNodeInListAfter(sourceFile, last(cast(clause.namedBindings, isNamedImports).elements), spec);
+            }
+        }
+        else {
+            if (specifiers.length) {
+                const namedImports = createNamedImports(specifiers);
+                if (clause.namedBindings) {
+                    changes.replaceNode(sourceFile, clause.namedBindings, namedImports);
+                }
+                else {
+                    changes.insertNodeAfter(sourceFile, Debug.checkDefined(clause.name, "Import clause must have either named imports or a default import"), namedImports);
+                }
+            }
+        }
+    }
+    if (convertTypeOnlyToRegular) {
+        changes.delete(sourceFile, getTypeKeywordOfTypeOnlyImport(clause, sourceFile));
+    }
+}
+function addNamespaceQualifier(changes, sourceFile, { namespacePrefix, position }) {
+    changes.insertText(sourceFile, position, namespacePrefix + ".");
+}
+// Na tag, também o `import * as ns` e o `import x = require(…)` (CK-03).
+function getNewImports(moduleSpecifier, quotePreference, imports) {
+    let statements;
+    if (imports.defaultImport !== undefined || imports.namedImports?.length) {
+        statements = combine(statements, makeImport(imports.defaultImport === undefined ? undefined : createIdentifier(imports.defaultImport), imports.namedImports?.map(n => createImportSpecifier(/*propertyName*/ undefined, createIdentifier(n))), moduleSpecifier, quotePreference));
+    }
+    return Debug.checkDefined(statements);
+}
+// Na tag, também o `getNewRequires` e o `createConstEqualsRequireDeclaration`, que escreviam o `const x = require(…)`
+// de um arquivo JavaScript (CK-03).
+function symbolHasMeaning({ declarations }, meaning) {
+    return some(declarations, decl => !!(getMeaningFromDeclaration(decl) & meaning));
+}
+// Na tag, também se o filtro dos módulos pelo `package.json` valia; o filtro, o arquivo de dentro de um `node_modules`
+// que um import não alcançava, o symlink e o registro do que o filtro tirava eram do host (CK-46, CK-47). O nome de um
+// arquivo é uma chave virtual, e todo módulo do programa se importa.
+export function forEachExternalModuleToImportFrom(program, _host, from, cb) {
+    forEachExternalModule(program.getTypeChecker(), program.getSourceFiles(), (module, sourceFile) => {
+        if (sourceFile !== from) {
+            cb(module);
+        }
+    });
+}
+// Na tag, também os módulos ambientes, de um `declare module "x"` (CK-02, princípio 4).
+function forEachExternalModule(checker, allSourceFiles, cb) {
+    for (const sourceFile of allSourceFiles) {
+        if (isExternalOrCommonJsModule(sourceFile)) {
+            cb(checker.getMergedSymbol(sourceFile.symbol), sourceFile);
+        }
+    }
+}
+// Na tag, aqui vinham o `isImportableFile` e o `isImportablePath`, do `node_modules` e do symlink, e o
+// `createAutoImportFilter`, do `package.json` (CK-46, CK-47). O `moduleSymbolToValidIdentifier` e o
+// `moduleSpecifierToValidIdentifier` desceram para o `utilities.ts` da leitura, que os usa sem a edição (CK-67).
+// O auto-import do completion: a leitura o alcança por este registro, que a edição faz ao carregar (CK-67). O completion
+// passa as opções de formatação cruas, e o contexto de formatação se monta aqui, como a casca da tag o montava.
+Completions.registerAutoImportProvider({
+    forEachExternalModuleToImportFrom,
+    getImportCompletionAction: (exportedSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatOptions, position, preferences) => getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, symbolName, host, program, (formatOptions && formatting.getFormatContext(formatOptions, host)), position, preferences),
+});

package/dist/codefixes/inferFromUsage.d.ts

@@ -0,0 +1 @@
+export {};