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

package/dist/languageService/completionProvider.js

@@ -37,6 +37,7 @@ const docStringConversion_1 = require("../analyzer/docStringConversion");
 const parameterUtils_1 = require("../analyzer/parameterUtils");
 const ParseTreeUtils = __importStar(require("../analyzer/parseTreeUtils"));
 const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
+const pythonPathUtils_1 = require("../analyzer/pythonPathUtils");
 const scopeUtils_1 = require("../analyzer/scopeUtils");
 const sourceMapper_1 = require("../analyzer/sourceMapper");
 const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
@@ -51,6 +52,7 @@ const collectionUtils_1 = require("../common/collectionUtils");
 const debug = __importStar(require("../common/debug"));
 const debug_1 = require("../common/debug");
 const lspUtils_1 = require("../common/lspUtils");
+const pathUtils_1 = require("../common/pathUtils");
 const positionUtils_1 = require("../common/positionUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
 const StringUtils = __importStar(require("../common/stringUtils"));
@@ -62,6 +64,7 @@ const parseNodes_1 = require("../parser/parseNodes");
 const autoImporter_1 = require("./autoImporter");
 const completionProviderUtils_1 = require("./completionProviderUtils");
 const documentSymbolCollector_1 = require("./documentSymbolCollector");
+const importAdder_1 = require("./importAdder");
 const tooltipUtils_1 = require("./tooltipUtils");
 var Keywords;
 (function (Keywords) {
@@ -820,71 +823,89 @@ class CompletionProvider {
         if (!classResults) {
             return undefined;
         }
-        const symbolTable = new Map();
-        for (let i = 1; i < classResults.classType.details.mro.length; i++) {
-            const mroClass = classResults.classType.details.mro[i];
-            if ((0, types_1.isInstantiableClass)(mroClass)) {
-                (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
-            }
-        }
         const staticmethod = (_a = decorators === null || decorators === void 0 ? void 0 : decorators.some((d) => this._checkDecorator(d, 'staticmethod'))) !== null && _a !== void 0 ? _a : false;
         const classmethod = (_b = decorators === null || decorators === void 0 ? void 0 : decorators.some((d) => this._checkDecorator(d, 'classmethod'))) !== null && _b !== void 0 ? _b : false;
-        const completionMap = new CompletionMap();
-        symbolTable.forEach((symbol, name) => {
-            var _a;
-            let decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-            if (decl && decl.type === 5 /* Function */) {
-                if (StringUtils.isPatternInSymbol(partialName.value, name)) {
-                    const declaredType = (_a = this._evaluator.getTypeForDeclaration(decl)) === null || _a === void 0 ? void 0 : _a.type;
-                    if (!declaredType) {
-                        return;
-                    }
-                    let isProperty = (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isPropertyClass(declaredType);
-                    if (SymbolNameUtils.isDunderName(name)) {
-                        // Don't offer suggestions for built-in properties like "__class__", etc.
-                        isProperty = false;
-                    }
-                    if (!(0, types_1.isFunction)(declaredType) && !isProperty) {
-                        return;
-                    }
-                    if (isProperty) {
-                        // For properties, we should override the "getter", which is typically
-                        // the first declaration.
-                        const typedDecls = symbol.getTypedDeclarations();
-                        if (typedDecls.length > 0 && typedDecls[0].type === 5 /* Function */) {
-                            decl = typedDecls[0];
-                        }
-                    }
-                    const isDeclaredStaticMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isStaticMethod(declaredType);
-                    // Special-case the "__init__subclass__" method because it's an implicit
-                    // classmethod that the type evaluator flags as a real classmethod.
-                    const isDeclaredClassMethod = (0, types_1.isFunction)(declaredType) &&
-                        types_1.FunctionType.isClassMethod(declaredType) &&
-                        name !== '__init_subclass__';
-                    if (staticmethod !== isDeclaredStaticMethod || classmethod !== isDeclaredClassMethod) {
-                        return;
-                    }
-                    const methodSignature = this._printMethodSignature(classResults.classType, decl);
-                    let text;
-                    if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
-                        text = `${methodSignature}: ...`;
-                    }
-                    else {
-                        const methodBody = this._printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl);
-                        text = `${methodSignature}:\n${methodBody}`;
-                    }
-                    const textEdit = this._createReplaceEdits(priorWord, partialName, text);
-                    this._addSymbol(name, symbol, partialName.value, completionMap, {
-                        // method signature already contains ()
-                        funcParensDisabled: true,
-                        edits: {
-                            format: this._options.snippet ? vscode_languageserver_1.InsertTextFormat.Snippet : undefined,
-                            textEdit,
-                        },
-                    });
+        const fallbackPath = (0, pythonPathUtils_1.getTypeShedFallbackPath)(this._importResolver.fileSystem);
+        const typingFilePath = fallbackPath ? (0, pathUtils_1.combinePaths)(fallbackPath, 'stdlib/typing.pyi') : undefined;
+        const appendMember = (map, member, name) => {
+            if (!(0, types_1.isInstantiableClass)(member.classType) ||
+                member.classType.details === classResults.classType.details ||
+                !StringUtils.isPatternInSymbol(partialName.value, name)) {
+                // Quick bail out if member is something we don't want to override.
+                return;
+            }
+            const symbol = member.symbol;
+            const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (!decl || decl.type !== 5 /* Function */) {
+                return;
+            }
+            const declaredType = this._evaluator.getTypeOfMember(member);
+            if (!declaredType) {
+                return;
+            }
+            const isDeclaredStaticMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isStaticMethod(declaredType);
+            // Special-case the "__init__subclass__" method because it's an implicit
+            // classmethod that the type evaluator flags as a real classmethod.
+            const isDeclaredClassMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isClassMethod(declaredType) && name !== '__init_subclass__';
+            if (staticmethod !== isDeclaredStaticMethod || classmethod !== isDeclaredClassMethod) {
+                return;
+            }
+            let isProperty = (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isPropertyClass(declaredType);
+            if (SymbolNameUtils.isDunderName(name)) {
+                // Don't offer suggestions for built-in properties like "__class__", etc.
+                isProperty = false;
+            }
+            let funcType = undefined;
+            if ((0, types_1.isFunction)(declaredType)) {
+                funcType = declaredType;
+            }
+            else if (isProperty) {
+                const getter = (0, typeUtils_1.lookUpClassMember)(declaredType, 'fget');
+                if (!getter) {
+                    return;
+                }
+                const member = this._evaluator.getTypeOfMember(getter);
+                if (!(0, types_1.isFunction)(member)) {
+                    return;
                 }
+                funcType = member;
             }
-        });
+            if (!funcType || !funcType.details.declaration) {
+                return;
+            }
+            const importAdder = new importAdder_1.ImportAdder(this._configOptions, this._importResolver, this._evaluator);
+            const result = this._printMethodSignature(importAdder, classResults.classType, funcType, typingFilePath);
+            let text;
+            if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
+                text = `${result.methodSignature}: ...`;
+            }
+            else {
+                const methodBody = this._printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl);
+                text = `${result.methodSignature}:\n${methodBody}`;
+            }
+            const textEdit = this._createReplaceEdits(priorWord, partialName, text);
+            // This will add new import statements, but for now, it won't add new
+            // `TypeVar` statement such as TypeVar, TypeVarTuple, ParamSpec even if
+            // the overridden method uses them.
+            const additionalTextEdits = importAdder.applyImports(result.importData, this._filePath, this._parseResults, this._parseResults.parseTree.length, "absolute" /* Absolute */, this._cancellationToken);
+            this._addSymbol(name, symbol, partialName.value, map, {
+                // method signature already contains ()
+                funcParensDisabled: true,
+                edits: {
+                    format: this._options.snippet ? vscode_languageserver_1.InsertTextFormat.Snippet : undefined,
+                    textEdit,
+                    additionalTextEdits,
+                },
+            });
+        };
+        const completionMap = new CompletionMap();
+        const classMemberMap = (0, typeUtils_1.getClassFieldsRecursive)(classResults.classType);
+        classMemberMap.forEach((member, name) => appendMember(completionMap, member, name));
+        if (classResults.classType.details.effectiveMetaclass &&
+            !(0, types_1.isUnknown)(classResults.classType.details.effectiveMetaclass)) {
+            const metaClassMemberMap = (0, typeUtils_1.getClassFieldsRecursive)(classResults.classType.details.effectiveMetaclass);
+            metaClassMemberMap.forEach((member, name) => appendMember(completionMap, member, name));
+        }
         return { completionMap };
     }
     _createReplaceEdits(priorWord, node, text) {
@@ -897,23 +918,34 @@ class CompletionProvider {
         };
         return vscode_languageserver_1.TextEdit.replace(range, text);
     }
-    _printMethodSignature(classType, decl) {
-        const node = decl.node;
+    _printMethodSignature(importAdder, classType, funcType, typingFilePath) {
+        const declaration = funcType.details.declaration;
         let ellipsisForDefault;
         if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
             // In stubs, always use "...".
             ellipsisForDefault = true;
         }
-        else if (classType.details.moduleName === decl.moduleName) {
+        else if (classType.details.moduleName === declaration.moduleName) {
             // In the same file, always print the full default.
             ellipsisForDefault = false;
         }
-        const printFlags = (0, sourceMapper_1.isStubFile)(this._filePath)
+        const printOptionsUsingSyntax = (0, sourceMapper_1.isStubFile)(this._filePath)
             ? 1 /* ForwardDeclarations */ |
                 2 /* DoNotLimitStringLength */
             : 2 /* DoNotLimitStringLength */;
-        const paramList = node.parameters
-            .map((param, index) => {
+        const printOptionsUsingType = {
+            enforcePythonSyntax: true,
+            expandTypeAlias: false,
+            omitTypeArgumentsIfUnknown: true,
+            printUnknownWithAny: true,
+        };
+        const getTypeToPrint = (mainType, fallbackType) => {
+            return mainType && (!(0, types_1.isUnknown)(mainType) || (fallbackType === null || fallbackType === void 0 ? void 0 : fallbackType.category) === 10 /* TypeVar */)
+                ? mainType
+                : fallbackType;
+        };
+        const importData = createImportData(importAdder, funcType, declaration, typingFilePath, (t) => this._sourceMapper.findClassDeclarationsByType(this._filePath, t), this._cancellationToken);
+        const paramList = funcType.details.parameters.map((param, index) => {
             let paramString = '';
             if (param.category === 1 /* VarArgList */) {
                 paramString += '*';
@@ -922,35 +954,169 @@ class CompletionProvider {
                 paramString += '**';
             }
             if (param.name) {
-                paramString += param.name.value;
+                paramString += param.name;
+            }
+            if (param.typeAnnotation) {
+                const originalType = funcType.details.parameters[index].type;
+                const typeToPrint = getTypeToPrint(types_1.FunctionType.getEffectiveParameterType(funcType, index), originalType);
+                // If we have actual type, then use type to generate string representation of the type, otherwise, use syntax (text).
+                const strType = isTypeUsableForPrint(typeToPrint, originalType)
+                    ? this._evaluator.printType(typeToPrint, printOptionsUsingType)
+                    : ParseTreeUtils.printExpression(param.typeAnnotation, printOptionsUsingSyntax);
+                paramString += ': ' + strType;
+            }
+            if (param.defaultValueExpression) {
+                paramString += param.typeAnnotation ? ' = ' : '=';
+                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !isSimpleDefault(param.defaultValueExpression);
+                paramString += useEllipsis
+                    ? '...'
+                    : ParseTreeUtils.printExpression(param.defaultValueExpression, printOptionsUsingSyntax);
+            }
+            if (!paramString &&
+                !param.name &&
+                param.category === 0 /* Simple */ &&
+                index < funcType.details.parameters.length - 1) {
+                return '/';
             }
-            // Currently, we don't automatically add import if the type used in the annotation is not imported
-            // in current file.
-            const paramTypeAnnotation = ParseTreeUtils.getTypeAnnotationForParameter(node, index);
-            if (paramTypeAnnotation) {
-                paramString += ': ' + ParseTreeUtils.printExpression(paramTypeAnnotation, printFlags);
+            return paramString;
+        });
+        // Remove empty parameters at the end.
+        for (let i = paramList.length - 1; i >= 0; i--) {
+            if (paramList[i] !== '') {
+                break;
             }
-            if (param.defaultValue) {
-                paramString += paramTypeAnnotation ? ' = ' : '=';
-                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !isSimpleDefault(param.defaultValue);
-                paramString += useEllipsis ? '...' : ParseTreeUtils.printExpression(param.defaultValue, printFlags);
+            paramList.pop();
+        }
+        let methodSignature = funcType.details.name + '(' + paramList.join(', ') + ')';
+        const strReturnType = getReturnTypeStr(this._evaluator, funcType, printOptionsUsingSyntax);
+        if (strReturnType) {
+            methodSignature += ' -> ' + strReturnType;
+        }
+        return { methodSignature, importData };
+        function createImportData(importAdder, funcType, declaration, typingFilePath, declarationGetter, token) {
+            var _a, _b;
+            // Handle regular case. In this case, we can get import info from
+            // import used in the file where the function is declared.
+            const ranges = [];
+            (0, collectionUtils_1.addIfNotNull)(ranges, textRange_2.TextRange.combine(declaration.node.parameters));
+            (0, collectionUtils_1.addIfNotNull)(ranges, declaration.node.returnTypeAnnotation);
+            (0, collectionUtils_1.addIfNotNull)(ranges, declaration.node.functionAnnotationComment);
+            const moduleNode = ParseTreeUtils.getModuleNode(declaration.node);
+            const importData = importAdder.collectImportsForSymbolsUsed(moduleNode, ranges, token);
+            // Handle special case where function has type arguments. In this case,
+            // we can't use the file the function is declared in because it doesn't
+            // have those type arguments. It just has the type vars.
+            // We could walk the mro to discover imports for the type arguments, but
+            // for now, instead, this creates import statement out of type arguments itself.
+            const effectiveTypes = [];
+            funcType.details.parameters.forEach((param, index) => {
+                if (!param.typeAnnotation) {
+                    return;
+                }
+                const originalType = funcType.details.parameters[index].type;
+                if (!(0, types_1.isTypeVar)(originalType)) {
+                    return;
+                }
+                const effectiveType = types_1.FunctionType.getEffectiveParameterType(funcType, index);
+                effectiveTypes.push([effectiveType, param.typeAnnotation]);
+            });
+            const node = declaration.node;
+            const originalType = funcType.details.declaredReturnType;
+            if (originalType &&
+                (0, types_1.isTypeVar)(originalType) &&
+                (node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation))) {
+                effectiveTypes.push([
+                    types_1.FunctionType.getSpecializedReturnType(funcType),
+                    (_b = node.returnTypeAnnotation) !== null && _b !== void 0 ? _b : node.functionAnnotationComment.returnTypeAnnotation,
+                ]);
+            }
+            const visited = new Set();
+            const addImport = (t, n) => {
+                var _a, _b;
+                if (visited.has(t)) {
+                    return;
+                }
+                visited.add(t);
+                // We need to special case `Any` since we can't get decl from `Any`.
+                if ((0, types_1.isAny)(t)) {
+                    if (!typingFilePath) {
+                        return;
+                    }
+                    importAdder.addImportInfo({ filePath: typingFilePath, nameInfo: { name: 'Any' } }, importData);
+                }
+                if (!(0, types_1.isClass)(t)) {
+                    return;
+                }
+                // We need to special case `List`, `Dict` and `Tuple` since user might have
+                // used typing.List or typing.Dict in the code, but we internally already
+                // converted them to built-in `list` and `dict`.
+                // We could avoid doing this if class type holds onto decl it was created from
+                // if it is not synthesized like func type.
+                if (typingFilePath && types_1.ClassType.isBuiltIn(t)) {
+                    const name = (_a = t.aliasName) !== null && _a !== void 0 ? _a : t.details.name;
+                    if (t.details.moduleName === 'typing' && name) {
+                        importAdder.addImportInfo({
+                            filePath: typingFilePath,
+                            nameInfo: { name },
+                        }, importData);
+                    }
+                    else if (t.details.moduleName === 'builtins' && t.aliasName) {
+                        importAdder.addImportInfo({
+                            filePath: typingFilePath,
+                            nameInfo: { name },
+                        }, importData);
+                    }
+                }
+                else {
+                    const decls = declarationGetter(t);
+                    if (decls.length === 0) {
+                        return;
+                    }
+                    importAdder.addDeclaration(decls[0], n, importData);
+                }
+                if (t.isTypeArgumentExplicit) {
+                    (_b = t.typeArguments) === null || _b === void 0 ? void 0 : _b.forEach((ta) => {
+                        addImport(ta, n);
+                        (0, typeUtils_1.doForEachSubtype)(ta, (subtype) => {
+                            addImport(subtype, n);
+                        });
+                    });
+                }
+            };
+            effectiveTypes.forEach(([t, n]) => {
+                addImport(t, n);
+                (0, typeUtils_1.doForEachSubtype)(t, (subtype) => {
+                    addImport(subtype, n);
+                });
+            });
+            return importData;
+        }
+        function getReturnTypeStr(evaluator, funcType, printFlags) {
+            var _a;
+            const originalType = funcType.details.declaredReturnType;
+            const typeToPrint = getTypeToPrint(types_1.FunctionType.getSpecializedReturnType(funcType), originalType);
+            const node = funcType.details.declaration.node;
+            if (!node.returnTypeAnnotation && !((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation)) {
+                return undefined;
             }
-            if (!paramString && !param.name && param.category === 0 /* Simple */) {
-                return '/';
+            if (typeToPrint && isTypeUsableForPrint(typeToPrint, originalType)) {
+                return evaluator.printType(typeToPrint, printOptionsUsingType);
             }
-            return paramString;
-        })
-            .join(', ');
-        let methodSignature = node.name.value + '(' + paramList + ')';
-        if (node.returnTypeAnnotation) {
-            methodSignature += ' -> ' + ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
-        }
-        else if (node.functionAnnotationComment) {
-            methodSignature +=
-                ' -> ' +
-                    ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
-        }
-        return methodSignature;
+            if (node.returnTypeAnnotation) {
+                return ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
+            }
+            if (node.functionAnnotationComment) {
+                return ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
+            }
+            return undefined;
+        }
+        function isTypeUsableForPrint(effectiveType, originalType) {
+            if (!effectiveType) {
+                return false;
+            }
+            // If original type was `TypeVar`, we want to use `Unknown` as `Any`
+            return !(0, types_1.isUnknown)(effectiveType) || (originalType === null || originalType === void 0 ? void 0 : originalType.category) === 10 /* TypeVar */;
+        }
         function isSimpleDefault(node) {
             switch (node.nodeType) {
                 case 40 /* Number */:
@@ -1873,7 +2039,7 @@ class CompletionProvider {
     }
     _addSymbolsForSymbolTable(symbolTable, includeSymbolCallback, priorWord, node, isInImport, boundObjectOrClass, completionMap) {
         const insideTypeAnnotation = ParseTreeUtils.isWithinAnnotationComment(node) ||
-            ParseTreeUtils.isWithinTypeAnnotation(node, /*requireQuotedAnnotation*/ false);
+            ParseTreeUtils.isWithinTypeAnnotation(node, /* requireQuotedAnnotation */ false);
         symbolTable.forEach((symbol, name) => {
             // If there are no declarations or the symbol is not
             // exported from this scope, don't include it in the