@zzzen/pyright-internal 1.2.0-dev.20260809 → 1.2.0-dev.20260823

package/dist/languageService/completionProvider.js

@@ -42,11 +42,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionMap = exports.CompletionProvider = exports.indexValueDetail = exports.autoImportDetail = void 0;
+exports.CompletionMap = exports.CompletionProvider = exports.indexValueDetail = exports.autoImportDetail = exports.SortCategory = 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 analyzerNodeInfo_1 = require("../analyzer/analyzerNodeInfo");
 const declaration_1 = require("../analyzer/declaration");
 const declarationUtils_1 = require("../analyzer/declarationUtils");
 const enums_1 = require("../analyzer/enums");
@@ -190,30 +191,32 @@ var SortCategory;
     SortCategory[SortCategory["ImportModuleName"] = 2] = "ImportModuleName";
     // A literal string.
     SortCategory[SortCategory["LiteralValue"] = 3] = "LiteralValue";
+    // A class that is one of the subject's union members in a `match`/`case` pattern.
+    SortCategory[SortCategory["MatchClassPattern"] = 4] = "MatchClassPattern";
     // A named parameter in a call expression.
-    SortCategory[SortCategory["NamedParameter"] = 4] = "NamedParameter";
+    SortCategory[SortCategory["NamedParameter"] = 5] = "NamedParameter";
     // A keyword or symbol that was recently used for completion.
-    SortCategory[SortCategory["RecentKeywordOrSymbol"] = 5] = "RecentKeywordOrSymbol";
+    SortCategory[SortCategory["RecentKeywordOrSymbol"] = 6] = "RecentKeywordOrSymbol";
     // An auto-import symbol that was recently used for completion.
-    SortCategory[SortCategory["RecentAutoImport"] = 6] = "RecentAutoImport";
+    SortCategory[SortCategory["RecentAutoImport"] = 7] = "RecentAutoImport";
     // A keyword in the python syntax.
-    SortCategory[SortCategory["Keyword"] = 7] = "Keyword";
+    SortCategory[SortCategory["Keyword"] = 8] = "Keyword";
     // An enum member.
-    SortCategory[SortCategory["EnumMember"] = 8] = "EnumMember";
+    SortCategory[SortCategory["EnumMember"] = 9] = "EnumMember";
     // A symbol declared directly on the object or class being accessed.
-    SortCategory[SortCategory["DeclaredSymbol"] = 9] = "DeclaredSymbol";
+    SortCategory[SortCategory["DeclaredSymbol"] = 10] = "DeclaredSymbol";
     // A private symbol declared directly on the object or class being accessed.
-    SortCategory[SortCategory["DeclaredPrivateSymbol"] = 10] = "DeclaredPrivateSymbol";
+    SortCategory[SortCategory["DeclaredPrivateSymbol"] = 11] = "DeclaredPrivateSymbol";
     // A normal symbol.
-    SortCategory[SortCategory["NormalSymbol"] = 11] = "NormalSymbol";
+    SortCategory[SortCategory["NormalSymbol"] = 12] = "NormalSymbol";
     // A symbol that starts with _ or __ (used only when there is
     // no matching filter).
-    SortCategory[SortCategory["PrivateSymbol"] = 12] = "PrivateSymbol";
+    SortCategory[SortCategory["PrivateSymbol"] = 13] = "PrivateSymbol";
     // A symbol with a dunder name (e.g. __init__).
-    SortCategory[SortCategory["DunderSymbol"] = 13] = "DunderSymbol";
+    SortCategory[SortCategory["DunderSymbol"] = 14] = "DunderSymbol";
     // An auto-import symbol.
-    SortCategory[SortCategory["AutoImport"] = 14] = "AutoImport";
-})(SortCategory || (SortCategory = {}));
+    SortCategory[SortCategory["AutoImport"] = 15] = "AutoImport";
+})(SortCategory || (exports.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
@@ -262,6 +265,7 @@ class CompletionProvider {
         this.execEnv = this.configOptions.findExecEnvironment(this.fileUri);
         this.parseResults = this.program.getParseResults(this.fileUri);
         this.sourceMapper = this.program.getSourceMapper(this.fileUri, this.cancellationToken, /* mapCompiled */ true);
+        this.nodeInfo = (0, analyzerNodeInfo_1.getInfoReader)(this.program);
     }
     getCompletions() {
         if (!this.program.getSourceFileInfo(this.fileUri)) {
@@ -592,7 +596,7 @@ class CompletionProvider {
             // Handle enum members specially. Enum members normally look like
             // variables, but the are declared using assignment expressions
             // within an enum class.
-            if (this._isEnumMember(detail.boundObjectOrClass, name)) {
+            if (this.isEnumMember(detail.boundObjectOrClass, name)) {
                 itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
             }
             this.addNameToCompletions(detail.autoImportAlias ?? name, itemKind, priorWord, completionMap, {
@@ -651,7 +655,7 @@ class CompletionProvider {
                     // 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(resolvedClassSubtype, name)) {
+                        if (this.isEnumMember(resolvedClassSubtype, name)) {
                             symbolTable.delete(name);
                         }
                     }
@@ -756,7 +760,7 @@ class CompletionProvider {
         }
         else if (detail?.autoImportText) {
             // Force auto-import entries to the end.
-            completionItem.sortText = this._makeSortText(SortCategory.AutoImport, `${name}.${this._formatInteger(detail.autoImportText.source.length, 2)}.${detail.autoImportText.source}`, detail.autoImportText.importText);
+            completionItem.sortText = this.makeSortText(SortCategory.AutoImport, `${name}.${this._formatInteger(detail.autoImportText.source.length, 2)}.${detail.autoImportText.source}`, detail.autoImportText.importText);
             completionItemData.autoImportText = detail.autoImportText.importText;
             completionItem.detail = exports.autoImportDetail;
             if (detail.autoImportText.source) {
@@ -765,23 +769,23 @@ class CompletionProvider {
         }
         else if (itemKind === vscode_languageserver_1.CompletionItemKind.EnumMember) {
             // Handle enum members separately so they are sorted above other symbols.
-            completionItem.sortText = this._makeSortText(SortCategory.EnumMember, name);
+            completionItem.sortText = this.makeSortText(SortCategory.EnumMember, name);
         }
         else if (SymbolNameUtils.isDunderName(name)) {
             // Force dunder-named symbols to appear after all other symbols.
-            completionItem.sortText = this._makeSortText(SortCategory.DunderSymbol, name);
+            completionItem.sortText = this.makeSortText(SortCategory.DunderSymbol, name);
         }
         else if (filter === '' && SymbolNameUtils.isPrivateOrProtectedName(name)) {
             // 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(detail?.declaredOnBoundObjectOrClass ? SortCategory.DeclaredPrivateSymbol : 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);
+            completionItem.sortText = this.makeSortText(SortCategory.DeclaredSymbol, name);
         }
         else {
-            completionItem.sortText = this._makeSortText(SortCategory.NormalSymbol, name);
+            completionItem.sortText = this.makeSortText(SortCategory.NormalSymbol, name);
         }
         completionItemData.symbolLabel = name;
         if (this.options.format === vscode_languageserver_1.MarkupKind.Markdown) {
@@ -874,6 +878,24 @@ class CompletionProvider {
             importText,
         };
     }
+    // Extension hook for `match`/`case` pattern-slot completions. The base implementation does
+    // nothing (it returns undefined so the normal expression path continues); a subclass
+    // (Pylance) overrides this to provide slot-aware pattern completions. When it returns a
+    // completion map (possibly empty, to deliberately suppress suggestions) the caller short-
+    // circuits and uses it; when it returns undefined the cursor is not in a pattern slot.
+    tryGetMatchCasePatternCompletions(_node, _priorWord, _priorText, _postText) {
+        return undefined;
+    }
+    isEnumMember(containingType, name) {
+        if (!containingType || !types_1.ClassType.isEnumClass(containingType)) {
+            return false;
+        }
+        const symbolType = (0, enums_1.transformTypeForEnumMember)(this.evaluator, containingType, name, (0, analyzerNodeInfo_1.getInfoReader)(this.evaluator));
+        return (symbolType &&
+            (0, types_1.isClassInstance)(symbolType) &&
+            types_1.ClassType.isSameGenericClass(symbolType, types_1.TypeBase.isInstance(containingType) ? containingType : types_1.ClassType.cloneAsInstance(containingType)) &&
+            symbolType.priv.literalValue instanceof types_1.EnumLiteral);
+    }
     get _fileContents() {
         return this.parseResults?.text ?? '';
     }
@@ -898,7 +920,7 @@ class CompletionProvider {
         if (offset === undefined) {
             return originalType;
         }
-        const node = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, offset);
+        const node = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, offset, this.nodeInfo);
         const memberAccessNode = node
             ? ParseTreeUtils.getParentNodeOfType(node, 35 /* ParseNodeType.MemberAccess */)
             : undefined;
@@ -915,7 +937,7 @@ class CompletionProvider {
         if (offset === undefined) {
             return undefined;
         }
-        let node = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, offset);
+        let node = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, offset, this.nodeInfo);
         // See if we're inside a string literal or an f-string statement.
         const token = ParseTreeUtils.getTokenOverlapping(this.parseResults.tokenizerOutput.tokens, offset);
         if (token?.type === 5 /* TokenType.String */) {
@@ -950,7 +972,7 @@ class CompletionProvider {
                 if (curChar === ',') {
                     sawComma = true;
                 }
-                const curNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, curOffset);
+                const curNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, curOffset, this.nodeInfo);
                 if (curNode && curNode !== initialNode) {
                     if ((curNode.nodeType === 48 /* ParseNodeType.StringList */ ||
                         curNode.nodeType === 49 /* ParseNodeType.String */ ||
@@ -1287,7 +1309,7 @@ class CompletionProvider {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
                     const previousOffset = textRange_1.TextRange.getEnd(prevToken);
-                    const previousNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, previousOffset);
+                    const previousNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, previousOffset, this.nodeInfo);
                     if (previousNode?.nodeType !== 0 /* ParseNodeType.Error */ ||
                         previousNode.d.category !== 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
@@ -1357,7 +1379,7 @@ class CompletionProvider {
     _createSingleKeywordCompletion(keyword) {
         const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
         completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
-        completionItem.sortText = this._makeSortText(SortCategory.LikelyKeyword, keyword);
+        completionItem.sortText = this.makeSortText(SortCategory.LikelyKeyword, keyword);
         const completionMap = new CompletionMap();
         completionMap.set(completionItem);
         return completionMap;
@@ -1392,7 +1414,7 @@ class CompletionProvider {
                 expandTypeAlias: false,
             });
             this.addNameToCompletions(text, vscode_languageserver_1.CompletionItemKind.Reference, priorWord, completionMap, {
-                sortText: this._makeSortText(SortCategory.LikelyKeyword, text),
+                sortText: this.makeSortText(SortCategory.LikelyKeyword, text),
             });
             return;
         }
@@ -1429,7 +1451,7 @@ class CompletionProvider {
             : 2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */;
         const text = `${ParseTreeUtils.printExpression(declWithTypeAnnotations[declWithTypeAnnotations.length - 1].typeAnnotationNode, printFlags)}`;
         this.addNameToCompletions(text, vscode_languageserver_1.CompletionItemKind.Reference, priorWord, completionMap, {
-            sortText: this._makeSortText(SortCategory.LikelyKeyword, text),
+            sortText: this.makeSortText(SortCategory.LikelyKeyword, text),
         });
     }
     _getClassVariableCompletions(partialName) {
@@ -1468,7 +1490,7 @@ class CompletionProvider {
         return completionMap.size > 0 ? completionMap : undefined;
     }
     _getMethodOverloadsCompletions(priorWord, partialName) {
-        const symbolTable = getSymbolTable(this.evaluator, partialName);
+        const symbolTable = getSymbolTable(this.evaluator, partialName, this.nodeInfo);
         if (!symbolTable) {
             return undefined;
         }
@@ -1498,7 +1520,7 @@ class CompletionProvider {
             }
         });
         return completionMap;
-        function getSymbolTable(evaluator, partialName) {
+        function getSymbolTable(evaluator, partialName, nodeInfo) {
             const enclosingClass = ParseTreeUtils.getEnclosingClass(partialName, false);
             if (enclosingClass) {
                 const classResults = evaluator.getTypeOfClass(enclosingClass);
@@ -1516,7 +1538,7 @@ class CompletionProvider {
             // For function overload, we only care about top level functions
             const moduleNode = ParseTreeUtils.getEnclosingModule(partialName);
             if (moduleNode) {
-                const moduleScope = AnalyzerNodeInfo.getScope(moduleNode);
+                const moduleScope = AnalyzerNodeInfo.getScope(moduleNode, nodeInfo);
                 return moduleScope?.symbolTable;
             }
             return undefined;
@@ -1622,12 +1644,32 @@ class CompletionProvider {
                 // The condition of `if <expr>:` / `elif <expr>:` (elif is a
                 // nested `IfNode`).
                 return parent.d.testExpr === node;
+            case 64 /* ParseNodeType.Case */:
+                // The guard of `case <pattern> if <expr>:`. The guard is a real
+                // expression (not a pattern), but a statement-only keyword is never
+                // valid there. The pattern slot itself is handled separately via
+                // `tryGetMatchCasePatternCompletions`.
+                return parent.d.guardExpr === node;
             default:
                 return false;
         }
     }
     _getExpressionCompletions(parseNode, priorWord, priorText, postText) {
         const isIndexArgument = this._isIndexArgument(parseNode);
+        // A `match`/`case` pattern slot is not an arbitrary expression: only a restricted
+        // grammar is valid there. When the cursor sits in such a slot, build a tailored
+        // completion set (filtered/narrowed to what can form a pattern) and short-circuit
+        // the generic symbol/keyword dump below. This runs before the numeric-literal and
+        // `with ... as` guards so that pattern slots whose node-resolution lands on a numeric
+        // element (e.g. `case (1, ‸)`, where the cursor resolves to the `1` literal) still get
+        // slot-aware completions. The base implementation returns undefined; Pylance overrides
+        // `tryGetMatchCasePatternCompletions` to provide the slot-aware set (and intentionally
+        // returns undefined when the cursor is inside the numeric literal being typed, e.g.
+        // `case 3.‸`, so the numeric guard below still suppresses completions there).
+        const matchCaseCompletions = this.tryGetMatchCasePatternCompletions(parseNode, priorWord, priorText, postText);
+        if (matchCaseCompletions) {
+            return matchCaseCompletions;
+        }
         // If the user typed a "." as part of a number, don't present
         // any completion options.
         if (!isIndexArgument && parseNode.nodeType === 40 /* ParseNodeType.Number */) {
@@ -1650,9 +1692,9 @@ class CompletionProvider {
         this._addClassVariableTypeAnnotationCompletions(priorWord, parseNode, completionMap);
         // Add call argument completions.
         this._addCallArgumentCompletions(parseNode, priorWord, priorText, postText, 
-        /* atArgument */ false, completionMap);
+        /* atArgument */ this._isInsideContainerArgument(parseNode), completionMap);
         // Add symbols that are in scope.
-        this._addSymbols(parseNode, priorWord, completionMap);
+        this.addSymbols(parseNode, priorWord, completionMap);
         this.addAdditionalExpressionCompletions(parseNode, priorWord, completionMap);
         // 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
@@ -1660,13 +1702,13 @@ class CompletionProvider {
         const keywords = this._isExpressionOnlySlot(parseNode)
             ? Keywords.expressionKeywordsForVersion(this.execEnv.pythonVersion)
             : Keywords.forVersion(this.execEnv.pythonVersion);
-        this._findMatchingKeywords(keywords, priorWord).map((keyword) => {
+        this.findMatchingKeywords(keywords, priorWord).map((keyword) => {
             if (completionMap.has(keyword)) {
                 return;
             }
             const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
             completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
-            completionItem.sortText = this._makeSortText(SortCategory.Keyword, keyword);
+            completionItem.sortText = this.makeSortText(SortCategory.Keyword, keyword);
             completionMap.set(completionItem);
         });
         // Add auto-import suggestions from other modules.
@@ -1689,6 +1731,34 @@ class CompletionProvider {
             currentNode.parent.d.leftExpr &&
             currentNode.parent.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */);
     }
+    _isInsideContainerArgument(node) {
+        // Walk up from the cursor node. If we reach a collection literal
+        // (list/dict/set/tuple) before reaching the enclosing call's argument,
+        // the cursor is inside a collection value rather than at an argument slot,
+        // so keyword-argument (named parameter) completions should be suppressed.
+        //
+        // A parenthesized single expression (e.g. `f(x=(value))`) is intentionally NOT a
+        // container: it parses as the inner expression, not a Tuple node, so the walk stops
+        // at the Argument/Call. Only an actual tuple literal (which has a comma) counts here.
+        //
+        // This is only consulted when the cursor is inside a call; the caller early-returns
+        // when there is no enclosing call, so a `true` result outside call context is a no-op.
+        let current = node;
+        while (current) {
+            switch (current.nodeType) {
+                case 34 /* ParseNodeType.List */:
+                case 18 /* ParseNodeType.Dictionary */:
+                case 45 /* ParseNodeType.Set */:
+                case 52 /* ParseNodeType.Tuple */:
+                    return true;
+                case 1 /* ParseNodeType.Argument */:
+                case 9 /* ParseNodeType.Call */:
+                    return false;
+            }
+            current = current.parent;
+        }
+        return false;
+    }
     _addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap) {
         // If we're within the argument list of a call, add parameter names.
         const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
@@ -1719,23 +1789,61 @@ class CompletionProvider {
                 return undefined;
             }
             const paramType = types_1.FunctionType.getParamType(type, paramIndex);
-            this._addLiteralValuesForTargetType(paramType, priorWord, priorText, postText, completionMap);
+            this.addLiteralValuesForTargetType(paramType, priorWord, priorText, postText, completionMap);
             return undefined;
         });
     }
-    _addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap) {
+    // Kept in place (rather than relocated above the private accessors) to minimize the subrepo diff.
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap) {
         const quoteValue = this._getQuoteInfo(priorWord, priorText);
+        // When the cursor is inside a string/bytes token, only offer the
+        // matching literal kind so a `b"..."` context doesn't surface str
+        // literals (and vice versa) for a mixed `Literal[b"x", "y"]`.
+        const insideStringToken = this._stringLiteralContainer !== undefined;
+        const insideBytesToken = insideStringToken && (this._stringLiteralContainer.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+        // The bytes re-wrap below hard-codes a single-char `b` prefix. A raw-bytes
+        // token (`rb"..."`/`br"..."`, prefixLength > 1) is outside the documented
+        // `b`-only scope; its multi-char prefix would make the replacement range
+        // off by one and leave a dangling prefix char, so don't offer bytes
+        // completions inside it.
+        const insideMultiCharPrefixToken = insideStringToken && this._stringLiteralContainer.prefixLength > 1;
         this._getSubTypesWithLiteralValues(type).forEach((v) => {
-            if (types_1.ClassType.isBuiltIn(v, 'str')) {
-                const value = (0, typePrinter_1.printLiteralValue)(v, quoteValue.quoteCharacter);
-                if (quoteValue.stringValue === undefined) {
-                    this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
-                        sortText: this._makeSortText(SortCategory.LiteralValue, v.priv.literalValue),
-                    });
+            const isStr = types_1.ClassType.isBuiltIn(v, 'str');
+            const isBytes = types_1.ClassType.isBuiltIn(v, 'bytes');
+            if (!isStr && !isBytes) {
+                return;
+            }
+            if (insideStringToken) {
+                if (isBytes && !insideBytesToken) {
+                    return;
                 }
-                else {
-                    this._addStringLiteralToCompletions(value.substr(1, value.length - 2), quoteValue, postText, completionMap);
+                if (isStr && insideBytesToken) {
+                    return;
                 }
+                if (isBytes && insideMultiCharPrefixToken) {
+                    return;
+                }
+            }
+            // `printLiteralValue` truncates long literals to a `…`-suffixed form.
+            // That is fine for a label, but the same text is used for the inserted
+            // source here, and inserting `…` would produce invalid, wrong code.
+            // Skip offering the completion rather than writing a broken value.
+            if ((0, typePrinter_1.isLiteralValueTruncated)(v)) {
+                return;
+            }
+            // Bytes literals are printed as `b"..."`; the `b` prefix must be
+            // stripped before re-wrapping and accounted for in the range.
+            const prefix = isBytes ? 'b' : '';
+            const value = (0, typePrinter_1.printLiteralValue)(v, quoteValue.quoteCharacter);
+            if (quoteValue.stringValue === undefined) {
+                this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
+                    sortText: this.makeSortText(SortCategory.LiteralValue, v.priv.literalValue),
+                });
+            }
+            else {
+                this._addStringLiteralToCompletions(value.substr(prefix.length + 1, value.length - prefix.length - 2), quoteValue, postText, completionMap, 
+                /* detail */ undefined, prefix, isBytes ? '"' : quoteValue.quoteCharacter);
             }
         });
     }
@@ -1812,6 +1920,14 @@ class CompletionProvider {
                     !types_1.ClassType.isEnumClass(v)) {
                     return;
                 }
+                // printLiteralValue truncates long str/bytes literals to a `…`-suffixed
+                // form. Since bare-bracket keys are inserted verbatim (str/bytes keys now
+                // route through _addStringLiteralToCompletions with a textEdit), offering
+                // a truncated key would write invalid, wrong source. Skip it (mirrors the
+                // annotation-path guard in addLiteralValuesForTargetType).
+                if ((0, typePrinter_1.isLiteralValueTruncated)(v)) {
+                    return;
+                }
                 keys.push((0, typePrinter_1.printLiteralValue)(v, this.parseResults.tokenizerOutput.predominantSingleQuoteCharacter));
             });
             if (keys.length > 0) {
@@ -1834,9 +1950,9 @@ class CompletionProvider {
         }
         let startingNode = indexNode.d.leftExpr;
         if (declaration.node) {
-            const scopeRoot = ParseTreeUtils.getEvaluationScopeNode(declaration.node).node;
+            const scopeRoot = ParseTreeUtils.getEvaluationScopeNode(declaration.node, this.nodeInfo).node;
             // Find the lowest tree to search the symbol.
-            if (ParseTreeUtils.getFileInfoFromNode(startingNode)?.fileUri.equals(ParseTreeUtils.getFileInfoFromNode(scopeRoot)?.fileUri)) {
+            if (ParseTreeUtils.getFileInfoFromNode(startingNode, this.nodeInfo)?.fileUri.equals(ParseTreeUtils.getFileInfoFromNode(scopeRoot, this.nodeInfo)?.fileUri)) {
                 startingNode = scopeRoot;
             }
         }
@@ -1921,7 +2037,11 @@ class CompletionProvider {
     }
     _getLiteralCompletions(parseNode, offset, priorWord, priorText, postText) {
         if (this.options.triggerCharacter === '"' || this.options.triggerCharacter === "'") {
-            if (parseNode.start !== offset - 1) {
+            // A prefixed string (e.g. b"" or r"") starts at the prefix, so the opening quote is
+            // offset by the prefix length. Account for that so typing the opening quote of a
+            // b"..." still triggers literal completions (matching plain str behavior).
+            const prefixLength = parseNode.nodeType === 49 /* ParseNodeType.String */ ? parseNode.d.token.prefixLength : 0;
+            if (parseNode.start + prefixLength !== offset - 1) {
                 // If completion is triggered by typing " or ', it must be the one that starts a string
                 // literal. In another word, it can't be something inside of another string or comment
                 return undefined;
@@ -1949,6 +2069,19 @@ class CompletionProvider {
             }
             const quoteInfo = this._getQuoteInfo(priorWord, priorTextInString);
             const keys = this._getIndexKeys(argument.parent, parseNode);
+            // When the cursor is inside a string/bytes token, only offer the matching
+            // literal kind so a `b"..."` context doesn't surface str keys (and vice versa).
+            const insideBytesToken = parseNode.nodeType === 49 /* ParseNodeType.String */ &&
+                this._stringLiteralContainer !== undefined &&
+                (this._stringLiteralContainer.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+            // The bytes re-wrap below hard-codes a single-char `b` prefix. A raw-bytes
+            // token (`rb"..."`/`br"..."`, prefixLength > 1) is outside the documented
+            // `b`-only scope; its multi-char prefix would make the replacement range
+            // off by one and leave a dangling prefix char, so don't offer bytes keys
+            // inside it. Mirrors the annotation-path guard.
+            const insideMultiCharPrefixToken = parseNode.nodeType === 49 /* ParseNodeType.String */ &&
+                this._stringLiteralContainer !== undefined &&
+                this._stringLiteralContainer.prefixLength > 1;
             let keyFound = false;
             for (const key of keys) {
                 if (completionMap.has(key)) {
@@ -1958,18 +2091,37 @@ class CompletionProvider {
                     //     print(dict[<key will come from symbol table provider>]))
                     continue;
                 }
-                const stringLiteral = /^["|'].*["|']$/.test(key);
+                // Index keys are printed via printLiteralValue (str as `"..."`, bytes as
+                // `b"..."`) or collected as raw source text. Recognize an optional bytes
+                // prefix; f/r/u prefixes never denote a distinct completable value here
+                // (f-strings can't be keys/Literals, and raw/unicode normalize to str).
+                const isBytesLiteral = /^[bB]["'].*["']$/.test(key);
+                const stringLiteral = isBytesLiteral || /^["'].*["']$/.test(key);
                 if (parseNode.nodeType === 49 /* ParseNodeType.String */ && !stringLiteral) {
                     continue;
                 }
+                if (parseNode.nodeType === 49 /* ParseNodeType.String */) {
+                    if (isBytesLiteral && !insideBytesToken) {
+                        continue;
+                    }
+                    if (!isBytesLiteral && insideBytesToken) {
+                        continue;
+                    }
+                    if (isBytesLiteral && insideMultiCharPrefixToken) {
+                        continue;
+                    }
+                }
                 keyFound = true;
                 if (stringLiteral) {
-                    const keyWithoutQuote = key.substr(1, key.length - 2);
-                    this._addStringLiteralToCompletions(keyWithoutQuote, quoteInfo, postText, completionMap, exports.indexValueDetail);
+                    // Bytes keys carry a `b`/`B` prefix; strip it (and the quotes) and
+                    // re-wrap using the key's own quote so raw/embedded quotes stay valid.
+                    const prefix = isBytesLiteral ? key[0] : '';
+                    const keyWithoutQuote = key.substr(prefix.length + 1, key.length - prefix.length - 2);
+                    this._addStringLiteralToCompletions(keyWithoutQuote, quoteInfo, postText, completionMap, exports.indexValueDetail, prefix, isBytesLiteral ? key[prefix.length] : undefined);
                 }
                 else {
                     this.addNameToCompletions(key, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
-                        sortText: this._makeSortText(SortCategory.LiteralValue, key),
+                        sortText: this.makeSortText(SortCategory.LiteralValue, key),
                         itemDetail: exports.indexValueDetail,
                     });
                 }
@@ -2026,12 +2178,12 @@ class CompletionProvider {
             const type = this.evaluator.getType(comparison.d.leftExpr);
             if (type) {
                 if ((0, typeUtils_1.containsLiteralType)(type)) {
-                    this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                    this.addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                     return true;
                 }
                 const enumValueLiteralType = getStringLiteralValueTypeFromEnumType(this.evaluator, type);
                 if (enumValueLiteralType) {
-                    this._addLiteralValuesForTargetType(enumValueLiteralType, priorWord, priorText, postText, completionMap);
+                    this.addLiteralValuesForTargetType(enumValueLiteralType, priorWord, priorText, postText, completionMap);
                     return true;
                 }
             }
@@ -2042,7 +2194,7 @@ class CompletionProvider {
             assignmentExpression.d.rightExpr === parentAndChild.child) {
             const type = this.evaluator.getType(assignmentExpression.d.name);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                this.addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
@@ -2066,7 +2218,7 @@ class CompletionProvider {
                 const enumMemberSymbols = new Map();
                 (0, typeUtils_1.getMembersForClass)(enumClassType, enumMemberSymbols, /* includeInstanceVars */ false);
                 enumMemberSymbols.forEach((_, name) => {
-                    const enumMemberType = (0, enums_1.transformTypeForEnumMember)(evaluator, enumClassType, name);
+                    const enumMemberType = (0, enums_1.transformTypeForEnumMember)(evaluator, enumClassType, name, (0, analyzerNodeInfo_1.getInfoReader)(evaluator));
                     if (!enumMemberType || !(0, types_1.isClassInstance)(enumMemberType)) {
                         return;
                     }
@@ -2100,11 +2252,12 @@ class CompletionProvider {
         }
     }
     _tryAddMatchCaseLiteralCompletions(parentAndChild, priorWord, priorText, postText, completionMap) {
-        // For now, we only support simple cases. no complex pattern matching.
+        // Basic literal-completion support for an empty case slot (`case /* here */`) or a `case`
+        // pattern that is already a literal or a capture name (`case "..."` / `case Sym`). Richer
+        // slot-aware pattern completions are provided by the subclass override of
+        // `tryGetMatchCasePatternCompletions`.
         // match c:
         //     case /* here */
-        // and
-        // match c:
         //     case "/* here */"
         //     case Sym/*here*/
         const parent = parentAndChild.parent;
@@ -2115,6 +2268,7 @@ class CompletionProvider {
             parent.d.pattern.d.category === 11 /* ErrorExpressionCategory.MissingPattern */ &&
             parent.d.suite === parentAndChild.child &&
             parent.parent?.nodeType === 63 /* ParseNodeType.Match */) {
+            // Empty case slot: `case /* here */`. Offer the subject type's literal values.
             matchNode = parent.parent;
             caseNode = parent;
         }
@@ -2128,9 +2282,12 @@ class CompletionProvider {
         else {
             return false;
         }
-        const type = this._getFilteredMatchSubjectTypeForCaseCompletions(matchNode, caseNode);
-        if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-            this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+        const type = this.getFilteredMatchSubjectTypeForCaseCompletions(matchNode, caseNode);
+        if (!type) {
+            return false;
+        }
+        if ((0, typeUtils_1.containsLiteralType)(type)) {
+            this.addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
             return true;
         }
         return false;
@@ -2144,7 +2301,7 @@ class CompletionProvider {
             if (!(0, typeUtils_1.containsLiteralType)(candidateType)) {
                 continue;
             }
-            this._addLiteralValuesForTargetType(candidateType, priorWord, priorText, postText, completionMap);
+            this.addLiteralValuesForTargetType(candidateType, priorWord, priorText, postText, completionMap);
             addedLiteralValues = true;
         }
         return addedLiteralValues;
@@ -2152,7 +2309,9 @@ class CompletionProvider {
     _canUseExpectedTypeForLiteralCompletion(expressionNode, expectedTypeNode) {
         return expressionNode === expectedTypeNode;
     }
-    _getFilteredMatchSubjectTypeForCaseCompletions(matchNode, currentCaseNode) {
+    // Kept in place (rather than relocated above the private accessors) to minimize the subrepo diff.
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    getFilteredMatchSubjectTypeForCaseCompletions(matchNode, currentCaseNode) {
         const getPriorCaseStringLiteralValues = () => {
             const values = new Set();
             const currentIndex = matchNode.d.cases.findIndex((c) => c === currentCaseNode);
@@ -2228,15 +2387,46 @@ class CompletionProvider {
         typedDicts = this._tryNarrowTypedDicts(typedDicts, existingKeys);
         const quoteInfo = this._getQuoteInfo(priorWord, priorText);
         const excludes = new Set(existingKeys);
+        // Collect the value type(s) for each key across all TypedDict subtypes. A key
+        // shared by a union of TypedDicts must advertise the union of its value types
+        // (that is the type produced by actually subscripting the union), not just the
+        // first subtype's value type.
+        const keyValueTypes = new Map();
         typedDicts.forEach((typedDict) => {
-            (0, typedDicts_1.getTypedDictMembersForClass)(this.evaluator, typedDict, /* allowNarrowed */ true).knownItems.forEach((_, key) => {
+            (0, typedDicts_1.getTypedDictMembersForClass)(this.evaluator, typedDict, /* allowNarrowed */ true).knownItems.forEach((entry, key) => {
                 // Unions of TypedDicts may define the same key.
                 if (excludes.has(key) || completionMap.has(key)) {
                     return;
                 }
-                excludes.add(key);
-                this._addStringLiteralToCompletions(key, quoteInfo, postText, completionMap);
+                let valueTypes = keyValueTypes.get(key);
+                if (!valueTypes) {
+                    valueTypes = [];
+                    keyValueTypes.set(key, valueTypes);
+                }
+                valueTypes.push(entry.valueType);
+            });
+        });
+        keyValueTypes.forEach((valueTypes, key) => {
+            // Short-circuit before the (relatively expensive) printType call on this hot
+            // path: skip keys that _addStringLiteralToCompletions would immediately drop,
+            // either because the typed prefix filters them out or because the quoted label
+            // already exists. These guards mirror the early returns in that helper.
+            if (!StringUtils.isPatternInSymbol(quoteInfo.filterText || '', key)) {
+                return;
+            }
+            const quotedLabel = `${quoteInfo.quoteCharacter}${key}${quoteInfo.quoteCharacter}`;
+            if (completionMap.has(quotedLabel)) {
+                return;
+            }
+            const valueType = valueTypes.length === 1 ? valueTypes[0] : (0, types_1.combineTypes)(valueTypes);
+            // The value type is surfaced as the completion item's detail. It must be set
+            // eagerly here: TypedDict key items carry no symbol, so resolveCompletionItem
+            // bails early and never lazily fills detail.
+            const valueTypeText = this.evaluator.printType(valueType, {
+                enforcePythonSyntax: true,
+                expandTypeAlias: false,
             });
+            this._addStringLiteralToCompletions(key, quoteInfo, postText, completionMap, valueTypeText);
         });
         return true;
     }
@@ -2323,20 +2513,35 @@ class CompletionProvider {
         }
         return this._tryAddTypedDictKeys(baseType, [], priorWord, priorText, postText, completionMap);
     }
-    _addStringLiteralToCompletions(value, quoteInfo, postText, completionMap, detail) {
+    _addStringLiteralToCompletions(value, quoteInfo, postText, completionMap, detail, prefix = '', valueQuoteCharacter) {
         if (!StringUtils.isPatternInSymbol(quoteInfo.filterText || '', value)) {
             return;
         }
-        const valueWithQuotes = `${quoteInfo.quoteCharacter}${value}${quoteInfo.quoteCharacter}`;
+        // The quote used to wrap the inserted literal must match how `value` was
+        // escaped. Bytes literals are always printed double-quoted (escaping only
+        // `"`), so they must be re-wrapped in double quotes even inside a single-
+        // quoted token; otherwise an embedded `'` would produce invalid source.
+        const wrapQuoteCharacter = valueQuoteCharacter ?? quoteInfo.quoteCharacter;
+        const valueWithQuotes = `${prefix}${wrapQuoteCharacter}${value}${wrapQuoteCharacter}`;
         if (completionMap.has(valueWithQuotes)) {
             return;
         }
         const completionItem = vscode_languageserver_1.CompletionItem.create(valueWithQuotes);
         completionItem.kind = vscode_languageserver_1.CompletionItemKind.Constant;
-        completionItem.sortText = this._makeSortText(SortCategory.LiteralValue, valueWithQuotes);
+        completionItem.sortText = this.makeSortText(SortCategory.LiteralValue, valueWithQuotes);
+        // When the inserted literal is wrapped in a different quote than the
+        // surrounding token (bytes are always double-quoted, even inside a
+        // single-quoted `b'...'` token), the label/insert text uses `"` while the
+        // text under the cursor uses `'`. The client fuzzy-filters the typed
+        // single-quoted text against the double-quoted label and would drop the
+        // item. Provide a filterText that matches the surrounding token's quote so
+        // the completion survives client-side filtering.
+        if (wrapQuoteCharacter !== quoteInfo.quoteCharacter) {
+            completionItem.filterText = `${prefix}${quoteInfo.quoteCharacter}${value}${quoteInfo.quoteCharacter}`;
+        }
         let rangeStartCol = this.position.character;
         if (quoteInfo.stringValue !== undefined) {
-            rangeStartCol -= quoteInfo.stringValue.length + 1;
+            rangeStartCol -= quoteInfo.stringValue.length + 1 + prefix.length;
         }
         else if (quoteInfo.priorWord) {
             rangeStartCol -= quoteInfo.priorWord.length;
@@ -2405,7 +2610,9 @@ class CompletionProvider {
             }
         });
     }
-    _findMatchingKeywords(keywordList, partialMatch) {
+    // Kept in place (rather than relocated above the private accessors) to minimize the subrepo diff.
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    findMatchingKeywords(keywordList, partialMatch) {
         return keywordList.filter((keyword) => {
             if (partialMatch) {
                 return StringUtils.isPatternInSymbol(partialMatch, keyword);
@@ -2443,7 +2650,7 @@ class CompletionProvider {
                 const completionItem = vscode_languageserver_1.CompletionItem.create(label);
                 completionItem.kind = vscode_languageserver_1.CompletionItemKind.Variable;
                 completionItem.data = this.createCompletionItemData({});
-                completionItem.sortText = this._makeSortText(SortCategory.NamedParameter, argName);
+                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
@@ -2469,14 +2676,16 @@ class CompletionProvider {
             }
         });
     }
-    _addSymbols(node, priorWord, completionMap) {
+    // Kept in place (rather than relocated above the private accessors) to minimize the subrepo diff.
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    addSymbols(node, priorWord, completionMap, includeSymbolCallback) {
         let curNode = node;
         while (curNode) {
             // Does this node have a scope associated with it?
-            let scope = (0, scopeUtils_1.getScopeForNode)(curNode);
+            let scope = (0, scopeUtils_1.getScopeForNode)(curNode, this.nodeInfo);
             if (scope) {
                 while (scope) {
-                    this._addSymbolsForSymbolTable(scope.symbolTable, () => true, priorWord, node, 
+                    this._addSymbolsForSymbolTable(scope.symbolTable, includeSymbolCallback ?? (() => true), priorWord, node, 
                     /* isInImport */ false, 
                     /* boundObject */ undefined, completionMap);
                     scope = scope.parent;
@@ -2487,14 +2696,17 @@ class CompletionProvider {
                     if (classType && (0, types_1.isInstantiableClass)(classType.classType)) {
                         classType.classType.shared.mro.forEach((baseClass, index) => {
                             if ((0, types_1.isInstantiableClass)(baseClass)) {
-                                this._addSymbolsForSymbolTable(types_1.ClassType.getSymbolTable(baseClass), (symbol) => {
+                                this._addSymbolsForSymbolTable(types_1.ClassType.getSymbolTable(baseClass), (symbol, name) => {
                                     if (!symbol.isClassMember()) {
                                         return false;
                                     }
                                     // Return only variables, not methods or classes.
-                                    return symbol
+                                    if (!symbol
                                         .getDeclarations()
-                                        .some((decl) => decl.type === 1 /* DeclarationType.Variable */);
+                                        .some((decl) => decl.type === 1 /* DeclarationType.Variable */)) {
+                                        return false;
+                                    }
+                                    return includeSymbolCallback ? includeSymbolCallback(symbol, name) : true;
                                 }, priorWord, node, 
                                 /* isInImport */ false, 
                                 /* boundObject */ undefined, completionMap);
@@ -2520,7 +2732,8 @@ class CompletionProvider {
             // If there are no declarations or the symbol is not
             // exported from this scope, don't include it in the
             // suggestion list unless we are in the same file.
-            const hidden = !(0, symbolUtils_1.isVisibleExternally)(symbol) && !symbol.getDeclarations().some((d) => (0, declarationUtils_1.isDefinedInFile)(d, this.fileUri));
+            const hidden = !(0, symbolUtils_1.isVisibleExternally)(symbol) &&
+                !symbol.getDeclarations().some((d) => (0, declarationUtils_1.isDefinedInFile)(d, this.fileUri, this.nodeInfo));
             if (!hidden && includeSymbolCallback(symbol, name)) {
                 // Don't add a symbol more than once. It may have already been
                 // added from an inner scope's symbol table.
@@ -2558,7 +2771,9 @@ class CompletionProvider {
     _getRecentListIndex(name, autoImportText) {
         return CompletionProvider._mostRecentCompletions.findIndex((item) => item.label === name && item.autoImportText === autoImportText);
     }
-    _makeSortText(sortCategory, name, autoImportText = '') {
+    // Kept in place (rather than relocated above the private accessors) to minimize the subrepo diff.
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    makeSortText(sortCategory, name, autoImportText = '') {
         const recentListIndex = this._getRecentListIndex(name, autoImportText);
         // If the label is in the recent list, modify the category
         // so it appears higher in our list.
@@ -2665,7 +2880,7 @@ class CompletionProvider {
             const keyword = 'import';
             const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
             completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
-            completionItem.sortText = this._makeSortText(SortCategory.Keyword, keyword);
+            completionItem.sortText = this.makeSortText(SortCategory.Keyword, keyword);
             completionMap.set(completionItem);
         }
         completions.forEach((modulePath, completionName) => {
@@ -2673,7 +2888,7 @@ class CompletionProvider {
                 ? SortCategory.PrivateSymbol
                 : SortCategory.ImportModuleName;
             this.addNameToCompletions(completionName, vscode_languageserver_1.CompletionItemKind.Module, '', completionMap, {
-                sortText: this._makeSortText(sortCategory, completionName),
+                sortText: this.makeSortText(sortCategory, completionName),
                 moduleUri: modulePath,
             });
         });
@@ -2684,16 +2899,6 @@ class CompletionProvider {
         // before doing more expensive type evaluation.
         return decl.isMethod && decl.node.d.decorators.length > 0;
     }
-    _isEnumMember(containingType, name) {
-        if (!containingType || !types_1.ClassType.isEnumClass(containingType)) {
-            return false;
-        }
-        const symbolType = (0, enums_1.transformTypeForEnumMember)(this.evaluator, containingType, name);
-        return (symbolType &&
-            (0, types_1.isClassInstance)(symbolType) &&
-            types_1.ClassType.isSameGenericClass(symbolType, types_1.TypeBase.isInstance(containingType) ? containingType : types_1.ClassType.cloneAsInstance(containingType)) &&
-            symbolType.priv.literalValue instanceof types_1.EnumLiteral);
-    }
 }
 exports.CompletionProvider = CompletionProvider;
 CompletionProvider._mostRecentCompletions = [];