@zzzen/pyright-internal 1.2.0-dev.20230305 → 1.2.0-dev.20230319

package/dist/languageService/completionProvider.js

@@ -250,7 +250,7 @@ class CompletionProvider {
         while (true) {
             (0, cancellationUtils_1.throwIfCancellationRequested)(this._cancellationToken);
             if (curNode.nodeType === 49 /* String */) {
-                return this._getLiteralCompletions(curNode, priorWord, priorText, postText);
+                return this._getLiteralCompletions(curNode, offset, priorWord, priorText, postText);
             }
             if (curNode.nodeType === 48 /* StringList */ || curNode.nodeType === 27 /* FormatString */) {
                 return undefined;
@@ -259,14 +259,15 @@ class CompletionProvider {
                 return this._getImportModuleCompletions(curNode);
             }
             if (curNode.nodeType === 0 /* Error */) {
-                return this._getExpressionErrorCompletions(curNode, priorWord, priorText, postText);
+                return this._getExpressionErrorCompletions(curNode, offset, priorWord, priorText, postText);
             }
             if (curNode.nodeType === 35 /* MemberAccess */) {
                 return this._getMemberAccessCompletions(curNode.leftExpression, priorWord);
             }
             if (curNode.nodeType === 15 /* Dictionary */) {
                 const completionMap = new CompletionMap();
-                if (this._addTypedDictKeys(curNode, /* stringNode */ undefined, priorText, postText, completionMap)) {
+                if (this._tryAddTypedDictKeysFromDictionary(curNode, 
+                /* stringNode */ undefined, priorWord, priorText, postText, completionMap)) {
                     return { completionMap };
                 }
             }
@@ -276,8 +277,8 @@ class CompletionProvider {
                     const dictionaryNode = dictionaryEntry.parent;
                     if (dictionaryNode.trailingCommaToken && dictionaryNode.trailingCommaToken.start < offset) {
                         const completionMap = new CompletionMap();
-                        if (this._addTypedDictKeys(dictionaryNode, 
-                        /* stringNode */ undefined, priorText, postText, completionMap)) {
+                        if (this._tryAddTypedDictKeysFromDictionary(dictionaryNode, 
+                        /* stringNode */ undefined, priorWord, priorText, postText, completionMap)) {
                             return { completionMap };
                         }
                     }
@@ -542,7 +543,7 @@ class CompletionProvider {
             return tokens.getItemAt(tokenIndex + 1);
         }
     }
-    _getExpressionErrorCompletions(node, priorWord, priorText, postText) {
+    _getExpressionErrorCompletions(node, offset, priorWord, priorText, postText) {
         var _a;
         // Is the error due to a missing member access name? If so,
         // we can evaluate the left side of the member access expression
@@ -605,8 +606,9 @@ class CompletionProvider {
             case 4 /* MissingDecoratorCallName */: {
                 return this._getExpressionCompletions(node, priorWord, priorText, postText);
             }
+            case 11 /* MissingPattern */:
             case 3 /* MissingIndexOrSlice */: {
-                let completionResults = this._getLiteralCompletions(node, priorWord, priorText, postText);
+                let completionResults = this._getLiteralCompletions(node, offset, priorWord, priorText, postText);
                 if (!completionResults) {
                     completionResults = this._getExpressionCompletions(node, priorWord, priorText, postText);
                 }
@@ -1052,10 +1054,8 @@ class CompletionProvider {
                 /* isInImport */ false, (0, types_1.isClass)(subtype) ? subtype : undefined, completionMap);
             });
         }
-        // If we don't know this type, look for a module we should stub.
-        if (!leftType || (0, types_1.isUnknown)(leftType) || (0, types_1.isUnbound)(leftType)) {
-            memberAccessInfo = this._getLastKnownModule(leftExprNode, leftType);
-        }
+        // Save member access info for every request
+        memberAccessInfo = this._getLastKnownModule(leftExprNode, leftType);
         return { completionMap, memberAccessInfo };
     }
     _getLastKnownModule(leftExprNode, leftType) {
@@ -1075,7 +1075,7 @@ class CompletionProvider {
                 }
             }
             else {
-                curNode = undefined;
+                break;
             }
             if (curNode) {
                 curType = this._evaluator.getType(curNode);
@@ -1108,7 +1108,7 @@ class CompletionProvider {
         return this._getExpressionCompletions(parseNode, priorWord, priorText, postText);
     }
     _getExpressionCompletions(parseNode, priorWord, priorText, postText) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         const isIndexArgument = this._isIndexArgument(parseNode);
         // If the user typed a "." as part of a number, don't present
         // any completion options.
@@ -1152,39 +1152,7 @@ class CompletionProvider {
             this._addAutoImportCompletions(priorWord, similarityLimit, this._options.lazyEdit, completionResults);
         }
         // Add literal values if appropriate.
-        if (parseNode.nodeType === 0 /* Error */) {
-            if (parseNode.category === 3 /* MissingIndexOrSlice */ &&
-                ((_c = parseNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 24 /* Index */) {
-                this._tryAddTypedDictStringLiteral(parseNode.parent, 
-                /* priorText */ undefined, 
-                /* postText */ undefined, completionMap);
-            }
-            else if (parseNode.category === 2 /* MissingExpression */) {
-                if (parseNode.parent && parseNode.parent.nodeType === 3 /* Assignment */) {
-                    const declaredTypeOfTarget = (_d = this._evaluator.getExpectedType(parseNode)) === null || _d === void 0 ? void 0 : _d.type;
-                    if (declaredTypeOfTarget) {
-                        this._addLiteralValuesForTargetType(declaredTypeOfTarget, priorText, priorWord, postText, completionMap);
-                    }
-                }
-            }
-        }
-        if (isIndexArgument) {
-            // Completion for dict key (ex, dict_variable[<here>])
-            const indexNode = parseNode.parent.parent;
-            this._getIndexerKeys(indexNode, parseNode).forEach((key) => {
-                if (completionMap.has(key)) {
-                    // Don't add key if it already exists in the completion.
-                    // ex) key = "dictKey"
-                    //     dict[key] = 1
-                    //     print(dict[<key will come from symbol table provider>]))
-                    return;
-                }
-                this._addNameToCompletions(key, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
-                    sortText: this._makeSortText(SortCategory.LiteralValue, key),
-                    itemDetail: exports.dictionaryKeyDetail,
-                });
-            });
-        }
+        this._tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap);
         return completionResults;
     }
     _isIndexArgument(node) {
@@ -1213,11 +1181,11 @@ class CompletionProvider {
                     this._addNamedParameters(signatureInfo, priorWord, completionMap);
                 }
                 // Add literals that apply to this parameter.
-                this._addLiteralValuesForArgument(signatureInfo, priorText, priorWord, postText, completionMap);
+                this._addLiteralValuesForArgument(signatureInfo, priorWord, priorText, postText, completionMap);
             }
         }
     }
-    _addLiteralValuesForArgument(signatureInfo, priorText, priorWord, postText, completionMap) {
+    _addLiteralValuesForArgument(signatureInfo, priorWord, priorText, postText, completionMap) {
         signatureInfo.signatures.forEach((signature) => {
             if (!signature.activeParam) {
                 return undefined;
@@ -1228,12 +1196,12 @@ class CompletionProvider {
                 return undefined;
             }
             const paramType = type.details.parameters[paramIndex].type;
-            this._addLiteralValuesForTargetType(paramType, priorText, priorWord, postText, completionMap);
+            this._addLiteralValuesForTargetType(paramType, priorWord, priorText, postText, completionMap);
             return undefined;
         });
     }
-    _addLiteralValuesForTargetType(type, priorText, priorWord, postText, completionMap) {
-        const quoteValue = this._getQuoteInfo(priorText);
+    _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);
@@ -1243,7 +1211,7 @@ class CompletionProvider {
                     });
                 }
                 else {
-                    this._addStringLiteralToCompletions(value.substr(1, value.length - 2), quoteValue.stringValue, postText, quoteValue.quoteCharacter, completionMap);
+                    this._addStringLiteralToCompletions(value.substr(1, value.length - 2), quoteValue, postText, completionMap);
                 }
             }
         });
@@ -1399,96 +1367,178 @@ class CompletionProvider {
         }
         return [...keys];
     }
-    _getLiteralCompletions(parseNode, priorWord, priorText, postText) {
-        var _a, _b, _c;
-        let parentNode = parseNode.parent;
-        if (!parentNode) {
-            return undefined;
+    _getLiteralCompletions(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
+                // literal. In another word, it can't be something inside of another string or comment
+                return undefined;
+            }
         }
         const completionMap = new CompletionMap();
+        if (!this._tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap)) {
+            return undefined;
+        }
+        return { completionMap };
+    }
+    _tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap) {
+        var _a, _b, _c, _d, _e, _f;
+        const parentAndChild = getParentSkippingStringList(parseNode);
+        if (!parentAndChild) {
+            return false;
+        }
         // See if the type evaluator can determine the expected type for this node.
-        if ((0, parseNodes_1.isExpressionNode)(parentNode)) {
-            const expectedTypeResult = this._evaluator.getExpectedType(parentNode);
+        // ex) a: Literal["str"] = /* here */
+        const nodeForExpectedType = parentAndChild.parent.nodeType === 3 /* Assignment */
+            ? parentAndChild.parent.rightExpression === parentAndChild.child
+                ? parentAndChild.child
+                : undefined
+            : (0, parseNodes_1.isExpressionNode)(parentAndChild.child)
+                ? parentAndChild.child
+                : undefined;
+        if (nodeForExpectedType) {
+            const expectedTypeResult = this._evaluator.getExpectedType(nodeForExpectedType);
             if (expectedTypeResult && (0, typeUtils_1.isLiteralTypeOrUnion)(expectedTypeResult.type)) {
-                this._addLiteralValuesForTargetType(expectedTypeResult.type, priorText, priorWord, postText, completionMap);
-                return { completionMap };
-            }
-            if (parseNode.nodeType === 49 /* String */ && ((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.parent)) {
-                const stringParent = parseNode.parent.parent;
-                // If the dictionary is not yet filled in, it will appear as though it's
-                // a set initially.
-                let dictOrSet;
-                if (stringParent.nodeType === 17 /* DictionaryKeyEntry */ &&
-                    stringParent.keyExpression === parseNode.parent &&
-                    ((_b = stringParent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 15 /* Dictionary */) {
-                    dictOrSet = stringParent.parent;
-                }
-                else if ((stringParent === null || stringParent === void 0 ? void 0 : stringParent.nodeType) === 45 /* Set */) {
-                    dictOrSet = stringParent;
-                }
-                if (dictOrSet) {
-                    if (this._addTypedDictKeys(dictOrSet, parseNode, priorText, postText, completionMap)) {
-                        return { completionMap };
-                    }
-                }
+                this._addLiteralValuesForTargetType(expectedTypeResult.type, priorWord, priorText, postText, completionMap);
+                return true;
             }
         }
-        if (parentNode.nodeType !== 1 /* Argument */) {
-            if (parentNode.nodeType !== 48 /* StringList */ || parentNode.strings.length > 1) {
-                return undefined;
+        // ex) a: TypedDictType = { "/* here */" } or a: TypedDictType = { A/* here */ }
+        const nodeForKey = parentAndChild.parent;
+        if (nodeForKey) {
+            // If the dictionary is not yet filled in, it will appear as though it's
+            // a set initially.
+            let dictOrSet;
+            if (nodeForKey.nodeType === 17 /* DictionaryKeyEntry */ &&
+                nodeForKey.keyExpression === parentAndChild.child &&
+                ((_a = nodeForKey.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 15 /* Dictionary */) {
+                dictOrSet = nodeForKey.parent;
             }
-            parentNode = parentNode.parent;
-            if (!parentNode) {
-                return undefined;
+            else if ((nodeForKey === null || nodeForKey === void 0 ? void 0 : nodeForKey.nodeType) === 45 /* Set */) {
+                dictOrSet = nodeForKey;
+            }
+            if (dictOrSet) {
+                if (this._tryAddTypedDictKeysFromDictionary(dictOrSet, parseNode.nodeType === 49 /* String */ ? parseNode : undefined, priorWord, priorText, postText, completionMap)) {
+                    return true;
+                }
             }
         }
-        if (parentNode.nodeType === 1 /* Argument */ && ((_c = parentNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 24 /* Index */) {
+        // a: DictType = { .... }
+        // a[/* here */] or a['/* here */'] or a[variable/*here*/]
+        const argument = parentAndChild.parent;
+        if (argument.nodeType === 1 /* Argument */ && ((_b = argument.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 24 /* Index */) {
             const priorTextInString = parseNode.nodeType === 49 /* String */ ? priorText : '';
-            if (!this._tryAddTypedDictStringLiteral(parentNode.parent, priorTextInString, postText, completionMap)) {
-                const keys = this._getIndexerKeys(parentNode.parent, parseNode);
-                const quoteValue = this._getQuoteInfo(priorTextInString);
-                for (const key of keys) {
-                    const stringLiteral = /^["|'].*["|']$/.test(key);
-                    if (parseNode.nodeType === 49 /* String */ && !stringLiteral) {
-                        continue;
-                    }
-                    if (stringLiteral) {
-                        const keyWithoutQuote = key.substr(1, key.length - 2);
-                        this._addStringLiteralToCompletions(keyWithoutQuote, quoteValue.stringValue, postText, quoteValue.quoteCharacter, completionMap, exports.dictionaryKeyDetail);
-                    }
-                    else {
-                        this._addNameToCompletions(key, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
-                            sortText: this._makeSortText(SortCategory.LiteralValue, key),
-                            itemDetail: exports.dictionaryKeyDetail,
-                        });
-                    }
+            if (this._tryAddTypedDictKeysFromIndexer(argument.parent, priorWord, priorTextInString, postText, completionMap)) {
+                return true;
+            }
+            const quoteInfo = this._getQuoteInfo(priorWord, priorTextInString);
+            const keys = this._getIndexerKeys(argument.parent, parseNode);
+            let keyFound = false;
+            for (const key of keys) {
+                if (completionMap.has(key)) {
+                    // Don't add key if it already exists in the completion.
+                    // ex) key = "dictKey"
+                    //     dict[key] = 1
+                    //     print(dict[<key will come from symbol table provider>]))
+                    continue;
                 }
-                if (completionMap.size === 0) {
-                    return undefined;
+                const stringLiteral = /^["|'].*["|']$/.test(key);
+                if (parseNode.nodeType === 49 /* String */ && !stringLiteral) {
+                    continue;
                 }
+                keyFound = true;
+                if (stringLiteral) {
+                    const keyWithoutQuote = key.substr(1, key.length - 2);
+                    this._addStringLiteralToCompletions(keyWithoutQuote, quoteInfo, postText, completionMap, exports.dictionaryKeyDetail);
+                }
+                else {
+                    this._addNameToCompletions(key, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
+                        sortText: this._makeSortText(SortCategory.LiteralValue, key),
+                        itemDetail: exports.dictionaryKeyDetail,
+                    });
+                }
+            }
+            if (keyFound) {
+                return true;
             }
         }
-        else {
-            debug.assert(parseNode.nodeType === 49 /* String */);
+        // if c == "/* here */"
+        const comparison = parentAndChild.parent;
+        const supportedOperators = [2 /* Assign */, 12 /* Equals */, 28 /* NotEquals */];
+        if (comparison.nodeType === 7 /* BinaryOperation */ && supportedOperators.includes(comparison.operator)) {
+            const type = this._evaluator.getType(comparison.leftExpression);
+            if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
+                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                return true;
+            }
+        }
+        // if c := "/* here */"
+        const assignmentExpression = parentAndChild.parent;
+        if (assignmentExpression.nodeType === 4 /* AssignmentExpression */ &&
+            assignmentExpression.rightExpression === parentAndChild.child) {
+            const type = this._evaluator.getType(assignmentExpression.name);
+            if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
+                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                return true;
+            }
+        }
+        // For now, we only support simple cases. no complex pattern matching.
+        // match c:
+        //     case /* here */
+        const caseNode = parentAndChild.parent;
+        if (caseNode.nodeType === 64 /* Case */ &&
+            caseNode.pattern.nodeType === 0 /* Error */ &&
+            caseNode.pattern.category === 11 /* MissingPattern */ &&
+            caseNode.suite === parentAndChild.child &&
+            ((_c = caseNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 63 /* Match */) {
+            const type = this._evaluator.getType(caseNode.parent.subjectExpression);
+            if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
+                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                return true;
+            }
+        }
+        // match c:
+        //     case "/* here */"
+        //     case Sym/*here*/
+        const patternLiteral = parentAndChild.parent;
+        if ((patternLiteral.nodeType === 67 /* PatternLiteral */ ||
+            patternLiteral.nodeType === 69 /* PatternCapture */) &&
+            ((_d = patternLiteral.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 66 /* PatternAs */ &&
+            ((_e = patternLiteral.parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 64 /* Case */ &&
+            ((_f = patternLiteral.parent.parent.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 63 /* Match */) {
+            const type = this._evaluator.getType(patternLiteral.parent.parent.parent.subjectExpression);
+            if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
+                this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
+                return true;
+            }
+        }
+        if (parseNode.nodeType === 49 /* String */) {
             const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, this._parseResults.tokenizerOutput.lines);
-            const atArgument = parentNode.start < offset && offset < textRange_2.TextRange.getEnd(parseNode);
+            const atArgument = parseNode.parent.start < offset && offset < textRange_2.TextRange.getEnd(parseNode);
             this._addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap);
+            return true;
         }
-        return { completionMap };
-    }
-    _addTypedDictKeys(dictionaryNode, stringNode, priorText, postText, completionMap) {
-        var _a;
-        const expectedTypeResult = this._evaluator.getExpectedType(dictionaryNode);
-        if (!expectedTypeResult) {
-            return false;
-        }
-        // If the expected type result is associated with a node above the
-        // dictionaryNode in the parse tree, there are no typed dict keys to add.
-        if (ParseTreeUtils.getNodeDepth(expectedTypeResult.node) < ParseTreeUtils.getNodeDepth(dictionaryNode)) {
-            return false;
+        return false;
+        function getParentSkippingStringList(node) {
+            var _a;
+            if (!node.parent) {
+                return undefined;
+            }
+            if (node.nodeType !== 49 /* String */) {
+                return { parent: node.parent, child: node };
+            }
+            if (!node.parent.parent) {
+                return undefined;
+            }
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 48 /* StringList */ || node.parent.strings.length > 1) {
+                return undefined;
+            }
+            return { parent: node.parent.parent, child: node.parent };
         }
+    }
+    _tryAddTypedDictKeys(type, existingKeys, priorWord, priorText, postText, completionMap) {
         let typedDicts = [];
-        (0, typeUtils_1.doForEachSubtype)(expectedTypeResult.type, (subtype) => {
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
             if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
                 typedDicts.push(subtype);
             }
@@ -1496,10 +1546,9 @@ class CompletionProvider {
         if (typedDicts.length === 0) {
             return false;
         }
-        const keys = this._getDictExpressionStringKeys(dictionaryNode, stringNode ? new Set([(_a = stringNode.parent) === null || _a === void 0 ? void 0 : _a.id]) : undefined);
-        typedDicts = this._tryNarrowTypedDicts(typedDicts, keys);
-        const quoteValue = this._getQuoteInfo(priorText);
-        const excludes = new Set(keys);
+        typedDicts = this._tryNarrowTypedDicts(typedDicts, existingKeys);
+        const quoteInfo = this._getQuoteInfo(priorWord, priorText);
+        const excludes = new Set(existingKeys);
         typedDicts.forEach((typedDict) => {
             (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, typedDict, /* allowNarrowed */ true).forEach((_, key) => {
                 // Unions of TypedDicts may define the same key.
@@ -1507,13 +1556,25 @@ class CompletionProvider {
                     return;
                 }
                 excludes.add(key);
-                this._addStringLiteralToCompletions(key, quoteValue ? quoteValue.stringValue : undefined, postText, quoteValue
-                    ? quoteValue.quoteCharacter
-                    : this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter, completionMap);
+                this._addStringLiteralToCompletions(key, quoteInfo, postText, completionMap);
             });
         });
         return true;
     }
+    _tryAddTypedDictKeysFromDictionary(dictionaryNode, stringNode, priorWord, priorText, postText, completionMap) {
+        var _a;
+        const expectedTypeResult = this._evaluator.getExpectedType(dictionaryNode);
+        if (!expectedTypeResult) {
+            return false;
+        }
+        // If the expected type result is associated with a node above the
+        // dictionaryNode in the parse tree, there are no typed dict keys to add.
+        if (ParseTreeUtils.getNodeDepth(expectedTypeResult.node) < ParseTreeUtils.getNodeDepth(dictionaryNode)) {
+            return false;
+        }
+        const keys = this._getDictExpressionStringKeys(dictionaryNode, stringNode ? new Set([(_a = stringNode.parent) === null || _a === void 0 ? void 0 : _a.id]) : undefined);
+        return this._tryAddTypedDictKeys(expectedTypeResult.type, keys, priorWord, priorText, postText, completionMap);
+    }
     _tryNarrowTypedDicts(types, keys) {
         const newTypes = types.flatMap((type) => {
             const entries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, type, /* allowNarrowed */ true);
@@ -1532,14 +1593,15 @@ class CompletionProvider {
     }
     // Find out quotation and string prefix to use for string literals
     // completion under current context.
-    _getQuoteInfo(priorText) {
+    _getQuoteInfo(priorWord, priorText) {
+        let filterText = priorWord;
         let stringValue = undefined;
         let quoteCharacter = this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter;
         // If completion is not inside of the existing string literal
         // ex) typedDict[ |<= here
         // use default quotation char without any string prefix.
         if (!this._insideStringLiteral) {
-            return { stringValue, quoteCharacter };
+            return { priorWord, priorText, filterText, stringValue, quoteCharacter };
         }
         const singleQuote = "'";
         const doubleQuote = '"';
@@ -1569,9 +1631,12 @@ class CompletionProvider {
         if (this._insideStringLiteral.flags & 64 /* Format */) {
             quoteCharacter = this._insideStringLiteral.flags & 1 /* SingleQuote */ ? doubleQuote : singleQuote;
         }
-        return { stringValue, quoteCharacter };
+        if (stringValue) {
+            filterText = stringValue;
+        }
+        return { priorWord, priorText, filterText, stringValue, quoteCharacter };
     }
-    _tryAddTypedDictStringLiteral(indexNode, priorText, postText, completionMap) {
+    _tryAddTypedDictKeysFromIndexer(indexNode, priorWord, priorText, postText, completionMap) {
         if (!indexNode) {
             return false;
         }
@@ -1579,26 +1644,11 @@ class CompletionProvider {
         if (!baseType) {
             return false;
         }
-        let foundTypedDict = false;
-        (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
-            if (!(0, types_1.isClassInstance)(subtype)) {
-                return;
-            }
-            if (!types_1.ClassType.isTypedDictClass(subtype)) {
-                return;
-            }
-            const entries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, subtype, /* allowNarrowed */ true);
-            const quoteValue = this._getQuoteInfo(priorText);
-            entries.forEach((_, key) => {
-                this._addStringLiteralToCompletions(key, quoteValue.stringValue, postText, quoteValue.quoteCharacter, completionMap);
-            });
-            foundTypedDict = true;
-        });
-        return foundTypedDict;
+        return this._tryAddTypedDictKeys(baseType, [], priorWord, priorText, postText, completionMap);
     }
-    _addStringLiteralToCompletions(value, priorString, postText, quoteCharacter, completionMap, detail) {
-        if (StringUtils.isPatternInSymbol(priorString || '', value)) {
-            const valueWithQuotes = `${quoteCharacter}${value}${quoteCharacter}`;
+    _addStringLiteralToCompletions(value, quoteInfo, postText, completionMap, detail) {
+        if (StringUtils.isPatternInSymbol(quoteInfo.filterText || '', value)) {
+            const valueWithQuotes = `${quoteInfo.quoteCharacter}${value}${quoteInfo.quoteCharacter}`;
             if (completionMap.has(valueWithQuotes)) {
                 return;
             }
@@ -1606,14 +1656,17 @@ class CompletionProvider {
             completionItem.kind = vscode_languageserver_1.CompletionItemKind.Constant;
             completionItem.sortText = this._makeSortText(SortCategory.LiteralValue, valueWithQuotes);
             let rangeStartCol = this._position.character;
-            if (priorString !== undefined) {
-                rangeStartCol -= priorString.length + 1;
+            if (quoteInfo.stringValue !== undefined) {
+                rangeStartCol -= quoteInfo.stringValue.length + 1;
+            }
+            else if (quoteInfo.priorWord) {
+                rangeStartCol -= quoteInfo.priorWord.length;
             }
             // If the text after the insertion point is the closing quote,
             // replace it.
             let rangeEndCol = this._position.character;
             if (postText !== undefined) {
-                if (postText.startsWith(quoteCharacter)) {
+                if (postText.startsWith(quoteInfo.quoteCharacter)) {
                     rangeEndCol++;
                 }
             }