@zzzen/pyright-internal 1.2.0-dev.20230212 → 1.2.0-dev.20230226

package/dist/analyzer/program.js

@@ -33,8 +33,10 @@ const vscode_languageserver_1 = require("vscode-languageserver");
 const vscode_languageserver_types_1 = require("vscode-languageserver-types");
 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_1 = require("../common/debug");
+const diagnosticSink_1 = require("../common/diagnosticSink");
 const extensibility_1 = require("../common/extensibility");
 const logTracker_1 = require("../common/logTracker");
 const pathUtils_1 = require("../common/pathUtils");
@@ -42,10 +44,14 @@ const positionUtils_1 = require("../common/positionUtils");
 const stringUtils_1 = require("../common/stringUtils");
 const textRange_1 = require("../common/textRange");
 const timing_1 = require("../common/timing");
+const workspaceEditUtils_1 = require("../common/workspaceEditUtils");
 const autoImporter_1 = require("../languageService/autoImporter");
 const callHierarchyProvider_1 = require("../languageService/callHierarchyProvider");
 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"));
@@ -137,6 +143,8 @@ class Program {
         this._cacheManager = cacheManager !== null && cacheManager !== void 0 ? cacheManager : new cacheManager_1.CacheManager();
         this._cacheManager.registerCacheOwner(this);
         this._createNewEvaluator();
+        this._id = Program._nextId;
+        Program._nextId += 1;
     }
     dispose() {
         this._cacheManager.unregisterCacheOwner(this);
@@ -147,6 +155,9 @@ class Program {
     get console() {
         return this._console;
     }
+    get id() {
+        return this._id;
+    }
     setConfigOptions(configOptions) {
         this._configOptions = configOptions;
         this._importResolver.setConfigOptions(configOptions);
@@ -208,6 +219,15 @@ class Program {
             this.addTrackedFile(filePath, isThirdPartyImport, isInPyTypedPackage);
         });
     }
+    addInterimFile(filePath) {
+        // Double check not already there.
+        let fileInfo = this.getSourceFileInfo(filePath);
+        if (!fileInfo) {
+            fileInfo = this._createInterimFileInfo(filePath);
+            this._addToSourceFileListAndMap(fileInfo);
+        }
+        return fileInfo;
+    }
     addTrackedFile(filePath, isThirdPartyImport = false, isInPyTypedPackage = false) {
         let sourceFileInfo = this.getSourceFileInfo(filePath);
         const importName = this._getImportNameForFile(filePath);
@@ -269,8 +289,6 @@ class Program {
             sourceFileInfo.diagnosticsVersion = 0;
         }
         sourceFileInfo.sourceFile.setClientVersion(version, contents);
-        // Tell any extensions that this source file changed.
-        (0, extensibility_1.getExtensions)().forEach((e) => (e.sourceFileChanged ? e.sourceFileChanged(sourceFileInfo) : undefined));
     }
     getChainedFilePath(filePath) {
         var _a;
@@ -358,8 +376,8 @@ class Program {
     getUserFileCount() {
         return this._sourceFileList.filter((s) => (0, sourceFileInfoUtils_1.isUserCode)(s)).length;
     }
-    getTracked() {
-        return this._sourceFileList.filter((s) => s.isTracked);
+    getUserFiles() {
+        return this._sourceFileList.filter((s) => (0, sourceFileInfoUtils_1.isUserCode)(s));
     }
     getOpened() {
         return this._sourceFileList.filter((s) => s.isOpenByClient);
@@ -388,6 +406,15 @@ class Program {
         const normalized = (0, pathUtils_1.normalizePathCase)(this._fs, folder);
         return this._sourceFileList.some((i) => i.sourceFile.getFilePath().startsWith(normalized));
     }
+    owns(filePath) {
+        const fileInfo = this.getSourceFileInfo(filePath);
+        if (fileInfo) {
+            // If we already determined whether the file is tracked or not, don't do it again.
+            // This will make sure we have consistent look at the state once it is loaded to the memory.
+            return fileInfo.isTracked;
+        }
+        return (0, configOptions_1.matchFileSpecs)(this._configOptions, filePath);
+    }
     getSourceFile(filePath) {
         const sourceFileInfo = this.getSourceFileInfo(filePath);
         if (!sourceFileInfo) {
@@ -402,12 +429,12 @@ class Program {
     getSourceFileInfo(filePath) {
         return this._sourceFileMap.get((0, pathUtils_1.normalizePathCase)(this._fs, filePath));
     }
-    getBoundSourceFileInfo(filePath) {
+    getBoundSourceFileInfo(filePath, content, force) {
         const sourceFileInfo = this.getSourceFileInfo(filePath);
         if (!sourceFileInfo) {
             return undefined;
         }
-        this._bindFile(sourceFileInfo);
+        this._bindFile(sourceFileInfo, content, force);
         return sourceFileInfo;
     }
     // Performs parsing and analysis of any source files in the program
@@ -658,8 +685,7 @@ class Program {
     _addShadowedFile(stubFile, shadowImplPath) {
         let shadowFileInfo = this.getSourceFileInfo(shadowImplPath);
         if (!shadowFileInfo) {
-            shadowFileInfo = this._createInterimFileInfo(shadowImplPath);
-            this._addToSourceFileListAndMap(shadowFileInfo);
+            shadowFileInfo = this.addInterimFile(shadowImplPath);
         }
         if (!shadowFileInfo.shadows.includes(stubFile)) {
             shadowFileInfo.shadows.push(stubFile);
@@ -707,8 +733,8 @@ class Program {
             : undefined);
         return this._evaluator;
     }
-    _parseFile(fileToParse, content) {
-        if (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired()) {
+    _parseFile(fileToParse, content, force) {
+        if (!force && (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired())) {
             return;
         }
         if (fileToParse.sourceFile.parse(this._configOptions, this._importResolver, content)) {
@@ -727,12 +753,12 @@ class Program {
     }
     // Binds the specified file and all of its dependencies, recursively. If
     // it runs out of time, it returns true. If it completes, it returns false.
-    _bindFile(fileToAnalyze, content) {
+    _bindFile(fileToAnalyze, content, force) {
         var _a, _b;
-        if (!this._isFileNeeded(fileToAnalyze) || !fileToAnalyze.sourceFile.isBindingRequired()) {
+        if (!force && (!this._isFileNeeded(fileToAnalyze) || !fileToAnalyze.sourceFile.isBindingRequired())) {
             return;
         }
-        this._parseFile(fileToAnalyze, content);
+        this._parseFile(fileToAnalyze, content, force);
         const getScopeIfAvailable = (fileInfo) => {
             if (!fileInfo || fileInfo === fileToAnalyze) {
                 return undefined;
@@ -1316,14 +1342,11 @@ class Program {
             autoImportInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.autoImportInfo,
             extensionInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.extensionInfo,
         };
-        if (!(0, extensibility_1.getExtensions)().some((e) => e.completionListExtension)) {
-            return completionResultsList;
-        }
         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((0, extensibility_1.getExtensions)().map((e) => {
+                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);
                 }));
@@ -1358,12 +1381,23 @@ class Program {
             return { edits: renameModuleProvider.getEdits(), fileOperations: [] };
         });
     }
-    moveSymbolAtPosition(filePath, newFilePath, position, token) {
+    moveSymbolAtPosition(filePath, newFilePath, position, options, token) {
         return this._runEvaluatorWithCancellationToken(token, () => {
+            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) {
@@ -1378,7 +1412,7 @@ class Program {
                 return undefined;
             }
             // If this isn't a name node, there are no references to be found.
-            if (node.nodeType !== 38 /* Name */) {
+            if (node.nodeType !== 38 /* Name */ || !renameModuleProvider_1.RenameModuleProvider.canMoveSymbol(this._evaluator, node)) {
                 return undefined;
             }
             const execEnv = this._configOptions.findExecEnvironment(filePath);
@@ -1389,8 +1423,71 @@ class Program {
                 return undefined;
             }
             this._processModuleReferences(renameModuleProvider, node.value, filePath);
-            return { edits: renameModuleProvider.getEdits(), fileOperations: [] };
+            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), '');
+            const fileOperations = [];
+            let codeSnippetToInsert = reindentResult.text;
+            if (newFileParseResults) {
+                // TODO: We need to "add import" statement for symbols defined in the destination file
+                //       if we couldn't find insertion point where all constraints are met.
+                //       For example, if the symbol we are moving is used before other symbols it references are declared.
+                importAdder.applyImportsTo(collectedimports, newFileParseResults, options.importFormat, renameModuleProvider.textEditTracker, token);
+                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, range.end);
+                codeSnippetToInsert = '\n'.repeat(newLinesToAdd) + codeSnippetToInsert;
+                renameModuleProvider.textEditTracker.addEdit(newFilePath, range, codeSnippetToInsert);
+            }
+            else {
+                fileOperations.push({ kind: 'create', filePath: newFilePath });
+                const tempParseResults = (0, sourceFile_1.parseFile)(this._configOptions, newFilePath, codeSnippetToInsert, sourceFile_1.IPythonMode.None, new diagnosticSink_1.DiagnosticSink());
+                const insertAddEdits = importAdder.applyImports(collectedimports, newFilePath, tempParseResults, insertionPoint, options.importFormat, token);
+                const updateContent = (0, workspaceEditUtils_1.applyTextEditsToString)(insertAddEdits, tempParseResults.tokenizerOutput.lines, codeSnippetToInsert);
+                renameModuleProvider.textEditTracker.addEdit(newFilePath, (0, textRange_1.getEmptyRange)(), updateContent);
+            }
+            return {
+                edits: renameModuleProvider.getEdits(),
+                fileOperations,
+            };
         });
+        function _getNumberOfBlankLinesToInsert(parseResults, position) {
+            // This basically try to add 2 blanks lines before previous line with text.
+            if (position.line === 0 && position.character === 0) {
+                return 0;
+            }
+            const linesToAdd = position.line > 0 && (0, parseTreeUtils_1.isBlankLine)(parseResults, position.line - 1)
+                ? position.line > 1 && (0, parseTreeUtils_1.isBlankLine)(parseResults, position.line - 2)
+                    ? 0
+                    : 1
+                : 2;
+            // Add one more line for the line that position is on if it is not blank.
+            return position.character !== 0 ? linesToAdd + 1 : linesToAdd;
+        }
     }
     canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token) {
         return this._runEvaluatorWithCancellationToken(token, () => {
@@ -1584,6 +1681,7 @@ class Program {
         this._createNewEvaluator();
         this._discardCachedParseResults();
         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);
@@ -1655,7 +1753,7 @@ class Program {
             if (!parseResult) {
                 continue;
             }
-            renameModuleProvider.renameReferences(filePath, parseResult);
+            renameModuleProvider.renameReferences(parseResult);
             // This operation can consume significant memory, so check
             // for situations where we need to discard the type cache.
             this._handleMemoryHighUsage();
@@ -1814,8 +1912,7 @@ class Program {
                 // Special case for import statement.
                 // ex) import X.Y
                 // SourceFile for X might not be in memory since import `X.Y` only brings in Y
-                stubFileInfo = this._createInterimFileInfo(stubFilePath);
-                this._addToSourceFileListAndMap(stubFileInfo);
+                stubFileInfo = this.addInterimFile(stubFilePath);
             }
             this._addShadowedFile(stubFileInfo, implFilePath);
             return this.getBoundSourceFile(implFilePath);
@@ -1825,8 +1922,7 @@ class Program {
                 // Special case for import statement.
                 // ex) import X.Y
                 // SourceFile for X might not be in memory since import `X.Y` only brings in Y
-                fileInfo = this._createInterimFileInfo(f);
-                this._addToSourceFileListAndMap(fileInfo);
+                fileInfo = this.addInterimFile(f);
                 // Even though this file is not referenced by anything, make sure
                 // we have parse tree for doc string.
                 fileInfo.sourceFile.parse(this._configOptions, this._importResolver);
@@ -2079,4 +2175,5 @@ class Program {
     }
 }
 exports.Program = Program;
+Program._nextId = 0;
 //# sourceMappingURL=program.js.map