basedpyright 1.34.0__py3-none-any.whl → 1.35.0__py3-none-any.whl

basedpyright/dist/pyright-langserver.js

@@ -93695,6 +93695,95 @@ class TypeInlayHintsWalker extends parseTreeWalker_1.ParseTreeWalker {
 exports.TypeInlayHintsWalker = TypeInlayHintsWalker;
 
 
+/***/ }),
+
+/***/ "../pyright-internal/src/analyzer/typeNameUtils.ts":
+/*!*********************************************************!*\
+  !*** ../pyright-internal/src/analyzer/typeNameUtils.ts ***!
+  \*********************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getLocalTypeNames = getLocalTypeNames;
+exports.getNestedClassNameParts = getNestedClassNameParts;
+const types_1 = __webpack_require__(/*! ./types */ "../pyright-internal/src/analyzer/types.ts");
+function handleSymbolTable(evaluator, type, symbolTable) {
+    const getFullName = (t) => ((0, types_1.isClass)(t) ? t.shared.fullName : t.priv.moduleName);
+    const fullName = getFullName(type);
+    // The symbols in symbolTable whose type is a non-instance class or a module
+    const symbols = [];
+    symbolTable.forEach((symbol, symbolName) => {
+        const symbolType = evaluator.getEffectiveTypeOfSymbol(symbol);
+        if (((0, types_1.isClass)(symbolType) && !types_1.TypeBase.isInstance(symbolType)) || (0, types_1.isModule)(symbolType)) {
+            symbols.push({ type: symbolType, localName: symbolName, fullName: getFullName(symbolType) });
+        }
+    });
+    // If there are symbols whose type has the same full name as `type`, return these
+    const exactMatches = symbols.filter((symbolInfo) => symbolInfo.fullName === fullName);
+    if (exactMatches.length > 0)
+        return exactMatches.map((symbolInfo) => symbolInfo.localName);
+    // If there are no full matches, try to find types whose name is a prefix to `type`’s full name
+    // and then recursively try to find a symbol with `type`’s full type.
+    return symbols
+        .filter((symbolInfo) => fullName.startsWith(symbolInfo.fullName))
+        .flatMap((symbolInfo) => handleSymbolTable(evaluator, type, (0, types_1.isClass)(symbolInfo.type) ? types_1.ClassType.getSymbolTable(symbolInfo.type) : symbolInfo.type.priv.fields).map((name) => `${symbolInfo.localName}.${name}`));
+}
+/**
+ * Determine the names (potentially including `.`) which can be used to reference `type` within `scope`.
+ *
+ * This function goes through the symbols defined within `scope` and its parent to find classes/modules
+ * whose full name is a prefix of `type`’s full name. For each of these, it recursively searches the symbols
+ * defined in that class/module for other classes/modules whose full name is a prefix of `type`’s full name
+ * until a type with `type`’s full name is found.
+ *
+ * For example, consider the following definition:
+ * ```python
+ * class A:
+ *     class B: pass
+ * ```
+ * After this, the type representing `A.B` has the local names `['A.B']`. However, if that definition is
+ * in a different module called `lib`, we have a few different cases for the local names of `A.B`
+ * depending on how `lib`/its members have been imported:
+ * - `import lib`: The local names are `['lib.A.B']`.
+ * - `import lib as mod`: The local names are `['mod.A.B']`.
+ * - `import lib as mod; from lib import A`: The local names are `['mod.A.B', 'A.B']`.
+ * - `import lib as mod; from lib import A as C`: The local names are `['mod.A.B', 'C.B']`.
+ */
+function getLocalTypeNames(evaluator, type, scope) {
+    const out = [];
+    let currentScope = scope;
+    while (currentScope) {
+        out.push(...handleSymbolTable(evaluator, type, currentScope.symbolTable));
+        currentScope = currentScope.parent;
+    }
+    return out;
+}
+/**
+ * Determine the parts names of `type` and its enclosing classes from least to most nested class.
+ *
+ * For example, if class `C` is defined in class `B`, which in turn is defined in class `A`,
+ * this function returns `['A', 'B', 'C']`.
+ *
+ * If there is anything but classes between `type` and the module it is defined in, e.g. if `type`
+ * is defined within a function, this function returns `undefined`.
+ */
+function getNestedClassNameParts(type) {
+    const parts = [];
+    let enclosingNode = type.shared.declaration ? type.shared.declaration?.node : undefined;
+    while (enclosingNode?.nodeType === 10 /* ParseNodeType.Class */ || enclosingNode?.nodeType === 50 /* ParseNodeType.Suite */) {
+        if (enclosingNode.nodeType === 10 /* ParseNodeType.Class */)
+            parts.push(enclosingNode.d.name.d.value);
+        enclosingNode = enclosingNode.parent;
+    }
+    if (enclosingNode?.nodeType !== 36 /* ParseNodeType.Module */) {
+        return undefined;
+    }
+    return parts.reverse();
+}
+
+
 /***/ }),
 
 /***/ "../pyright-internal/src/analyzer/typePrinter.ts":
@@ -118274,6 +118363,7 @@ const SymbolNameUtils = __importStar(__webpack_require__(/*! ../analyzer/symbolN
 const symbolUtils_1 = __webpack_require__(/*! ../analyzer/symbolUtils */ "../pyright-internal/src/analyzer/symbolUtils.ts");
 const typedDicts_1 = __webpack_require__(/*! ../analyzer/typedDicts */ "../pyright-internal/src/analyzer/typedDicts.ts");
 const typeDocStringUtils_1 = __webpack_require__(/*! ../analyzer/typeDocStringUtils */ "../pyright-internal/src/analyzer/typeDocStringUtils.ts");
+const typeNameUtils_1 = __webpack_require__(/*! ../analyzer/typeNameUtils */ "../pyright-internal/src/analyzer/typeNameUtils.ts");
 const typePrinter_1 = __webpack_require__(/*! ../analyzer/typePrinter */ "../pyright-internal/src/analyzer/typePrinter.ts");
 const types_1 = __webpack_require__(/*! ../analyzer/types */ "../pyright-internal/src/analyzer/types.ts");
 const typeUtils_1 = __webpack_require__(/*! ../analyzer/typeUtils */ "../pyright-internal/src/analyzer/typeUtils.ts");
@@ -118359,18 +118449,18 @@ var SortCategory;
     SortCategory[SortCategory["RecentImportModuleName"] = 1] = "RecentImportModuleName";
     // A module name used in an import statement.
     SortCategory[SortCategory["ImportModuleName"] = 2] = "ImportModuleName";
-    // A literal string.
+    // A literal value.
     SortCategory[SortCategory["LiteralValue"] = 3] = "LiteralValue";
+    // An enum member.
+    SortCategory[SortCategory["EnumMember"] = 4] = "EnumMember";
     // 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";
-    // An enum member.
-    SortCategory[SortCategory["EnumMember"] = 8] = "EnumMember";
+    SortCategory[SortCategory["Keyword"] = 8] = "Keyword";
     // A normal symbol.
     SortCategory[SortCategory["NormalSymbol"] = 9] = "NormalSymbol";
     // A symbol that starts with _ or __ (used only when there is
@@ -118711,7 +118801,7 @@ class CompletionProvider {
             ? this.evaluator.resolveAliasDeclaration(primaryDecl, /* resolveLocalNames */ true) ?? primaryDecl
             : undefined;
         const autoImportText = detail.autoImportSource && (this.program.configOptions.autoImportCompletions || this._codeActions)
-            ? this.getAutoImportText(name, detail.autoImportSource, detail.autoImportAlias)
+            ? this.getAutoImportText(detail.autoImportName ?? name, detail.autoImportSource, detail.autoImportAlias)
             : undefined;
         let isDeprecated;
         // Are we resolving a completion item? If so, see if this symbol
@@ -118773,10 +118863,12 @@ 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)) {
+            const maybeEnumMember = detail.actualName ?? name;
+            if (this._isEnumMember(detail.boundObjectOrClass, maybeEnumMember)) {
                 itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
             }
             this.addNameToCompletions(detail.autoImportAlias ?? name, itemKind, priorWord, completionMap, {
+                autoImportName: detail.autoImportName ?? name,
                 autoImportText,
                 extraCommitChars: detail.extraCommitChars,
                 funcParensDisabled: detail.funcParensDisabled,
@@ -118928,8 +119020,8 @@ class CompletionProvider {
             completionItem.detail = detail.itemDetail;
         }
         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);
+            // Force auto-import entries to the end unless they are `Enum` members.
+            completionItem.sortText = this._makeSortText(itemKind === vscode_languageserver_1.CompletionItemKind.EnumMember ? SortCategory.EnumMember : SortCategory.AutoImport, `${detail.autoImportName ?? 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) {
@@ -118953,7 +119045,7 @@ class CompletionProvider {
         else {
             completionItem.sortText = this._makeSortText(SortCategory.NormalSymbol, name);
         }
-        completionItemData.symbolLabel = name;
+        completionItemData.symbolLabel = detail?.autoImportName ?? name;
         if (this.options.format === vscode_languageserver_1.MarkupKind.Markdown) {
             let markdownString = '';
             if (detail?.autoImportText) {
@@ -119129,7 +119221,7 @@ class CompletionProvider {
         while (true) {
             (0, cancellationUtils_1.throwIfCancellationRequested)(this.cancellationToken);
             if (curNode.nodeType === 49 /* ParseNodeType.String */) {
-                return this._getLiteralCompletions(curNode, offset, priorWord, priorText, postText);
+                return this._getValueCompletions(curNode, offset, priorWord, priorText, postText);
             }
             if (curNode.nodeType === 48 /* ParseNodeType.StringList */ || curNode.nodeType === 30 /* ParseNodeType.FormatString */) {
                 return undefined;
@@ -119418,7 +119510,7 @@ class CompletionProvider {
             }
             case 11 /* ErrorExpressionCategory.MissingPattern */:
             case 3 /* ErrorExpressionCategory.MissingIndexOrSlice */: {
-                let completionResults = this._getLiteralCompletions(node, offset, priorWord, priorText, postText);
+                let completionResults = this._getValueCompletions(node, offset, priorWord, priorText, postText);
                 if (!completionResults) {
                     completionResults = this._getExpressionCompletions(node, priorWord, priorText, postText);
                 }
@@ -119721,8 +119813,8 @@ class CompletionProvider {
             const parensDisabled = parseNode.parent?.nodeType === 16 /* ParseNodeType.Decorator */;
             this.addAutoImportCompletions(priorWord, similarityLimit, this.options.lazyEdit, completionMap, parensDisabled, parseNode);
         }
-        // Add literal values if appropriate.
-        this._tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap);
+        // Add values if appropriate.
+        this._tryAddValues(parseNode, priorWord, priorText, postText, completionMap);
         return completionMap;
     }
     _isIndexArgument(node) {
@@ -119750,12 +119842,12 @@ class CompletionProvider {
                 if (!atArgument) {
                     this._addNamedParameters(signatureInfo, priorWord, completionMap);
                 }
-                // Add literals that apply to this parameter.
-                this._addLiteralValuesForArgument(signatureInfo, priorWord, priorText, postText, completionMap);
+                // Add values that apply to this parameter.
+                this._addLiteralValuesForArgument(parseNode, signatureInfo, priorWord, priorText, postText, completionMap);
             }
         }
     }
-    _addLiteralValuesForArgument(signatureInfo, priorWord, priorText, postText, completionMap) {
+    _addLiteralValuesForArgument(node, signatureInfo, priorWord, priorText, postText, completionMap) {
         signatureInfo.signatures.forEach((signature) => {
             if (!signature.activeParam) {
                 return undefined;
@@ -119766,22 +119858,114 @@ class CompletionProvider {
                 return undefined;
             }
             const paramType = types_1.FunctionType.getParamType(type, paramIndex);
-            this._addLiteralValuesForTargetType(paramType, priorWord, priorText, postText, completionMap);
+            this._addValuesForTargetType(node, paramType, priorWord, priorText, postText, completionMap);
             return undefined;
         });
     }
-    _addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap) {
-        const quoteValue = this._getQuoteInfo(priorWord, priorText);
-        this._getSubTypesWithLiteralValues(type).forEach((v) => {
-            if (types_1.ClassType.isBuiltIn(v, 'str')) {
-                const value = (0, typePrinter_1.printLiteralValue)(v, quoteValue.quoteCharacter, undefined);
-                if (quoteValue.stringValue === undefined) {
-                    this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
-                        sortText: this._makeSortText(SortCategory.LiteralValue, v.priv.literalValue),
+    _getEnumMemberCompletionsImpl(node, enumType, forEachMember, priorWord, completionMap) {
+        // Try to find names which the type of the left-hand side can be referenced by in the local scope.
+        const scope = (0, scopeUtils_1.getScopeForNode)(node);
+        const localTypeNames = scope ? (0, typeNameUtils_1.getLocalTypeNames)(this.evaluator, enumType, scope) : [];
+        if (localTypeNames.length > 0) {
+            // Add each combination of a local name and a member generated by `forEachMember` as a completion.
+            localTypeNames.forEach((className) => {
+                forEachMember((symbol, name) => {
+                    this.addSymbol(`${className}.${name}`, symbol, priorWord, completionMap, {
+                        actualName: name,
+                        boundObjectOrClass: enumType,
                     });
+                });
+            });
+        }
+        else {
+            // `enumType` does not have any local names: Try to add an auto-import completion.
+            const nestedClassNameParts = (0, typeNameUtils_1.getNestedClassNameParts)(enumType);
+            // If `getNestedClassNameParts` returns `undefined`, it was not able to find a way
+            // to import `enumType`, e.g. if `enumType` was defined within a function.
+            if (nestedClassNameParts) {
+                const className = nestedClassNameParts.join('.');
+                // Add an auto-import completion for each member generated by `forEachMember`.
+                // For nested types, the outermost class (the first part in `nestedClassNameParts`)
+                // is imported while the name of the member is prefixed with the combination of all enclosing types.
+                forEachMember((symbol, name) => {
+                    this.addSymbol(`${className}.${name}`, symbol, priorWord, completionMap, {
+                        actualName: name,
+                        autoImportName: nestedClassNameParts[0],
+                        autoImportSource: enumType.shared.moduleName,
+                        boundObjectOrClass: enumType,
+                    });
+                });
+            }
+        }
+    }
+    _getEnumMemberCompletions(node, enumType, memberName, priorWord, completionMap) {
+        const symbol = types_1.ClassType.getSymbolTable(enumType).get(memberName);
+        if (!symbol)
+            return;
+        this._getEnumMemberCompletionsImpl(node, enumType, (callback) => callback(symbol, memberName), priorWord, completionMap);
+    }
+    _getEnumCompletions(node, enumType, priorWord, completionMap) {
+        this._getEnumMemberCompletionsImpl(node, enumType, (callback) => types_1.ClassType.getSymbolTable(enumType).forEach((symbol, name) => {
+            if (this._isEnumMember(enumType, name)) {
+                callback(symbol, name);
+            }
+        }), priorWord, completionMap);
+    }
+    /**
+     * If `type` is a type whose values can be enumerated, or a union of such types, add completions
+     * for the values that `type` can exhibit.
+     * Currently, the values of a string/integer/Boolean/`Enum` literal, `bool`, or `Enum`s are added,
+     * including proper handling of nested classes and auto-imports for `Enum` classes.
+     *
+     * If quotes have already been entered, this function only adds completions for string literals.
+     */
+    _addValuesForTargetType(node, type, priorWord, priorText, postText, completionMap) {
+        const quoteValue = this._getQuoteInfo(priorWord, priorText);
+        // If quotes have already been entered, `stringValue` is defined and we do not add
+        // completions for anything other than string literals.
+        const isString = quoteValue.stringValue !== undefined;
+        (0, typeUtils_1.doForEachSubtype)(type, (v) => {
+            if (!(0, types_1.isClass)(v)) {
+                return;
+            }
+            if ((0, typeUtils_1.isLiteralType)(v)) {
+                if (types_1.ClassType.isBuiltIn(v, 'str')) {
+                    const value = (0, typePrinter_1.printLiteralValue)(v, quoteValue.quoteCharacter, undefined);
+                    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(1, value.length - 2), quoteValue, postText, completionMap);
+                    }
                 }
-                else {
-                    this._addStringLiteralToCompletions(value.substr(1, value.length - 2), quoteValue, postText, completionMap);
+                else if (!isString) {
+                    if (typeof v.priv.literalValue === 'number' || typeof v.priv.literalValue === 'bigint') {
+                        const value = v.priv.literalValue.toString();
+                        this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
+                            sortText: this._makeSortText(SortCategory.LiteralValue, value),
+                        });
+                    }
+                    else if (typeof v.priv.literalValue === 'boolean') {
+                        const value = v.priv.literalValue ? 'True' : 'False';
+                        this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
+                            sortText: this._makeSortText(SortCategory.LiteralValue, value),
+                        });
+                    }
+                    else if (types_1.ClassType.isEnumClass(v) && v.priv.literalValue instanceof types_1.EnumLiteral) {
+                        this._getEnumMemberCompletions(node, v, v.priv.literalValue.itemName, priorWord, completionMap);
+                    }
+                }
+            }
+            else if (!isString) {
+                if (types_1.ClassType.isEnumClass(v)) {
+                    this._getEnumCompletions(node, v, priorWord, completionMap);
+                }
+                else if (types_1.ClassType.isBuiltIn(v, 'bool')) {
+                    ['True', 'False'].forEach((value) => this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
+                        sortText: this._makeSortText(SortCategory.LiteralValue, value),
+                    }));
                 }
             }
         });
@@ -119930,7 +120114,16 @@ class CompletionProvider {
         }
         return Array.from(keys);
     }
-    _getLiteralCompletions(parseNode, offset, priorWord, priorText, postText) {
+    /**
+     * Checks whether `type` contains a _categorical_ type, i.e. its type or one of the types
+     * in a union has a limited number of values that can be enumerated as completions.
+     * Currently, this applies to `Literal[…]`, `Enum`, and `bool`.
+     */
+    _containsCategoricalType(type) {
+        return (0, typeUtils_1.someSubtypes)(type, (subType) => (0, types_1.isClassInstance)(subType) &&
+            ((0, typeUtils_1.isLiteralLikeType)(subType) || types_1.ClassType.isEnumClass(subType) || types_1.ClassType.isBuiltIn(subType, 'bool')));
+    }
+    _getValueCompletions(parseNode, offset, priorWord, priorText, postText) {
         if (this.options.triggerCharacter === '"' || this.options.triggerCharacter === "'") {
             if (parseNode.start !== offset - 1) {
                 // If completion is triggered by typing " or ', it must be the one that starts a string
@@ -119939,12 +120132,12 @@ class CompletionProvider {
             }
         }
         const completionMap = new CompletionMap();
-        if (!this._tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap)) {
+        if (!this._tryAddValues(parseNode, priorWord, priorText, postText, completionMap)) {
             return undefined;
         }
         return completionMap;
     }
-    _tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap) {
+    _tryAddValues(parseNode, priorWord, priorText, postText, completionMap) {
         const parentAndChild = getParentSkippingStringList(parseNode);
         if (!parentAndChild) {
             return false;
@@ -119962,8 +120155,8 @@ class CompletionProvider {
         const inCallArg = !!(0, parseTreeUtils_1.getCallNodeAndActiveParamIndex)(parseNode, offset, this.parseResults.tokenizerOutput.tokens);
         if (nodeForExpectedType) {
             const expectedTypeResult = this.evaluator.getExpectedType(nodeForExpectedType);
-            if (expectedTypeResult && (0, typeUtils_1.containsLiteralType)(expectedTypeResult.type)) {
-                this._addLiteralValuesForTargetType(expectedTypeResult.type, priorWord, priorText, postText, completionMap);
+            if (expectedTypeResult && this._containsCategoricalType(expectedTypeResult.type)) {
+                this._addValuesForTargetType(parseNode, expectedTypeResult.type, priorWord, priorText, postText, completionMap);
                 if (!inCallArg) {
                     return true;
                 }
@@ -120034,8 +120227,8 @@ class CompletionProvider {
         if (comparison.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
             supportedOperators.includes(comparison.d.operator)) {
             const type = this.evaluator.getType(comparison.d.leftExpr);
-            if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+            if (type && this._containsCategoricalType(type)) {
+                this._addValuesForTargetType(parseNode, type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
@@ -120044,8 +120237,8 @@ class CompletionProvider {
         if (assignmentExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */ &&
             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);
+            if (type && this._containsCategoricalType(type)) {
+                this._addValuesForTargetType(parseNode, type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
@@ -120059,8 +120252,8 @@ class CompletionProvider {
             caseNode.d.suite === parentAndChild.child &&
             caseNode.parent?.nodeType === 63 /* ParseNodeType.Match */) {
             const type = this.evaluator.getType(caseNode.parent.d.expr);
-            if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+            if (type && this._containsCategoricalType(type)) {
+                this._addValuesForTargetType(parseNode, type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
@@ -120074,8 +120267,8 @@ class CompletionProvider {
             patternLiteral.parent.parent?.nodeType === 64 /* ParseNodeType.Case */ &&
             patternLiteral.parent.parent.parent?.nodeType === 63 /* ParseNodeType.Match */) {
             const type = this.evaluator.getType(patternLiteral.parent.parent.parent.d.expr);
-            if (type && (0, typeUtils_1.containsLiteralType)(type)) {
-                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+            if (type && this._containsCategoricalType(type)) {
+                this._addValuesForTargetType(parseNode, type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
@@ -120613,6 +120806,10 @@ class CompletionMap {
     delete(key) {
         return this._completions.delete(key);
     }
+    /** Merges `other` into `this`, i.e. `this` is modified and `other` remains unchanged. */
+    merge(other) {
+        other._completions.forEach((item) => (Array.isArray(item) ? item.forEach((i) => this.set(i)) : this.set(item)));
+    }
     toArray() {
         const items = [];
         this._completions?.forEach((value) => {
@@ -138959,7 +139156,7 @@ exports.PyrightServer = PyrightServer;
 /***/ ((module) => {
 
 "use strict";
-module.exports = "1.34.0";
+module.exports = "1.35.0";
 
 /***/ }),