@zzzen/pyright-internal 1.1.254

package/dist/languageService/renameModuleProvider.js

@@ -0,0 +1,884 @@
+"use strict";
+/*
+ * renameModuleProvider.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Logic that updates affected references of a module rename/move.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenameModuleProvider = void 0;
+const vscode_languageserver_1 = require("vscode-languageserver");
+const analyzerNodeInfo_1 = require("../analyzer/analyzerNodeInfo");
+const declaration_1 = require("../analyzer/declaration");
+const declarationUtils_1 = require("../analyzer/declarationUtils");
+const importResolver_1 = require("../analyzer/importResolver");
+const importStatementUtils_1 = require("../analyzer/importStatementUtils");
+const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
+const parseTreeWalker_1 = require("../analyzer/parseTreeWalker");
+const sourceMapper_1 = require("../analyzer/sourceMapper");
+const collectionUtils_1 = require("../common/collectionUtils");
+const core_1 = require("../common/core");
+const debug_1 = require("../common/debug");
+const pathUtils_1 = require("../common/pathUtils");
+const positionUtils_1 = require("../common/positionUtils");
+const textRange_1 = require("../common/textRange");
+const parseNodes_1 = require("../parser/parseNodes");
+const documentSymbolCollector_1 = require("./documentSymbolCollector");
+var UpdateType;
+(function (UpdateType) {
+    UpdateType[UpdateType["File"] = 0] = "File";
+    UpdateType[UpdateType["Folder"] = 1] = "Folder";
+    UpdateType[UpdateType["Symbol"] = 2] = "Symbol";
+})(UpdateType || (UpdateType = {}));
+class RenameModuleProvider {
+    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._token = _token;
+        this._results = new Map();
+        this._aliasIntroduced = new Set();
+        // moduleName and newModuleName are always in the absolute path form.
+        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;
+        (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) {
+        if (!importResolver.fileSystem.existsSync(path)) {
+            return undefined;
+        }
+        if ((0, pathUtils_1.isFile)(importResolver.fileSystem, path)) {
+            return this._create(importResolver, configOptions, evaluator, path, newPath, UpdateType.File, token);
+        }
+        else if ((0, pathUtils_1.isDirectory)(importResolver.fileSystem, path)) {
+            // Make sure folder path is simple rename.
+            if ((0, pathUtils_1.getDirectoryChangeKind)(importResolver.fileSystem, path, newPath) !== 'Renamed') {
+                return undefined;
+            }
+            // We don't support namespace folder name. Currently, we don't have
+            // a way to find namespace folder references.
+            let fileNameForPackage = (0, pathUtils_1.combinePaths)(path, '__init__.pyi');
+            if (!importResolver.fileSystem.existsSync(fileNameForPackage)) {
+                fileNameForPackage = (0, pathUtils_1.combinePaths)(path, '__init__.py');
+                if (!importResolver.fileSystem.existsSync(fileNameForPackage)) {
+                    return undefined;
+                }
+            }
+            return this._create(importResolver, configOptions, evaluator, fileNameForPackage, (0, pathUtils_1.combinePaths)(newPath, (0, pathUtils_1.getFileName)(fileNameForPackage)), UpdateType.Folder, token);
+        }
+        return undefined;
+    }
+    static createForSymbol(importResolver, configOptions, evaluator, path, newPath, declarations, token) {
+        if (!importResolver.fileSystem.existsSync(path)) {
+            return undefined;
+        }
+        const filteredDecls = declarations.filter((d) => (0, declaration_1.isClassDeclaration)(d) || (0, declaration_1.isFunctionDeclaration)(d) || (0, declaration_1.isVariableDeclaration)(d));
+        if (filteredDecls.length === 0) {
+            return undefined;
+        }
+        return this._create(importResolver, configOptions, evaluator, path, newPath, UpdateType.Symbol, filteredDecls, token);
+    }
+    static getRenameModulePath(declarations) {
+        // If we have a decl with no node, we will prefer that decl over others.
+        // The decl with no node is a synthesized alias decl created only for IDE case
+        // that should point to the right module file.
+        const bestDecl = declarations.find((d) => !d.node);
+        if (bestDecl) {
+            return bestDecl.path;
+        }
+        // Otherwise, prefer stub if we have one. or just return first decl.
+        const declarationPaths = [...declarations.reduce((s, d) => s.add(d.path), new Set())];
+        const stubIndex = declarationPaths.findIndex((d) => (0, sourceMapper_1.isStubFile)(d));
+        if (stubIndex >= 0) {
+            return declarationPaths[stubIndex];
+        }
+        return declarationPaths[0];
+    }
+    static getRenameModulePathInfo(declarationPath, newName) {
+        const filePath = getFilePathToRename(declarationPath);
+        const newFilePath = replaceFileName(filePath, newName);
+        return { filePath, newFilePath };
+        function getFilePathToRename(filePath) {
+            const fileName = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
+            if (fileName === '__init__') {
+                return (0, pathUtils_1.getDirectoryPath)(filePath);
+            }
+            return filePath;
+        }
+        function replaceFileName(filePath, newName) {
+            const ext = (0, pathUtils_1.getFileExtension)(filePath);
+            const directory = (0, pathUtils_1.getDirectoryPath)(filePath);
+            return (0, pathUtils_1.combinePaths)(directory, `${newName}${ext}`);
+        }
+    }
+    static _create(importResolver, configOptions, evaluator, moduleFilePath, newModuleFilePath, type, tokenOrDeclarations, token) {
+        const execEnv = configOptions.findExecEnvironment(moduleFilePath);
+        const moduleName = importResolver.getModuleNameForImport(moduleFilePath, execEnv);
+        if (!moduleName.moduleName) {
+            return undefined;
+        }
+        const newModuleName = importResolver.getModuleNameForImport(newModuleFilePath, execEnv);
+        if (!newModuleName.moduleName) {
+            return undefined;
+        }
+        token = vscode_languageserver_1.CancellationToken.is(tokenOrDeclarations) ? tokenOrDeclarations : token;
+        const declarations = vscode_languageserver_1.CancellationToken.is(tokenOrDeclarations) ? [] : tokenOrDeclarations;
+        if (declarations.length === 0) {
+            // Create synthesized alias decls from the given file path. If the given file is for stub,
+            // create one for the corresponding py file as well.
+            declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(moduleFilePath));
+            if ((0, sourceMapper_1.isStubFile)(moduleFilePath)) {
+                // The resolveImport should make sure non stub file search to happen.
+                importResolver.resolveImport(moduleFilePath, execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName.moduleName));
+                importResolver
+                    .getSourceFilesFromStub(moduleFilePath, execEnv, /* mapCompiled */ false)
+                    .forEach((p) => declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(p)));
+            }
+        }
+        return new RenameModuleProvider(importResolver.fileSystem, evaluator, moduleFilePath, newModuleFilePath, moduleName, newModuleName, type, declarations, token);
+    }
+    renameReferences(filePath, parseResults) {
+        switch (this._type) {
+            case UpdateType.Folder:
+                return this._renameFolderReferences(filePath, parseResults);
+            case UpdateType.File:
+                return this._renameModuleReferences(filePath, parseResults);
+            case UpdateType.Symbol:
+                return this._updateSymbolReferences(filePath, parseResults);
+            default:
+                return (0, debug_1.assertNever)(this._type, `${this._type} is unknown`);
+        }
+    }
+    _updateSymbolReferences(filePath, parseResults) {
+        var _a, _b, _c, _d;
+        const collector = new documentSymbolCollector_1.DocumentSymbolCollector((_a = (0, declarationUtils_1.getNameFromDeclaration)(this._declarations[0])) !== null && _a !== void 0 ? _a : '', this._declarations, this._evaluator, this._token, parseResults.parseTree, 
+        /* treatModuleImportAndFromImportSame */ true, 
+        /* skipUnreachableCode */ false);
+        // See if we need to insert new import statement
+        const importStatements = (0, importStatementUtils_1.getTopLevelImports)(parseResults.parseTree, /* includeImplicitImports */ true);
+        // 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();
+        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.
+                continue;
+            }
+            if ((0, parseTreeUtils_1.isFromImportName)(nodeFound)) {
+                // ex) from ... import [symbol] ...
+                const fromNode = (_b = nodeFound.parent) === null || _b === void 0 ? void 0 : _b.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: (_c = importFromAs.alias) === null || _c === void 0 ? void 0 : _c.value,
+                    };
+                    this._addResultEdits(this._getTextEditsForNewOrExistingFromImport(filePath, fromNode, parseResults, nameRemoved, importStatements, newModuleName, [importNameInfo]));
+                }
+                continue;
+            }
+            const dottedName = (0, parseTreeUtils_1.getDottedNameWithGivenNodeAsLastName)(nodeFound);
+            if (dottedName === nodeFound || dottedName.nodeType !== 35 /* MemberAccess */) {
+                // 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 = (_d = this._evaluator
+                .getDeclarationsForNameNode(moduleName)) === null || _d === void 0 ? void 0 : _d.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;
+        }
+        // Handle symbol references that are used off imported modules.
+        for (const [key, value] of importUsed) {
+            let referenceModuleName;
+            if (this._canReplaceImportName(parseResults, key, value)) {
+                const moduleName = this._getReferenceModuleName(importStatements, imported);
+                if (key.nodeType === 21 /* ImportAs */) {
+                    if (moduleName) {
+                        referenceModuleName = moduleName;
+                        this._addImportNameDeletion(filePath, parseResults, nameRemoved, key.parent.list, key);
+                    }
+                    else {
+                        referenceModuleName = key.alias ? key.alias.value : this._newModuleName;
+                        this._addResultWithTextRange(filePath, key.module, parseResults, this._newModuleName);
+                    }
+                }
+                else {
+                    if (moduleName) {
+                        referenceModuleName = moduleName;
+                        this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, key.parent.imports, 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);
+                    }
+                }
+            }
+            else {
+                const moduleName = this._getReferenceModuleName(importStatements, imported);
+                if (moduleName) {
+                    referenceModuleName = moduleName;
+                }
+                else {
+                    referenceModuleName = this._newModuleName;
+                    this._addResultEdits((0, importStatementUtils_1.getTextEditsForAutoImportInsertion)([], importStatements, this._newModuleName, (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 })));
+                }
+            }
+            for (const node of value) {
+                this._addResultWithTextRange(filePath, node.leftExpression, parseResults, referenceModuleName);
+            }
+        }
+    }
+    _getReferenceModuleName(importStatements, imported) {
+        var _a, _b;
+        if (imported && imported.node.nodeType === 20 /* Import */) {
+            return ((_a = imported.subnode) === null || _a === void 0 ? void 0 : _a.alias) ? imported.subnode.alias.value : this._newModuleName;
+        }
+        else if ((_b = importStatements.implicitImports) === null || _b === void 0 ? void 0 : _b.has(this._newModuleFilePath)) {
+            const fromImportAs = importStatements.implicitImports.get(this._newModuleFilePath);
+            return fromImportAs.alias ? fromImportAs.alias.value : fromImportAs.name.value;
+        }
+        return undefined;
+    }
+    _canReplaceImportName(parseResults, importAs, symbolReferences) {
+        var _a;
+        const nameToBind = (_a = importAs.alias) !== null && _a !== void 0 ? _a : (importAs.nodeType === 21 /* ImportAs */
+            ? importAs.module.nameParts[importAs.module.nameParts.length - 1]
+            : importAs.name);
+        const declarations = documentSymbolCollector_1.DocumentSymbolCollector.getDeclarationsForNode(nameToBind, this._evaluator, 
+        /* resolveLocalName */ false, this._token);
+        if (declarations.length === 0) {
+            return false;
+        }
+        const collector = new documentSymbolCollector_1.DocumentSymbolCollector(nameToBind.value, declarations, this._evaluator, this._token, parseResults.parseTree, 
+        /* treatModuleImportAndFromImportSame */ true, 
+        /* skipUnreachableCode */ false);
+        for (const result of collector.collect()) {
+            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)) {
+                // collector will report decls as well. ignore decls.
+                continue;
+            }
+            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, 
+        /* 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);
+        }
+    }
+    _renameModuleReferences(filePath, 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);
+        // 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);
+    }
+    _updateRelativeModuleNamePath(filePath, parseResults, nameRemoved, results) {
+        if (filePath !== this._moduleFilePath) {
+            // We only update relative import paths for the file that has moved.
+            return;
+        }
+        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);
+            if (!edit.itemsToMove) {
+                continue;
+            }
+            // This could introduce multiple import statements for same modules with
+            // different symbols per module name. Unfortunately, there is no easy way to
+            // prevent it since we can't see changes made by other code until all changes
+            // are committed. In future, if we support snapshot and diff between snapshots,
+            // then we can support those complex code generations.
+            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);
+            }
+            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) => {
+                var _a;
+                return { name: i.name.value, alias: (_a = i.alias) === null || _a === void 0 ? void 0 : _a.value };
+            })));
+        }
+    }
+    _updateModuleReferences(filePath, parseResults, nameRemoved, results) {
+        var _a, _b, _c, _d, _e;
+        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);
+                continue;
+            }
+            if ((0, parseTreeUtils_1.isImportModuleName)(nodeFound)) {
+                if (!(0, parseTreeUtils_1.isLastNameOfModuleName)(nodeFound)) {
+                    // It must be directory and we don't support folder rename.
+                    continue;
+                }
+                const moduleNameNode = (0, parseTreeUtils_1.getFirstAncestorOrSelfOfKind)(nodeFound, 37 /* ModuleName */);
+                // * Enhancement * one case we don't handle is introducing new symbol in __all__
+                // or converting "import" statement to "from import" statement.
+                //
+                // when the existing statement was "import x as x" and it is changed to
+                // "import y.z as z". we either need to introduce "z" in __all__ or convert
+                // "import y.z as z" to "from y import z as z" to make sure we keep the symbol
+                // visibility same.
+                //
+                // when we convert "import x as x" to "from y import z as z", we need to handle
+                // deletion of existing import statement or (x as x) and inserting/merging
+                // new "from import" statement.
+                // If original module name was single word and it becomes dotted name without alias,
+                // then we introduce alias to keep references as a single word.
+                // ex) import [xxx] to import [aaa.bbb as bbb]
+                if (moduleNameNode.nameParts.length === 1 &&
+                    ((_a = moduleNameNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ImportAs */ &&
+                    !moduleNameNode.parent.alias &&
+                    this._newModuleNames.length > 1) {
+                    this._aliasIntroduced.add(moduleNameNode.parent);
+                    this._addResultWithTextRange(filePath, moduleNameNode, parseResults, `${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);
+                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);
+                continue;
+            }
+            if ((0, parseTreeUtils_1.isFromImportModuleName)(nodeFound)) {
+                if (!(0, parseTreeUtils_1.isLastNameOfModuleName)(nodeFound)) {
+                    // It must be directory and we don't support folder rename.
+                    continue;
+                }
+                const moduleNameNode = (0, parseTreeUtils_1.getFirstAncestorOrSelfOfKind)(nodeFound, 37 /* ModuleName */);
+                const fromNode = moduleNameNode.parent;
+                // We need to check whether imports of this import statement has
+                // any implicit submodule imports or not. If there is one, we need to
+                // either split or leave it as it is.
+                const exportedSymbols = [];
+                const subModules = [];
+                for (const importFromAs of fromNode.imports) {
+                    if (this._isExportedSymbol(importFromAs.name)) {
+                        exportedSymbols.push(importFromAs);
+                    }
+                    else {
+                        subModules.push(importFromAs);
+                    }
+                }
+                if (subModules.length === 0) {
+                    // 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, 
+                    /* isLastPartImportName */ false));
+                    continue;
+                }
+                if (exportedSymbols.length === 0) {
+                    // We only have sub modules. That means module name actually refers to
+                    // folder name, not module (ex, __init__.py). Folder rename is done by
+                    // different code path.
+                    continue;
+                }
+                // Now, we need to split "from import" statement to 2.
+                // 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);
+                    }
+                }
+                // First, delete existing exported symbols from "from import" statement.
+                for (const importFromAs of exportedSymbols) {
+                    this._addFromImportNameDeletion(filePath, parseResults, nameRemoved, fromNode.imports, 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) => {
+                    var _a;
+                    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 };
+                })));
+                continue;
+            }
+            if ((0, parseTreeUtils_1.isFromImportName)(nodeFound)) {
+                if (nameRemoved.has(nodeFound.id)) {
+                    // Import name is already removed.
+                    continue;
+                }
+                const fromNode = (_b = nodeFound.parent) === null || _b === void 0 ? void 0 : _b.parent;
+                const newModuleName = this._getNewModuleName(filePath, fromNode.module.leadingDots > 0, 
+                /* isLastPartImportName */ true);
+                // If the name bound to symbol re-exported, we don't need to update module name.
+                // 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);
+                    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);
+                }
+                else {
+                    // Delete the existing import name including alias.
+                    const importFromAs = nodeFound.parent;
+                    // 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._addFromImportNameDeletion(filePath, parseResults, nameRemoved, fromNode.imports, importFromAs);
+                    importStatements =
+                        importStatements !== null && importStatements !== void 0 ? importStatements : (0, importStatementUtils_1.getTopLevelImports)(parseResults.parseTree, /* includeImplicitImports */ false);
+                    // ex) from xxx import yyy, [zzz] to
+                    //     from xxx import yyy
+                    //     from [aaa.bbb] import [ccc]
+                    // or
+                    //     from aaa.bbb import ddd
+                    //     from xxx import yyy, [zzz] to
+                    //     from aaa.bbb import [ccc], ddd
+                    //
+                    // For now, this won't merge absolute and relative path "from import"
+                    // statement.
+                    const importNameInfo = {
+                        name: this._newLastModuleName,
+                        alias: ((_c = importFromAs.alias) === null || _c === void 0 ? void 0 : _c.value) === this.lastModuleName
+                            ? this._newLastModuleName
+                            : (_d = importFromAs.alias) === null || _d === void 0 ? void 0 : _d.value,
+                    };
+                    this._addResultEdits(this._getTextEditsForNewOrExistingFromImport(filePath, fromNode, parseResults, nameRemoved, importStatements, newModuleName, [importNameInfo]));
+                }
+                continue;
+            }
+            if ((0, parseTreeUtils_1.isFromImportAlias)(nodeFound)) {
+                if (nameRemoved.has(nodeFound.id)) {
+                    // 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);
+                continue;
+            }
+            /** TODO: if we get more than 1 decls, flag it as attention needed */
+            const decls = documentSymbolCollector_1.DocumentSymbolCollector.getDeclarationsForNode(nodeFound, this._evaluator, 
+            /* resolveLocalName */ false, this._token).filter((d) => (0, declaration_1.isAliasDeclaration)(d));
+            if (this._onlyNameChanged) {
+                // 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);
+                continue;
+            }
+            if (decls === null || decls === void 0 ? void 0 : decls.some((d) => !d.usesLocalName &&
+                (!d.node || d.node.nodeType === 21 /* ImportAs */) &&
+                !this._aliasIntroduced.has(d.node))) {
+                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);
+                    continue;
+                }
+                // Check whether name after me is sub module or not.
+                // ex) a.b.[c]
+                const nextNameDecl = this._evaluator.getDeclarationsForNameNode(dottedName.parent.memberName);
+                if (!nextNameDecl || nextNameDecl.length === 0) {
+                    // Next dotted name is sub module. That means dottedName actually refers to folder names, not modules.
+                    // and We don't support renaming folder. So, leave things as they are.
+                    // ex) import a.b.c
+                    //     [a.b].[c]
+                    continue;
+                }
+                // 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);
+                continue;
+            }
+            if (result.node.value !== this._newLastModuleName) {
+                this._addResultWithTextRange(filePath, result.range, parseResults, this._newLastModuleName);
+                continue;
+            }
+        }
+    }
+    _getNewRelativeModuleNamesForFileMoved(filePath, moduleNames) {
+        if (filePath !== this._moduleFilePath) {
+            // We only update relative import paths for the file that has moved.
+            return [];
+        }
+        const originalFileName = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
+        const originalInit = originalFileName === '__init__';
+        const originalDirectory = (0, pathUtils_1.getDirectoryPath)(filePath);
+        const newNames = [];
+        for (const moduleName of moduleNames) {
+            // Filter out all absolute path.
+            if (moduleName.leadingDots === 0) {
+                continue;
+            }
+            const result = this._getNewModuleNameInfoForFileMoved(moduleName, originalInit, originalDirectory);
+            if (!result) {
+                continue;
+            }
+            const newModuleName = (0, importStatementUtils_1.getRelativeModuleName)(this._fs, result.src, result.dest, 
+            /* ignoreFolderStructure */ false, 
+            /* sourceIsFile */ true);
+            newNames.push({ moduleName, newModuleName, itemsToMove: result.itemsToMove });
+        }
+        return newNames;
+    }
+    _getNewModuleNameInfoForFileMoved(moduleName, originalInit, originalDirectory) {
+        const importInfo = (0, analyzerNodeInfo_1.getImportInfo)(moduleName);
+        if (!importInfo) {
+            return undefined;
+        }
+        let importPath = importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1];
+        if (!importPath) {
+            // It is possible for the module name to point to namespace folder (no __init__).
+            // See whether we can use some heuristic to get importPath
+            if (moduleName.nameParts.length === 0) {
+                const directory = (0, importStatementUtils_1.getDirectoryLeadingDotsPointsTo)(originalDirectory, moduleName.leadingDots);
+                if (!directory) {
+                    return undefined;
+                }
+                // Add fake __init__.py since we know this is namespace folder.
+                importPath = (0, pathUtils_1.combinePaths)(directory, '__init__.py');
+            }
+            else {
+                return undefined;
+            }
+        }
+        // Check whether module is pointing to moved file itself and whether it is __init__
+        if (this._moduleFilePath !== importPath || !originalInit) {
+            return { src: this._newModuleFilePath, dest: importPath };
+        }
+        // Now, moduleName is pointing to __init__ which point to moved file itself.
+        // We need to check whether imports of this import statement has
+        // any implicit submodule imports or not. If there is one, we need to
+        // either split or leave it as it is.
+        const exportedSymbols = [];
+        const subModules = [];
+        for (const importFromAs of moduleName.parent.imports) {
+            if (this._isExportedSymbol(importFromAs.name)) {
+                exportedSymbols.push(importFromAs);
+            }
+            else {
+                subModules.push(importFromAs);
+            }
+        }
+        // Point to itself.
+        if (subModules.length === 0) {
+            return { src: this._newModuleFilePath, dest: this._newModuleFilePath };
+        }
+        // "." is used to point folder location.
+        if (exportedSymbols.length === 0) {
+            return { src: this._newModuleFilePath, dest: this._moduleFilePath };
+        }
+        // now we need to split, provide split info as well.
+        return {
+            src: this._newModuleFilePath,
+            dest: this._moduleFilePath,
+            itemsToMove: [...exportedSymbols],
+        };
+    }
+    _isExportedSymbol(nameNode) {
+        const decls = this._evaluator.getDeclarationsForNameNode(nameNode);
+        if (!decls) {
+            return false;
+        }
+        // If submoduleFallback exists, then, it points to submodule not symbol.
+        return !decls.some((d) => (0, declaration_1.isAliasDeclaration)(d) && d.submoduleFallback);
+    }
+    _getNewModuleName(currentFilePath, isRelativePath, isLastPartImportName) {
+        const filePath = currentFilePath === this._moduleFilePath ? this._newModuleFilePath : currentFilePath;
+        // If the existing code was using relative path, try to keep the relative path.
+        const moduleName = isRelativePath
+            ? (0, importStatementUtils_1.getRelativeModuleName)(this._fs, filePath, this._newModuleFilePath, isLastPartImportName, 
+            /* sourceIsFile*/ true)
+            : this._newModuleName;
+        if (isLastPartImportName && moduleName.endsWith(this._newLastModuleName)) {
+            const dotPrefix = moduleName === this._newLastModuleName
+                ? 0
+                : moduleName.length > this._newLastModuleName.length + 1
+                    ? moduleName[moduleName.length - this._newLastModuleName.length - 2] !== '.'
+                        ? 1
+                        : 0
+                    : 0;
+            const length = moduleName.length - this._newLastModuleName.length - dotPrefix;
+            //ex) x.y.z used in "from x.y import z"
+            const newModuleName = moduleName.substr(0, length);
+            return newModuleName.length > 0 ? newModuleName : '.';
+        }
+        // ex) x.y.z used in "from x.y.z import ..."
+        return moduleName;
+    }
+    getEdits() {
+        const edits = [];
+        this._results.forEach((v) => (0, collectionUtils_1.appendArray)(edits, v));
+        return edits;
+    }
+    get lastModuleName() {
+        return this._moduleNames[this._moduleNames.length - 1];
+    }
+    get _moduleName() {
+        return this._moduleNameAndType.moduleName;
+    }
+    get _newLastModuleName() {
+        return this._newModuleNames[this._newModuleNames.length - 1];
+    }
+    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 range = (0, importStatementUtils_1.getTextRangeForImportNameDeletion)(imports, imports.findIndex((v) => v === importToDelete));
+        this._addResultWithTextRange(filePath, range, 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._addResultWithRange(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._addResultWithRange(filePath, (0, positionUtils_1.convertTextRangeToRange)(range, parseResults.tokenizerOutput.lines), newName);
+    }
+    _addResultEdits(edits) {
+        edits.forEach((e) => this._addResultWithRange(e.filePath, e.range, e.replacementText));
+    }
+    _getDeletionsForSpan(filePathOrEdit, range) {
+        var _a;
+        if ((0, core_1.isString)(filePathOrEdit)) {
+            filePathOrEdit = (_a = this._results.get(filePathOrEdit)) !== null && _a !== void 0 ? _a : [];
+        }
+        return filePathOrEdit.filter((e) => e.replacementText === '' && (0, textRange_1.doRangesIntersect)(e.range, range));
+    }
+    _removeEdits(filePathOrEdit, edits) {
+        var _a;
+        if ((0, core_1.isString)(filePathOrEdit)) {
+            filePathOrEdit = (_a = this._results.get(filePathOrEdit)) !== null && _a !== void 0 ? _a : [];
+        }
+        (0, collectionUtils_1.removeArrayElements)(filePathOrEdit, (f) => edits.findIndex((e) => e === f) >= 0);
+    }
+    _addResultWithRange(filePath, range, replacementText) {
+        const edits = (0, collectionUtils_1.getOrAdd)(this._results, filePath, () => []);
+        if (replacementText === '') {
+            // If it is a deletion, merge with overlapping deletion edit if there is any.
+            const deletions = this._getDeletionsForSpan(edits, range);
+            if (deletions.length > 0) {
+                // Delete the existing ones.
+                this._removeEdits(edits, deletions);
+                // Extend range with deleted ones.
+                (0, textRange_1.extendRange)(range, deletions.map((d) => d.range));
+            }
+        }
+        // Don't put duplicated edit. It can happen if code has duplicated module import.
+        // ex) from a import b, b, c
+        // If we need to introduce new "from import" statement for "b", we will add new statement twice.
+        if (edits.some((e) => (0, textRange_1.rangesAreEqual)(e.range, range) && e.replacementText === replacementText)) {
+            return;
+        }
+        edits.push({ filePath, range, replacementText });
+    }
+    _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._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._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, importStatements, moduleName, (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 {
+    constructor() {
+        super(...arguments);
+        this._result = [];
+    }
+    walk(node) {
+        if ((0, parseNodes_1.isExpressionNode)(node)) {
+            return;
+        }
+        super.walk(node);
+    }
+    visitModuleName(node) {
+        this._result.push(node);
+        return false;
+    }
+    static collect(root) {
+        const collector = new ModuleNameCollector();
+        collector.walk(root);
+        return collector._result;
+    }
+}
+//# sourceMappingURL=renameModuleProvider.js.map