@zzzen/pyright-internal 1.2.0-dev.20230409 → 1.2.0-dev.20230423

package/dist/analyzer/program.d.ts

@@ -6,13 +6,13 @@ import { ConsoleInterface } from '../common/console';
 import { Diagnostic } from '../common/diagnostic';
 import { FileDiagnostics } from '../common/diagnosticSink';
 import { FileEditActions, TextEditAction } from '../common/editAction';
+import { ProgramView } from '../common/extensibility';
 import { LogTracker } from '../common/logTracker';
 import { DocumentRange, Position, Range } from '../common/textRange';
 import { AutoImportOptions, AutoImportResult, ImportFormat } from '../languageService/autoImporter';
 import { AbbreviationMap, CompletionOptions, CompletionResultsList } from '../languageService/completionProvider';
 import { DefinitionFilter } from '../languageService/definitionProvider';
 import { IndexOptions, IndexResults, WorkspaceSymbolCallback } from '../languageService/documentSymbolProvider';
-import { HoverResults } from '../languageService/hoverProvider';
 import { ReferenceCallback } from '../languageService/referencesProvider';
 import { SignatureHelpResults } from '../languageService/signatureHelpProvider';
 import { ParseResults } from '../parser/parser';
@@ -74,14 +74,14 @@ export declare class Program {
     private static _nextId;
     constructor(initialImportResolver: ImportResolver, initialConfigOptions: ConfigOptions, console?: ConsoleInterface, logTracker?: LogTracker, _disableChecker?: boolean | undefined, cacheManager?: CacheManager);
     dispose(): void;
-    get evaluator(): TypeEvaluator | undefined;
-    get console(): ConsoleInterface;
     get id(): number;
-    setConfigOptions(configOptions: ConfigOptions): void;
+    get console(): ConsoleInterface;
     get rootPath(): string;
-    getConfigOptions(): ConfigOptions;
+    get evaluator(): TypeEvaluator | undefined;
+    get configOptions(): ConfigOptions;
+    get importResolver(): ImportResolver;
+    setConfigOptions(configOptions: ConfigOptions): void;
     setImportResolver(importResolver: ImportResolver): void;
-    getImportResolver(): ImportResolver;
     setTrackedFiles(filePaths: string[]): FileDiagnostics[];
     setPreCheckCallback(preCheckCallback: PreCheckCallback): void;
     setAllowedThirdPartyImports(importNames: string[]): void;
@@ -110,6 +110,9 @@ export declare class Program {
     analyze(maxTime?: MaxAnalysisTime, token?: CancellationToken): boolean;
     analyzeFile(filePath: string, token?: CancellationToken): boolean;
     indexWorkspace(callback: (path: string, results: IndexResults) => void, token: CancellationToken): number;
+    run<T>(callback: (p: ProgramView) => T, token: CancellationToken): T;
+    getSourceMapper(filePath: string, token: CancellationToken, mapCompiled?: boolean, preferStubs?: boolean): SourceMapper;
+    getParseResults(filePath: string): ParseResults | undefined;
     printDetailedAnalysisTimes(): void;
     printDependencies(projectRootDir: string, verbose: boolean): void;
     writeTypeStub(targetImportPath: string, targetIsSingleFile: boolean, stubPath: string, token: CancellationToken): void;
@@ -144,7 +147,6 @@ export declare class Program {
     getFileIndex(filePath: string, options: IndexOptions, token: CancellationToken): IndexResults | undefined;
     addSymbolsForDocument(filePath: string, symbolList: DocumentSymbol[], token: CancellationToken): void;
     reportSymbolsForWorkspace(query: string, reporter: WorkspaceSymbolCallback, token: CancellationToken): void;
-    getHoverForPosition(filePath: string, position: Position, format: MarkupKind, token: CancellationToken): HoverResults | undefined;
     getDocumentHighlight(filePath: string, position: Position, token: CancellationToken): DocumentHighlight[] | undefined;
     getSignatureHelpForPosition(filePath: string, position: Position, format: MarkupKind, token: CancellationToken): SignatureHelpResults | undefined;
     getCompletionsForPosition(filePath: string, position: Position, workspacePath: string, options: CompletionOptions, nameMap: AbbreviationMap | undefined, libraryMap: Map<string, IndexResults> | undefined, token: CancellationToken): Promise<CompletionResultsList | undefined>;

package/dist/analyzer/program.js

@@ -59,6 +59,7 @@ 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");
@@ -150,14 +151,23 @@ class Program {
     dispose() {
         this._cacheManager.unregisterCacheOwner(this);
     }
-    get evaluator() {
-        return this._evaluator;
+    get id() {
+        return this._id;
     }
     get console() {
         return this._console;
     }
-    get id() {
-        return this._id;
+    get rootPath() {
+        return this._configOptions.projectRoot;
+    }
+    get evaluator() {
+        return this._evaluator;
+    }
+    get configOptions() {
+        return this._configOptions;
+    }
+    get importResolver() {
+        return this._importResolver;
     }
     setConfigOptions(configOptions) {
         this._configOptions = configOptions;
@@ -165,12 +175,6 @@ class Program {
         // Create a new evaluator with the updated config options.
         this._createNewEvaluator();
     }
-    get rootPath() {
-        return this._configOptions.projectRoot;
-    }
-    getConfigOptions() {
-        return this._configOptions;
-    }
     setImportResolver(importResolver) {
         this._importResolver = importResolver;
         // Create a new evaluator with the updated import resolver.
@@ -178,9 +182,6 @@ class Program {
         // older import resolver when resolving imports after parsing.
         this._createNewEvaluator();
     }
-    getImportResolver() {
-        return this._importResolver;
-    }
     // Sets the list of tracked files that make up the program.
     setTrackedFiles(filePaths) {
         if (this._sourceFileList.length > 0) {
@@ -539,6 +540,22 @@ class Program {
             }
         }
     }
+    // This will allow the callback to execute a type evaluator with an associated
+    // cancellation token and provide a read-only program.
+    run(callback, token) {
+        var _a;
+        const evaluator = (_a = this._evaluator) !== null && _a !== void 0 ? _a : this._createNewEvaluator();
+        return evaluator.runWithCancellationToken(token, () => callback(this));
+    }
+    getSourceMapper(filePath, token, mapCompiled, preferStubs) {
+        const sourceFileInfo = this.getSourceFileInfo(filePath);
+        const execEnv = this._configOptions.findExecEnvironment(filePath);
+        return this._createSourceMapper(execEnv, token, sourceFileInfo, mapCompiled, preferStubs);
+    }
+    getParseResults(filePath) {
+        var _a;
+        return (_a = this.getBoundSourceFile(filePath)) === null || _a === void 0 ? void 0 : _a.getParseResults();
+    }
     // Prints a detailed list of files that have been checked and the times associated
     // with each of them, sorted greatest to least.
     printDetailedAnalysisTimes() {
@@ -654,8 +671,8 @@ class Program {
         if (configOptions.diagnosticRuleSet.omitConditionalConstraint) {
             flags |= 64 /* OmitConditionalConstraint */;
         }
-        if (configOptions.diagnosticRuleSet.omitTypeArgsIfAny) {
-            flags |= 2 /* OmitTypeArgumentsIfAny */;
+        if (configOptions.diagnosticRuleSet.omitTypeArgsIfUnknown) {
+            flags |= 2 /* OmitTypeArgumentsIfUnknown */;
         }
         if (configOptions.diagnosticRuleSet.omitUnannotatedParamType) {
             flags |= 4 /* OmitUnannotatedParamType */;
@@ -738,8 +755,10 @@ class Program {
         if (!force && (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired())) {
             return;
         }
-        // sourceFile.parse should never be called directly. Otherwise, whole dependency graph maintained
-        // by program will be broken. Use _parseFile instead.
+        // SourceFile.parse should only be called here in the program, as calling it
+        // elsewhere could break the entire dependency graph maintained by the program.
+        // Other parts of the program should use _parseFile to create ParseResults from
+        // the sourceFile. For standalone parseResults, use parseFile or the Parser directly.
         if (fileToParse.sourceFile.parse(this._configOptions, this._importResolver, content)) {
             this._parsedFileCount++;
             this._updateSourceFileImports(fileToParse, this._configOptions);
@@ -793,7 +812,7 @@ class Program {
         let implicitImport = implicitImports.pop();
         while (implicitImport) {
             // Bind this file, but don't recurse into its imports.
-            this._bindFile(implicitImport, undefined, undefined, /*isImplicitImport*/ true);
+            this._bindFile(implicitImport, undefined, undefined, /* isImplicitImport */ true);
             implicitImport = implicitImports.pop();
         }
     }
@@ -850,9 +869,28 @@ class Program {
     }
     // Build a map of all modules within this program and the module-
     // level scope that contains the symbol table for the module.
-    _buildModuleSymbolsMap(sourceFileToExclude, userFileOnly, includeIndexUserSymbols, token) {
+    _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 && (userFileOnly ? (0, sourceFileInfoUtils_1.isUserCode)(s) : true)), includeIndexUserSymbols, token);
+        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.
@@ -1115,8 +1153,8 @@ class Program {
                 return [];
             }
             const writtenWord = fileContents.substr(textRange.start, textRange.length);
-            const map = this._buildModuleSymbolsMap(sourceFileInfo, !!options.libraryMap, 
-            /* includeIndexUserSymbols */ true, token);
+            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);
@@ -1335,17 +1373,6 @@ class Program {
             }
         });
     }
-    getHoverForPosition(filePath, position, format, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            return sourceFileInfo.sourceFile.getHoverForPosition(this._createSourceMapper(execEnv, token, sourceFileInfo, /* mapCompiled */ true), position, format, this._evaluator, this.functionSignatureDisplay(), token);
-        });
-    }
     getDocumentHighlight(filePath, position, token) {
         return this._runEvaluatorWithCancellationToken(token, () => {
             const sourceFileInfo = this.getSourceFileInfo(filePath);
@@ -1380,7 +1407,7 @@ class Program {
                 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);
+                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;
@@ -1411,7 +1438,7 @@ class Program {
             }
             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);
+            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) {
@@ -1521,7 +1548,7 @@ class Program {
                 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);
+                const newLinesToAdd = _getNumberOfBlankLinesToInsert(newFileParseResults, sourceDecl, range.end);
                 codeSnippetToInsert = '\n'.repeat(newLinesToAdd) + codeSnippetToInsert;
                 renameModuleProvider.textEditTracker.addEdit(newFilePath, range, codeSnippetToInsert);
             }
@@ -1642,18 +1669,51 @@ class Program {
                 realFilePath,
             });
         }
-        function _getNumberOfBlankLinesToInsert(parseResults, position) {
-            // This basically try to add 2 blanks lines before previous line with text.
+        function _getNumberOfBlankLinesToInsert(parseResults, decl, position) {
             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;
+            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() {
@@ -1874,7 +1934,7 @@ class Program {
         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);
+        return this._createSourceMapper(execEnv, vscode_languageserver_1.CancellationToken.None, /* from */ from, /* mapCompiled */ false);
     }
     _getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace) {
         // We have 2 different cases