@zzzen/pyright-internal 1.2.0-dev.20260222 → 1.2.0-dev.20260422

package/dist/languageService/completionProvider.js

@@ -264,6 +264,11 @@ class CompletionProvider {
     getCompletionItemData(item) {
         return (0, lspUtils_1.fromLSPAny)(item.data);
     }
+    addAdditionalExpressionCompletions(parseNode, priorWord, completionMap) {
+        // Default implementation is a no-op.
+        // Subclasses can override to inject additional completion items that are not produced by the
+        // core completion algorithm (e.g. product-specific synthesized completions).
+    }
     getMethodOverrideCompletions(priorWord, partialName, decorators) {
         const enclosingClass = ParseTreeUtils.getEnclosingClass(partialName, /* stopAtFunction */ true);
         if (!enclosingClass) {
@@ -441,7 +446,7 @@ class CompletionProvider {
             }
             // 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);
+            const type = this._getTypeOfSymbol(symbol, detail, name);
             if (!type) {
                 // Can't resolve. so bail out.
                 return;
@@ -737,6 +742,39 @@ class CompletionProvider {
     get _fileContents() {
         return this.parseResults?.text ?? '';
     }
+    _getTypeOfSymbol(symbol, detail, memberName) {
+        const originalType = this.evaluator.getEffectiveTypeOfSymbol(symbol);
+        if (!originalType) {
+            return undefined;
+        }
+        // If this completion item came from a member access on an object
+        // (as opposed to a name completion), compute the accessed type
+        // so descriptors report the correct type via __get__.
+        //
+        // Note that we intentionally exclude `property` here. `getTypeDetail` already
+        // understands `property` and includes the `(property)` suffix in hover/docs.
+        if (!detail.boundObjectOrClass || !types_1.TypeBase.isInstance(detail.boundObjectOrClass)) {
+            return originalType;
+        }
+        if ((0, typeUtils_1.isProperty)(originalType) || !(0, typeUtils_1.isMaybeDescriptorInstance)(originalType, /* requireSetter */ false)) {
+            return originalType;
+        }
+        const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
+        if (offset === undefined) {
+            return originalType;
+        }
+        const node = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, offset);
+        const memberAccessNode = node
+            ? ParseTreeUtils.getParentNodeOfType(node, 35 /* ParseNodeType.MemberAccess */)
+            : undefined;
+        if (!memberAccessNode || memberAccessNode.nodeType !== 35 /* ParseNodeType.MemberAccess */) {
+            return originalType;
+        }
+        const boundType = this.evaluator.getTypeOfBoundMember(memberAccessNode, detail.boundObjectOrClass, memberName, 
+        /* usage */ undefined, 
+        /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
+        return boundType?.type ?? originalType;
+    }
     _getCompletions() {
         const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
         if (offset === undefined) {
@@ -779,6 +817,18 @@ class CompletionProvider {
                 }
                 const curNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, curOffset);
                 if (curNode && curNode !== initialNode) {
+                    if ((curNode.nodeType === 48 /* ParseNodeType.StringList */ ||
+                        curNode.nodeType === 49 /* ParseNodeType.String */ ||
+                        curNode.nodeType === 30 /* ParseNodeType.FormatString */) &&
+                        !(textRange_1.TextRange.contains(curNode, offset) || textRange_1.TextRange.getEnd(curNode) === offset)) {
+                        // When completing after something like a trailing comma, ParseTreeUtils may return the
+                        // preceding string node even though the cursor is outside the string.
+                        //
+                        // In that case, intentionally stop scanning and keep the existing context node
+                        // (typically a call). Continuing would only move further into the previous argument and
+                        // could select an even more misleading context.
+                        break;
+                    }
                     if (ParseTreeUtils.getNodeDepth(curNode) > initialDepth) {
                         node = curNode;
                         // If we're at the end of a list with a hanging comma, handle the
@@ -1396,6 +1446,7 @@ class CompletionProvider {
         /* atArgument */ false, completionMap);
         // Add symbols that are in scope.
         this._addSymbols(parseNode, priorWord, completionMap);
+        this.addAdditionalExpressionCompletions(parseNode, priorWord, completionMap);
         // Add keywords.
         this._findMatchingKeywords(Keywords.forVersion(this.execEnv.pythonVersion), priorWord).map((keyword) => {
             if (completionMap.has(keyword)) {
@@ -1441,7 +1492,6 @@ class CompletionProvider {
                 if (!atArgument) {
                     this._addNamedParameters(signatureInfo, priorWord, completionMap);
                 }
-                // Add literals that apply to this parameter.
                 this._addLiteralValuesForArgument(signatureInfo, priorWord, priorText, postText, completionMap);
             }
         }
@@ -1640,48 +1690,9 @@ class CompletionProvider {
         if (!parentAndChild) {
             return false;
         }
-        // See if the type evaluator can determine the expected type for this node.
-        // ex) a: Literal["str"] = /* here */
-        const nodeForExpectedType = parentAndChild.parent.nodeType === 3 /* ParseNodeType.Assignment */
-            ? parentAndChild.parent.d.rightExpr === parentAndChild.child
-                ? parentAndChild.child
-                : undefined
-            : (0, parseNodes_1.isExpressionNode)(parentAndChild.child)
-                ? parentAndChild.child
-                : undefined;
-        const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
-        const inCallArg = !!(0, parseTreeUtils_1.getCallNodeAndActiveParamIndex)(parseNode, offset, this.parseResults.tokenizerOutput.tokens);
-        if (nodeForExpectedType) {
-            const expectedTypeResult = this.evaluator.getExpectedType(nodeForExpectedType);
-            if (expectedTypeResult && (0, typeUtils_1.containsLiteralType)(expectedTypeResult.type)) {
-                this._addLiteralValuesForTargetType(expectedTypeResult.type, priorWord, priorText, postText, completionMap);
-                if (!inCallArg) {
-                    return true;
-                }
-            }
-        }
-        // ex) a: TypedDictType = { "/* here */" } or a: TypedDictType = { A/* here */ }
-        const nodeForKey = parentAndChild.parent;
-        if (nodeForKey) {
-            // If the dictionary is not yet filled in, it will appear as though it's
-            // a set initially.
-            let dictOrSet;
-            if (nodeForKey.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */ &&
-                nodeForKey.d.keyExpr === parentAndChild.child &&
-                nodeForKey.parent?.nodeType === 18 /* ParseNodeType.Dictionary */) {
-                dictOrSet = nodeForKey.parent;
-            }
-            else if (nodeForKey?.nodeType === 45 /* ParseNodeType.Set */) {
-                dictOrSet = nodeForKey;
-            }
-            if (dictOrSet) {
-                if (this._tryAddTypedDictKeysFromDictionary(dictOrSet, parseNode.nodeType === 49 /* ParseNodeType.String */ ? parseNode : undefined, priorWord, priorText, postText, completionMap)) {
-                    return true;
-                }
-            }
-        }
         // a: DictType = { .... }
         // a[/* here */] or a['/* here */'] or a[variable/*here*/]
+        // Check subscript/index context BEFORE assignment context to prioritize TypedDict keys
         const argument = parentAndChild.parent;
         if (argument.nodeType === 1 /* ParseNodeType.Argument */ && argument.parent?.nodeType === 27 /* ParseNodeType.Index */) {
             const priorTextInString = parseNode.nodeType === 49 /* ParseNodeType.String */ ? priorText : '';
@@ -1719,15 +1730,62 @@ class CompletionProvider {
                 return true;
             }
         }
+        // See if the type evaluator can determine the expected type for this node.
+        // ex) a: Literal["str"] = /* here */
+        const nodeForExpectedType = parentAndChild.parent.nodeType === 3 /* ParseNodeType.Assignment */
+            ? parentAndChild.parent.d.rightExpr === parentAndChild.child
+                ? parentAndChild.child
+                : undefined
+            : (0, parseNodes_1.isExpressionNode)(parentAndChild.child)
+                ? parentAndChild.child
+                : undefined;
+        const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
+        const inCallArg = !!(0, parseTreeUtils_1.getCallNodeAndActiveParamIndex)(parseNode, offset, this.parseResults.tokenizerOutput.tokens);
+        if (nodeForExpectedType) {
+            const expectedTypeResult = this.evaluator.getExpectedType(nodeForExpectedType);
+            if (expectedTypeResult &&
+                this._addLiteralValuesForExpectedTypes(nodeForExpectedType, expectedTypeResult, priorWord, priorText, postText, completionMap)) {
+                if (!inCallArg) {
+                    return true;
+                }
+            }
+        }
+        // ex) a: TypedDictType = { "/* here */" } or a: TypedDictType = { A/* here */ }
+        const nodeForKey = parentAndChild.parent;
+        if (nodeForKey) {
+            // If the dictionary is not yet filled in, it will appear as though it's
+            // a set initially.
+            let dictOrSet;
+            if (nodeForKey.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */ &&
+                nodeForKey.d.keyExpr === parentAndChild.child &&
+                nodeForKey.parent?.nodeType === 18 /* ParseNodeType.Dictionary */) {
+                dictOrSet = nodeForKey.parent;
+            }
+            else if (nodeForKey?.nodeType === 45 /* ParseNodeType.Set */) {
+                dictOrSet = nodeForKey;
+            }
+            if (dictOrSet) {
+                if (this._tryAddTypedDictKeysFromDictionary(dictOrSet, parseNode.nodeType === 49 /* ParseNodeType.String */ ? parseNode : undefined, priorWord, priorText, postText, completionMap)) {
+                    return true;
+                }
+            }
+        }
         // if c == "/* here */"
         const comparison = parentAndChild.parent;
         const supportedOperators = [2 /* OperatorType.Assign */, 12 /* OperatorType.Equals */, 28 /* OperatorType.NotEquals */];
         if (comparison.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
             supportedOperators.includes(comparison.d.operator)) {
             const type = this.evaluator.getType(comparison.d.leftExpr);
-            if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
-                return true;
+            if (type) {
+                if ((0, typeUtils_1.containsLiteralType)(type)) {
+                    this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                    return true;
+                }
+                const enumValueLiteralType = getStringLiteralValueTypeFromEnumType(this.evaluator, type);
+                if (enumValueLiteralType) {
+                    this._addLiteralValuesForTargetType(enumValueLiteralType, priorWord, priorText, postText, completionMap);
+                    return true;
+                }
             }
         }
         // if c := "/* here */"
@@ -1740,35 +1798,8 @@ class CompletionProvider {
                 return true;
             }
         }
-        // For now, we only support simple cases. no complex pattern matching.
-        // match c:
-        //     case /* here */
-        const caseNode = parentAndChild.parent;
-        if (caseNode.nodeType === 64 /* ParseNodeType.Case */ &&
-            caseNode.d.pattern.nodeType === 0 /* ParseNodeType.Error */ &&
-            caseNode.d.pattern.d.category === 11 /* ErrorExpressionCategory.MissingPattern */ &&
-            caseNode.d.suite === parentAndChild.child &&
-            caseNode.parent?.nodeType === 63 /* ParseNodeType.Match */) {
-            const type = this.evaluator.getType(caseNode.parent.d.expr);
-            if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
-                return true;
-            }
-        }
-        // match c:
-        //     case "/* here */"
-        //     case Sym/*here*/
-        const patternLiteral = parentAndChild.parent;
-        if ((patternLiteral.nodeType === 67 /* ParseNodeType.PatternLiteral */ ||
-            patternLiteral.nodeType === 69 /* ParseNodeType.PatternCapture */) &&
-            patternLiteral.parent?.nodeType === 66 /* ParseNodeType.PatternAs */ &&
-            patternLiteral.parent.parent?.nodeType === 64 /* ParseNodeType.Case */ &&
-            patternLiteral.parent.parent.parent?.nodeType === 63 /* ParseNodeType.Match */) {
-            const type = this.evaluator.getType(patternLiteral.parent.parent.parent.d.expr);
-            if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
-                return true;
-            }
+        if (this._tryAddMatchCaseLiteralCompletions(parentAndChild, priorWord, priorText, postText, completionMap)) {
+            return true;
         }
         if (parseNode.nodeType === 49 /* ParseNodeType.String */) {
             const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
@@ -1777,6 +1808,33 @@ class CompletionProvider {
             return true;
         }
         return false;
+        function getStringLiteralValueTypeFromEnumType(evaluator, type) {
+            const enumValueTypes = [];
+            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isEnumClass(subtype)) {
+                    return;
+                }
+                const enumClassType = types_1.ClassType.cloneAsInstantiable(subtype);
+                const enumMemberSymbols = new Map();
+                (0, typeUtils_1.getMembersForClass)(enumClassType, enumMemberSymbols, /* includeInstanceVars */ false);
+                enumMemberSymbols.forEach((_, name) => {
+                    const enumMemberType = (0, enums_1.transformTypeForEnumMember)(evaluator, enumClassType, name);
+                    if (!enumMemberType || !(0, types_1.isClassInstance)(enumMemberType)) {
+                        return;
+                    }
+                    const literalValue = enumMemberType.priv.literalValue;
+                    if (!(literalValue instanceof types_1.EnumLiteral)) {
+                        return;
+                    }
+                    (0, typeUtils_1.doForEachSubtype)(literalValue.itemType, (valueSubtype) => {
+                        if ((0, types_1.isClassInstance)(valueSubtype) && typeof valueSubtype.priv.literalValue === 'string') {
+                            enumValueTypes.push(valueSubtype);
+                        }
+                    });
+                });
+            });
+            return enumValueTypes.length > 0 ? (0, types_1.combineTypes)(enumValueTypes) : undefined;
+        }
         function getParentSkippingStringList(node) {
             if (!node.parent) {
                 return undefined;
@@ -1793,6 +1851,122 @@ class CompletionProvider {
             return { parent: node.parent.parent, child: node.parent };
         }
     }
+    _tryAddMatchCaseLiteralCompletions(parentAndChild, priorWord, priorText, postText, completionMap) {
+        // For now, we only support simple cases. no complex pattern matching.
+        // match c:
+        //     case /* here */
+        // and
+        // match c:
+        //     case "/* here */"
+        //     case Sym/*here*/
+        const parent = parentAndChild.parent;
+        let matchNode;
+        let caseNode;
+        if (parent.nodeType === 64 /* ParseNodeType.Case */ &&
+            parent.d.pattern.nodeType === 0 /* ParseNodeType.Error */ &&
+            parent.d.pattern.d.category === 11 /* ErrorExpressionCategory.MissingPattern */ &&
+            parent.d.suite === parentAndChild.child &&
+            parent.parent?.nodeType === 63 /* ParseNodeType.Match */) {
+            matchNode = parent.parent;
+            caseNode = parent;
+        }
+        else if ((parent.nodeType === 67 /* ParseNodeType.PatternLiteral */ || parent.nodeType === 69 /* ParseNodeType.PatternCapture */) &&
+            parent.parent?.nodeType === 66 /* ParseNodeType.PatternAs */ &&
+            parent.parent.parent?.nodeType === 64 /* ParseNodeType.Case */ &&
+            parent.parent.parent.parent?.nodeType === 63 /* ParseNodeType.Match */) {
+            matchNode = parent.parent.parent.parent;
+            caseNode = parent.parent.parent;
+        }
+        else {
+            return false;
+        }
+        const type = this._getFilteredMatchSubjectTypeForCaseCompletions(matchNode, caseNode);
+        if (type && (0, typeUtils_1.containsLiteralType)(type)) {
+            this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+            return true;
+        }
+        return false;
+    }
+    _addLiteralValuesForExpectedTypes(expressionNode, expectedTypeResult, priorWord, priorText, postText, completionMap) {
+        if (!this._canUseExpectedTypeForLiteralCompletion(expressionNode, expectedTypeResult.node)) {
+            return false;
+        }
+        let addedLiteralValues = false;
+        for (const candidateType of expectedTypeResult.candidates) {
+            if (!(0, typeUtils_1.containsLiteralType)(candidateType)) {
+                continue;
+            }
+            this._addLiteralValuesForTargetType(candidateType, priorWord, priorText, postText, completionMap);
+            addedLiteralValues = true;
+        }
+        return addedLiteralValues;
+    }
+    _canUseExpectedTypeForLiteralCompletion(expressionNode, expectedTypeNode) {
+        return expressionNode === expectedTypeNode;
+    }
+    _getFilteredMatchSubjectTypeForCaseCompletions(matchNode, currentCaseNode) {
+        const getPriorCaseStringLiteralValues = () => {
+            const values = new Set();
+            const currentIndex = matchNode.d.cases.findIndex((c) => c === currentCaseNode);
+            if (currentIndex <= 0) {
+                return values;
+            }
+            for (let i = 0; i < currentIndex; i++) {
+                const caseNode = matchNode.d.cases[i];
+                // Be conservative: a guard means the case may not actually match.
+                if (caseNode.d.guardExpr) {
+                    continue;
+                }
+                addStringLiteralValuesFromPattern(caseNode.d.pattern, values);
+            }
+            return values;
+        };
+        const addStringLiteralValuesFromPattern = (pattern, values) => {
+            if (pattern.nodeType === 67 /* ParseNodeType.PatternLiteral */) {
+                addStringLiteralValuesFromExpression(pattern.d.expr, values);
+                return;
+            }
+            if (pattern.nodeType === 66 /* ParseNodeType.PatternAs */) {
+                pattern.d.orPatterns.forEach((orPattern) => {
+                    addStringLiteralValuesFromPattern(orPattern, values);
+                });
+            }
+        };
+        const addStringLiteralValuesFromExpression = (expr, values) => {
+            if (expr.nodeType === 49 /* ParseNodeType.String */) {
+                values.add(expr.d.value);
+                return;
+            }
+            if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
+                // Be conservative: only treat it as covered if all pieces are plain string literals.
+                if (expr.d.strings.every((s) => s.nodeType === 49 /* ParseNodeType.String */)) {
+                    values.add(expr.d.strings.map((s) => s.d.value).join(''));
+                }
+            }
+        };
+        const type = this.evaluator.getType(matchNode.d.expr);
+        if (!type || !(0, typeUtils_1.containsLiteralType)(type)) {
+            return type;
+        }
+        const priorCaseLiteralValues = getPriorCaseStringLiteralValues();
+        if (priorCaseLiteralValues.size === 0) {
+            return type;
+        }
+        const remainingSubtypes = [];
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) &&
+                (0, typeUtils_1.isLiteralType)(subtype) &&
+                types_1.ClassType.isBuiltIn(subtype, 'str') &&
+                typeof subtype.priv.literalValue === 'string' &&
+                priorCaseLiteralValues.has(subtype.priv.literalValue)) {
+                return;
+            }
+            remainingSubtypes.push(subtype);
+        });
+        // If we've filtered everything out, don't offer any redundant literal completions.
+        // Other (non-literal) completion behaviors can still contribute suggestions.
+        return remainingSubtypes.length > 0 ? (0, types_1.combineTypes)(remainingSubtypes) : undefined;
+    }
     _tryAddTypedDictKeys(type, existingKeys, priorWord, priorText, postText, completionMap) {
         let typedDicts = [];
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
@@ -2241,8 +2415,11 @@ class CompletionProvider {
             completionMap.set(completionItem);
         }
         completions.forEach((modulePath, completionName) => {
+            const sortCategory = completionName.startsWith('_')
+                ? SortCategory.PrivateSymbol
+                : SortCategory.ImportModuleName;
             this.addNameToCompletions(completionName, vscode_languageserver_1.CompletionItemKind.Module, '', completionMap, {
-                sortText: this._makeSortText(SortCategory.ImportModuleName, completionName),
+                sortText: this._makeSortText(sortCategory, completionName),
                 moduleUri: modulePath,
             });
         });