@zzzen/pyright-internal 1.2.0-dev.20260607 → 1.2.0-dev.20260621

package/dist/languageService/completionProvider.d.ts

@@ -13,7 +13,7 @@ import { Uri } from '../common/uri/uri';
 import { DecoratorNode, ExpressionNode, NameNode, ParseNode } from '../parser/parseNodes';
 import { ParseFileResults } from '../parser/parser';
 import { AutoImporter, AutoImportResult } from './autoImporter';
-import { CompletionDetail, SymbolDetail } from './completionProviderUtils';
+import { CompletionDetail, SymbolDetail, TrailingOverlap } from './completionProviderUtils';
 export interface CompletionItemData {
     uri: string;
     position: Position;
@@ -53,9 +53,10 @@ export declare class CompletionProvider {
     protected getMethodOverrideCompletions(priorWord: string, partialName: NameNode, decorators?: DecoratorNode[]): CompletionMap | undefined;
     protected printOverriddenMethodBody(classType: ClassType, isStaticMethod: boolean, isProperty: boolean, decl: FunctionDeclaration, insertAwait?: boolean): string;
     protected createReplaceEdits(priorWord: string, node: ParseNode | undefined, text: string): TextEdit;
+    protected createReplaceEditWithOverlap(priorWord: string, overlap: TrailingOverlap | undefined, text: string): TextEdit;
     protected shouldProcessDeclaration(declaration: Declaration | undefined): boolean;
     protected addSymbol(name: string, symbol: Symbol, priorWord: string, completionMap: CompletionMap, detail: SymbolDetail): void;
-    protected getMemberAccessCompletions(leftExprNode: ExpressionNode, priorWord: string): CompletionMap | undefined;
+    protected getMemberAccessCompletions(leftExprNode: ExpressionNode, priorWord: string, preserveEnumMembers?: boolean): CompletionMap | undefined;
     protected createAutoImporter(completionMap: CompletionMap, lazyEdit: boolean): AutoImporter;
     protected addAutoImportCompletions(priorWord: string, similarityLimit: number, lazyEdit: boolean, completionMap: CompletionMap, parensDisabled?: boolean): void;
     protected addImportResults(results: AutoImportResult[], priorWord: string, completionMap: CompletionMap, parensDisabled?: boolean): void;
@@ -69,6 +70,7 @@ export declare class CompletionProvider {
     private _getTypeOfSymbol;
     private _getCompletions;
     private _tryGetNameCompletions;
+    private _isRecoveredPatternMemberAccessName;
     private _isWithinComment;
     private _getExpressionErrorCompletions;
     private _getMissingMemberAccessNameCompletions;
@@ -88,6 +90,7 @@ export declare class CompletionProvider {
     private _getSubTypesWithLiteralValues;
     private _getIndexKeyType;
     private _getIndexKeys;
+    private _isSubscriptInTypeContext;
     private _getLiteralCompletions;
     private _tryAddLiterals;
     private _tryAddMatchCaseLiteralCompletions;

package/dist/languageService/completionProvider.js

@@ -24,13 +24,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompletionMap = exports.CompletionProvider = exports.indexValueDetail = exports.autoImportDetail = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
@@ -111,7 +121,11 @@ var Keywords;
     ];
     const python3_5 = [...base, 'async', 'await'];
     const python3_10 = [...python3_5, 'case', 'match'];
+    const python3_15 = [...python3_10, 'lazy'];
     function forVersion(version) {
+        if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(version, pythonVersion_1.pythonVersion3_15)) {
+            return python3_15;
+        }
         if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(version, pythonVersion_1.pythonVersion3_10)) {
             return python3_10;
         }
@@ -406,6 +420,13 @@ class CompletionProvider {
         };
         return vscode_languageserver_1.TextEdit.replace(range, text);
     }
+    createReplaceEditWithOverlap(priorWord, overlap, text) {
+        const range = {
+            start: { line: this.position.line, character: this.position.character - priorWord.length },
+            end: { line: this.position.line, character: this.position.character + (overlap?.consumedChars ?? 0) },
+        };
+        return vscode_languageserver_1.TextEdit.replace(range, text);
+    }
     shouldProcessDeclaration(declaration) {
         // By default, we allow all symbol/decl to be included in the completion.
         return true;
@@ -494,7 +515,7 @@ class CompletionProvider {
             }
         }
     }
-    getMemberAccessCompletions(leftExprNode, priorWord) {
+    getMemberAccessCompletions(leftExprNode, priorWord, preserveEnumMembers = false) {
         const symbolTable = new Map();
         const completionMap = new CompletionMap();
         let leftType = this.evaluator.getType(leftExprNode);
@@ -509,14 +530,26 @@ class CompletionProvider {
         }
         (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
             subtype = this.evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            let resolvedClassSubtype;
             if ((0, types_1.isClass)(subtype)) {
-                const instance = types_1.TypeBase.isInstance(subtype);
-                (0, typeUtils_1.getMembersForClass)(subtype, symbolTable, instance);
-                if (types_1.ClassType.isEnumClass(subtype) && instance) {
+                if (preserveEnumMembers && types_1.ClassType.isEnumClass(subtype) && types_1.TypeBase.isInstance(subtype)) {
+                    // Preserve enum members by switching back to the class view before member enumeration.
+                    resolvedClassSubtype = types_1.ClassType.cloneAsInstantiable(subtype);
+                }
+                else {
+                    resolvedClassSubtype = subtype;
+                }
+                const instance = types_1.TypeBase.isInstance(resolvedClassSubtype);
+                (0, typeUtils_1.getMembersForClass)(resolvedClassSubtype, symbolTable, instance);
+                if (types_1.ClassType.isEnumClass(resolvedClassSubtype) && instance && !preserveEnumMembers) {
                     // Don't show enum member out of another enum member
-                    // ex) Enum.Member. <= shouldn't show `Member` again.
+                    // ex) Enum.Member. <= shouldn't show `Member` again. This pruning stays separate
+                    // from the clone above because the clone only changes which members are enumerated.
+                    // Note: when preserveEnumMembers=true, the cloneAsInstantiable above already makes
+                    // instance=false, so this block is independently unreachable. The explicit
+                    // !preserveEnumMembers guard is defense-in-depth for clarity.
                     for (const name of symbolTable.keys()) {
-                        if (this._isEnumMember(subtype, name)) {
+                        if (this._isEnumMember(resolvedClassSubtype, name)) {
                             symbolTable.delete(name);
                         }
                     }
@@ -538,7 +571,7 @@ class CompletionProvider {
                 }
             }
             this._addSymbolsForSymbolTable(symbolTable, () => true, priorWord, leftExprNode, 
-            /* isInImport */ false, (0, types_1.isClass)(subtype) ? subtype : undefined, completionMap);
+            /* isInImport */ false, resolvedClassSubtype, completionMap);
         });
         return completionMap;
     }
@@ -1004,6 +1037,12 @@ class CompletionProvider {
         if (curNode.parent.nodeType === 35 /* ParseNodeType.MemberAccess */ && curNode === curNode.parent.d.member) {
             return this.getMemberAccessCompletions(curNode.parent.d.leftExpr, priorWord);
         }
+        if (this._isRecoveredPatternMemberAccessName(curNode, priorWord, priorText)) {
+            // Pass curNode (the Name node) rather than a MemberAccess leftExpr: the type evaluator
+            // resolves the Name to the same class type, and no MemberAccess parent exists in this
+            // recovered-pattern context.
+            return this.getMemberAccessCompletions(curNode, priorWord, /* preserveEnumMembers */ true);
+        }
         if (curNode.parent.nodeType === 28 /* ParseNodeType.Except */ && curNode === curNode.parent.d.name) {
             return undefined;
         }
@@ -1059,6 +1098,17 @@ class CompletionProvider {
         }
         return false;
     }
+    _isRecoveredPatternMemberAccessName(curNode, priorWord, priorText) {
+        if (priorWord.length > 0 || !priorText.endsWith('.')) {
+            return false;
+        }
+        // Parser recovery keeps `case Direction.` as a `PatternCapture > Name`, so detect the
+        // trailing-dot text shape directly instead of waiting for a `MemberAccess` node.
+        if (curNode.parent?.nodeType !== 69 /* ParseNodeType.PatternCapture */) {
+            return false;
+        }
+        return !!ParseTreeUtils.getFirstAncestorOrSelfOfKind(curNode.parent, 64 /* ParseNodeType.Case */);
+    }
     _isWithinComment(offset) {
         const token = getTokenAfter(offset, this.parseResults.tokenizerOutput.tokens);
         if (!token) {
@@ -1161,6 +1211,17 @@ class CompletionProvider {
             case 3 /* ErrorExpressionCategory.MissingIndexOrSlice */: {
                 let completionResults = this._getLiteralCompletions(node, offset, priorWord, priorText, postText);
                 if (!completionResults) {
+                    if (node.d.category === 3 /* ErrorExpressionCategory.MissingIndexOrSlice */ &&
+                        this.options.triggerCharacter === '[' &&
+                        !this._isSubscriptInTypeContext(node)) {
+                        // When `[` auto-triggers a subscript and there are no literal key
+                        // suggestions, return undefined so the caller produces an empty
+                        // CompletionList instead of noisy generic expression completions.
+                        // Skip this suppression inside type-like contexts (annotations,
+                        // class bases, type aliases) where generic subscripts are the
+                        // expected workflow.
+                        return undefined;
+                    }
                     completionResults = this._getExpressionCompletions(node, priorWord, priorText, postText);
                 }
                 return completionResults;
@@ -1490,7 +1551,7 @@ class CompletionProvider {
             const callNameEnd = (0, positionUtils_1.convertOffsetToPosition)(signatureInfo.callNode.d.leftExpr.start + signatureInfo.callNode.d.leftExpr.length, this.parseResults.tokenizerOutput.lines);
             if ((0, textRange_1.comparePositions)(this.position, callNameEnd) > 0) {
                 if (!atArgument) {
-                    this._addNamedParameters(signatureInfo, priorWord, completionMap);
+                    this._addNamedParameters(signatureInfo, priorWord, postText, completionMap);
                 }
                 this._addLiteralValuesForArgument(signatureInfo, priorWord, priorText, postText, completionMap);
             }
@@ -1671,6 +1732,42 @@ class CompletionProvider {
         }
         return Array.from(keys);
     }
+    _isSubscriptInTypeContext(node) {
+        // Standard type annotation contexts: TypeAnnotation, Parameter annotation, return annotation.
+        if (ParseTreeUtils.isWithinTypeAnnotation(node, /* requireQuotedAnnotation */ false)) {
+            return true;
+        }
+        // PEP 695 type alias: `type MyAlias = list[...]`
+        if (ParseTreeUtils.getParentNodeOfType(node, 77 /* ParseNodeType.TypeAlias */)) {
+            return true;
+        }
+        // Class bases: `class Foo(list[...])` or `class Foo(Generic[...])`
+        let curNode = node.parent;
+        while (curNode) {
+            if (curNode.nodeType === 1 /* ParseNodeType.Argument */ && curNode.parent?.nodeType === 10 /* ParseNodeType.Class */) {
+                return true;
+            }
+            if (curNode.nodeType === 50 /* ParseNodeType.Suite */ ||
+                curNode.nodeType === 31 /* ParseNodeType.Function */ ||
+                curNode.nodeType === 33 /* ParseNodeType.Lambda */) {
+                break;
+            }
+            curNode = curNode.parent;
+        }
+        // Old-style TypeAlias assignment: `MyAlias: TypeAlias = list[...]`
+        const assignmentNode = ParseTreeUtils.getParentNodeOfType(node, 3 /* ParseNodeType.Assignment */);
+        if (assignmentNode && assignmentNode.nodeType === 3 /* ParseNodeType.Assignment */) {
+            const leftExpr = assignmentNode.d.leftExpr;
+            if (leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+                const annotation = leftExpr.d.annotation;
+                if ((annotation.nodeType === 38 /* ParseNodeType.Name */ && annotation.d.value === 'TypeAlias') ||
+                    (annotation.nodeType === 35 /* ParseNodeType.MemberAccess */ && annotation.d.member.d.value === 'TypeAlias')) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     _getLiteralCompletions(parseNode, offset, priorWord, priorText, postText) {
         if (this.options.triggerCharacter === '"' || this.options.triggerCharacter === "'") {
             if (parseNode.start !== offset - 1) {
@@ -2094,11 +2191,13 @@ class CompletionProvider {
             rangeStartCol -= quoteInfo.priorWord.length;
         }
         // If the text after the insertion point is the closing quote,
-        // replace it.
+        // extend the replacement range so we don't end up with a duplicated
+        // quote after the completion is applied.
         let rangeEndCol = this.position.character;
         if (postText !== undefined) {
-            if (postText.startsWith(quoteInfo.quoteCharacter)) {
-                rangeEndCol++;
+            const overlap = (0, completionProviderUtils_1.detectTrailingOverlap)(quoteInfo.quoteCharacter, postText, 'adjacent');
+            if (overlap) {
+                rangeEndCol += overlap.consumedChars;
             }
         }
         const range = {
@@ -2168,7 +2267,7 @@ class CompletionProvider {
             }
         });
     }
-    _addNamedParameters(signatureInfo, priorWord, completionMap) {
+    _addNamedParameters(signatureInfo, priorWord, postText, completionMap) {
         const argNameSet = new Set();
         signatureInfo.signatures.forEach((signature) => {
             this._addNamedParametersToMap(signature.type, argNameSet);
@@ -2202,6 +2301,13 @@ class CompletionProvider {
                 completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
                 completionItem.sortText = this._makeSortText(SortCategory.NamedParameter, argName);
                 completionItem.filterText = argName;
+                // If the text immediately after the cursor already starts with
+                // `=`, extend the replacement range so we don't end up with
+                // `argName==` after the completion is applied (pylance-release#4808).
+                const overlap = (0, completionProviderUtils_1.detectTrailingOverlap)('=', postText, 'adjacent');
+                if (overlap) {
+                    completionItem.textEdit = this.createReplaceEditWithOverlap(priorWord, overlap, label);
+                }
                 completionMap.set(completionItem);
             }
         });