@tslite/services 0.0.0-stage → 1.13.0

package/dist/refactors/extractType.d.ts

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

package/dist/refactors/extractType.js

@@ -0,0 +1,102 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/extractType.ts: o namespace virou módulo ES, com os imports explícitos.
+// Fica a extração para um alias de tipo. Saem a extração para um typedef do JSDoc, com o arquivo JavaScript que a
+// oferecia (CK-03), e a extração para uma `interface`, com o achatamento dos membros que só ela usava: a Linguagem não tem
+// `interface` (CK-02), e o alias diz o mesmo (CK-69).
+import { Debug, Diagnostics, SymbolFlags, cast, createTextRangeFromSpan, createTypeAliasDeclaration, createTypeReferenceNode, emptyArray, findAncestor, first, forEachChild, getLocaleSpecificMessage, getRefactorContextSpan, getRenameLocation, getTokenAtPosition, getUniqueName, ignoreSourceNewlines, isConditionalTypeNode, isFunctionLike, isIdentifier, isInferTypeNode, isStatement, isTypeNode, isTypeParameterDeclaration, isTypePredicateNode, isTypeQueryNode, isTypeReferenceNode, rangeContainsStartEnd, skipTrivia, textChanges, updateTypeParameterDeclaration, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Extract type";
+const extractToTypeAlias = "Extract to type alias";
+registerRefactor(refactorName, {
+    getAvailableActions(context) {
+        const info = getRangeToExtract(context);
+        if (!info)
+            return emptyArray;
+        return [{
+                name: refactorName,
+                description: getLocaleSpecificMessage(Diagnostics.Extract_type),
+                actions: [{
+                        name: extractToTypeAlias, description: getLocaleSpecificMessage(Diagnostics.Extract_to_type_alias)
+                    }]
+            }];
+    },
+    getEditsForAction(context, actionName) {
+        const { file } = context;
+        const info = Debug.checkDefined(getRangeToExtract(context), "Expected to find a range to extract");
+        const name = getUniqueName("NewType", file);
+        const edits = textChanges.ChangeTracker.with(context, changes => {
+            switch (actionName) {
+                case extractToTypeAlias:
+                    return doTypeAliasChange(changes, file, name, info);
+                default:
+                    Debug.fail("Unexpected action name");
+            }
+        });
+        const renameFilename = file.fileName;
+        const renameLocation = getRenameLocation(edits, renameFilename, name, /*preferLastLocation*/ false);
+        return { edits, renameFilename, renameLocation };
+    }
+});
+function getRangeToExtract(context) {
+    const { file, startPosition } = context;
+    const current = getTokenAtPosition(file, startPosition);
+    const range = createTextRangeFromSpan(getRefactorContextSpan(context));
+    const selection = findAncestor(current, (node => node.parent && rangeContainsSkipTrivia(range, node, file) && !rangeContainsSkipTrivia(range, node.parent, file)));
+    if (!selection || !isTypeNode(selection))
+        return undefined;
+    const checker = context.program.getTypeChecker();
+    const firstStatement = Debug.checkDefined(findAncestor(selection, isStatement), "Should find a statement");
+    const typeParameters = collectTypeParameters(checker, selection, firstStatement, file);
+    if (!typeParameters)
+        return undefined;
+    return { selection, firstStatement, typeParameters };
+}
+function rangeContainsSkipTrivia(r1, node, file) {
+    return rangeContainsStartEnd(r1, skipTrivia(file.text, node.pos), node.end);
+}
+function collectTypeParameters(checker, selection, statement, file) {
+    const result = [];
+    return visitor(selection) ? undefined : result;
+    function visitor(node) {
+        if (isTypeReferenceNode(node)) {
+            if (isIdentifier(node.typeName)) {
+                const symbol = checker.resolveName(node.typeName.text, node.typeName, SymbolFlags.TypeParameter, /* excludeGlobals */ true);
+                if (symbol) {
+                    const declaration = cast(first(symbol.declarations), isTypeParameterDeclaration);
+                    if (rangeContainsSkipTrivia(statement, declaration, file) && !rangeContainsSkipTrivia(selection, declaration, file)) {
+                        result.push(declaration);
+                    }
+                }
+            }
+        }
+        else if (isInferTypeNode(node)) {
+            const conditionalTypeNode = findAncestor(node, n => isConditionalTypeNode(n) && rangeContainsSkipTrivia(n.extendsType, node, file));
+            if (!conditionalTypeNode || !rangeContainsSkipTrivia(selection, conditionalTypeNode, file)) {
+                return true;
+            }
+        }
+        // Na tag, também o tipo `this`, que dependia da função em volta como o predicado de tipo (CK-02).
+        else if (isTypePredicateNode(node)) {
+            const functionLikeNode = findAncestor(node.parent, isFunctionLike);
+            if (functionLikeNode && functionLikeNode.type && rangeContainsSkipTrivia(functionLikeNode.type, node, file) && !rangeContainsSkipTrivia(selection, functionLikeNode, file)) {
+                return true;
+            }
+        }
+        // Na tag, também o `typeof this.x`, que dependia da classe em volta (CK-02).
+        else if (isTypeQueryNode(node)) {
+            if (isIdentifier(node.exprName)) {
+                const symbol = checker.resolveName(node.exprName.text, node.exprName, SymbolFlags.Value, /* excludeGlobals */ false);
+                if (symbol && rangeContainsSkipTrivia(statement, symbol.valueDeclaration, file) && !rangeContainsSkipTrivia(selection, symbol.valueDeclaration, file)) {
+                    return true;
+                }
+            }
+        }
+        return forEachChild(node, visitor);
+    }
+}
+function doTypeAliasChange(changes, file, name, info) {
+    const { firstStatement, selection, typeParameters } = info;
+    const newTypeNode = createTypeAliasDeclaration(
+    /* modifiers */ undefined, name, typeParameters.map(id => updateTypeParameterDeclaration(id, id.name, id.constraint, /* defaultType */ undefined)), selection);
+    changes.insertNodeBefore(file, firstStatement, ignoreSourceNewlines(newTypeNode), /* blankLineBetween */ true);
+    changes.replaceNode(file, selection, createTypeReferenceNode(name, typeParameters.map(id => createTypeReferenceNode(id.name, /* typeArguments */ undefined))));
+}

package/dist/refactors/moveToNewFile.d.ts

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

package/dist/refactors/moveToNewFile.js

@@ -0,0 +1,477 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/moveToNewFile.ts: o namespace virou módulo ES, com os imports explícitos.
+// Saem o CommonJS inteiro — o `require`, o `exports.x = …` e o `import =` — e com ele a escolha entre as duas sintaxes de
+// módulo: um arquivo-módulo usa a do ES (CK-03). Saem também a `function`, a classe, o enum e a interface de topo, e o
+// modificador `default` de uma declaração (CK-02, CK-46); o import da fábrica do JSX, que é do emit (CK-19); e a inclusão
+// do arquivo novo no `files` do `tsconfig` (CK-47, CK-06).
+import { Debug, Diagnostics, FindAllReferences, ModifierFlags, ScriptTarget, SymbolFlags, SyntaxKind, append, cast, combinePaths, concatenate, contains, copyEntries, createIdentifier, createImportClause, createImportDeclaration, createImportSpecifier, createLiteral, createMap, createModifier, createNamedImports, createNamespaceImport, createTextRangeFromSpan, emptyArray, ensurePathIsNonModuleName, extensionFromPath, findIndex, firstDefined, flatMap, forEachEntry, getBaseFileName, getDirectoryPath, getLocaleSpecificMessage, getPropertySymbolFromBindingElement, getQuotePreference, getRangesWhere, getRefactorContextSpan, getSymbolId, getUniqueName, hasModifier, insertImports, isBindingElement, isDeclarationName, isIdentifier, isImportDeclaration, isNamedDeclaration, isOmittedExpression, isPropertyAccessExpression, isSourceFile, isStringLiteral, isVariableDeclaration, isVariableStatement, makeImportIfNecessary, moduleSpecifierToValidIdentifier, nodeSeenTracker, rangeContainsRange, removeFileExtension, skipAlias, symbolNameNoDefault, textChanges, tryCast, updateImportClause, updateModuleDeclaration, updateTypeAliasDeclaration, updateVariableStatement, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Move to a new file";
+registerRefactor(refactorName, {
+    getAvailableActions(context) {
+        if (!context.preferences.allowTextChangesInNewFiles || getStatementsToMove(context) === undefined)
+            return emptyArray;
+        const description = getLocaleSpecificMessage(Diagnostics.Move_to_a_new_file);
+        return [{ name: refactorName, description, actions: [{ name: refactorName, description }] }];
+    },
+    getEditsForAction(context, actionName) {
+        Debug.assert(actionName === refactorName, "Wrong refactor invoked");
+        const statements = Debug.checkDefined(getStatementsToMove(context));
+        const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program, statements, t, context.host, context.preferences));
+        return { edits, renameFilename: undefined, renameLocation: undefined };
+    }
+});
+function getRangeToMove(context) {
+    const { file } = context;
+    const range = createTextRangeFromSpan(getRefactorContextSpan(context));
+    const { statements } = file;
+    const startNodeIndex = findIndex(statements, s => s.end > range.pos);
+    if (startNodeIndex === -1)
+        return undefined;
+    const startStatement = statements[startNodeIndex];
+    if (isNamedDeclaration(startStatement) && startStatement.name && rangeContainsRange(startStatement.name, range)) {
+        return { toMove: [statements[startNodeIndex]], afterLast: statements[startNodeIndex + 1] };
+    }
+    // Can't only partially include the start node or be partially into the next node
+    if (range.pos > startStatement.getStart(file))
+        return undefined;
+    const afterEndNodeIndex = findIndex(statements, s => s.end > range.end, startNodeIndex);
+    // Can't be partially into the next node
+    if (afterEndNodeIndex !== -1 && (afterEndNodeIndex === 0 || statements[afterEndNodeIndex].getStart(file) < range.end))
+        return undefined;
+    return {
+        toMove: statements.slice(startNodeIndex, afterEndNodeIndex === -1 ? statements.length : afterEndNodeIndex),
+        afterLast: afterEndNodeIndex === -1 ? undefined : statements[afterEndNodeIndex],
+    };
+}
+function doChange(oldFile, program, toMove, changes, host, preferences) {
+    const checker = program.getTypeChecker();
+    const usage = getUsageInfo(oldFile, toMove.all, checker);
+    const currentDirectory = getDirectoryPath(oldFile.fileName);
+    const extension = extensionFromPath(oldFile.fileName);
+    const newModuleName = makeUniqueModuleName(getNewModuleName(usage.movedSymbols), extension, currentDirectory, host);
+    const newFileNameWithExtension = newModuleName + extension;
+    // If previous file was global, this is easy.
+    changes.createNewFile(oldFile, combinePaths(currentDirectory, newFileNameWithExtension), getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences));
+    // Na tag, o arquivo novo entrava também no `files` do `tsconfig` do programa (CK-47, CK-06).
+}
+// Filters imports out of the range of statements to move. Imports will be copied to the new file anyway, and may still be needed in the old file.
+function getStatementsToMove(context) {
+    const rangeToMove = getRangeToMove(context);
+    if (rangeToMove === undefined)
+        return undefined;
+    const all = [];
+    const ranges = [];
+    const { toMove, afterLast } = rangeToMove;
+    getRangesWhere(toMove, s => !isPureImport(s), (start, afterEndIndex) => {
+        for (let i = start; i < afterEndIndex; i++)
+            all.push(toMove[i]);
+        ranges.push({ first: toMove[start], afterLast });
+    });
+    return all.length === 0 ? undefined : { all, ranges };
+}
+// Na tag, também o `import =` sem `export` e o `const x = require(…)` (CK-03).
+function isPureImport(node) {
+    switch (node.kind) {
+        case SyntaxKind.ImportDeclaration:
+            return true;
+        default:
+            return false;
+    }
+}
+function getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences) {
+    const checker = program.getTypeChecker();
+    if (!oldFile.externalModuleIndicator) {
+        deleteMovedStatements(oldFile, toMove.ranges, changes);
+        return toMove.all;
+    }
+    const quotePreference = getQuotePreference(oldFile, preferences);
+    const importsFromNewFile = createOldFileImportsFromNewFile(usage.oldFileImportsFromNewFile, newModuleName, quotePreference);
+    if (importsFromNewFile) {
+        insertImports(changes, oldFile, importsFromNewFile, /*blankLineBetween*/ true);
+    }
+    deleteUnusedOldImports(oldFile, toMove.all, changes, usage.unusedImportsFromOldFile, checker);
+    deleteMovedStatements(oldFile, toMove.ranges, changes);
+    updateImportsInOtherFiles(changes, program, oldFile, usage.movedSymbols, newModuleName);
+    return [
+        ...getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, quotePreference),
+        ...addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile),
+    ];
+}
+function deleteMovedStatements(sourceFile, moved, changes) {
+    for (const { first, afterLast } of moved) {
+        changes.deleteNodeRangeExcludingEnd(sourceFile, first, afterLast);
+    }
+}
+function deleteUnusedOldImports(oldFile, toMove, changes, toDelete, checker) {
+    for (const statement of oldFile.statements) {
+        if (contains(toMove, statement))
+            continue;
+        forEachImportInStatement(statement, i => deleteUnusedImports(oldFile, i, changes, name => toDelete.has(checker.getSymbolAtLocation(name))));
+    }
+}
+function updateImportsInOtherFiles(changes, program, oldFile, movedSymbols, newModuleName) {
+    const checker = program.getTypeChecker();
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile === oldFile)
+            continue;
+        for (const statement of sourceFile.statements) {
+            forEachImportInStatement(statement, importNode => {
+                if (checker.getSymbolAtLocation(moduleSpecifierFromImport(importNode)) !== oldFile.symbol)
+                    return;
+                const shouldMove = (name) => {
+                    const symbol = isBindingElement(name.parent)
+                        ? getPropertySymbolFromBindingElement(checker, name.parent)
+                        : skipAlias(checker.getSymbolAtLocation(name), checker);
+                    return !!symbol && movedSymbols.has(symbol);
+                };
+                deleteUnusedImports(sourceFile, importNode, changes, shouldMove); // These will be changed to imports from the new file
+                const newModuleSpecifier = combinePaths(getDirectoryPath(moduleSpecifierFromImport(importNode).text), newModuleName);
+                const newImportDeclaration = filterImport(importNode, createLiteral(newModuleSpecifier), shouldMove);
+                if (newImportDeclaration)
+                    changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);
+                const ns = getNamespaceLikeImport(importNode);
+                if (ns)
+                    updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, ns, importNode);
+            });
+        }
+    }
+}
+function getNamespaceLikeImport(node) {
+    switch (node.kind) {
+        case SyntaxKind.ImportDeclaration:
+            return node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport ?
+                node.importClause.namedBindings.name : undefined;
+        default:
+            return Debug.assertNever(node.kind, `Unexpected node kind ${node.kind}`);
+    }
+}
+function updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, oldImportId, oldImportNode) {
+    const preferredNewNamespaceName = moduleSpecifierToValidIdentifier(newModuleName, ScriptTarget.ESNext);
+    let needUniqueName = false;
+    const toChange = [];
+    FindAllReferences.Core.eachSymbolReferenceInFile(oldImportId, checker, sourceFile, ref => {
+        if (!isPropertyAccessExpression(ref.parent))
+            return;
+        needUniqueName = needUniqueName || !!checker.resolveName(preferredNewNamespaceName, ref, SymbolFlags.All, /*excludeGlobals*/ true);
+        if (movedSymbols.has(checker.getSymbolAtLocation(ref.parent.name))) {
+            toChange.push(ref);
+        }
+    });
+    if (toChange.length) {
+        const newNamespaceName = needUniqueName ? getUniqueName(preferredNewNamespaceName, sourceFile) : preferredNewNamespaceName;
+        for (const ref of toChange) {
+            changes.replaceNode(sourceFile, ref, createIdentifier(newNamespaceName));
+        }
+        changes.insertNodeAfter(sourceFile, oldImportNode, updateNamespaceLikeImportNode(oldImportNode, newModuleName, newModuleSpecifier));
+    }
+}
+function updateNamespaceLikeImportNode(node, newNamespaceName, newModuleSpecifier) {
+    const newNamespaceId = createIdentifier(newNamespaceName);
+    const newModuleString = createLiteral(newModuleSpecifier);
+    switch (node.kind) {
+        case SyntaxKind.ImportDeclaration:
+            return createImportDeclaration(
+            /*modifiers*/ undefined, createImportClause(/*name*/ undefined, createNamespaceImport(newNamespaceId)), newModuleString);
+        default:
+            return Debug.assertNever(node.kind, `Unexpected node kind ${node.kind}`);
+    }
+}
+function moduleSpecifierFromImport(i) {
+    return i.moduleSpecifier;
+}
+function forEachImportInStatement(statement, cb) {
+    if (isImportDeclaration(statement)) {
+        if (isStringLiteral(statement.moduleSpecifier))
+            cb(statement);
+    }
+}
+function createOldFileImportsFromNewFile(newFileNeedExport, newFileNameWithExtension, quotePreference) {
+    const imports = [];
+    // Na tag, o símbolo `default` movido vinha como import default; só a `function` e a classe o declaravam (CK-02).
+    newFileNeedExport.forEach(symbol => {
+        imports.push(symbol.name);
+    });
+    return makeImportOrRequire(/*defaultImport*/ undefined, imports, newFileNameWithExtension, quotePreference);
+}
+function makeImportOrRequire(defaultImport, imports, path, quotePreference) {
+    path = ensurePathIsNonModuleName(path);
+    const specifiers = imports.map(i => createImportSpecifier(/*propertyName*/ undefined, createIdentifier(i)));
+    return makeImportIfNecessary(defaultImport, specifiers, path, quotePreference);
+}
+function addExports(sourceFile, toMove, needExport) {
+    return flatMap(toMove, statement => {
+        if (isTopLevelDeclarationStatement(statement) &&
+            !isExported(sourceFile, statement) &&
+            forEachTopLevelDeclaration(statement, d => needExport.has(Debug.checkDefined(d.symbol)))) {
+            const exports = addExport(statement);
+            if (exports)
+                return exports;
+        }
+        return statement;
+    });
+}
+function deleteUnusedImports(sourceFile, importDecl, changes, isUnused) {
+    switch (importDecl.kind) {
+        case SyntaxKind.ImportDeclaration:
+            deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused);
+            break;
+        default:
+            Debug.assertNever(importDecl.kind, `Unexpected import decl kind ${importDecl.kind}`);
+    }
+}
+function deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused) {
+    if (!importDecl.importClause)
+        return;
+    const { name, namedBindings } = importDecl.importClause;
+    const defaultUnused = !name || isUnused(name);
+    const namedBindingsUnused = !namedBindings ||
+        (namedBindings.kind === SyntaxKind.NamespaceImport ? isUnused(namedBindings.name) : namedBindings.elements.length !== 0 && namedBindings.elements.every(e => isUnused(e.name)));
+    if (defaultUnused && namedBindingsUnused) {
+        changes.delete(sourceFile, importDecl);
+    }
+    else {
+        if (name && defaultUnused) {
+            changes.delete(sourceFile, name);
+        }
+        if (namedBindings) {
+            if (namedBindingsUnused) {
+                changes.replaceNode(sourceFile, importDecl.importClause, updateImportClause(importDecl.importClause, name, /*namedBindings*/ undefined, importDecl.importClause.isTypeOnly));
+            }
+            else if (namedBindings.kind === SyntaxKind.NamedImports) {
+                for (const element of namedBindings.elements) {
+                    if (isUnused(element.name))
+                        changes.delete(sourceFile, element);
+                }
+            }
+        }
+    }
+}
+function getNewFileImportsAndAddExportInOldFile(oldFile, importsToCopy, newFileImportsFromOldFile, changes, checker, quotePreference) {
+    const copiedOldImports = [];
+    for (const oldStatement of oldFile.statements) {
+        forEachImportInStatement(oldStatement, i => {
+            append(copiedOldImports, filterImport(i, moduleSpecifierFromImport(i), name => importsToCopy.has(checker.getSymbolAtLocation(name))));
+        });
+    }
+    // Also, import things used from the old file, and insert 'export' modifiers as necessary in the old file.
+    const oldFileNamedImports = [];
+    const markSeenTop = nodeSeenTracker(); // Needed because multiple declarations may appear in `const x = 0, y = 1;`.
+    newFileImportsFromOldFile.forEach(symbol => {
+        for (const decl of symbol.declarations) {
+            if (!isTopLevelDeclaration(decl))
+                continue;
+            const name = nameOfTopLevelDeclaration(decl);
+            if (!name)
+                continue;
+            const top = getTopLevelDeclarationStatement(decl);
+            if (markSeenTop(top)) {
+                addExportToChanges(oldFile, top, changes);
+            }
+            // Na tag, a declaração com o modificador `default` vinha como import default (CK-02).
+            oldFileNamedImports.push(name.text);
+        }
+    });
+    append(copiedOldImports, makeImportOrRequire(/*defaultImport*/ undefined, oldFileNamedImports, removeFileExtension(getBaseFileName(oldFile.fileName)), quotePreference));
+    return copiedOldImports;
+}
+// Na tag, o nome se conferia pelo `fileExists` do host, que lia o disco; o host da Linguagem dá um mundo fechado, e um
+// arquivo existe quando está entre os arquivos dele (CK-47).
+function makeUniqueModuleName(moduleName, extension, inDirectory, host) {
+    let newModuleName = moduleName;
+    for (let i = 1;; i++) {
+        const name = combinePaths(inDirectory, newModuleName + extension);
+        if (!contains(host.getScriptFileNames(), name))
+            return newModuleName;
+        newModuleName = `${moduleName}.${i}`;
+    }
+}
+function getNewModuleName(movedSymbols) {
+    return movedSymbols.forEachEntry(symbolNameNoDefault) || "newFile";
+}
+function getUsageInfo(oldFile, toMove, checker) {
+    const movedSymbols = new SymbolSet();
+    const oldImportsNeededByNewFile = new SymbolSet();
+    const newFileImportsFromOldFile = new SymbolSet();
+    // Na tag, o import da fábrica do JSX ia junto com o JSX movido (CK-19).
+    for (const statement of toMove) {
+        forEachTopLevelDeclaration(statement, decl => {
+            movedSymbols.add(Debug.checkDefined(decl.symbol, "Need a symbol here"));
+        });
+    }
+    for (const statement of toMove) {
+        forEachReference(statement, checker, symbol => {
+            if (!symbol.declarations)
+                return;
+            for (const decl of symbol.declarations) {
+                if (isInImport(decl)) {
+                    oldImportsNeededByNewFile.add(symbol);
+                }
+                else if (isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile && !movedSymbols.has(symbol)) {
+                    newFileImportsFromOldFile.add(symbol);
+                }
+            }
+        });
+    }
+    const unusedImportsFromOldFile = oldImportsNeededByNewFile.clone();
+    const oldFileImportsFromNewFile = new SymbolSet();
+    for (const statement of oldFile.statements) {
+        if (contains(toMove, statement))
+            continue;
+        forEachReference(statement, checker, symbol => {
+            if (movedSymbols.has(symbol))
+                oldFileImportsFromNewFile.add(symbol);
+            unusedImportsFromOldFile.delete(symbol);
+        });
+    }
+    return { movedSymbols, newFileImportsFromOldFile, oldFileImportsFromNewFile, oldImportsNeededByNewFile, unusedImportsFromOldFile };
+}
+// Below should all be utilities
+// Na tag, também o `import =` e o `const x = require(…)` de topo (CK-03).
+function isInImport(decl) {
+    switch (decl.kind) {
+        case SyntaxKind.ImportSpecifier:
+        case SyntaxKind.ImportClause:
+        case SyntaxKind.NamespaceImport:
+            return true;
+        default:
+            return false;
+    }
+}
+function filterImport(i, moduleSpecifier, keep) {
+    switch (i.kind) {
+        case SyntaxKind.ImportDeclaration: {
+            const clause = i.importClause;
+            if (!clause)
+                return undefined;
+            const defaultImport = clause.name && keep(clause.name) ? clause.name : undefined;
+            const namedBindings = clause.namedBindings && filterNamedBindings(clause.namedBindings, keep);
+            return defaultImport || namedBindings
+                ? createImportDeclaration(/*modifiers*/ undefined, createImportClause(defaultImport, namedBindings), moduleSpecifier)
+                : undefined;
+        }
+        default:
+            return Debug.assertNever(i.kind, `Unexpected import kind ${i.kind}`);
+    }
+}
+function filterNamedBindings(namedBindings, keep) {
+    if (namedBindings.kind === SyntaxKind.NamespaceImport) {
+        return keep(namedBindings.name) ? namedBindings : undefined;
+    }
+    else {
+        const newElements = namedBindings.elements.filter(e => keep(e.name));
+        return newElements.length ? createNamedImports(newElements) : undefined;
+    }
+}
+function forEachReference(node, checker, onReference) {
+    node.forEachChild(function cb(node) {
+        if (isIdentifier(node) && !isDeclarationName(node)) {
+            const sym = checker.getSymbolAtLocation(node);
+            if (sym)
+                onReference(sym);
+        }
+        else {
+            node.forEachChild(cb);
+        }
+    });
+}
+class SymbolSet {
+    constructor() {
+        this.map = createMap();
+    }
+    add(symbol) {
+        this.map.set(String(getSymbolId(symbol)), symbol);
+    }
+    has(symbol) {
+        return this.map.has(String(getSymbolId(symbol)));
+    }
+    delete(symbol) {
+        this.map.delete(String(getSymbolId(symbol)));
+    }
+    forEach(cb) {
+        this.map.forEach(cb);
+    }
+    forEachEntry(cb) {
+        return forEachEntry(this.map, cb);
+    }
+    clone() {
+        const clone = new SymbolSet();
+        copyEntries(this.map, clone.map);
+        return clone;
+    }
+}
+function isTopLevelDeclaration(node) {
+    return isNonVariableTopLevelDeclaration(node) && isSourceFile(node.parent) || isVariableDeclaration(node) && isSourceFile(node.parent.parent.parent);
+}
+function sourceFileOfTopLevelDeclaration(node) {
+    return isVariableDeclaration(node) ? node.parent.parent.parent : node.parent;
+}
+function isTopLevelDeclarationStatement(node) {
+    Debug.assert(isSourceFile(node.parent), "Node parent should be a SourceFile");
+    return isNonVariableTopLevelDeclaration(node) || isVariableStatement(node);
+}
+function isNonVariableTopLevelDeclaration(node) {
+    switch (node.kind) {
+        case SyntaxKind.ModuleDeclaration:
+        case SyntaxKind.TypeAliasDeclaration:
+            return true;
+        default:
+            return false;
+    }
+}
+function forEachTopLevelDeclaration(statement, cb) {
+    switch (statement.kind) {
+        case SyntaxKind.ModuleDeclaration:
+        case SyntaxKind.TypeAliasDeclaration:
+            return cb(statement);
+        case SyntaxKind.VariableStatement:
+            return firstDefined(statement.declarationList.declarations, decl => forEachTopLevelDeclarationInBindingName(decl.name, cb));
+    }
+}
+function forEachTopLevelDeclarationInBindingName(name, cb) {
+    switch (name.kind) {
+        case SyntaxKind.Identifier:
+            return cb(cast(name.parent, (x) => isVariableDeclaration(x) || isBindingElement(x)));
+        case SyntaxKind.ArrayBindingPattern:
+        case SyntaxKind.ObjectBindingPattern:
+            return firstDefined(name.elements, em => isOmittedExpression(em) ? undefined : forEachTopLevelDeclarationInBindingName(em.name, cb));
+        default:
+            return Debug.assertNever(name, `Unexpected name kind ${name.kind}`);
+    }
+}
+function nameOfTopLevelDeclaration(d) {
+    return tryCast(d.name, isIdentifier);
+}
+function getTopLevelDeclarationStatement(d) {
+    switch (d.kind) {
+        case SyntaxKind.VariableDeclaration:
+            return d.parent.parent;
+        case SyntaxKind.BindingElement:
+            return getTopLevelDeclarationStatement(cast(d.parent.parent, (p) => isVariableDeclaration(p) || isBindingElement(p)));
+        default:
+            return d;
+    }
+}
+function addExportToChanges(sourceFile, decl, changes) {
+    if (isExported(sourceFile, decl))
+        return;
+    changes.insertExportModifier(sourceFile, decl);
+}
+function isExported(_sourceFile, decl) {
+    return hasModifier(decl, ModifierFlags.Export);
+}
+function addExport(decl) {
+    return [addEs6Export(decl)];
+}
+function addEs6Export(d) {
+    const modifiers = concatenate([createModifier(SyntaxKind.ExportKeyword)], d.modifiers);
+    switch (d.kind) {
+        case SyntaxKind.VariableStatement:
+            return updateVariableStatement(d, modifiers, d.declarationList);
+        case SyntaxKind.ModuleDeclaration:
+            return updateModuleDeclaration(d, modifiers, d.name, d.body);
+        case SyntaxKind.TypeAliasDeclaration:
+            return updateTypeAliasDeclaration(d, modifiers, d.name, d.typeParameters, d.type);
+        default:
+            return Debug.assertNever(d, `Unexpected declaration kind ${d.kind}`);
+    }
+}

package/dist/rename.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RenameInfo, RenameInfoOptions, SourceFile } from "./_namespaces/ts.js";
+export declare function getRenameInfo(program: CheckResult, sourceFile: SourceFile, position: number, options?: RenameInfoOptions): RenameInfo;