@zzzen/pyright-internal 1.2.0-dev.20230205 → 1.2.0-dev.20230219

package/dist/languageService/renameModuleProvider.js

@@ -20,7 +20,6 @@ const sourceMapper_1 = require("../analyzer/sourceMapper");
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const pathUtils_1 = require("../common/pathUtils");
-const positionUtils_1 = require("../common/positionUtils");
 const textEditUtils_1 = require("../common/textEditUtils");
 const textRange_1 = require("../common/textRange");
 const parseNodes_1 = require("../parser/parseNodes");
@@ -32,14 +31,14 @@ var UpdateType;
     UpdateType[UpdateType["Symbol"] = 2] = "Symbol";
 })(UpdateType || (UpdateType = {}));
 class RenameModuleProvider {
-    constructor(_fs, _evaluator, _moduleFilePath, newModuleFilePath, _moduleNameAndType, _newModuleNameAndType, _type, _declarations, _token) {
+    constructor(_fs, _evaluator, _moduleFilePath, newModuleFilePath, _moduleNameAndType, _newModuleNameAndType, _type, declarations, _token) {
         this._fs = _fs;
         this._evaluator = _evaluator;
         this._moduleFilePath = _moduleFilePath;
         this._moduleNameAndType = _moduleNameAndType;
         this._newModuleNameAndType = _newModuleNameAndType;
         this._type = _type;
-        this._declarations = _declarations;
+        this.declarations = declarations;
         this._token = _token;
         this._aliasIntroduced = new Set();
         this._textEditTracker = new textEditUtils_1.TextEditTracker();
@@ -47,17 +46,7 @@ class RenameModuleProvider {
         this._newModuleFilePath = (0, pathUtils_1.resolvePaths)(newModuleFilePath);
         this._moduleNames = this._moduleName.split('.');
         this._newModuleNames = this._newModuleName.split('.');
-        if (this._moduleNames.length !== this._newModuleNames.length) {
-            this._onlyNameChanged = false;
-            return;
-        }
-        let i = 0;
-        for (i = 0; i < this._moduleNames.length - 1; i++) {
-            if (this._moduleNames[i] !== this._newModuleNames[i]) {
-                break;
-            }
-        }
-        this._onlyNameChanged = i === this._moduleNames.length - 1;
+        this._onlyNameChanged = (0, importStatementUtils_1.haveSameParentModule)(this._moduleNames, this._newModuleNames);
         (0, debug_1.assert)(this._type !== UpdateType.Folder || this._onlyNameChanged, 'We only support simple rename for folder');
     }
     static createForModule(importResolver, configOptions, evaluator, path, newPath, token) {
@@ -154,21 +143,48 @@ class RenameModuleProvider {
         }
         return new RenameModuleProvider(importResolver.fileSystem, evaluator, moduleFilePath, newModuleFilePath, moduleName, newModuleName, type, declarations, token);
     }
-    renameReferences(filePath, parseResults) {
+    get lastModuleName() {
+        return this._moduleNames[this._moduleNames.length - 1];
+    }
+    get textEditTracker() {
+        return this._textEditTracker;
+    }
+    getEdits() {
+        return this._textEditTracker.getEdits(this._token);
+    }
+    renameReferences(parseResults) {
         switch (this._type) {
             case UpdateType.Folder:
-                return this._renameFolderReferences(filePath, parseResults);
+                return this._renameFolderReferences(parseResults);
             case UpdateType.File:
-                return this._renameModuleReferences(filePath, parseResults);
+                return this._renameModuleReferences(parseResults);
             case UpdateType.Symbol:
-                return this._updateSymbolReferences(filePath, parseResults);
+                return this._updateSymbolReferences(parseResults);
             default:
                 return (0, debug_1.assertNever)(this._type, `${this._type} is unknown`);
         }
     }
-    _updateSymbolReferences(filePath, parseResults) {
-        var _a, _b, _c;
-        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([(0, declarationUtils_1.getNameFromDeclaration)(this._declarations[0]) || ''], this._declarations, this._evaluator, this._token, parseResults.parseTree, 
+    tryGetFirstSymbolUsage(parseResults) {
+        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([(0, declarationUtils_1.getNameFromDeclaration)(this.declarations[0]) || ''], this.declarations, this._evaluator, this._token, parseResults.parseTree, 
+        /* treatModuleImportAndFromImportSame */ true, 
+        /* skipUnreachableCode */ false);
+        for (const result of collector.collect().sort((r1, r2) => r1.range.start - r2.range.start)) {
+            // We only care about symbol usages, not alias decl of the symbol.
+            if ((0, parseTreeUtils_1.isImportModuleName)(result.node) ||
+                (0, parseTreeUtils_1.isImportAlias)(result.node) ||
+                (0, parseTreeUtils_1.isFromImportModuleName)(result.node) ||
+                (0, parseTreeUtils_1.isFromImportName)(result.node) ||
+                (0, parseTreeUtils_1.isFromImportAlias)(result.node)) {
+                continue;
+            }
+            return result.range.start;
+        }
+        return undefined;
+    }
+    _updateSymbolReferences(parseResults) {
+        const filePath = (0, analyzerNodeInfo_1.getFileInfo)(parseResults.parseTree).filePath;
+        const isSource = filePath === this._moduleFilePath;
+        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([(0, declarationUtils_1.getNameFromDeclaration)(this.declarations[0]) || ''], this.declarations, this._evaluator, this._token, parseResults.parseTree, 
         /* treatModuleImportAndFromImportSame */ true, 
         /* skipUnreachableCode */ false);
         // See if we need to insert new import statement
@@ -176,76 +192,73 @@ class RenameModuleProvider {
         // See whether we have existing import statement for the same module
         // ex) import [moduleName] or from ... import [moduleName]
         const imported = importStatements.orderedImports.find((i) => i.moduleName === this._newModuleName);
-        const nameRemoved = new Set();
+        // Indicate whether current file has any usage of the symbol
+        let hasSymbolUsage = false;
+        const wildcardImports = new Map();
         const importUsed = new Map();
         for (const result of collector.collect()) {
             const nodeFound = result.node;
             if (nodeFound.nodeType === 49 /* String */) {
-                // Ignore symbol appearing in the __all__. it should be handled
-                // when decl is moved.
+                if (isSource) {
+                    // Delete the symbol reference in __all__ if the file is the source file.
+                    this._textEditTracker.addEditWithTextRange(parseResults, nodeFound, '');
+                }
                 continue;
             }
             if ((0, parseTreeUtils_1.isFromImportName)(nodeFound)) {
-                // ex) from ... import [symbol] ...
-                const fromNode = (_a = nodeFound.parent) === null || _a === void 0 ? void 0 : _a.parent;
-                const newModuleName = this._getNewModuleName(filePath, fromNode.module.leadingDots > 0, 
-                /* isLastPartImportName */ false);
-                if (fromNode.imports.length === 1) {
-                    // ex) "from [module] import symbol" to "from [module.changed] import symbol"
-                    this._addResultWithTextRange(filePath, fromNode.module, parseResults, newModuleName);
-                }
-                else {
-                    // ex) "from module import symbol, another_symbol" to
-                    //     "from module import another_symbol" and "from module.changed import symbol"
-                    // Delete the existing import name including alias.
-                    const importFromAs = nodeFound.parent;
-                    this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, fromNode.imports, importFromAs);
-                    // For now, this won't merge absolute and relative path "from import" statement.
-                    const importNameInfo = {
-                        name: importFromAs.name.value,
-                        alias: (_b = importFromAs.alias) === null || _b === void 0 ? void 0 : _b.value,
-                    };
-                    this._addResultEdits(this._getTextEditsForNewOrExistingFromImport(filePath, fromNode, parseResults, nameRemoved, importStatements, newModuleName, [importNameInfo]));
-                }
+                this._updateNameInFromImportForSymbolReferences(parseResults, importStatements, nodeFound);
                 continue;
             }
+            // Exclude symbol decl itself.
+            hasSymbolUsage = isSource
+                ? !this.declarations.some((d) => textRange_1.TextRange.containsRange(d.node, nodeFound))
+                : true;
             const dottedName = (0, parseTreeUtils_1.getDottedNameWithGivenNodeAsLastName)(nodeFound);
             if (dottedName === nodeFound || dottedName.nodeType !== 35 /* MemberAccess */) {
+                this._collectWildcardImports(nodeFound, wildcardImports);
                 // ex) from module import foo
                 //     foo
                 //     foo.method()
-                //
-                //     from module import *
-                //     foo()
-                //     bar()
-                //
-                //     we don't need to do anything for wild card case since
-                //     we will preserve __all__ entries.
-                continue;
-            }
-            const moduleName = dottedName.leftExpression.nodeType === 35 /* MemberAccess */
-                ? dottedName.leftExpression.memberName
-                : dottedName.leftExpression.nodeType === 38 /* Name */
-                    ? dottedName.leftExpression
-                    : undefined;
-            if (!moduleName) {
-                // ex) from module import foo
-                //     getModule().foo
-                continue;
-            }
-            const moduleDecl = (_c = this._evaluator
-                .getDeclarationsForNameNode(moduleName)) === null || _c === void 0 ? void 0 : _c.filter((d) => (0, declaration_1.isAliasDeclaration)(d) &&
-                (d.node.nodeType === 21 /* ImportAs */ || d.node.nodeType === 23 /* ImportFromAs */));
-            if (!moduleDecl || moduleDecl.length === 0) {
-                // ex) from xxx import yyy
-                //     yyy.property.foo
                 continue;
             }
-            const importAs = moduleDecl[0].node;
-            (0, collectionUtils_1.getOrAdd)(importUsed, importAs, () => []).push(dottedName);
-            continue;
+            this._collectSymbolReferencesPerImports(dottedName, importUsed);
+        }
+        if (isSource && hasSymbolUsage) {
+            // If the original file has references to the symbol moved, we need to either
+            // insert import statement or update existing one.
+            const newModuleName = (imported === null || imported === void 0 ? void 0 : imported.node.nodeType) === 22 /* ImportFrom */
+                ? this._getNewModuleName(filePath, imported.node.module.leadingDots > 0, 
+                /* isLastPartImportName */ false)
+                : undefined;
+            const options = (imported === null || imported === void 0 ? void 0 : imported.node.nodeType) === 22 /* ImportFrom */
+                ? {
+                    currentFromImport: imported.node,
+                    originalModuleName: this._moduleName,
+                }
+                : undefined;
+            this._textEditTracker.addOrUpdateImport(parseResults, importStatements, { name: this._newModuleName, nameForImportFrom: newModuleName }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), [{ name: (0, declarationUtils_1.getNameFromDeclaration)(this.declarations[0]) }], options);
         }
+        // Handle symbol references that are used off wildcard imports.
+        this._processSymbolReferenceOffWildcardImports(parseResults, importStatements, wildcardImports);
         // Handle symbol references that are used off imported modules.
+        this._processSymbolReferenceOffImports(parseResults, importStatements, imported, importUsed);
+    }
+    _processSymbolReferenceOffImports(parseResults, importStatements, imported, importUsed) {
+        const filePath = (0, analyzerNodeInfo_1.getFileInfo)(parseResults.parseTree).filePath;
+        const isDestination = filePath === this._newModuleFilePath;
+        if (isDestination) {
+            for (const [key, value] of importUsed) {
+                if (this._canReplaceImportName(parseResults, key, value)) {
+                    // We can remove existing import statement.
+                    this._textEditTracker.deleteImportName(parseResults, key);
+                }
+                for (const node of value) {
+                    this._textEditTracker.addEditWithTextRange(parseResults, textRange_1.TextRange.fromBounds(node.start, node.memberName.start), '');
+                }
+            }
+            return;
+        }
+        // Other files.
         for (const [key, value] of importUsed) {
             let referenceModuleName;
             if (this._canReplaceImportName(parseResults, key, value)) {
@@ -253,25 +266,25 @@ class RenameModuleProvider {
                 if (key.nodeType === 21 /* ImportAs */) {
                     if (moduleName) {
                         referenceModuleName = moduleName;
-                        this._addImportNameDeletion(filePath, parseResults, nameRemoved, key.parent.list, key);
+                        this._textEditTracker.deleteImportName(parseResults, key);
                     }
                     else {
                         referenceModuleName = key.alias ? key.alias.value : this._newModuleName;
-                        this._addResultWithTextRange(filePath, key.module, parseResults, this._newModuleName);
+                        this._textEditTracker.addEditWithTextRange(parseResults, key.module, this._newModuleName);
                     }
                 }
                 else {
                     if (moduleName) {
                         referenceModuleName = moduleName;
-                        this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, key.parent.imports, key);
+                        this._textEditTracker.deleteImportName(parseResults, key);
                     }
                     else {
                         const fromNode = key.parent;
                         const newModuleName = this._getNewModuleName(filePath, fromNode.module.leadingDots > 0, 
                         /* isLastPartImportName */ true);
                         referenceModuleName = key.alias ? key.alias.value : this._newLastModuleName;
-                        this._addResultWithTextRange(filePath, fromNode.module, parseResults, newModuleName);
-                        this._addResultWithTextRange(filePath, key.name, parseResults, this._newLastModuleName);
+                        this._textEditTracker.addEditWithTextRange(parseResults, fromNode.module, newModuleName);
+                        this._textEditTracker.addEditWithTextRange(parseResults, key.name, this._newLastModuleName);
                     }
                 }
             }
@@ -282,14 +295,108 @@ class RenameModuleProvider {
                 }
                 else {
                     referenceModuleName = this._newModuleName;
-                    this._addResultEdits((0, importStatementUtils_1.getTextEditsForAutoImportInsertion)([], { name: this._newModuleName }, importStatements, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), parseResults, (0, positionUtils_1.convertOffsetToPosition)(parseResults.parseTree.length, parseResults.tokenizerOutput.lines)).map((e) => ({ filePath, range: e.range, replacementText: e.replacementText })));
+                    this._textEditTracker.addOrUpdateImport(parseResults, importStatements, { name: this._newModuleName }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType));
                 }
             }
             for (const node of value) {
-                this._addResultWithTextRange(filePath, node.leftExpression, parseResults, referenceModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, node.leftExpression, referenceModuleName);
             }
         }
     }
+    _processSymbolReferenceOffWildcardImports(parseResults, importStatements, wildcardImports) {
+        const filePath = (0, analyzerNodeInfo_1.getFileInfo)(parseResults.parseTree).filePath;
+        const isDestination = filePath === this._newModuleFilePath;
+        if (isDestination) {
+            // Destination file contains the moved symbol decl. no need to insert
+            // import statement for the symbol moved.
+            return;
+        }
+        for (const [key, value] of wildcardImports) {
+            const fromNode = key;
+            const newModuleName = this._getNewModuleName(filePath, fromNode.module.leadingDots > 0, 
+            /* isLastPartImportName */ false);
+            this._textEditTracker.addOrUpdateImport(parseResults, importStatements, { name: this._newModuleName, nameForImportFrom: newModuleName }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), [...value].map((v) => ({ name: v })), {
+                currentFromImport: fromNode,
+                originalModuleName: this._moduleName,
+            });
+        }
+    }
+    _collectSymbolReferencesPerImports(dottedName, importUsed) {
+        var _a;
+        const moduleName = dottedName.leftExpression.nodeType === 35 /* MemberAccess */
+            ? dottedName.leftExpression.memberName
+            : dottedName.leftExpression.nodeType === 38 /* Name */
+                ? dottedName.leftExpression
+                : undefined;
+        if (!moduleName) {
+            // ex) from module import foo
+            //     getModule().foo
+            return;
+        }
+        const moduleDecl = (_a = this._evaluator
+            .getDeclarationsForNameNode(moduleName)) === null || _a === void 0 ? void 0 : _a.filter((d) => (0, declaration_1.isAliasDeclaration)(d) &&
+            (d.node.nodeType === 21 /* ImportAs */ || d.node.nodeType === 23 /* ImportFromAs */));
+        if (!moduleDecl || moduleDecl.length === 0) {
+            // ex) from xxx import yyy
+            //     yyy.property.foo
+            return;
+        }
+        const importAs = moduleDecl[0].node;
+        (0, collectionUtils_1.getOrAdd)(importUsed, importAs, () => []).push(dottedName);
+    }
+    _collectWildcardImports(nodeFound, wildcardImports) {
+        const nameDecls = this._evaluator.getDeclarationsForNameNode(nodeFound);
+        const aliasDeclFromWildCardImport = nameDecls === null || nameDecls === void 0 ? void 0 : nameDecls.find((d) => d.node.nodeType === 22 /* ImportFrom */ && d.node.isWildcardImport);
+        if (!aliasDeclFromWildCardImport || !(0, declaration_1.isAliasDeclaration)(aliasDeclFromWildCardImport)) {
+            return;
+        }
+        // ex) from module import *
+        //     foo()
+        //     bar()
+        (0, collectionUtils_1.getOrAdd)(wildcardImports, aliasDeclFromWildCardImport.node, () => new Set()).add(nodeFound.value);
+    }
+    _updateNameInFromImportForSymbolReferences(parseResults, importStatements, nodeFound) {
+        var _a;
+        const filePath = (0, analyzerNodeInfo_1.getFileInfo)(parseResults.parseTree).filePath;
+        const isDestination = filePath === this._newModuleFilePath;
+        // ex) from ... import [symbol] ...
+        const importFromAs = nodeFound.parent;
+        const fromNode = importFromAs === null || importFromAs === void 0 ? void 0 : importFromAs.parent;
+        const newModuleName = this._getNewModuleName(filePath, fromNode.module.leadingDots > 0, 
+        /* isLastPartImportName */ false);
+        const hasAlias = !!importFromAs.alias;
+        if (isDestination && !hasAlias) {
+            if (fromNode.imports.length === 1) {
+                // If we have import statement for the symbol in the destination file,
+                // we need to remove it.
+                this._textEditTracker.deleteImportName(parseResults, importFromAs);
+                return;
+            }
+            // ex) "from module import symbol, another_symbol" to
+            //     "from module import another_symbol" and "from module.changed import symbol"
+            // Delete the existing import name including alias.
+            this._textEditTracker.deleteImportName(parseResults, importFromAs);
+            return;
+        }
+        if (fromNode.imports.length === 1) {
+            // ex) "from [module] import symbol" to "from [module.changed] import symbol"
+            this._textEditTracker.addEditWithTextRange(parseResults, fromNode.module, newModuleName);
+            return;
+        }
+        // ex) "from module import symbol, another_symbol" to
+        //     "from module import another_symbol" and "from module.changed import symbol"
+        // Delete the existing import name including alias.
+        this._textEditTracker.deleteImportName(parseResults, importFromAs);
+        // For now, this won't merge absolute and relative path "from import" statement.
+        const importNameInfo = {
+            name: importFromAs.name.value,
+            alias: (_a = importFromAs.alias) === null || _a === void 0 ? void 0 : _a.value,
+        };
+        this._textEditTracker.addOrUpdateImport(parseResults, importStatements, { name: this._newModuleName, nameForImportFrom: newModuleName }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), [importNameInfo], {
+            currentFromImport: fromNode,
+            originalModuleName: this._moduleName,
+        });
+    }
     _getReferenceModuleName(importStatements, imported) {
         var _a, _b;
         if (imported && imported.node.nodeType === 20 /* Import */) {
@@ -323,34 +430,35 @@ class RenameModuleProvider {
                 // collector will report decls as well. ignore decls.
                 continue;
             }
+            // other symbols from the module are used in the file.
             if (!symbolReferences.some((s) => textRange_1.TextRange.containsRange(s, result.node))) {
                 return false;
             }
         }
         return true;
     }
-    _renameFolderReferences(filePath, parseResults) {
-        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([this.lastModuleName], this._declarations, this._evaluator, this._token, parseResults.parseTree, 
+    _renameFolderReferences(parseResults) {
+        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([this.lastModuleName], this.declarations, this._evaluator, this._token, parseResults.parseTree, 
         /* treatModuleImportAndFromImportSame */ true, 
         /* skipUnreachableCode */ false);
         // We only support simple rename of folder. Change all occurrence of the old folder name
         // to new name.
         for (const result of collector.collect()) {
-            this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+            this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
         }
     }
-    _renameModuleReferences(filePath, parseResults) {
-        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([this.lastModuleName], this._declarations, this._evaluator, this._token, parseResults.parseTree, 
+    _renameModuleReferences(parseResults) {
+        const collector = new documentSymbolCollector_1.DocumentSymbolCollector([this.lastModuleName], this.declarations, this._evaluator, this._token, parseResults.parseTree, 
         /* treatModuleImportAndFromImportSame */ true, 
         /* skipUnreachableCode */ false);
-        const nameRemoved = new Set();
         const results = collector.collect();
         // Update module references first.
-        this._updateModuleReferences(filePath, parseResults, nameRemoved, results);
+        this._updateModuleReferences(parseResults, results);
         // If the module file has moved, we need to update all relative paths used in the file to reflect the move.
-        this._updateRelativeModuleNamePath(filePath, parseResults, nameRemoved, results);
+        this._updateRelativeModuleNamePath(parseResults, results);
     }
-    _updateRelativeModuleNamePath(filePath, parseResults, nameRemoved, results) {
+    _updateRelativeModuleNamePath(parseResults, results) {
+        const filePath = (0, analyzerNodeInfo_1.getFileInfo)(parseResults.parseTree).filePath;
         if (filePath !== this._moduleFilePath) {
             // We only update relative import paths for the file that has moved.
             return;
@@ -358,7 +466,7 @@ class RenameModuleProvider {
         let importStatements;
         // Filter out module name that is already re-written.
         for (const edit of this._getNewRelativeModuleNamesForFileMoved(filePath, ModuleNameCollector.collect(parseResults.parseTree).filter((m) => !results.some((r) => textRange_1.TextRange.containsRange(m.parent, r.node))))) {
-            this._addResultWithTextRange(filePath, edit.moduleName, parseResults, edit.newModuleName);
+            this._textEditTracker.addEditWithTextRange(parseResults, edit.moduleName, edit.newModuleName);
             if (!edit.itemsToMove) {
                 continue;
             }
@@ -370,28 +478,35 @@ class RenameModuleProvider {
             const fromNode = edit.moduleName.parent;
             // First, delete existing exported symbols from "from import" statement.
             for (const importFromAs of edit.itemsToMove) {
-                this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, fromNode.imports, importFromAs);
+                this._textEditTracker.deleteImportName(parseResults, importFromAs);
             }
             importStatements =
                 importStatements !== null && importStatements !== void 0 ? importStatements : (0, importStatementUtils_1.getTopLevelImports)(parseResults.parseTree, /* includeImplicitImports */ false);
             // For now, this won't merge absolute and relative path "from import"
             // statement.
-            this._addResultEdits(this._getTextEditsForNewOrExistingFromImport(filePath, fromNode, parseResults, nameRemoved, importStatements, (0, importStatementUtils_1.getRelativeModuleName)(this._fs, this._newModuleFilePath, this._newModuleFilePath, 
-            /* ignoreFolderStructure */ false, 
-            /* sourceIsFile */ true), edit.itemsToMove.map((i) => {
+            this._textEditTracker.addOrUpdateImport(parseResults, importStatements, {
+                name: this._newModuleName,
+                nameForImportFrom: (0, importStatementUtils_1.getRelativeModuleName)(this._fs, this._newModuleFilePath, this._newModuleFilePath, 
+                /* ignoreFolderStructure */ false, 
+                /* sourceIsFile */ true),
+            }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), edit.itemsToMove.map((i) => {
                 var _a;
                 return { name: i.name.value, alias: (_a = i.alias) === null || _a === void 0 ? void 0 : _a.value };
-            })));
+            }), {
+                currentFromImport: fromNode,
+                originalModuleName: this._moduleName,
+            });
         }
     }
-    _updateModuleReferences(filePath, parseResults, nameRemoved, results) {
+    _updateModuleReferences(parseResults, results) {
         var _a, _b, _c, _d, _e;
+        const filePath = (0, analyzerNodeInfo_1.getFileInfo)(parseResults.parseTree).filePath;
         let importStatements;
         for (const result of results) {
             const nodeFound = result.node;
             if (nodeFound.nodeType === 49 /* String */) {
                 // ex) __all__ = ["[a]"]
-                this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                 continue;
             }
             if ((0, parseTreeUtils_1.isImportModuleName)(nodeFound)) {
@@ -419,17 +534,17 @@ class RenameModuleProvider {
                     !moduleNameNode.parent.alias &&
                     this._newModuleNames.length > 1) {
                     this._aliasIntroduced.add(moduleNameNode.parent);
-                    this._addResultWithTextRange(filePath, moduleNameNode, parseResults, `${this._newModuleName} as ${this._newLastModuleName}`);
+                    this._textEditTracker.addEditWithTextRange(parseResults, moduleNameNode, `${this._newModuleName} as ${this._newLastModuleName}`);
                     continue;
                 }
                 // Otherwise, update whole module name to new name
                 // ex) import [xxx.yyy] to import [aaa.bbb]
-                this._addResultWithTextRange(filePath, moduleNameNode, parseResults, this._newModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, moduleNameNode, this._newModuleName);
                 continue;
             }
             if ((0, parseTreeUtils_1.isImportAlias)(nodeFound)) {
                 // ex) import xxx as [yyy] to import xxx as [zzz]
-                this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                 continue;
             }
             if ((0, parseTreeUtils_1.isFromImportModuleName)(nodeFound)) {
@@ -456,7 +571,7 @@ class RenameModuleProvider {
                     // We don't have any sub modules, we can change module name to new one.
                     // Update whole module name to new name.
                     // ex) from [xxx.yyy] import zzz to from [aaa.bbb] import zzz
-                    this._addResultWithTextRange(filePath, moduleNameNode, parseResults, this._getNewModuleName(filePath, moduleNameNode.leadingDots > 0, 
+                    this._textEditTracker.addEditWithTextRange(parseResults, moduleNameNode, this._getNewModuleName(filePath, moduleNameNode.leadingDots > 0, 
                     /* isLastPartImportName */ false));
                     continue;
                 }
@@ -470,31 +585,32 @@ class RenameModuleProvider {
                 // Update module name if needed.
                 if (fromNode.module.leadingDots > 0) {
                     for (const edit of this._getNewRelativeModuleNamesForFileMoved(filePath, [fromNode.module])) {
-                        this._addResultWithTextRange(filePath, edit.moduleName, parseResults, edit.newModuleName);
+                        this._textEditTracker.addEditWithTextRange(parseResults, edit.moduleName, edit.newModuleName);
                     }
                 }
                 // First, delete existing exported symbols from "from import" statement.
                 for (const importFromAs of exportedSymbols) {
-                    this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, fromNode.imports, importFromAs);
+                    this._textEditTracker.deleteImportName(parseResults, importFromAs);
                 }
                 importStatements =
                     importStatements !== null && importStatements !== void 0 ? importStatements : (0, importStatementUtils_1.getTopLevelImports)(parseResults.parseTree, /* includeImplicitImports */ false);
                 // For now, this won't merge absolute and relative path "from import"
                 // statement.
-                this._addResultEdits(this._getTextEditsForNewOrExistingFromImport(filePath, fromNode, parseResults, nameRemoved, importStatements, this._newModuleName, exportedSymbols.map((i) => {
+                this._textEditTracker.addOrUpdateImport(parseResults, importStatements, { name: this._newModuleName }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), exportedSymbols.map((i) => {
                     var _a;
-                    const name = results.findIndex((r) => r.node === i.name) >= 0
-                        ? this._newLastModuleName
-                        : i.name.value;
+                    const name = results.findIndex((r) => r.node === i.name) >= 0 ? this._newLastModuleName : i.name.value;
                     const alias = results.findIndex((r) => r.node === i.alias) >= 0
                         ? this._newLastModuleName
                         : (_a = i.alias) === null || _a === void 0 ? void 0 : _a.value;
                     return { name, alias };
-                })));
+                }), {
+                    currentFromImport: fromNode,
+                    originalModuleName: this._moduleName,
+                });
                 continue;
             }
             if ((0, parseTreeUtils_1.isFromImportName)(nodeFound)) {
-                if (nameRemoved.has(nodeFound.id)) {
+                if (this._textEditTracker.isNodeRemoved(nodeFound)) {
                     // Import name is already removed.
                     continue;
                 }
@@ -505,13 +621,13 @@ class RenameModuleProvider {
                 // Existing logic should make sure re-exported symbol name work as before after
                 // symbol rename.
                 if (this._isExportedSymbol(nodeFound)) {
-                    this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                    this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                     continue;
                 }
                 if (fromNode.imports.length === 1) {
                     // ex) from xxx import [yyy] to from [aaa.bbb] import [zzz]
-                    this._addResultWithTextRange(filePath, fromNode.module, parseResults, newModuleName);
-                    this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                    this._textEditTracker.addEditWithTextRange(parseResults, fromNode.module, newModuleName);
+                    this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                 }
                 else {
                     // Delete the existing import name including alias.
@@ -519,10 +635,10 @@ class RenameModuleProvider {
                     // Update module name if needed.
                     if (fromNode.module.leadingDots > 0) {
                         for (const edit of this._getNewRelativeModuleNamesForFileMoved(filePath, [fromNode.module])) {
-                            this._addResultWithTextRange(filePath, edit.moduleName, parseResults, edit.newModuleName);
+                            this._textEditTracker.addEditWithTextRange(parseResults, edit.moduleName, edit.newModuleName);
                         }
                     }
-                    this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, fromNode.imports, importFromAs);
+                    this._textEditTracker.deleteImportName(parseResults, importFromAs);
                     importStatements =
                         importStatements !== null && importStatements !== void 0 ? importStatements : (0, importStatementUtils_1.getTopLevelImports)(parseResults.parseTree, /* includeImplicitImports */ false);
                     // ex) from xxx import yyy, [zzz] to
@@ -541,17 +657,20 @@ class RenameModuleProvider {
                             ? this._newLastModuleName
                             : (_d = importFromAs.alias) === null || _d === void 0 ? void 0 : _d.value,
                     };
-                    this._addResultEdits(this._getTextEditsForNewOrExistingFromImport(filePath, fromNode, parseResults, nameRemoved, importStatements, newModuleName, [importNameInfo]));
+                    this._textEditTracker.addOrUpdateImport(parseResults, importStatements, { name: this._newModuleName, nameForImportFrom: newModuleName }, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), [importNameInfo], {
+                        currentFromImport: fromNode,
+                        originalModuleName: this._moduleName,
+                    });
                 }
                 continue;
             }
             if ((0, parseTreeUtils_1.isFromImportAlias)(nodeFound)) {
-                if (nameRemoved.has(nodeFound.id)) {
+                if (this._textEditTracker.isNodeRemoved(nodeFound)) {
                     // alias is already removed.
                     continue;
                 }
                 // ex) from ccc import xxx as [yyy] to from ccc import xxx as [zzz]
-                this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                 continue;
             }
             /** TODO: if we get more than 1 decls, flag it as attention needed */
@@ -561,7 +680,7 @@ class RenameModuleProvider {
                 // Simple case. only name has changed. but not path.
                 // Just replace name to new symbol name.
                 // ex) a.[b].foo() to a.[z].foo()
-                this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                 continue;
             }
             if (decls === null || decls === void 0 ? void 0 : decls.some((d) => !d.usesLocalName &&
@@ -570,7 +689,7 @@ class RenameModuleProvider {
                 const dottedName = (0, parseTreeUtils_1.getDottedNameWithGivenNodeAsLastName)(nodeFound);
                 if (((_e = dottedName.parent) === null || _e === void 0 ? void 0 : _e.nodeType) !== 35 /* MemberAccess */) {
                     // Replace whole dotted name with new module name.
-                    this._addResultWithTextRange(filePath, dottedName, parseResults, this._newModuleName);
+                    this._textEditTracker.addEditWithTextRange(parseResults, dottedName, this._newModuleName);
                     continue;
                 }
                 // Check whether name after me is sub module or not.
@@ -586,11 +705,11 @@ class RenameModuleProvider {
                 // Next name is actual symbol. Replace whole name to new module name.
                 // ex) import a.b.c
                 //     [a.b.c].[foo]()
-                this._addResultWithTextRange(filePath, dottedName, parseResults, this._newModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, dottedName, this._newModuleName);
                 continue;
             }
             if (result.node.value !== this._newLastModuleName) {
-                this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                this._textEditTracker.addEditWithTextRange(parseResults, result.range, this._newLastModuleName);
                 continue;
             }
         }
@@ -705,12 +824,6 @@ class RenameModuleProvider {
         // ex) x.y.z used in "from x.y.z import ..."
         return moduleName;
     }
-    getEdits() {
-        return this._textEditTracker.getEdits(this._token);
-    }
-    get lastModuleName() {
-        return this._moduleNames[this._moduleNames.length - 1];
-    }
     get _moduleName() {
         return this._moduleNameAndType.moduleName;
     }
@@ -720,108 +833,6 @@ class RenameModuleProvider {
     get _newModuleName() {
         return this._newModuleNameAndType.moduleName;
     }
-    _addImportNameDeletion(filePath, parseResults, nameRemoved, imports, importToDelete) {
-        this._addImportNameDeletionInternal(filePath, parseResults, nameRemoved, imports, importToDelete, 20 /* Import */);
-        // Mark that we don't need to process these node again later.
-        nameRemoved.add(importToDelete.module.id);
-        importToDelete.module.nameParts.forEach((n) => nameRemoved.add(n.id));
-        if (importToDelete.alias) {
-            nameRemoved.add(importToDelete.alias.id);
-        }
-    }
-    _addFromImportNameDeletion(filePath, parseResults, nameRemoved, imports, importToDelete) {
-        this._addImportNameDeletionInternal(filePath, parseResults, nameRemoved, imports, importToDelete, 22 /* ImportFrom */);
-        // Mark that we don't need to process these node again later.
-        nameRemoved.add(importToDelete.name.id);
-        if (importToDelete.alias) {
-            nameRemoved.add(importToDelete.alias.id);
-        }
-    }
-    _addImportNameDeletionInternal(filePath, parseResults, nameRemoved, imports, importToDelete, importKind) {
-        const ranges = (0, importStatementUtils_1.getTextRangeForImportNameDeletion)(imports, imports.findIndex((v) => v === importToDelete));
-        ranges.forEach((r) => this._addResultWithTextRange(filePath, r, parseResults, ''));
-        // Mark that we don't need to process these node again later.
-        nameRemoved.add(importToDelete.id);
-        // Check whether we have deleted all trailing import names.
-        // If either no trailing import is deleted or handled properly
-        // then, there is nothing to do. otherwise, either delete the whole statement
-        // or remove trailing comma.
-        // ex) from x import [y], z or from x import y[, z]
-        let lastImportIndexNotDeleted = 0;
-        for (lastImportIndexNotDeleted = imports.length - 1; lastImportIndexNotDeleted >= 0; lastImportIndexNotDeleted--) {
-            if (!nameRemoved.has(imports[lastImportIndexNotDeleted].id)) {
-                break;
-            }
-        }
-        if (lastImportIndexNotDeleted === -1) {
-            // Whole statement is deleted. Remove the statement itself.
-            // ex) [from x import a, b, c] or [import a]
-            const importStatement = (0, parseTreeUtils_1.getFirstAncestorOrSelfOfKind)(importToDelete, importKind);
-            if (importStatement) {
-                this._textEditTracker.addEdit(filePath, (0, parseTreeUtils_1.getFullStatementRange)(importStatement, parseResults.tokenizerOutput), '');
-            }
-        }
-        else if (lastImportIndexNotDeleted >= 0 && lastImportIndexNotDeleted < imports.length - 2) {
-            // We need to delete trailing comma
-            // ex) from x import a, [b, c]
-            const start = textRange_1.TextRange.getEnd(imports[lastImportIndexNotDeleted]);
-            const length = textRange_1.TextRange.getEnd(imports[lastImportIndexNotDeleted + 1]) - start;
-            this._addResultWithTextRange(filePath, { start, length }, parseResults, '');
-        }
-    }
-    _addResultWithTextRange(filePath, range, parseResults, newName) {
-        const existing = parseResults.text.substr(range.start, range.length);
-        if (existing === newName) {
-            // No change. Return as it is.
-            return;
-        }
-        this._textEditTracker.addEdit(filePath, (0, positionUtils_1.convertTextRangeToRange)(range, parseResults.tokenizerOutput.lines), newName);
-    }
-    _addResultEdits(edits) {
-        this._textEditTracker.addEdits(...edits);
-    }
-    _getTextEditsForNewOrExistingFromImport(filePath, currentFromImport, parseResults, nameRemoved, importStatements, moduleName, importNameInfo) {
-        // See whether we have existing from import statement for the same module
-        // ex) from [|moduleName|] import subModule
-        const imported = importStatements.orderedImports.find((i) => i.moduleName === moduleName);
-        if (imported && imported.node.nodeType === 22 /* ImportFrom */ && !imported.node.isWildcardImport) {
-            const edits = (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)(importNameInfo, imported, parseResults);
-            if (imported.node !== currentFromImport) {
-                // Add what we want to the existing "import from" statement as long as it is not the same import
-                // node we are working on.
-                return edits.map((e) => ({ filePath, range: e.range, replacementText: e.replacementText }));
-            }
-            // Check whether we can avoid creating a new statement. We can't just merge with existing one since
-            // we could create invalid text edits (2 edits that change the same span, or invalid replacement text since
-            // texts on the node has changed)
-            if (this._onlyNameChanged && importNameInfo.length === 1 && edits.length === 1) {
-                const deletions = this._textEditTracker.getDeletionsForSpan(filePath, edits[0].range);
-                if (deletions.length === 0) {
-                    return [{ filePath, range: edits[0].range, replacementText: edits[0].replacementText }];
-                }
-                else {
-                    const alias = importNameInfo[0].alias === this._newLastModuleName
-                        ? this.lastModuleName
-                        : importNameInfo[0].alias;
-                    const importName = currentFromImport.imports.find((i) => { var _a; return i.name.value === this.lastModuleName && ((_a = i.alias) === null || _a === void 0 ? void 0 : _a.value) === alias; });
-                    if (importName) {
-                        this._textEditTracker.removeEdits(filePath, deletions);
-                        if (importName.alias) {
-                            nameRemoved.delete(importName.alias.id);
-                        }
-                        return [
-                            {
-                                filePath,
-                                range: (0, positionUtils_1.convertTextRangeToRange)(importName.name, parseResults.tokenizerOutput.lines),
-                                replacementText: this._newLastModuleName,
-                            },
-                        ];
-                    }
-                }
-            }
-        }
-        return (0, importStatementUtils_1.getTextEditsForAutoImportInsertion)(importNameInfo, { name: moduleName }, importStatements, (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(this._newModuleNameAndType), parseResults, (0, positionUtils_1.convertOffsetToPosition)(parseResults.parseTree.length, parseResults.tokenizerOutput.lines)).map((e) => ({ filePath, range: e.range, replacementText: e.replacementText }));
-    }
 }
 exports.RenameModuleProvider = RenameModuleProvider;
 class ModuleNameCollector extends parseTreeWalker_1.ParseTreeWalker {