@zzzen/pyright-internal 1.2.0-dev.20230226 → 1.2.0-dev.20230312

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
@@ -554,53 +555,65 @@ class CompletionProvider {
             case 1 /* MissingElse */: {
                 return this._createSingleKeywordCompletion('else');
             }
+            case 7 /* MissingMemberAccessName */:
             case 2 /* MissingExpression */: {
                 // Don't show completion after random dots.
                 const tokenizerOutput = this._parseResults.tokenizerOutput;
                 const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, tokenizerOutput.lines);
                 const index = ParseTreeUtils.getTokenIndexAtLeft(tokenizerOutput.tokens, offset);
                 const token = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index);
-                if ((token === null || token === void 0 ? void 0 : token.type) === 20 /* Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* Ellipsis */) {
-                    break;
-                }
-                // ex) class MyType:
-                //         def is_str(self): ...
-                //     myType = MyType()
-                //
-                // In incomplete code such as "myType.is" <= "is" will be tokenized as keyword not identifier,
-                // so even if user's intention is writing "is_str", completion after "is" won't include "is_str"
-                // since parser won't see "is" as partially written member name instead it will see it as
-                // expression statement with missing expression after "is" keyword.
-                // In such case, use "MyType." to get completion.
-                if ((token === null || token === void 0 ? void 0 : token.type) !== 8 /* Keyword */ || textRange_2.TextRange.getEnd(token) !== offset) {
-                    return this._getExpressionCompletions(node, priorWord, priorText, postText);
-                }
-                const previousToken = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index - 1);
-                if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.type) !== 20 /* Dot */) {
-                    return this._getExpressionCompletions(node, priorWord, priorText, postText);
+                const prevToken = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index - 1);
+                if (node.category === 2 /* MissingExpression */) {
+                    // Skip dots on expressions.
+                    if ((token === null || token === void 0 ? void 0 : token.type) === 20 /* Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* Ellipsis */) {
+                        break;
+                    }
+                    // ex) class MyType:
+                    //         def is_str(self): ...
+                    //     myType = MyType()
+                    //
+                    // In incomplete code such as "myType.is" <= "is" will be tokenized as keyword not identifier,
+                    // so even if user's intention is writing "is_str", completion after "is" won't include "is_str"
+                    // since parser won't see "is" as partially written member name instead it will see it as
+                    // expression statement with missing expression after "is" keyword.
+                    // In such case, use "MyType." to get completion.
+                    if ((token === null || token === void 0 ? void 0 : token.type) !== 8 /* Keyword */ || textRange_2.TextRange.getEnd(token) !== offset) {
+                        return this._getExpressionCompletions(node, priorWord, priorText, postText);
+                    }
+                    if ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) !== 20 /* Dot */) {
+                        return this._getExpressionCompletions(node, priorWord, priorText, postText);
+                    }
+                    const previousOffset = textRange_2.TextRange.getEnd(prevToken);
+                    const previousNode = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, previousOffset);
+                    if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.nodeType) !== 0 /* Error */ ||
+                        previousNode.category !== 7 /* MissingMemberAccessName */) {
+                        return this._getExpressionCompletions(node, priorWord, priorText, postText);
+                    }
+                    else {
+                        // Update node to previous node so we get the member access completions.
+                        node = previousNode;
+                    }
                 }
-                const previousOffset = textRange_2.TextRange.getEnd(previousToken);
-                const previousNode = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, previousOffset);
-                if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.nodeType) !== 0 /* Error */ ||
-                    previousNode.category !== 7 /* MissingMemberAccessName */) {
-                    return this._getExpressionCompletions(node, priorWord, priorText, postText);
+                else if (node.category === 7 /* MissingMemberAccessName */) {
+                    // Skip double dots on member access.
+                    if (((token === null || token === void 0 ? void 0 : token.type) === 20 /* Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* Ellipsis */) &&
+                        ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 20 /* Dot */ || (prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 19 /* Ellipsis */)) {
+                        return undefined;
+                    }
                 }
-                return this._getMissingMemberAccessNameCompletions(previousNode, previousOffset, priorWord);
+                return this._getMissingMemberAccessNameCompletions(node, priorWord);
             }
             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);
                 }
                 return completionResults;
             }
-            case 7 /* MissingMemberAccessName */: {
-                const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, this._parseResults.tokenizerOutput.lines);
-                return this._getMissingMemberAccessNameCompletions(node, offset, priorWord);
-            }
             case 10 /* MissingFunctionParameterList */: {
                 if (node.child && node.child.nodeType === 38 /* Name */) {
                     if ((_a = node.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
@@ -615,13 +628,7 @@ class CompletionProvider {
         }
         return undefined;
     }
-    _getMissingMemberAccessNameCompletions(node, offset, priorWord) {
-        const index = ParseTreeUtils.getTokenIndexAtLeft(this._parseResults.tokenizerOutput.tokens, offset) - 1;
-        const previousToken = ParseTreeUtils.getTokenAtIndex(this._parseResults.tokenizerOutput.tokens, index);
-        if ((previousToken === null || previousToken === void 0 ? void 0 : previousToken.type) === 20 /* Dot */ || (previousToken === null || previousToken === void 0 ? void 0 : previousToken.type) === 19 /* Ellipsis */) {
-            // Don't allow multiple dot bring up completions.
-            return undefined;
-        }
+    _getMissingMemberAccessNameCompletions(node, priorWord) {
         if (!node.child || !(0, parseNodes_1.isExpressionNode)(node.child)) {
             return undefined;
         }
@@ -824,10 +831,11 @@ class CompletionProvider {
         const classmethod = (_b = decorators === null || decorators === void 0 ? void 0 : decorators.some((d) => this._checkDecorator(d, 'classmethod'))) !== null && _b !== void 0 ? _b : false;
         const completionMap = new CompletionMap();
         symbolTable.forEach((symbol, name) => {
+            var _a;
             let decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
             if (decl && decl.type === 5 /* Function */) {
                 if (StringUtils.isPatternInSymbol(partialName.value, name)) {
-                    const declaredType = this._evaluator.getTypeForDeclaration(decl);
+                    const declaredType = (_a = this._evaluator.getTypeForDeclaration(decl)) === null || _a === void 0 ? void 0 : _a.type;
                     if (!declaredType) {
                         return;
                     }
@@ -1102,7 +1110,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.
@@ -1146,39 +1154,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) {
@@ -1207,11 +1183,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;
@@ -1222,12 +1198,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);
@@ -1237,7 +1213,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);
                 }
             }
         });
@@ -1281,7 +1257,7 @@ class CompletionProvider {
         return values;
     }
     _getIndexerKeyType(baseType) {
-        var _a;
+        var _a, _b;
         // Handle dict type
         if (types_1.ClassType.isBuiltIn(baseType, 'dict') || types_1.ClassType.isBuiltIn(baseType, 'Mapping')) {
             if (((_a = baseType.typeArguments) === null || _a === void 0 ? void 0 : _a.length) === 2) {
@@ -1293,7 +1269,7 @@ class CompletionProvider {
         if (member === null || member === void 0 ? void 0 : member.symbol.hasDeclarations()) {
             const declaration = member.symbol.getDeclarations()[0];
             if ((0, declaration_1.isFunctionDeclaration)(declaration) && declaration.isMethod) {
-                const getItemType = this._evaluator.getTypeForDeclaration(declaration);
+                const getItemType = (_b = this._evaluator.getTypeForDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.type;
                 if (getItemType && (0, types_1.isFunction)(getItemType) && getItemType.details.parameters.length === 2) {
                     return getItemType.details.parameters[1].type;
                 }
@@ -1393,96 +1369,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);
             }
@@ -1490,10 +1548,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.
@@ -1501,13 +1558,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);
@@ -1526,14 +1595,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 = '"';
@@ -1563,9 +1633,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;
         }
@@ -1573,26 +1646,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;
             }
@@ -1600,14 +1658,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++;
                 }
             }
@@ -1878,7 +1939,7 @@ class CompletionProvider {
                 boundObjectOrClass: detail.boundObjectOrClass,
             });
             if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown || this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
-                this._itemToResolve.documentation = (0, completionProviderUtils_1.getCompletionItemDocumention)(typeDetail, documentation, this._options.format);
+                this._itemToResolve.documentation = (0, completionProviderUtils_1.getCompletionItemDocumentation)(typeDetail, documentation, this._options.format);
             }
             else {
                 (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
@@ -1955,7 +2016,7 @@ class CompletionProvider {
             filePath: this._filePath,
             position: this._position,
         };
-        if (detail === null || detail === void 0 ? void 0 : detail.funcParensDisabled) {
+        if ((detail === null || detail === void 0 ? void 0 : detail.funcParensDisabled) || !this._options.snippet) {
             completionItemData.funcParensDisabled = true;
         }
         if (detail === null || detail === void 0 ? void 0 : detail.modulePath) {