@zzzen/pyright-internal 1.2.0-dev.20260614 → 1.2.0-dev.20260628

package/dist/languageService/completionProvider.js

@@ -24,16 +24,28 @@ 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;
+exports.hoistCompletionItemDataDefault = hoistCompletionItemDataDefault;
 const vscode_languageserver_1 = require("vscode-languageserver");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
 const AnalyzerNodeInfo = __importStar(require("../analyzer/analyzerNodeInfo"));
 const declaration_1 = require("../analyzer/declaration");
 const declarationUtils_1 = require("../analyzer/declarationUtils");
@@ -69,6 +81,7 @@ const tokenizer_1 = require("../parser/tokenizer");
 const autoImporter_1 = require("./autoImporter");
 const completionProviderUtils_1 = require("./completionProviderUtils");
 const documentSymbolCollector_1 = require("./documentSymbolCollector");
+const importStatementCandidates_1 = require("./importStatementCandidates");
 const tooltipUtils_1 = require("./tooltipUtils");
 var Keywords;
 (function (Keywords) {
@@ -111,7 +124,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;
         }
@@ -121,6 +138,45 @@ var Keywords;
         return base;
     }
     Keywords.forVersion = forVersion;
+    // Keywords that can only begin a statement and can never begin an expression,
+    // so they are suppressed in the expression-only slots recognized here. (Some
+    // of these, like `from`, can still appear *within* an expression form such as
+    // `yield from <expr>`, but never as the start of one.) Keywords like `if`,
+    // `else`, `for`, `in`, `lambda`, `yield`, and `await` are intentionally
+    // excluded because they can appear inside expressions (ternaries,
+    // comprehensions, lambdas, etc.).
+    // Keep in sync with the counterpart in
+    // pylance-internal/src/languageService/asyncCompletionProvider.ts.
+    const statementOnlyKeywords = new Set([
+        'assert',
+        'break',
+        'case',
+        'class',
+        'continue',
+        'def',
+        'del',
+        'elif',
+        'except',
+        'finally',
+        'from',
+        'global',
+        'import',
+        'match',
+        'nonlocal',
+        'pass',
+        'raise',
+        'return',
+        'try',
+        'type',
+        'while',
+        'with',
+    ]);
+    // Returns the version-appropriate keywords that are valid in an expression
+    // context (i.e. the full keyword set minus the statement-only keywords).
+    function expressionKeywordsForVersion(version) {
+        return forVersion(version).filter((keyword) => !statementOnlyKeywords.has(keyword));
+    }
+    Keywords.expressionKeywordsForVersion = expressionKeywordsForVersion;
 })(Keywords || (Keywords = {}));
 var SortCategory;
 (function (SortCategory) {
@@ -144,16 +200,48 @@ var SortCategory;
     SortCategory[SortCategory["Keyword"] = 7] = "Keyword";
     // An enum member.
     SortCategory[SortCategory["EnumMember"] = 8] = "EnumMember";
+    // A symbol declared directly on the object or class being accessed.
+    SortCategory[SortCategory["DeclaredSymbol"] = 9] = "DeclaredSymbol";
+    // A private symbol declared directly on the object or class being accessed.
+    SortCategory[SortCategory["DeclaredPrivateSymbol"] = 10] = "DeclaredPrivateSymbol";
     // A normal symbol.
-    SortCategory[SortCategory["NormalSymbol"] = 9] = "NormalSymbol";
+    SortCategory[SortCategory["NormalSymbol"] = 11] = "NormalSymbol";
     // A symbol that starts with _ or __ (used only when there is
     // no matching filter).
-    SortCategory[SortCategory["PrivateSymbol"] = 10] = "PrivateSymbol";
+    SortCategory[SortCategory["PrivateSymbol"] = 12] = "PrivateSymbol";
     // A symbol with a dunder name (e.g. __init__).
-    SortCategory[SortCategory["DunderSymbol"] = 11] = "DunderSymbol";
+    SortCategory[SortCategory["DunderSymbol"] = 13] = "DunderSymbol";
     // An auto-import symbol.
-    SortCategory[SortCategory["AutoImport"] = 12] = "AutoImport";
+    SortCategory[SortCategory["AutoImport"] = 14] = "AutoImport";
 })(SortCategory || (SortCategory = {}));
+// Publishes the shared completion item `data` fields (uri/position) once via
+// `CompletionList.itemDefaults.data` and requests a shallow merge via `CompletionList.applyKind`,
+// so each item only needs to carry its per-item data. Items are built without the shared fields in
+// the first place (see `createCompletionItemData`), so there is nothing to strip here. The client
+// reconstructs the full `data` (merging the defaults back in) before issuing a resolve request, so
+// the resolve handler is unaffected.
+//
+// The caller must only invoke this when the client advertises both
+// `completionList.itemDefaults` containing `data` and `completionList.applyKindSupport`.
+//
+// Note: `applyKind` only configures `data` (Merge); other itemDefaults (e.g. a future
+// `commitCharacters` default) would fall back to the client default of `Replace` unless this
+// object is extended. For data-less items (keywords, string literals) the shared `itemDefaults.data`
+// still applies via the client merge, but they have nothing to resolve. The resolve dispatch
+// short-circuits them by item kind so the merge doesn't drag them into a needless resolve
+// round-trip: keywords are identified by `CompletionItemKind.Keyword`, and string literals by
+// `CompletionItemKind.Constant` with no `symbolLabel` (data-bearing name completions always carry
+// a `symbolLabel`). Named-parameter items (`Variable`, no `symbolLabel`) are not kind-short-circuited
+// and may still reach resolve via the merge, but resolve is a no-op for them; the MRU is updated only
+// when a completion is accepted.
+function hoistCompletionItemDataDefault(list, fileUri, position) {
+    if (list.items.length === 0) {
+        return;
+    }
+    const sharedData = { uri: fileUri.toString(), position };
+    list.itemDefaults = { ...list.itemDefaults, data: (0, lspUtils_1.toLSPAny)(sharedData) };
+    list.applyKind = { ...list.applyKind, data: vscode_languageserver_types_1.ApplyKind.Merge };
+}
 exports.autoImportDetail = localize_1.Localizer.Completion.autoImportDetail();
 exports.indexValueDetail = localize_1.Localizer.Completion.indexValueDetail();
 // We'll use a somewhat-arbitrary cutoff value here to determine
@@ -180,24 +268,32 @@ class CompletionProvider {
             return null;
         }
         const completionMap = this._getCompletions();
-        return vscode_languageserver_1.CompletionList.create(completionMap?.toArray());
-    }
-    // When the user selects a completion, this callback is invoked,
-    // allowing us to record what was selected. This allows us to
-    // build our MRU cache so we can better predict entries.
-    resolveCompletionItem(completionItem) {
-        (0, cancellationUtils_1.throwIfCancellationRequested)(this.cancellationToken);
-        const completionItemData = this.getCompletionItemData(completionItem);
-        const label = completionItem.label;
-        let autoImportText = '';
-        if (completionItemData.autoImportText) {
-            autoImportText = completionItemData.autoImportText;
-        }
+        const completionList = vscode_languageserver_1.CompletionList.create(completionMap?.toArray());
+        if (this.options.completionItemDataDefault) {
+            hoistCompletionItemDataDefault(completionList, this.fileUri, this.position);
+        }
+        return completionList;
+    }
+    // Single source of truth for which completion item kinds participate in the MRU cache.
+    // Keyword items and data-less string-literal `Constant` items (no `symbolLabel`) carry no
+    // server-side identity: they are never resolved and were never recorded in the MRU. Every other
+    // kind can feed the MRU when accepted. Both the resolve short-circuit (languageService.ts) and the
+    // accept-command attach gate (asynchronousFeatures.ts) key off this predicate so MRU membership is
+    // defined in one place instead of as two hand-synced inverse checks.
+    static feedsMru(kind, hasSymbolLabel) {
+        return kind !== vscode_languageserver_1.CompletionItemKind.Keyword && !(kind === vscode_languageserver_1.CompletionItemKind.Constant && !hasSymbolLabel);
+    }
+    // Records an accepted completion in the MRU cache so we can better predict entries.
+    // This is called when a completion is actually committed (via the accept command), not when
+    // it is merely highlighted/previewed. Recording on highlight would let an inline preview that
+    // resolves on every keystroke reorder the list and make results oscillate.
+    static recordCompletionAccepted(label, autoImportText) {
         const curIndex = CompletionProvider._mostRecentCompletions.findIndex((item) => item.label === label && item.autoImportText === autoImportText);
         if (curIndex > 0) {
             // If there's an existing entry with the same name that's not at the
-            // beginning of the array, remove it.
-            CompletionProvider._mostRecentCompletions = CompletionProvider._mostRecentCompletions.splice(curIndex, 1);
+            // beginning of the array, remove it in place. (Array.splice mutates the
+            // array and returns the removed elements, so it must not be reassigned.)
+            CompletionProvider._mostRecentCompletions.splice(curIndex, 1);
         }
         if (curIndex !== 0) {
             // Add to the start of the array.
@@ -207,6 +303,13 @@ class CompletionProvider {
             // Prevent the MRU list from growing indefinitely.
             CompletionProvider._mostRecentCompletions.pop();
         }
+    }
+    // When the user highlights/previews a completion, this callback is invoked so we can fill in
+    // additional details (documentation, auto-import edits). It must NOT mutate the MRU cache; MRU
+    // updates happen only when a completion is accepted (see recordCompletionAccepted).
+    resolveCompletionItem(completionItem) {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(this.cancellationToken);
+        const completionItemData = this.getCompletionItemData(completionItem);
         if (!completionItemData.symbolLabel) {
             return;
         }
@@ -264,6 +367,17 @@ class CompletionProvider {
     getCompletionItemData(item) {
         return (0, lspUtils_1.fromLSPAny)(item.data);
     }
+    // Builds the `data` payload for a completion item. When the client supports `itemDefaults.data`
+    // (completionItemDataDefault), the shared `uri`/`position` live once in
+    // `CompletionList.itemDefaults.data` (see hoistCompletionItemDataDefault), so we never write them
+    // per item in the first place (rather than writing then stripping them); an item left with no
+    // per-item fields carries no `data` at all. Otherwise we inline `uri`/`position` on each item.
+    createCompletionItemData(data) {
+        if (!this.options.completionItemDataDefault) {
+            return (0, lspUtils_1.toLSPAny)({ uri: this.fileUri.toString(), position: this.position, ...data });
+        }
+        return Object.keys(data).length > 0 ? (0, lspUtils_1.toLSPAny)(data) : undefined;
+    }
     addAdditionalExpressionCompletions(parseNode, priorWord, completionMap) {
         // Default implementation is a no-op.
         // Subclasses can override to inject additional completion items that are not produced by the
@@ -406,6 +520,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;
@@ -476,6 +597,7 @@ class CompletionProvider {
             }
             this.addNameToCompletions(detail.autoImportAlias ?? name, itemKind, priorWord, completionMap, {
                 autoImportText,
+                declaredOnBoundObjectOrClass: detail.declaredOnBoundObjectOrClass,
                 extraCommitChars: detail.extraCommitChars,
                 funcParensDisabled: detail.funcParensDisabled,
                 edits: detail.edits,
@@ -487,6 +609,7 @@ class CompletionProvider {
             if (synthesizedType) {
                 const itemKind = this._convertTypeToItemKind(synthesizedType);
                 this.addNameToCompletions(name, itemKind, priorWord, completionMap, {
+                    declaredOnBoundObjectOrClass: detail.declaredOnBoundObjectOrClass,
                     extraCommitChars: detail.extraCommitChars,
                     funcParensDisabled: detail.funcParensDisabled,
                     edits: detail.edits,
@@ -494,7 +617,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 +632,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 +673,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;
     }
@@ -608,17 +743,13 @@ class CompletionProvider {
         if (detail?.extraCommitChars) {
             this.addExtraCommitChar(completionItem);
         }
-        const completionItemData = {
-            uri: this.fileUri.toString(),
-            position: this.position,
-        };
+        const completionItemData = {};
         if (detail?.funcParensDisabled || !this.options.snippet) {
             completionItemData.funcParensDisabled = true;
         }
         if (detail?.moduleUri) {
             completionItemData.moduleUri = detail.moduleUri.toString();
         }
-        completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
         if (detail?.sortText || detail?.itemDetail) {
             completionItem.sortText = detail.sortText;
             completionItem.detail = detail.itemDetail;
@@ -644,7 +775,10 @@ class CompletionProvider {
             // Distinguish between normal and private symbols only if there is
             // currently no filter text. Once we get a single character to filter
             // upon, we'll no longer differentiate.
-            completionItem.sortText = this._makeSortText(SortCategory.PrivateSymbol, name);
+            completionItem.sortText = this._makeSortText(detail?.declaredOnBoundObjectOrClass ? SortCategory.DeclaredPrivateSymbol : SortCategory.PrivateSymbol, name);
+        }
+        else if (filter === '' && detail?.declaredOnBoundObjectOrClass) {
+            completionItem.sortText = this._makeSortText(SortCategory.DeclaredSymbol, name);
         }
         else {
             completionItem.sortText = this._makeSortText(SortCategory.NormalSymbol, name);
@@ -720,6 +854,7 @@ class CompletionProvider {
                 }
             }
         }
+        completionItem.data = this.createCompletionItemData(completionItemData);
         completionMap.set(completionItem);
     }
     getAutoImportText(importName, importFrom, importAlias) {
@@ -1004,6 +1139,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 +1200,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 +1313,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;
@@ -1419,6 +1582,50 @@ class CompletionProvider {
         // For now, use the same logic for expressions and statements.
         return this._getExpressionCompletions(parseNode, priorWord, priorText, postText);
     }
+    // Returns true when `node` occupies a slot that can only contain an
+    // expression (never the start of a statement), so statement-only keywords
+    // must be suppressed. Biased toward a superset: only well-understood
+    // expression slots return true; anything uncertain returns false so the
+    // full keyword set is offered (it's better to leak a wrong keyword than to
+    // drop a valid one). Keep in sync with the counterpart in
+    // pylance-internal/src/languageService/asyncCompletionProvider.ts.
+    _isExpressionOnlySlot(node) {
+        const parent = node.parent;
+        if (!parent) {
+            return false;
+        }
+        switch (parent.nodeType) {
+            case 29 /* ParseNodeType.For */:
+                // The iterable of `for target in <iterable>` (but not the target).
+                return parent.d.iterableExpr === node;
+            case 12 /* ParseNodeType.ComprehensionFor */:
+                // The iterable of a comprehension `... for target in <iterable>`.
+                return parent.d.iterableExpr === node;
+            case 3 /* ParseNodeType.Assignment */:
+                // The right-hand side of `target = <value>` (but not the target).
+                return parent.d.rightExpr === node;
+            case 4 /* ParseNodeType.AssignmentExpression */:
+                // The right-hand side of a walrus `name := <value>`.
+                return parent.d.rightExpr === node;
+            case 1 /* ParseNodeType.Argument */:
+                // Any `ArgumentNode` slot: call arguments, subscript index items,
+                // class bases, and decorator arguments. A statement-only keyword
+                // is never valid in any of these, so suppressing it is always safe.
+                return true;
+            case 44 /* ParseNodeType.Return */:
+                // The value of `return <expr>`.
+                return parent.d.expr === node;
+            case 57 /* ParseNodeType.While */:
+                // The condition of `while <expr>:`.
+                return parent.d.testExpr === node;
+            case 22 /* ParseNodeType.If */:
+                // The condition of `if <expr>:` / `elif <expr>:` (elif is a
+                // nested `IfNode`).
+                return parent.d.testExpr === node;
+            default:
+                return false;
+        }
+    }
     _getExpressionCompletions(parseNode, priorWord, priorText, postText) {
         const isIndexArgument = this._isIndexArgument(parseNode);
         // If the user typed a "." as part of a number, don't present
@@ -1447,8 +1654,13 @@ class CompletionProvider {
         // 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) => {
+        // Add keywords. In slots that can only contain an expression, suppress
+        // keywords that are only valid at the start of a statement (e.g. don't
+        // offer `raise` in the iterable of a `for ... in`).
+        const keywords = this._isExpressionOnlySlot(parseNode)
+            ? Keywords.expressionKeywordsForVersion(this.execEnv.pythonVersion)
+            : Keywords.forVersion(this.execEnv.pythonVersion);
+        this._findMatchingKeywords(keywords, priorWord).map((keyword) => {
             if (completionMap.has(keyword)) {
                 return;
             }
@@ -1490,7 +1702,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 +1883,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 +2342,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 = {
@@ -2116,21 +2366,18 @@ class CompletionProvider {
         }
         // Access the imported module information, which is hanging
         // off the ImportFromNode.
-        const importInfo = AnalyzerNodeInfo.getImportInfo(importFromNode.d.module);
+        const importFromTarget = (0, importStatementCandidates_1.getImportFromTarget)(this.program, importFromNode);
+        const importInfo = importFromTarget.importInfo;
         if (!importInfo) {
             return undefined;
         }
         const completionMap = new CompletionMap();
-        const resolvedPath = importInfo.resolvedUris.length > 0
-            ? importInfo.resolvedUris[importInfo.resolvedUris.length - 1]
-            : uri_1.Uri.empty();
-        const parseResults = this.program.getParseResults(resolvedPath);
-        if (!parseResults) {
+        if (!importFromTarget.hasParseResults) {
             // Add the implicit imports.
             this._addImplicitImportsToCompletion(importInfo, importFromNode, priorWord, completionMap);
             return completionMap;
         }
-        const symbolTable = AnalyzerNodeInfo.getScope(parseResults.parserOutput.parseTree)?.symbolTable;
+        const symbolTable = importFromTarget.symbolTable;
         if (!symbolTable) {
             return completionMap;
         }
@@ -2168,7 +2415,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);
@@ -2195,13 +2442,16 @@ class CompletionProvider {
                 }
                 const completionItem = vscode_languageserver_1.CompletionItem.create(label);
                 completionItem.kind = vscode_languageserver_1.CompletionItemKind.Variable;
-                const completionItemData = {
-                    uri: this.fileUri.toString(),
-                    position: this.position,
-                };
-                completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
+                completionItem.data = this.createCompletionItemData({});
                 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);
             }
         });
@@ -2260,6 +2510,12 @@ class CompletionProvider {
     _addSymbolsForSymbolTable(symbolTable, includeSymbolCallback, priorWord, node, isInImport, boundObjectOrClass, completionMap) {
         const insideTypeAnnotation = ParseTreeUtils.isWithinAnnotationComment(node) ||
             ParseTreeUtils.isWithinTypeAnnotation(node, /* requireQuotedAnnotation */ false);
+        // `boundSymbolTable` holds only the fields declared directly on the leaf `boundObjectOrClass`,
+        // whereas `symbolTable` is the merged-MRO table that also includes inherited members. The
+        // declared-vs-inherited check below relies on this distinction, so callers must keep passing the
+        // leaf type here even if they iterate per-MRO-class; otherwise inherited members would be
+        // mis-bucketed as directly declared.
+        const boundSymbolTable = boundObjectOrClass ? types_1.ClassType.getSymbolTable(boundObjectOrClass) : undefined;
         symbolTable.forEach((symbol, name) => {
             // If there are no declarations or the symbol is not
             // exported from this scope, don't include it in the
@@ -2272,8 +2528,10 @@ class CompletionProvider {
                     // Skip func parens for classes when not a direct assignment or an argument (passed as a value)
                     const skipForClass = !this._shouldShowAutoParensForClass(symbol, node);
                     const skipForDecorator = node.parent?.nodeType === 16 /* ParseNodeType.Decorator */;
+                    const declaredOnBoundObjectOrClass = boundSymbolTable?.has(name);
                     this.addSymbol(name, symbol, priorWord, completionMap, {
                         boundObjectOrClass,
+                        declaredOnBoundObjectOrClass,
                         funcParensDisabled: isInImport || insideTypeAnnotation || skipForClass || skipForDecorator,
                         extraCommitChars: !isInImport && !!priorWord,
                     });
@@ -2312,6 +2570,8 @@ class CompletionProvider {
                 sortCategory = SortCategory.RecentImportModuleName;
             }
             else if (sortCategory === SortCategory.Keyword ||
+                sortCategory === SortCategory.DeclaredSymbol ||
+                sortCategory === SortCategory.DeclaredPrivateSymbol ||
                 sortCategory === SortCategory.NormalSymbol ||
                 sortCategory === SortCategory.PrivateSymbol ||
                 sortCategory === SortCategory.DunderSymbol) {
@@ -2394,13 +2654,7 @@ class CompletionProvider {
         }
     }
     _getImportModuleCompletions(node) {
-        const moduleDescriptor = {
-            leadingDots: node.d.leadingDots,
-            hasTrailingDot: node.d.hasTrailingDot || false,
-            nameParts: node.d.nameParts.map((part) => part.d.value),
-            importedSymbols: new Set(),
-        };
-        const completions = this.importResolver.getCompletionSuggestions(this.fileUri, this.execEnv, moduleDescriptor);
+        const completions = (0, importStatementCandidates_1.getModuleNameCompletionSuggestions)(this.importResolver, this.fileUri, this.execEnv, node);
         const completionMap = new CompletionMap();
         // If we're in the middle of a "from X import Y" statement, offer
         // the "import" keyword as a completion.