@zzzen/pyright-internal 1.2.0-dev.20230101 → 1.2.0-dev.20230108

package/dist/languageService/completionProvider.d.ts

@@ -15,6 +15,7 @@ export interface CompletionItemData {
     autoImportText?: string;
     symbolLabel?: string;
     funcParensDisabled?: boolean;
+    modulePath?: string;
 }
 export interface MemberAccessInfo {
     lastKnownModule?: string;
@@ -129,12 +130,14 @@ export declare class CompletionProvider {
     private _addSymbols;
     private _addSymbolsForSymbolTable;
     private _addSymbol;
+    private _getTypeDetail;
     private _getAutoImportText;
     private _addNameToCompletions;
     private _getRecentListIndex;
     private _makeSortText;
     private _formatInteger;
     private _convertDeclarationTypeToItemKind;
+    private _convertTypeToItemKind;
     private _getImportModuleCompletions;
     private _getExtraCommitCharsForKind;
     private _addExtraCommitChar;

package/dist/languageService/completionProvider.js

@@ -41,6 +41,7 @@ const sourceMapper_1 = require("../analyzer/sourceMapper");
 const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
 const symbolUtils_1 = require("../analyzer/symbolUtils");
 const typedDicts_1 = require("../analyzer/typedDicts");
+const typeDocStringUtils_1 = require("../analyzer/typeDocStringUtils");
 const typePrinter_1 = require("../analyzer/typePrinter");
 const types_1 = require("../analyzer/types");
 const typeUtils_1 = require("../analyzer/typeUtils");
@@ -52,6 +53,7 @@ const lspUtils_1 = require("../common/lspUtils");
 const positionUtils_1 = require("../common/positionUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
 const StringUtils = __importStar(require("../common/stringUtils"));
+const textEditUtils_1 = require("../common/textEditUtils");
 const textRange_1 = require("../common/textRange");
 const textRange_2 = require("../common/textRange");
 const timing_1 = require("../common/timing");
@@ -360,22 +362,44 @@ class CompletionProvider {
             // Prevent the MRU list from growing indefinitely.
             CompletionProvider._mostRecentCompletions.pop();
         }
-        if (completionItemData.symbolLabel) {
-            this._itemToResolve = completionItem;
-            if (!completionItemData.autoImportText) {
-                // Rerun the completion lookup. It will fill in additional information
-                // about the item to be resolved. We'll ignore the rest of the returned
-                // list. This is a bit wasteful, but all of that information should be
-                // cached, so it's not as bad as it might seem.
-                this.getCompletionsForPosition();
+        if (!completionItemData.symbolLabel) {
+            return;
+        }
+        if (completionItemData.modulePath) {
+            const documentation = (0, typeDocStringUtils_1.getModuleDocStringFromPaths)([completionItemData.modulePath], this._sourceMapper);
+            if (!documentation) {
+                return;
             }
-            else if (!completionItem.additionalTextEdits) {
-                const completionMap = new CompletionMap();
-                const completionResults = { completionMap };
-                this._addAutoImportCompletions(completionItemData.symbolLabel, 
-                /* similarityLimit */ 1, 
-                /* lazyEdit */ false, completionResults);
+            if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+                const markdownString = (0, docStringConversion_1.convertDocStringToMarkdown)(documentation);
+                completionItem.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.Markdown,
+                    value: markdownString,
+                };
+            }
+            else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+                const plainTextString = (0, docStringConversion_1.convertDocStringToPlainText)(documentation);
+                completionItem.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.PlainText,
+                    value: plainTextString,
+                };
             }
+            return;
+        }
+        this._itemToResolve = completionItem;
+        if (!completionItemData.autoImportText) {
+            // Rerun the completion lookup. It will fill in additional information
+            // about the item to be resolved. We'll ignore the rest of the returned
+            // list. This is a bit wasteful, but all of that information should be
+            // cached, so it's not as bad as it might seem.
+            this.getCompletionsForPosition();
+        }
+        else if (!completionItem.additionalTextEdits) {
+            const completionMap = new CompletionMap();
+            const completionResults = { completionMap };
+            this._addAutoImportCompletions(completionItemData.symbolLabel, 
+            /* similarityLimit */ 1, 
+            /* lazyEdit */ false, completionResults);
         }
     }
     // This method will return false if it wants
@@ -1678,7 +1702,9 @@ class CompletionProvider {
         // Add the implicit imports.
         importInfo.implicitImports.forEach((implImport) => {
             if (!importFromNode.imports.find((imp) => imp.name.value === implImport.name)) {
-                this._addNameToCompletions(implImport.name, vscode_languageserver_1.CompletionItemKind.Module, priorWord, completionMap);
+                this._addNameToCompletions(implImport.name, vscode_languageserver_1.CompletionItemKind.Module, priorWord, completionMap, {
+                    modulePath: implImport.path,
+                });
             }
         });
         return { completionMap };
@@ -1795,7 +1821,7 @@ class CompletionProvider {
         });
     }
     _addSymbol(name, symbol, priorWord, completionMap, detail) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         let primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
         if (!primaryDecl) {
             const declarations = symbol.getDeclarations();
@@ -1803,132 +1829,83 @@ class CompletionProvider {
                 primaryDecl = declarations[declarations.length - 1];
             }
         }
-        if (primaryDecl) {
-            let itemKind = vscode_languageserver_1.CompletionItemKind.Variable;
-            primaryDecl = this._evaluator.resolveAliasDeclaration(primaryDecl, /* resolveLocalNames */ true);
-            if (primaryDecl) {
-                itemKind = this._convertDeclarationTypeToItemKind(primaryDecl);
-                // Handle enum members specially. Enum members normally look like
-                // variables, but the are declared using assignment expressions
-                // within an enum class.
-                if (primaryDecl.type === 1 /* Variable */ &&
-                    detail.boundObjectOrClass &&
-                    (0, types_1.isInstantiableClass)(detail.boundObjectOrClass) &&
-                    types_1.ClassType.isEnumClass(detail.boundObjectOrClass) &&
-                    ((_a = primaryDecl.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
-                    itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
-                }
-                // Are we resolving a completion item? If so, see if this symbol
-                // is the one that we're trying to match.
-                if (this._itemToResolve) {
-                    const completionItemData = (0, lspUtils_1.fromLSPAny)(this._itemToResolve.data);
-                    if (completionItemData.symbolLabel === name && !completionItemData.autoImportText) {
-                        // This call can be expensive to perform on every completion item
-                        // that we return, so we do it lazily in the "resolve" callback.
-                        const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-                        if (type) {
-                            let typeDetail;
-                            let documentation;
-                            switch (primaryDecl.type) {
-                                case 0 /* Intrinsic */:
-                                case 1 /* Variable */:
-                                case 2 /* Parameter */:
-                                case 3 /* TypeParameter */: {
-                                    let expandTypeAlias = false;
-                                    if (type && types_1.TypeBase.isInstantiable(type)) {
-                                        const typeAliasInfo = (0, types_1.getTypeAliasInfo)(type);
-                                        if (typeAliasInfo) {
-                                            if (typeAliasInfo.name === name) {
-                                                expandTypeAlias = true;
-                                            }
-                                        }
-                                    }
-                                    typeDetail = name + ': ' + this._evaluator.printType(type, { expandTypeAlias });
-                                    break;
-                                }
-                                case 5 /* Function */: {
-                                    const functionType = detail.boundObjectOrClass && ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type))
-                                        ? this._evaluator.bindFunctionToClassOrObject(detail.boundObjectOrClass, type)
-                                        : type;
-                                    if (functionType) {
-                                        if ((0, typeUtils_1.isProperty)(functionType) &&
-                                            detail.boundObjectOrClass &&
-                                            (0, types_1.isClassInstance)(detail.boundObjectOrClass)) {
-                                            const propertyType = this._evaluator.getGetterTypeFromProperty(functionType, 
-                                            /* inferTypeIfNeeded */ true) || types_1.UnknownType.create();
-                                            typeDetail =
-                                                name + ': ' + this._evaluator.printType(propertyType) + ' (property)';
-                                        }
-                                        else if ((0, types_1.isOverloadedFunction)(functionType)) {
-                                            // 35 is completion tooltip's default width size
-                                            typeDetail = (0, tooltipUtils_1.getOverloadedFunctionTooltip)(functionType, this._evaluator, 
-                                            /* columnThreshold */ 35);
-                                        }
-                                        else if ((0, types_1.isFunction)(functionType)) {
-                                            typeDetail = name + this._evaluator.printType(functionType);
-                                        }
-                                        else {
-                                            typeDetail = name + ': ' + this._evaluator.printType(functionType);
-                                        }
-                                    }
-                                    break;
-                                }
-                                case 6 /* Class */:
-                                case 7 /* SpecialBuiltInClass */: {
-                                    typeDetail = 'class ' + name + '()';
-                                    break;
-                                }
-                                case 8 /* Alias */: {
-                                    typeDetail = name;
-                                    if (primaryDecl.path) {
-                                        const lookupResults = this._importLookup(primaryDecl.path);
-                                        if (lookupResults) {
-                                            documentation = lookupResults.docString;
-                                        }
-                                    }
-                                    break;
-                                }
-                                default: {
-                                    typeDetail = name;
-                                    break;
-                                }
-                            }
-                            documentation = (0, tooltipUtils_1.getDocumentationPartsForTypeAndDecl)(this._sourceMapper, type, primaryDecl, this._evaluator, symbol, detail.boundObjectOrClass);
-                            if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
-                                let markdownString = '```python\n' + typeDetail + '\n```\n';
-                                if (documentation) {
-                                    markdownString += '---\n';
-                                    markdownString += (0, docStringConversion_1.convertDocStringToMarkdown)(documentation);
-                                }
-                                markdownString = markdownString.trimEnd();
-                                this._itemToResolve.documentation = {
-                                    kind: vscode_languageserver_1.MarkupKind.Markdown,
-                                    value: markdownString,
-                                };
-                            }
-                            else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
-                                let plainTextString = typeDetail + '\n';
-                                if (documentation) {
-                                    plainTextString += '\n';
-                                    plainTextString += (0, docStringConversion_1.convertDocStringToPlainText)(documentation);
-                                }
-                                plainTextString = plainTextString.trimEnd();
-                                this._itemToResolve.documentation = {
-                                    kind: vscode_languageserver_1.MarkupKind.PlainText,
-                                    value: plainTextString,
-                                };
-                            }
-                            else {
-                                (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
-                            }
-                        }
-                    }
+        primaryDecl = primaryDecl
+            ? (_a = this._evaluator.resolveAliasDeclaration(primaryDecl, /* resolveLocalNames */ true)) !== null && _a !== void 0 ? _a : primaryDecl
+            : undefined;
+        const autoImportText = detail.autoImportSource
+            ? this._getAutoImportText(name, detail.autoImportSource, detail.autoImportAlias)
+            : undefined;
+        // Are we resolving a completion item? If so, see if this symbol
+        // is the one that we're trying to match.
+        if (this._itemToResolve) {
+            const completionItemData = (0, lspUtils_1.fromLSPAny)(this._itemToResolve.data);
+            if (completionItemData.symbolLabel !== name) {
+                // It's not what we are looking for.
+                return;
+            }
+            if (completionItemData.autoImportText) {
+                if (completionItemData.autoImportText === (autoImportText === null || autoImportText === void 0 ? void 0 : autoImportText.importText) &&
+                    ((_b = detail.edits) === null || _b === void 0 ? void 0 : _b.additionalTextEdits)) {
+                    this._itemToResolve.additionalTextEdits = (0, textEditUtils_1.convertEditActionsToTextEdits)(detail.edits.additionalTextEdits);
+                }
+                return;
+            }
+            // This call can be expensive to perform on every completion item
+            // that we return, so we do it lazily in the "resolve" callback.
+            const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+            if (!type) {
+                // Can't resolve. so bail out.
+                return;
+            }
+            const typeDetail = this._getTypeDetail(primaryDecl, type, name, detail);
+            const documentation = (0, tooltipUtils_1.getDocumentationPartsForTypeAndDecl)(this._sourceMapper, type, primaryDecl, this._evaluator, {
+                name,
+                symbol,
+                boundObjectOrClass: detail.boundObjectOrClass,
+            });
+            if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+                let markdownString = '```python\n' + typeDetail + '\n```\n';
+                if (documentation) {
+                    markdownString += '---\n';
+                    markdownString += (0, docStringConversion_1.convertDocStringToMarkdown)(documentation);
+                }
+                markdownString = markdownString.trimEnd();
+                this._itemToResolve.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.Markdown,
+                    value: markdownString,
+                };
+            }
+            else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+                let plainTextString = typeDetail + '\n';
+                if (documentation) {
+                    plainTextString += '\n';
+                    plainTextString += (0, docStringConversion_1.convertDocStringToPlainText)(documentation);
                 }
+                plainTextString = plainTextString.trimEnd();
+                this._itemToResolve.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.PlainText,
+                    value: plainTextString,
+                };
+            }
+            else {
+                (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
             }
-            const autoImportText = detail.autoImportSource
-                ? this._getAutoImportText(name, detail.autoImportSource, detail.autoImportAlias)
-                : undefined;
-            this._addNameToCompletions((_b = detail.autoImportAlias) !== null && _b !== void 0 ? _b : name, itemKind, priorWord, completionMap, {
+            // Bail out. We don't need to add items to completion.
+            return;
+        }
+        if (primaryDecl) {
+            let itemKind = this._convertDeclarationTypeToItemKind(primaryDecl);
+            // Handle enum members specially. Enum members normally look like
+            // variables, but the are declared using assignment expressions
+            // within an enum class.
+            if (primaryDecl.type === 1 /* Variable */ &&
+                detail.boundObjectOrClass &&
+                (0, types_1.isInstantiableClass)(detail.boundObjectOrClass) &&
+                types_1.ClassType.isEnumClass(detail.boundObjectOrClass) &&
+                ((_c = primaryDecl.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
+            }
+            this._addNameToCompletions((_d = detail.autoImportAlias) !== null && _d !== void 0 ? _d : name, itemKind, priorWord, completionMap, {
                 autoImportText,
                 extraCommitChars: detail.extraCommitChars,
                 funcParensDisabled: detail.funcParensDisabled,
@@ -1939,7 +1916,7 @@ class CompletionProvider {
             // Does the symbol have no declaration but instead has a synthesized type?
             const synthesizedType = symbol.getSynthesizedType();
             if (synthesizedType) {
-                const itemKind = vscode_languageserver_1.CompletionItemKind.Variable;
+                const itemKind = this._convertTypeToItemKind(synthesizedType);
                 this._addNameToCompletions(name, itemKind, priorWord, completionMap, {
                     extraCommitChars: detail.extraCommitChars,
                     funcParensDisabled: detail.funcParensDisabled,
@@ -1948,6 +1925,72 @@ class CompletionProvider {
             }
         }
     }
+    _getTypeDetail(primaryDecl, type, name, detail) {
+        if (!primaryDecl) {
+            if ((0, types_1.isModule)(type)) {
+                // Special casing import modules.
+                // submodule imported through `import` statement doesn't have
+                // corresponding decls. so use given name as it is.
+                //
+                // ex) import X.Y
+                // X.[Y]
+                return name;
+            }
+            return;
+        }
+        switch (primaryDecl.type) {
+            case 0 /* Intrinsic */:
+            case 1 /* Variable */:
+            case 2 /* Parameter */:
+            case 3 /* TypeParameter */: {
+                let expandTypeAlias = false;
+                if (type && types_1.TypeBase.isInstantiable(type)) {
+                    const typeAliasInfo = (0, types_1.getTypeAliasInfo)(type);
+                    if (typeAliasInfo) {
+                        if (typeAliasInfo.name === name) {
+                            expandTypeAlias = true;
+                        }
+                    }
+                }
+                return name + ': ' + this._evaluator.printType(type, { expandTypeAlias });
+            }
+            case 5 /* Function */: {
+                const functionType = detail.boundObjectOrClass && ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type))
+                    ? this._evaluator.bindFunctionToClassOrObject(detail.boundObjectOrClass, type)
+                    : type;
+                if (!functionType) {
+                    return undefined;
+                }
+                if ((0, typeUtils_1.isProperty)(functionType) &&
+                    detail.boundObjectOrClass &&
+                    (0, types_1.isClassInstance)(detail.boundObjectOrClass)) {
+                    const propertyType = this._evaluator.getGetterTypeFromProperty(functionType, 
+                    /* inferTypeIfNeeded */ true) || types_1.UnknownType.create();
+                    return name + ': ' + this._evaluator.printType(propertyType) + ' (property)';
+                }
+                if ((0, types_1.isOverloadedFunction)(functionType)) {
+                    // 35 is completion tooltip's default width size
+                    return (0, tooltipUtils_1.getOverloadedFunctionTooltip)(functionType, this._evaluator, /* columnThreshold */ 35);
+                }
+                else if ((0, types_1.isFunction)(functionType)) {
+                    return name + this._evaluator.printType(functionType);
+                }
+                else {
+                    return name + ': ' + this._evaluator.printType(functionType);
+                }
+            }
+            case 6 /* Class */:
+            case 7 /* SpecialBuiltInClass */: {
+                return 'class ' + name + '()';
+            }
+            case 8 /* Alias */: {
+                return name;
+            }
+            default: {
+                return name;
+            }
+        }
+    }
     _getAutoImportText(importName, importFrom, importAlias) {
         const autoImportText = (0, tooltipUtils_1.getAutoImportText)(importName, importFrom, importAlias);
         let importText = '';
@@ -1988,6 +2031,9 @@ class CompletionProvider {
         if (detail === null || detail === void 0 ? void 0 : detail.funcParensDisabled) {
             completionItemData.funcParensDisabled = true;
         }
+        if (detail === null || detail === void 0 ? void 0 : detail.modulePath) {
+            completionItemData.modulePath = detail.modulePath;
+        }
         completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
         if ((detail === null || detail === void 0 ? void 0 : detail.sortText) || (detail === null || detail === void 0 ? void 0 : detail.itemDetail)) {
             completionItem.sortText = detail.sortText;
@@ -2077,16 +2123,8 @@ class CompletionProvider {
             completionItem.textEdit = detail.edits.textEdit;
         }
         if ((_d = detail === null || detail === void 0 ? void 0 : detail.edits) === null || _d === void 0 ? void 0 : _d.additionalTextEdits) {
-            completionItem.additionalTextEdits = detail.edits.additionalTextEdits.map((te) => {
-                const textEdit = {
-                    range: {
-                        start: { line: te.range.start.line, character: te.range.start.character },
-                        end: { line: te.range.end.line, character: te.range.end.character },
-                    },
-                    newText: te.replacementText,
-                };
-                return textEdit;
-            });
+            completionItem.additionalTextEdits = (0, textEditUtils_1.convertEditActionsToTextEdits)(detail.edits.additionalTextEdits);
+            // This is for auto import entries from indices which skip symbols.
             if (this._itemToResolve) {
                 const data = (0, lspUtils_1.fromLSPAny)(this._itemToResolve.data);
                 if (data.autoImportText === completionItemData.autoImportText) {
@@ -2173,6 +2211,24 @@ class CompletionProvider {
                 return vscode_languageserver_1.CompletionItemKind.Module;
         }
     }
+    _convertTypeToItemKind(type) {
+        switch (type.category) {
+            case 8 /* Module */:
+                return vscode_languageserver_1.CompletionItemKind.Module;
+            case 7 /* Class */:
+                return vscode_languageserver_1.CompletionItemKind.Class;
+            case 5 /* Function */:
+            case 6 /* OverloadedFunction */:
+                if ((0, typeUtils_1.isProperty)(type)) {
+                    return vscode_languageserver_1.CompletionItemKind.Property;
+                }
+                return vscode_languageserver_1.CompletionItemKind.Function;
+            case 10 /* TypeVar */:
+                return vscode_languageserver_1.CompletionItemKind.TypeParameter;
+            default:
+                return vscode_languageserver_1.CompletionItemKind.Variable;
+        }
+    }
     _getImportModuleCompletions(node) {
         const moduleDescriptor = {
             leadingDots: node.leadingDots,
@@ -2194,14 +2250,11 @@ class CompletionProvider {
             completionItem.sortText = this._makeSortText(SortCategory.Keyword, keyword);
             completionMap.set(completionItem);
         }
-        completions.forEach((completionName) => {
-            if (completionMap.has(completionName)) {
-                return;
-            }
-            const completionItem = vscode_languageserver_1.CompletionItem.create(completionName);
-            completionItem.kind = vscode_languageserver_1.CompletionItemKind.Module;
-            completionItem.sortText = this._makeSortText(SortCategory.ImportModuleName, completionName);
-            completionMap.set(completionItem);
+        completions.forEach((modulePath, completionName) => {
+            this._addNameToCompletions(completionName, vscode_languageserver_1.CompletionItemKind.Module, '', completionMap, {
+                sortText: this._makeSortText(SortCategory.ImportModuleName, completionName),
+                modulePath,
+            });
         });
         return { completionMap };
     }