@zzzen/pyright-internal 1.2.0-dev.20230430 → 1.2.0-dev.20230514

package/dist/analyzer/program.js

@@ -30,9 +30,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Program = exports.MaxWorkspaceIndexFileCount = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
-const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const cancellationUtils_1 = require("../common/cancellationUtils");
-const collectionUtils_1 = require("../common/collectionUtils");
 const configOptions_1 = require("../common/configOptions");
 const console_1 = require("../common/console");
 const debug = __importStar(require("../common/debug"));
@@ -41,30 +40,15 @@ const extensibility_1 = require("../common/extensibility");
 const logTracker_1 = require("../common/logTracker");
 const pathUtils_1 = require("../common/pathUtils");
 const positionUtils_1 = require("../common/positionUtils");
-const stringUtils_1 = require("../common/stringUtils");
-const textEditTracker_1 = require("../common/textEditTracker");
 const textRange_1 = require("../common/textRange");
-const textRangeCollection_1 = require("../common/textRangeCollection");
 const timing_1 = require("../common/timing");
-const workspaceEditUtils_1 = require("../common/workspaceEditUtils");
-const autoImporter_1 = require("../languageService/autoImporter");
-const completionProvider_1 = require("../languageService/completionProvider");
-const documentSymbolCollector_1 = require("../languageService/documentSymbolCollector");
-const importAdder_1 = require("../languageService/importAdder");
-const indentationUtils_1 = require("../languageService/indentationUtils");
-const insertionPointUtils_1 = require("../languageService/insertionPointUtils");
-const referencesProvider_1 = require("../languageService/referencesProvider");
-const renameModuleProvider_1 = require("../languageService/renameModuleProvider");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const cacheManager_1 = require("./cacheManager");
 const circularDependency_1 = require("./circularDependency");
-const declaration_1 = require("./declaration");
 const parseTreeUtils_1 = require("./parseTreeUtils");
-const scopeUtils_1 = require("./scopeUtils");
 const sourceFile_1 = require("./sourceFile");
 const sourceFileInfoUtils_1 = require("./sourceFileInfoUtils");
 const sourceMapper_1 = require("./sourceMapper");
-const symbolNameUtils_1 = require("./symbolNameUtils");
 const tracePrinter_1 = require("./tracePrinter");
 const typeEvaluatorWithTracker_1 = require("./typeEvaluatorWithTracker");
 const typeStubWriter_1 = require("./typeStubWriter");
@@ -82,6 +66,7 @@ class Program {
         this._sourceFileList = [];
         this._sourceFileMap = new Map();
         this._parsedFileCount = 0;
+        this._isEditMode = false;
         this._lookUpImport = (filePathOrModule, options) => {
             var _a;
             let sourceFileInfo;
@@ -171,6 +156,41 @@ class Program {
     dispose() {
         this._cacheManager.unregisterCacheOwner(this);
     }
+    enterEditMode() {
+        // Keep track of edit mode so we can apply it to new source files.
+        this._isEditMode = true;
+        // Tell all source files we're in edit mode.
+        this._sourceFileList.forEach((sourceFile) => {
+            sourceFile.sourceFile.enterEditMode();
+        });
+    }
+    exitEditMode() {
+        // Tell all source files we're no longer in edit mode. Gather
+        // up all of their edits.
+        const edits = [];
+        this._sourceFileList.forEach((sourceFile) => {
+            const newContents = sourceFile.sourceFile.exitEditMode();
+            if (newContents) {
+                // This means this source file was modified. We need to recompute its imports after
+                // we put it back to how it was.
+                this._updateSourceFileImports(sourceFile, this.configOptions);
+                // Create a text document so we can compute the edits.
+                const textDocument = vscode_languageserver_textdocument_1.TextDocument.create(sourceFile.sourceFile.getFilePath(), 'python', 1, sourceFile.sourceFile.getFileContent() || '');
+                // Add an edit action to the list.
+                edits.push({
+                    filePath: sourceFile.sourceFile.getFilePath(),
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: textDocument.lineCount, character: 0 },
+                    },
+                    replacementText: newContents,
+                });
+            }
+        });
+        // Stop applying edit mode to new source files.
+        this._isEditMode = false;
+        return edits;
+    }
     setConfigOptions(configOptions) {
         this._configOptions = configOptions;
         this._importResolver.setConfigOptions(configOptions);
@@ -242,7 +262,7 @@ class Program {
             sourceFileInfo.isTracked = true;
             return sourceFileInfo.sourceFile;
         }
-        const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, isThirdPartyImport, isInPyTypedPackage, this._console, this._logTracker);
+        const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, isThirdPartyImport, isInPyTypedPackage, this._isEditMode, this._console, this._logTracker);
         sourceFileInfo = {
             sourceFile,
             isTracked: true,
@@ -266,7 +286,7 @@ class Program {
             const importName = this._getImportNameForFile(filePath);
             const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, 
             /* isThirdPartyImport */ false, 
-            /* isInPyTypedPackage */ false, this._console, this._logTracker, options === null || options === void 0 ? void 0 : options.realFilePath, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : sourceFile_1.IPythonMode.None);
+            /* isInPyTypedPackage */ false, this._isEditMode, this._console, this._logTracker, options === null || options === void 0 ? void 0 : options.realFilePath, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : sourceFile_1.IPythonMode.None);
             const chainedFilePath = options === null || options === void 0 ? void 0 : options.chainedFilePath;
             sourceFileInfo = {
                 sourceFile,
@@ -499,59 +519,6 @@ class Program {
             return false;
         });
     }
-    indexWorkspace(callback, token) {
-        if (!this._configOptions.indexing) {
-            return 0;
-        }
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            // Go through all workspace files to create indexing data.
-            // This will cause all files in the workspace to be parsed and bound. But
-            // _handleMemoryHighUsage will make sure we don't OOM and
-            // at the end of this method, we will drop all trees and symbol tables
-            // created due to indexing.
-            let count = 0;
-            const initiallyParsedSet = new Set();
-            for (const sourceFileInfo of this._sourceFileList) {
-                if (!sourceFileInfo.sourceFile.isParseRequired()) {
-                    initiallyParsedSet.add(sourceFileInfo);
-                }
-                if ((0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo) && !sourceFileInfo.sourceFile.isIndexingRequired()) {
-                    count++;
-                }
-            }
-            if (count >= exports.MaxWorkspaceIndexFileCount) {
-                // Already processed max files.
-                return 0;
-            }
-            for (const sourceFileInfo of this._sourceFileList) {
-                if (!(0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo) || !sourceFileInfo.sourceFile.isIndexingRequired()) {
-                    continue;
-                }
-                this._bindFile(sourceFileInfo);
-                const results = sourceFileInfo.sourceFile.index({ indexingForAutoImportMode: false }, token);
-                if (results) {
-                    if (++count > exports.MaxWorkspaceIndexFileCount) {
-                        this._console.warn(`Workspace indexing has hit its upper limit: 2000 files`);
-                        dropParseAndBindInfoCreatedForIndexing(this._sourceFileList, initiallyParsedSet);
-                        return count;
-                    }
-                    callback(sourceFileInfo.sourceFile.getFilePath(), results);
-                }
-                this._handleMemoryHighUsage();
-            }
-            dropParseAndBindInfoCreatedForIndexing(this._sourceFileList, initiallyParsedSet);
-            return count;
-        });
-        function dropParseAndBindInfoCreatedForIndexing(sourceFiles, initiallyParsedSet) {
-            for (const sourceFileInfo of sourceFiles) {
-                if (sourceFileInfo.sourceFile.isParseRequired() || initiallyParsedSet.has(sourceFileInfo)) {
-                    continue;
-                }
-                // Drop parse and bind info created during indexing.
-                sourceFileInfo.sourceFile.dropParseAndBindInfo();
-            }
-        }
-    }
     // This will allow the callback to execute a type evaluator with an associated
     // cancellation token and provide a read-only program.
     run(callback, token) {
@@ -559,6 +526,38 @@ class Program {
         const evaluator = (_a = this._evaluator) !== null && _a !== void 0 ? _a : this._createNewEvaluator();
         return evaluator.runWithCancellationToken(token, () => callback(this));
     }
+    // This will allow the callback to execute a type evaluator with an associated
+    // cancellation token and provide a mutable program. Should already be in edit mode when called.
+    runWithMutation(callback, token) {
+        var _a;
+        if (this._isEditMode) {
+            // Create a temporary mutator that doesn't talk to the
+            // background thread. In edit mode there is no background thread.
+            const mutator = {
+                addInterimFile: (f) => {
+                    return this.addInterimFile(f);
+                },
+                setFileOpened: (p, v, c, i, ch, r) => {
+                    this.setFileOpened(p, v, c, {
+                        isTracked: this.owns(p),
+                        ipythonMode: i,
+                        chainedFilePath: ch,
+                        realFilePath: r,
+                    });
+                },
+                updateOpenFileContents: (p, v, c, i, r) => {
+                    this.setFileOpened(p, v, c, {
+                        isTracked: this.owns(p),
+                        ipythonMode: i,
+                        chainedFilePath: undefined,
+                        realFilePath: r,
+                    });
+                },
+            };
+            const evaluator = (_a = this._evaluator) !== null && _a !== void 0 ? _a : this._createNewEvaluator();
+            evaluator.runWithCancellationToken(token, () => callback(this, mutator));
+        }
+    }
     getSourceMapper(filePath, token, mapCompiled, preferStubs) {
         const sourceFileInfo = this.getSourceFileInfo(filePath);
         const execEnv = this._configOptions.findExecEnvironment(filePath);
@@ -699,51 +698,6 @@ class Program {
             return fileContents.substr(textRange.start, textRange.length);
         });
     }
-    getAutoImports(filePath, range, similarityLimit, nameMap, options, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return [];
-        }
-        const sourceFile = sourceFileInfo.sourceFile;
-        const fileContents = sourceFile.getOpenFileContents();
-        if (fileContents === undefined) {
-            // this only works with opened file
-            return [];
-        }
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a;
-            this._bindFile(sourceFileInfo);
-            const parseTree = sourceFile.getParseResults();
-            const textRange = (0, positionUtils_1.convertRangeToTextRange)(range, parseTree.tokenizerOutput.lines);
-            if (!textRange) {
-                return [];
-            }
-            const currentNode = (0, parseTreeUtils_1.findNodeByOffset)(parseTree.parseTree, textRange.start);
-            if (!currentNode) {
-                return [];
-            }
-            const writtenWord = fileContents.substr(textRange.start, textRange.length);
-            const map = this._buildModuleSymbolsMap(sourceFileInfo, options.libraryMap, 
-            /* includeSymbolsFromIndices */ true, token);
-            options.patternMatcher =
-                (_a = options.patternMatcher) !== null && _a !== void 0 ? _a : ((p, t) => (0, stringUtils_1.computeCompletionSimilarity)(p, t) > similarityLimit);
-            const autoImporter = new autoImporter_1.AutoImporter(this._configOptions.findExecEnvironment(filePath), this._importResolver, parseTree, range.start, new completionProvider_1.CompletionMap(), map, options);
-            // Filter out any name that is already defined in the current scope.
-            const results = [];
-            const currentScope = (0, scopeUtils_1.getScopeForNode)(currentNode);
-            if (currentScope) {
-                const info = nameMap === null || nameMap === void 0 ? void 0 : nameMap.get(writtenWord);
-                if (info) {
-                    // No scope filter is needed since we only do exact match.
-                    (0, collectionUtils_1.appendArray)(results, autoImporter.getAutoImportCandidatesForAbbr(writtenWord, info, token));
-                }
-                results.push(...autoImporter
-                    .getAutoImportCandidates(writtenWord, similarityLimit, /* abbrFromUsers */ undefined, token)
-                    .filter((r) => !currentScope.lookUpSymbolRecursive(r.name)));
-            }
-            return results;
-        });
-    }
     getDiagnostics(options) {
         const fileDiagnostics = this._removeUnneededFiles();
         this._sourceFileList.forEach((sourceFileInfo) => {
@@ -788,396 +742,6 @@ class Program {
             return (0, textRange_1.doRangesIntersect)(diag.range, range);
         });
     }
-    getFileIndex(filePath, options, token) {
-        if (options.indexingForAutoImportMode) {
-            // Memory optimization. We only want to hold onto symbols
-            // usable outside when importSymbolsOnly is on.
-            const name = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
-            if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
-                return undefined;
-            }
-        }
-        this._handleMemoryHighUsage();
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a;
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            const content = (_a = sourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
-            if (options.indexingForAutoImportMode &&
-                !options.includeAllSymbols &&
-                !sourceFileInfo.sourceFile.isStubFile() &&
-                !sourceFileInfo.sourceFile.isThirdPartyPyTypedPresent()) {
-                // Perf optimization. if py file doesn't contain __all__
-                // No need to parse and bind.
-                if (content.indexOf('__all__') < 0) {
-                    return undefined;
-                }
-            }
-            this._bindFile(sourceFileInfo, content);
-            return sourceFileInfo.sourceFile.index(options, token);
-        });
-    }
-    addSymbolsForDocument(filePath, symbolList, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (sourceFileInfo) {
-                if (!sourceFileInfo.sourceFile.getCachedIndexResults()) {
-                    // If we already have cached index for this file, no need to bind this file.
-                    this._bindFile(sourceFileInfo);
-                }
-                sourceFileInfo.sourceFile.addHierarchicalSymbolsForDocument(symbolList, token);
-            }
-        });
-    }
-    reportSymbolsForWorkspace(query, reporter, token) {
-        this._runEvaluatorWithCancellationToken(token, () => {
-            // Don't do a search if the query is empty. We'll return
-            // too many results in this case.
-            if (!query) {
-                return;
-            }
-            // "Workspace symbols" searches symbols only from user code.
-            for (const sourceFileInfo of this._sourceFileList) {
-                if (!(0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo)) {
-                    continue;
-                }
-                if (!sourceFileInfo.sourceFile.getCachedIndexResults()) {
-                    // If we already have cached index for this file, no need to bind this file.
-                    this._bindFile(sourceFileInfo);
-                }
-                const symbolList = sourceFileInfo.sourceFile.getSymbolsForDocument(query, token);
-                if (symbolList.length > 0) {
-                    reporter(symbolList);
-                }
-                // This operation can consume significant memory, so check
-                // for situations where we need to discard the type cache.
-                this._handleMemoryHighUsage();
-            }
-        });
-    }
-    async getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, libraryMap, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
-        }
-        let sourceMapper;
-        const completionResult = this._logTracker.log(`completion at ${filePath}:${position.line}:${position.character}`, (ls) => {
-            var _a;
-            const result = this._runEvaluatorWithCancellationToken(token, () => {
-                this._bindFile(sourceFileInfo);
-                const execEnv = this._configOptions.findExecEnvironment(filePath);
-                sourceMapper = this._createSourceMapper(execEnv, token, sourceFileInfo, /* mapCompiled */ true);
-                return sourceFileInfo.sourceFile.getCompletionsForPosition(position, workspacePath, this._configOptions, this._importResolver, this._lookUpImport, this._evaluator, options, sourceMapper, nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), token);
-            });
-            ls.add(`found ${(_a = result === null || result === void 0 ? void 0 : result.completionMap.size) !== null && _a !== void 0 ? _a : 'null'} items`);
-            return result;
-        });
-        const completionResultsList = {
-            completionList: vscode_languageserver_types_1.CompletionList.create(completionResult === null || completionResult === void 0 ? void 0 : completionResult.completionMap.toArray()),
-            memberAccessInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.memberAccessInfo,
-            autoImportInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.autoImportInfo,
-            extensionInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.extensionInfo,
-        };
-        const parseResults = sourceFileInfo.sourceFile.getParseResults();
-        if ((parseResults === null || parseResults === void 0 ? void 0 : parseResults.parseTree) && (parseResults === null || parseResults === void 0 ? void 0 : parseResults.text)) {
-            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
-            if (offset !== undefined && sourceMapper) {
-                await Promise.all(extensibility_1.Extensions.getProgramExtensions(parseResults.parseTree).map((e) => {
-                    var _a;
-                    return (_a = e.completionListExtension) === null || _a === void 0 ? void 0 : _a.updateCompletionResults(this.evaluator, sourceMapper, options, completionResultsList, parseResults, offset, this._configOptions.functionSignatureDisplay, token);
-                }));
-            }
-        }
-        return completionResultsList;
-    }
-    resolveCompletionItem(filePath, completionItem, options, nameMap, libraryMap, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return;
-            }
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            sourceFileInfo.sourceFile.resolveCompletionItem(this._configOptions, this._importResolver, this._lookUpImport, this._evaluator, options, this._createSourceMapper(execEnv, token, sourceFileInfo, /* mapCompiled */ true), nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), completionItem, token);
-        });
-    }
-    renameModule(path, newPath, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            if ((0, pathUtils_1.isFile)(this.fileSystem, path)) {
-                const fileInfo = this.getSourceFileInfo(path);
-                if (!fileInfo) {
-                    return undefined;
-                }
-            }
-            const renameModuleProvider = renameModuleProvider_1.RenameModuleProvider.createForModule(this._importResolver, this._configOptions, this._evaluator, path, newPath, token);
-            if (!renameModuleProvider) {
-                return undefined;
-            }
-            this._processModuleReferences(renameModuleProvider, renameModuleProvider.lastModuleName, path);
-            return { edits: renameModuleProvider.getEdits(), fileOperations: [] };
-        });
-    }
-    moveSymbolAtPosition(filePath, newFilePath, position, options, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a, _b;
-            const sourceFileExt = (0, pathUtils_1.getFileExtension)(filePath);
-            const destFileExt = (0, pathUtils_1.getFileExtension)(newFilePath);
-            if (sourceFileExt.toLowerCase() !== destFileExt.toLowerCase()) {
-                // Don't allow moving a symbol from py to pyi or vice versa.
-                return undefined;
-            }
-            const fileInfo = this.getSourceFileInfo(filePath);
-            if (!fileInfo) {
-                return undefined;
-            }
-            const newFileInfo = this.getBoundSourceFileInfo(newFilePath);
-            if (fileInfo === newFileInfo) {
-                // Can't move symbol to the same file.
-                return undefined;
-            }
-            this._bindFile(fileInfo);
-            const parseResults = fileInfo.sourceFile.getParseResults();
-            if (!parseResults) {
-                return undefined;
-            }
-            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
-            if (offset === undefined) {
-                return undefined;
-            }
-            const node = (0, parseTreeUtils_1.findNodeByOffset)(parseResults.parseTree, offset);
-            if (node === undefined) {
-                return undefined;
-            }
-            // If this isn't a name node, there are no references to be found.
-            if (node.nodeType !== 38 /* Name */ ||
-                !renameModuleProvider_1.RenameModuleProvider.canMoveSymbol(this._configOptions, this._evaluator, node)) {
-                return undefined;
-            }
-            // We will try to
-            // 1. Find symbol to move.
-            // 2. Update all references to the symbol to new location.
-            // 3. Remove the existing symbol.
-            // 4. Insert the symbol to the destination module.
-            // 5. Insert imports required for the symbol moved to the destination module.
-            // 6. Remove import no longer needed from the original module.
-            //
-            // Here all changes are done to edits, no features in LS will apply changes to
-            // program directly. All modification is done through LSP by a edit request so
-            // things like undo or edit stacks UI works.
-            // 1. Find symbol to move.
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            const declarations = documentSymbolCollector_1.DocumentSymbolCollector.getDeclarationsForNode(node, this._evaluator, 
-            /* resolveLocalNames */ false, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Rename, token, this._createSourceMapper(execEnv, token, fileInfo));
-            const renameModuleProvider = renameModuleProvider_1.RenameModuleProvider.createForSymbol(this._importResolver, this._configOptions, this._evaluator, filePath, newFilePath, declarations, token);
-            if (!renameModuleProvider) {
-                return undefined;
-            }
-            // 2. Update affected references.
-            this._processModuleReferences(renameModuleProvider, node.value, filePath);
-            // 3. Remove existing symbols.
-            const sourceDecl = renameModuleProvider.declarations.find((d) => d.node && (0, pathUtils_1.getFileExtension)(d.path) === sourceFileExt);
-            if (!sourceDecl) {
-                // Can't find symbol we can move.
-                return undefined;
-            }
-            const symbolRange = renameModuleProvider_1.RenameModuleProvider.getSymbolTextRange(parseResults, sourceDecl);
-            const importAdder = new importAdder_1.ImportAdder(this._configOptions, this._importResolver, this._evaluator);
-            const collectedImports = importAdder.collectImportsForSymbolsUsed(parseResults, symbolRange, token);
-            let insertionPoint = 0;
-            let insertionIndentation = 0;
-            const newFileParseResults = newFileInfo === null || newFileInfo === void 0 ? void 0 : newFileInfo.sourceFile.getParseResults();
-            if (newFileParseResults) {
-                const insertBefore = renameModuleProvider.tryGetFirstSymbolUsage(newFileParseResults);
-                insertionPoint = (0, insertionPointUtils_1.getInsertionPointForSymbolUnderModule)(this._evaluator, newFileParseResults, node.value, {
-                    symbolDeclToIgnore: sourceDecl.path,
-                    insertBefore,
-                });
-                if (insertionPoint === undefined) {
-                    // No place to insert the symbol.
-                    return undefined;
-                }
-                insertionIndentation = (0, indentationUtils_1.getModuleStatementIndentation)(newFileParseResults);
-            }
-            const reindentResult = (0, indentationUtils_1.reindentSpan)(parseResults, symbolRange, insertionIndentation);
-            const fullRange = renameModuleProvider_1.RenameModuleProvider.getSymbolFullStatementTextRange(parseResults, sourceDecl);
-            renameModuleProvider.textEditTracker.addEdit(filePath, (0, positionUtils_1.convertTextRangeToRange)(textRange_1.TextRange.combine([reindentResult.originalSpan, fullRange]), parseResults.tokenizerOutput.lines), '');
-            // 4. Add the symbol to the destination file.
-            const fileOperations = [];
-            let codeSnippetToInsert = reindentResult.text;
-            if (newFileParseResults) {
-                const range = (0, positionUtils_1.convertTextRangeToRange)({ start: insertionPoint, length: 0 }, newFileParseResults.tokenizerOutput.lines);
-                // If we are adding at the end of line (ex, end of a file),
-                // add new lines.
-                const newLinesToAdd = _getNumberOfBlankLinesToInsert(newFileParseResults, sourceDecl, range.end);
-                codeSnippetToInsert = '\n'.repeat(newLinesToAdd) + codeSnippetToInsert;
-                renameModuleProvider.textEditTracker.addEdit(newFilePath, range, codeSnippetToInsert);
-            }
-            else {
-                fileOperations.push({ kind: 'create', filePath: newFilePath });
-                renameModuleProvider.textEditTracker.addEdit(newFilePath, (0, textRange_1.getEmptyRange)(), codeSnippetToInsert);
-            }
-            // 5. Insert imports required for the symbol moved to the destination module.
-            //
-            // Since step 5 and 6 can create nested edits, we clone the program and apply all changes to re-calculate
-            // edits we need to apply to the destination file. The same workflow as `fix all` but done in program level
-            // not service level.
-            const cloned = this.clone();
-            let edits = renameModuleProvider.getEdits();
-            const textAfterSymbolAdded = (0, workspaceEditUtils_1.applyTextEditsToString)(edits.filter((v) => v.filePath === newFilePath), (_a = newFileParseResults === null || newFileParseResults === void 0 ? void 0 : newFileParseResults.tokenizerOutput.lines) !== null && _a !== void 0 ? _a : new textRangeCollection_1.TextRangeCollection([]), (_b = newFileInfo === null || newFileInfo === void 0 ? void 0 : newFileInfo.sourceFile.getFileContent()) !== null && _b !== void 0 ? _b : '');
-            _updateFileContent(cloned, newFilePath, textAfterSymbolAdded);
-            const textAfterImportsAdded = _tryGetTextAfterImportsAdded(cloned, newFilePath, collectedImports, insertionPoint, token);
-            edits = _updateFileEditActions(edits, newFilePath, newFileParseResults, textAfterSymbolAdded, textAfterImportsAdded);
-            // 6. Remove imports no longer required from original module.
-            const textAfterSymbolRemoved = (0, workspaceEditUtils_1.applyTextEditsToString)(edits.filter((v) => v.filePath === filePath), parseResults.tokenizerOutput.lines, fileInfo.sourceFile.getFileContent());
-            _updateFileContent(cloned, filePath, textAfterSymbolRemoved);
-            const textAfterUnusedImportsRemoved = _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, collectedImports, 0, token);
-            edits = _updateFileEditActions(edits, filePath, parseResults, textAfterSymbolRemoved, textAfterUnusedImportsRemoved);
-            cloned.dispose();
-            return {
-                edits,
-                fileOperations,
-            };
-            function _updateFileEditActions(edits, filePath, parseResults, oldText, newText) {
-                if (newText === undefined || oldText === newText) {
-                    return edits;
-                }
-                // There were nested edits. Replace whole file.
-                edits = edits.filter((v) => v.filePath !== filePath);
-                edits.push({
-                    filePath,
-                    range: parseResults
-                        ? (0, positionUtils_1.convertTextRangeToRange)(parseResults.parseTree, parseResults.tokenizerOutput.lines)
-                        : (0, textRange_1.getEmptyRange)(),
-                    replacementText: newText,
-                });
-                return edits;
-            }
-            function _tryGetTextAfterImportsAdded(cloned, filePath, importData, insertionPoint, token) {
-                const sourceFile = cloned.getBoundSourceFile(filePath);
-                const parseResults = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.getParseResults();
-                if (!parseResults) {
-                    return undefined;
-                }
-                const insertAddEdits = importAdder.applyImports(importData, filePath, parseResults, insertionPoint, options.importFormat, token);
-                return (0, workspaceEditUtils_1.applyTextEditsToString)(insertAddEdits, parseResults.tokenizerOutput.lines, sourceFile.getFileContent());
-            }
-            function _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, importData, attempt, token) {
-                var _a;
-                (0, cancellationUtils_1.throwIfCancellationRequested)(token);
-                cloned.analyzeFile(filePath, token);
-                const sourceFile = cloned.getBoundSourceFile(filePath);
-                const parseResults = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.getParseResults();
-                if (!parseResults) {
-                    return undefined;
-                }
-                const tracker = new textEditTracker_1.TextEditTracker();
-                for (const diagnostic of cloned
-                    .getDiagnosticsForRange(filePath, (0, positionUtils_1.convertTextRangeToRange)(parseResults.parseTree, parseResults.tokenizerOutput.lines))
-                    .filter((d) => {
-                    var _a;
-                    return d.category === 3 /* UnusedCode */ &&
-                        ((_a = d.getActions()) === null || _a === void 0 ? void 0 : _a.some((a) => a.action === "pyright.unusedImport" /* unusedImport */));
-                })) {
-                    const nameNode = (0, parseTreeUtils_1.findNodeByPosition)(parseResults.parseTree, diagnostic.range.start, parseResults.tokenizerOutput.lines);
-                    if ((nameNode === null || nameNode === void 0 ? void 0 : nameNode.nodeType) !== 38 /* Name */) {
-                        continue;
-                    }
-                    // decl is synthesized. there is no node associated with the decl.
-                    // ex) import a or import a.b
-                    const dottedName1 = ((_a = nameNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 37 /* ModuleName */ ? nameNode.parent.nameParts : [nameNode];
-                    for (const [decl, names] of importData.declarations) {
-                        if (decl.node) {
-                            if (textRange_1.TextRange.containsRange(decl.node, nameNode)) {
-                                tracker.removeNodes({ node: nameNode, parseResults: parseResults });
-                                break;
-                            }
-                        }
-                        const dottedName2 = (0, parseTreeUtils_1.getDottedName)((0, parseTreeUtils_1.getDottedNameWithGivenNodeAsLastName)(names[0]));
-                        if (dottedName2 && (0, collectionUtils_1.arrayEquals)(dottedName1, dottedName2, (e1, e2) => e1.value === e2.value)) {
-                            tracker.removeNodes({ node: nameNode, parseResults: parseResults });
-                            break;
-                        }
-                    }
-                }
-                const oldText = sourceFile.getFileContent();
-                const newText = (0, workspaceEditUtils_1.applyTextEditsToString)(tracker.getEdits(token).filter((v) => v.filePath === filePath), parseResults.tokenizerOutput.lines, oldText);
-                // We will attempt to remove unused imports multiple times since removing 1 unused import
-                // could make another import unused. This is due to how we calculate which import is not used.
-                // ex) import os, os.path, os.path.xxx
-                // `os.path` and `os.path.xxx` will be marked as used due to `import os`.
-                // once `os` is removed `os.path` will be marked as unused and so on.
-                // We will attempt to remove those chained unused imports up to 10 chain.
-                if (attempt > 10 || oldText === newText) {
-                    return newText;
-                }
-                _updateFileContent(cloned, filePath, newText);
-                return _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, importData, attempt + 1, token);
-            }
-        });
-        function _updateFileContent(cloned, filePath, text) {
-            var _a, _b;
-            const info = cloned.getSourceFileInfo(filePath);
-            const version = info ? ((_a = info.sourceFile.getClientVersion()) !== null && _a !== void 0 ? _a : 0) + 1 : 0;
-            const chainedFilePath = info ? (_b = info.chainedSourceFile) === null || _b === void 0 ? void 0 : _b.sourceFile.getFilePath() : undefined;
-            const ipythonMode = info ? info.sourceFile.getIPythonMode() : sourceFile_1.IPythonMode.None;
-            const isTracked = info ? info.isTracked : true;
-            const realFilePath = info ? info.sourceFile.getRealFilePath() : filePath;
-            cloned.setFileOpened(filePath, version, text, {
-                chainedFilePath,
-                ipythonMode,
-                isTracked,
-                realFilePath,
-            });
-        }
-        function _getNumberOfBlankLinesToInsert(parseResults, decl, position) {
-            if (position.line === 0 && position.character === 0) {
-                return 0;
-            }
-            let previousStatement;
-            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
-            if (offset && parseResults.parseTree.statements.length > 0) {
-                previousStatement = parseResults.parseTree.statements.reduce((prev, curr) => offset < curr.start ? prev : curr);
-            }
-            // This basically try to add some blank lines after the last line with text.
-            let linesToAdd = 0;
-            if (previousStatement) {
-                if ((0, declaration_1.isVariableDeclaration)(decl)) {
-                    switch (previousStatement.nodeType) {
-                        case 47 /* StatementList */:
-                            // Small statement such as call, assignment, etc.
-                            linesToAdd = 0;
-                            break;
-                        case 10 /* Class */:
-                        case 28 /* Function */:
-                            linesToAdd = 2;
-                            break;
-                        default:
-                            // any other statement such as if, while, etc. we will add 1 blank line.
-                            linesToAdd = 1;
-                    }
-                }
-                else {
-                    linesToAdd = 2;
-                }
-            }
-            // If the position is not at the beginning of the line, we need to add 1 more '\n'
-            // to start from blank line.
-            linesToAdd += position.character !== 0 ? 1 : 0;
-            // If there are already blank lines, we only add the difference.
-            const desiredBlankLines = linesToAdd;
-            const startingLine = position.character !== 0 ? position.line : position.line - 1;
-            for (let i = 0; i < desiredBlankLines; i++) {
-                const currentLine = startingLine - i;
-                if (currentLine < 0 || !(0, parseTreeUtils_1.isBlankLine)(parseResults, currentLine)) {
-                    break;
-                }
-                linesToAdd--;
-            }
-            return linesToAdd;
-        }
-    }
     clone() {
         var _a, _b;
         const program = new Program(this._importResolver, this._configOptions, this._console, new logTracker_1.LogTracker(this._console, 'Cloned'));
@@ -1200,123 +764,6 @@ class Program {
         }
         return program;
     }
-    canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const referencesResult = this._getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token);
-            if (!referencesResult) {
-                return undefined;
-            }
-            if (referencesResult.containsOnlyImportDecls &&
-                !this._supportRenameModule(referencesResult.declarations, isDefaultWorkspace)) {
-                return undefined;
-            }
-            const renameMode = this._getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace);
-            if (renameMode === 'none') {
-                return undefined;
-            }
-            // Return the range of the symbol.
-            const parseResult = sourceFileInfo.sourceFile.getParseResults();
-            return {
-                range: (0, positionUtils_1.convertTextRangeToRange)(referencesResult.nodeAtOffset, parseResult.tokenizerOutput.lines),
-                declarations: referencesResult.declarations,
-            };
-        });
-    }
-    renameSymbolAtPosition(filePath, position, newName, isDefaultWorkspace, allowModuleRename, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a;
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const referencesResult = this._getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token);
-            if (!referencesResult) {
-                return undefined;
-            }
-            if (referencesResult.containsOnlyImportDecls) {
-                // All decls must be on a user file.
-                if (!this._supportRenameModule(referencesResult.declarations, isDefaultWorkspace)) {
-                    return undefined;
-                }
-                const moduleInfo = renameModuleProvider_1.RenameModuleProvider.getRenameModulePathInfo(renameModuleProvider_1.RenameModuleProvider.getRenameModulePath(referencesResult.declarations), newName);
-                if (!moduleInfo) {
-                    // Can't figure out module to rename.
-                    return undefined;
-                }
-                const editActions = this.renameModule(moduleInfo.filePath, moduleInfo.newFilePath, token);
-                // Add file system rename.
-                editActions === null || editActions === void 0 ? void 0 : editActions.fileOperations.push({
-                    kind: 'rename',
-                    oldFilePath: moduleInfo.filePath,
-                    newFilePath: moduleInfo.newFilePath,
-                });
-                if ((0, sourceMapper_1.isStubFile)(moduleInfo.filePath)) {
-                    const matchingFiles = this._importResolver.getSourceFilesFromStub(moduleInfo.filePath, this._configOptions.findExecEnvironment(filePath), 
-                    /* mapCompiled */ false);
-                    for (const matchingFile of matchingFiles) {
-                        const matchingFileInfo = renameModuleProvider_1.RenameModuleProvider.getRenameModulePathInfo(matchingFile, newName);
-                        if (matchingFileInfo) {
-                            editActions === null || editActions === void 0 ? void 0 : editActions.fileOperations.push({
-                                kind: 'rename',
-                                oldFilePath: matchingFileInfo.filePath,
-                                newFilePath: matchingFileInfo.newFilePath,
-                            });
-                        }
-                    }
-                }
-                return editActions;
-            }
-            const referenceProvider = new referencesProvider_1.ReferencesProvider(this, token);
-            const renameMode = this._getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace);
-            switch (renameMode) {
-                case 'singleFileMode':
-                    referenceProvider.addReferencesToResult(sourceFileInfo.sourceFile.getFilePath(), 
-                    /* includeDeclaration */ true, referencesResult);
-                    break;
-                case 'multiFileMode': {
-                    for (const curSourceFileInfo of this._sourceFileList) {
-                        // Make sure we only add user code to the references to prevent us
-                        // from accidentally changing third party library or type stub.
-                        if ((0, sourceFileInfoUtils_1.isUserCode)(curSourceFileInfo)) {
-                            // Make sure searching symbol name exists in the file.
-                            const content = (_a = curSourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
-                            if (!referencesResult.symbolNames.some((s) => content.search(s) >= 0)) {
-                                continue;
-                            }
-                            this._bindFile(curSourceFileInfo, content);
-                            referenceProvider.addReferencesToResult(curSourceFileInfo.sourceFile.getFilePath(), 
-                            /* includeDeclaration */ true, referencesResult);
-                        }
-                        // This operation can consume significant memory, so check
-                        // for situations where we need to discard the type cache.
-                        this._handleMemoryHighUsage();
-                    }
-                    break;
-                }
-                case 'none':
-                    // Rename is not allowed.
-                    // ex) rename symbols from libraries.
-                    return undefined;
-                default:
-                    (0, debug_1.assertNever)(renameMode);
-            }
-            const edits = [];
-            referencesResult.locations.forEach((loc) => {
-                edits.push({
-                    filePath: loc.path,
-                    range: loc.range,
-                    replacementText: newName,
-                });
-            });
-            return { edits, fileOperations: [] };
-        });
-    }
     // Returns a value from 0 to 1 (or more) indicating how "full" the cache is
     // relative to some predetermined high-water mark. We'll compute this value
     // based on two easy-to-compute metrics: the number of entries in the type
@@ -1334,90 +781,6 @@ class Program {
         this._parsedFileCount = 0;
         extensibility_1.Extensions.getProgramExtensions(this.rootPath).forEach((e) => (e.clearCache ? e.clearCache() : null));
     }
-    test_createSourceMapper(execEnv, from) {
-        return this._createSourceMapper(execEnv, vscode_languageserver_1.CancellationToken.None, /* from */ from, /* mapCompiled */ false);
-    }
-    _getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace) {
-        // We have 2 different cases
-        // Single file mode.
-        // 1. rename on default workspace (ex, standalone file mode).
-        // 2. rename local symbols.
-        // 3. rename symbols defined in the non user open file.
-        //
-        // and Multi file mode.
-        // 1. rename public symbols defined in user files on regular workspace (ex, open folder mode).
-        const userFile = (0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo);
-        if (isDefaultWorkspace ||
-            (userFile && !referencesResult.requiresGlobalSearch) ||
-            (!userFile &&
-                sourceFileInfo.isOpenByClient &&
-                referencesResult.declarations.every((d) => this.getSourceFileInfo(d.path) === sourceFileInfo))) {
-            return 'singleFileMode';
-        }
-        if (referencesResult.declarations.every((d) => (0, sourceFileInfoUtils_1.isUserCode)(this.getSourceFileInfo(d.path)))) {
-            return 'multiFileMode';
-        }
-        // Rename is not allowed.
-        // ex) rename symbols from libraries.
-        return 'none';
-    }
-    _supportRenameModule(declarations, isDefaultWorkspace) {
-        // Rename module is not supported for standalone file and all decls must be on a user file.
-        return !isDefaultWorkspace && declarations.every((d) => (0, sourceFileInfoUtils_1.isUserCode)(this.getSourceFileInfo(d.path)));
-    }
-    _getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token) {
-        const execEnv = this._configOptions.findExecEnvironment(filePath);
-        const referencesResult = this._getDeclarationForPosition(sourceFileInfo, position, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Rename, this._createSourceMapper(execEnv, token), token);
-        if (!referencesResult) {
-            return undefined;
-        }
-        if (allowModuleRename && referencesResult.containsOnlyImportDecls) {
-            return referencesResult;
-        }
-        if (referencesResult.nonImportDeclarations.length === 0) {
-            // There is no symbol we can rename.
-            return undefined;
-        }
-        // Use declarations that doesn't contain import decls.
-        return new referencesProvider_1.ReferencesResult(referencesResult.requiresGlobalSearch, referencesResult.nodeAtOffset, referencesResult.symbolNames, referencesResult.nonImportDeclarations, referencesResult.useCase);
-    }
-    _getDeclarationForPosition(sourceFileInfo, position, useCase, sourceMapper, token, reporter) {
-        // If we have no completed analysis job, there's nothing to do.
-        const parseResults = sourceFileInfo.sourceFile.getParseResults();
-        if (!parseResults) {
-            return undefined;
-        }
-        return referencesProvider_1.ReferencesProvider.getDeclarationForPosition(sourceMapper, parseResults, sourceFileInfo.sourceFile.getFilePath(), position, this._evaluator, reporter, useCase, token, Array.from((0, sourceFileInfoUtils_1.collectImportedByFiles)(sourceFileInfo)).map((fileInfo) => fileInfo.sourceFile));
-    }
-    _processModuleReferences(renameModuleProvider, filteringText, currentFilePath) {
-        var _a;
-        // _sourceFileList contains every user files that match "include" pattern including
-        // py file even if corresponding pyi exists.
-        for (const currentFileInfo of this._sourceFileList) {
-            // Make sure we only touch user code to prevent us
-            // from accidentally changing third party library or type stub.
-            if (!(0, sourceFileInfoUtils_1.isUserCode)(currentFileInfo)) {
-                continue;
-            }
-            // If module name isn't mentioned in the current file, skip the file
-            // except the file that got actually renamed/moved.
-            // The file that got moved might have relative import paths we need to update.
-            const filePath = currentFileInfo.sourceFile.getFilePath();
-            const content = (_a = currentFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
-            if (filePath !== currentFilePath && content.indexOf(filteringText) < 0) {
-                continue;
-            }
-            this._bindFile(currentFileInfo, content);
-            const parseResult = currentFileInfo.sourceFile.getParseResults();
-            if (!parseResult) {
-                continue;
-            }
-            renameModuleProvider.renameReferences(parseResult);
-            // This operation can consume significant memory, so check
-            // for situations where we need to discard the type cache.
-            this._handleMemoryHighUsage();
-        }
-    }
     _handleMemoryHighUsage() {
         const cacheUsage = this._cacheManager.getCacheUsage();
         // If the total cache has exceeded 75%, determine whether we should empty
@@ -1769,7 +1132,7 @@ class Program {
                 let importedFileInfo = this.getSourceFileInfo(importInfo.path);
                 if (!importedFileInfo) {
                     const importName = this._getImportNameForFile(importInfo.path);
-                    const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, importInfo.path, importName, importInfo.isThirdPartyImport, importInfo.isPyTypedPresent, this._console, this._logTracker);
+                    const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, importInfo.path, importName, importInfo.isThirdPartyImport, importInfo.isPyTypedPresent, this._isEditMode, this._console, this._logTracker);
                     importedFileInfo = {
                         sourceFile,
                         isTracked: false,
@@ -1878,7 +1241,7 @@ class Program {
         const importName = this._getImportNameForFile(filePath);
         const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, 
         /* isThirdPartyImport */ false, 
-        /* isInPyTypedPackage */ false, this._console, this._logTracker);
+        /* isInPyTypedPackage */ false, this._isEditMode, this._console, this._logTracker);
         const sourceFileInfo = {
             sourceFile,
             isTracked: false,
@@ -2028,31 +1391,6 @@ class Program {
         });
         return effectiveFutureImports;
     }
-    // Build a map of all modules within this program and the module-
-    // level scope that contains the symbol table for the module.
-    _buildModuleSymbolsMap(sourceFileToExclude, libraryMap, includeSymbolsFromIndices, token) {
-        // If we have library map, always use the map for library symbols.
-        const predicate = (s) => {
-            if (!libraryMap) {
-                // We don't have any prebuilt indices, so we need to include
-                // all files.
-                return true;
-            }
-            if (!this._configOptions.indexing) {
-                // We have some prebuilt indices such as stdlib, but indexing is disabled.
-                // Include files we don't have prebuilt indices.
-                return libraryMap.get(s.sourceFile.getFilePath()) === undefined;
-            }
-            // We have prebuilt indices for third party libraries. Include only
-            // user files.
-            return (0, sourceFileInfoUtils_1.isUserCode)(s);
-        };
-        // Only include import alias from user files if indexing is off for now.
-        // Currently, when indexing is off, we don't do import alias deduplication, so
-        // adding import alias is cheap. But when indexing is on, we do deduplication, which
-        // require resolveAliasDeclaration that can cause more files to be parsed and bound.
-        return (0, autoImporter_1.buildModuleSymbolsMap)(this._sourceFileList.filter((s) => s !== sourceFileToExclude && predicate(s)), includeSymbolsFromIndices, token);
-    }
     _shouldCheckFile(fileInfo) {
         // Always do a full checking for a file that's open in the editor.
         if (fileInfo.isOpenByClient) {