@zzzen/pyright-internal 1.1.254

package/dist/languageService/completionProvider.js

@@ -0,0 +1,2220 @@
+"use strict";
+/*
+ * completionProvider.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Logic that maps a position within a Python program file into
+ * a list of zero or more text completions that apply in the context.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionMap = exports.CompletionProvider = exports.dictionaryKeyDetail = exports.autoImportDetail = void 0;
+const vscode_languageserver_1 = require("vscode-languageserver");
+const AnalyzerNodeInfo = __importStar(require("../analyzer/analyzerNodeInfo"));
+const declaration_1 = require("../analyzer/declaration");
+const declarationUtils_1 = require("../analyzer/declarationUtils");
+const docStringConversion_1 = require("../analyzer/docStringConversion");
+const ParseTreeUtils = __importStar(require("../analyzer/parseTreeUtils"));
+const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
+const scopeUtils_1 = require("../analyzer/scopeUtils");
+const sourceMapper_1 = require("../analyzer/sourceMapper");
+const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
+const symbolUtils_1 = require("../analyzer/symbolUtils");
+const typedDicts_1 = require("../analyzer/typedDicts");
+const typeDocStringUtils_1 = require("../analyzer/typeDocStringUtils");
+const typePrinter_1 = require("../analyzer/typePrinter");
+const types_1 = require("../analyzer/types");
+const typeUtils_1 = require("../analyzer/typeUtils");
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const collectionUtils_1 = require("../common/collectionUtils");
+const debug = __importStar(require("../common/debug"));
+const debug_1 = require("../common/debug");
+const lspUtils_1 = require("../common/lspUtils");
+const positionUtils_1 = require("../common/positionUtils");
+const pythonVersion_1 = require("../common/pythonVersion");
+const StringUtils = __importStar(require("../common/stringUtils"));
+const textRange_1 = require("../common/textRange");
+const textRange_2 = require("../common/textRange");
+const timing_1 = require("../common/timing");
+const parseNodes_1 = require("../parser/parseNodes");
+const autoImporter_1 = require("./autoImporter");
+const documentSymbolCollector_1 = require("./documentSymbolCollector");
+const tooltipUtils_1 = require("./tooltipUtils");
+var Keywords;
+(function (Keywords) {
+    const base = [
+        // Expression keywords
+        'True',
+        'False',
+        'None',
+        'and',
+        'or',
+        'not',
+        'is',
+        'lambda',
+        'yield',
+        // Statement keywords
+        'assert',
+        'break',
+        'class',
+        'continue',
+        'def',
+        'del',
+        'elif',
+        'else',
+        'except',
+        'finally',
+        'for',
+        'from',
+        'global',
+        'if',
+        'import',
+        'in',
+        'nonlocal',
+        'pass',
+        'raise',
+        'return',
+        'try',
+        'while',
+        'with',
+    ];
+    const python3_5 = [...base, 'async', 'await'];
+    const python3_10 = [...python3_5, 'case', 'match'];
+    function forVersion(version) {
+        if (version >= pythonVersion_1.PythonVersion.V3_10) {
+            return python3_10;
+        }
+        if (version >= pythonVersion_1.PythonVersion.V3_5) {
+            return python3_5;
+        }
+        return base;
+    }
+    Keywords.forVersion = forVersion;
+})(Keywords || (Keywords = {}));
+var SortCategory;
+(function (SortCategory) {
+    // The order of the following is important. We use
+    // this to order the completion suggestions.
+    // A keyword that must be entered for the syntax to be correct.
+    SortCategory[SortCategory["LikelyKeyword"] = 0] = "LikelyKeyword";
+    // A module name recently used in an import statement.
+    SortCategory[SortCategory["RecentImportModuleName"] = 1] = "RecentImportModuleName";
+    // A module name used in an import statement.
+    SortCategory[SortCategory["ImportModuleName"] = 2] = "ImportModuleName";
+    // A literal string.
+    SortCategory[SortCategory["LiteralValue"] = 3] = "LiteralValue";
+    // A named parameter in a call expression.
+    SortCategory[SortCategory["NamedParameter"] = 4] = "NamedParameter";
+    // A keyword or symbol that was recently used for completion.
+    SortCategory[SortCategory["RecentKeywordOrSymbol"] = 5] = "RecentKeywordOrSymbol";
+    // An auto-import symbol that was recently used for completion.
+    SortCategory[SortCategory["RecentAutoImport"] = 6] = "RecentAutoImport";
+    // A keyword in the python syntax.
+    SortCategory[SortCategory["Keyword"] = 7] = "Keyword";
+    // An enum member.
+    SortCategory[SortCategory["EnumMember"] = 8] = "EnumMember";
+    // A normal symbol.
+    SortCategory[SortCategory["NormalSymbol"] = 9] = "NormalSymbol";
+    // A symbol that starts with _ or __ (used only when there is
+    // no matching filter).
+    SortCategory[SortCategory["PrivateSymbol"] = 10] = "PrivateSymbol";
+    // A symbol with a dunder name (e.g. __init__).
+    SortCategory[SortCategory["DunderSymbol"] = 11] = "DunderSymbol";
+    // An auto-import symbol.
+    SortCategory[SortCategory["AutoImport"] = 12] = "AutoImport";
+})(SortCategory || (SortCategory = {}));
+exports.autoImportDetail = 'Auto-import';
+exports.dictionaryKeyDetail = 'Dictionary key';
+// We'll use a somewhat-arbitrary cutoff value here to determine
+// whether it's sufficiently similar.
+const similarityLimit = 0.25;
+// We'll remember this many completions in the MRU list.
+const maxRecentCompletions = 128;
+class CompletionProvider {
+    constructor(_workspacePath, _parseResults, _fileContents, _importResolver, _position, _filePath, _configOptions, _importLookup, _evaluator, _options, _sourceMapper, _autoImportMaps, _cancellationToken) {
+        this._workspacePath = _workspacePath;
+        this._parseResults = _parseResults;
+        this._fileContents = _fileContents;
+        this._importResolver = _importResolver;
+        this._position = _position;
+        this._filePath = _filePath;
+        this._configOptions = _configOptions;
+        this._importLookup = _importLookup;
+        this._evaluator = _evaluator;
+        this._options = _options;
+        this._sourceMapper = _sourceMapper;
+        this._autoImportMaps = _autoImportMaps;
+        this._cancellationToken = _cancellationToken;
+        // Indicate whether invocation is inside of string literal.
+        this._insideStringLiteral = undefined;
+        this._execEnv = this._configOptions.findExecEnvironment(this._filePath);
+    }
+    getCompletionsForPosition() {
+        var _a, _b;
+        const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, this._parseResults.tokenizerOutput.lines);
+        if (offset === undefined) {
+            return undefined;
+        }
+        const token = ParseTreeUtils.getTokenOverlapping(this._parseResults.tokenizerOutput.tokens, offset);
+        if ((token === null || token === void 0 ? void 0 : token.type) === 5 /* String */) {
+            const stringToken = token;
+            this._insideStringLiteral = textRange_2.TextRange.contains(stringToken, offset)
+                ? stringToken
+                : stringToken.flags & 65536 /* Unterminated */
+                    ? stringToken
+                    : undefined;
+        }
+        let node = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, offset);
+        // See if we can get to a "better" node by backing up a few columns.
+        // A "better" node is defined as one that's deeper than the current
+        // node.
+        const initialNode = node;
+        const initialDepth = node ? ParseTreeUtils.getNodeDepth(node) : 0;
+        if (!initialNode || initialNode.nodeType !== 38 /* Name */) {
+            let curOffset = offset;
+            let sawComma = false;
+            while (curOffset >= 0) {
+                curOffset--;
+                // Stop scanning backward if we hit certain stop characters.
+                const curChar = this._fileContents.substr(curOffset, 1);
+                if (curChar === '(' || curChar === '\n' || curChar === '}') {
+                    break;
+                }
+                if (curChar === ',') {
+                    sawComma = true;
+                }
+                const curNode = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, curOffset);
+                if (curNode && curNode !== initialNode) {
+                    if (ParseTreeUtils.getNodeDepth(curNode) > initialDepth) {
+                        node = curNode;
+                        // If we're at the end of a list with a hanging comma, handle the
+                        // special case of "from x import y, ".
+                        if (sawComma && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ImportFromAs */) {
+                            node = node.parent;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        if (node === undefined) {
+            return undefined;
+        }
+        // Get the text on that line prior to the insertion point.
+        const lineTextRange = this._parseResults.tokenizerOutput.lines.getItemAt(this._position.line);
+        const textOnLine = this._fileContents.substr(lineTextRange.start, lineTextRange.length);
+        const priorText = textOnLine.substr(0, this._position.character);
+        const postText = textOnLine.substr(this._position.character);
+        const priorWordIndex = priorText.search(/\w+$/);
+        const priorWord = priorWordIndex >= 0 ? priorText.substr(priorWordIndex) : '';
+        // Don't offer completions if we're within a comment.
+        if (this._isWithinComment(offset)) {
+            return undefined;
+        }
+        // See if the node is part of an error node. If so, that takes
+        // precedence.
+        let errorNode = node;
+        while (errorNode) {
+            if (errorNode.nodeType === 0 /* Error */) {
+                break;
+            }
+            errorNode = errorNode.parent;
+        }
+        // Determine the context based on the parse node's type and
+        // that of its ancestors.
+        let curNode = errorNode || node;
+        while (true) {
+            (0, cancellationUtils_1.throwIfCancellationRequested)(this._cancellationToken);
+            if (curNode.nodeType === 49 /* String */) {
+                return this._getLiteralCompletions(curNode, priorWord, priorText, postText);
+            }
+            if (curNode.nodeType === 48 /* StringList */ || curNode.nodeType === 27 /* FormatString */) {
+                return undefined;
+            }
+            if (curNode.nodeType === 37 /* ModuleName */) {
+                return this._getImportModuleCompletions(curNode);
+            }
+            if (curNode.nodeType === 0 /* Error */) {
+                return this._getExpressionErrorCompletions(curNode, 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)) {
+                    return { completionMap };
+                }
+            }
+            const dictionaryEntry = ParseTreeUtils.getFirstAncestorOrSelfOfKind(curNode, 17 /* DictionaryKeyEntry */);
+            if (dictionaryEntry) {
+                if (((_b = dictionaryEntry.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 15 /* Dictionary */) {
+                    const dictionaryNode = dictionaryEntry.parent;
+                    if (dictionaryNode.trailingCommaToken && dictionaryNode.trailingCommaToken.start < offset) {
+                        const completionMap = new CompletionMap();
+                        if (this._addTypedDictKeys(dictionaryNode, 
+                        /* stringNode */ undefined, priorText, postText, completionMap)) {
+                            return { completionMap };
+                        }
+                    }
+                }
+            }
+            if (curNode.nodeType === 38 /* Name */) {
+                // This condition is little different than others since it does its own
+                // tree walk up to find context and let outer tree walk up to proceed if it can't find
+                // one to show completion.
+                const result = this._tryGetNameCompletions(curNode, offset, priorWord, priorText, postText);
+                if (result || result === undefined) {
+                    return result;
+                }
+            }
+            if (curNode.nodeType === 22 /* ImportFrom */) {
+                return this._getImportFromCompletions(curNode, priorWord);
+            }
+            if ((0, parseNodes_1.isExpressionNode)(curNode)) {
+                return this._getExpressionCompletions(curNode, priorWord, priorText, postText);
+            }
+            if (curNode.nodeType === 50 /* Suite */) {
+                if (curNode.parent &&
+                    curNode.parent.nodeType === 25 /* Except */ &&
+                    !curNode.parent.name &&
+                    curNode.parent.typeExpression &&
+                    textRange_2.TextRange.getEnd(curNode.parent.typeExpression) < offset &&
+                    offset <= curNode.parent.exceptSuite.start) {
+                    // except Exception as [<empty>]
+                    return undefined;
+                }
+                if (curNode.parent &&
+                    curNode.parent.nodeType === 10 /* Class */ &&
+                    (!curNode.parent.name || !curNode.parent.name.value) &&
+                    curNode.parent.arguments.length === 0 &&
+                    offset <= curNode.parent.suite.start) {
+                    // class [<empty>]
+                    return undefined;
+                }
+                return this._getStatementCompletions(curNode, priorWord, priorText, postText);
+            }
+            if (curNode.nodeType === 36 /* Module */) {
+                return this._getStatementCompletions(curNode, priorWord, priorText, postText);
+            }
+            if (curNode.nodeType === 41 /* Parameter */ &&
+                curNode.length === 0 &&
+                curNode.parent &&
+                curNode.parent.nodeType === 30 /* Lambda */) {
+                // lambda [<empty>] or lambda x, [<empty>]
+                return undefined;
+            }
+            if (!curNode.parent) {
+                break;
+            }
+            curNode = curNode.parent;
+        }
+        return undefined;
+    }
+    // When the user selects a completion, this callback is invoked,
+    // allowing us to record what was selected. This allows us to
+    // build our MRU cache so we can better predict entries.
+    resolveCompletionItem(completionItem) {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(this._cancellationToken);
+        const completionItemData = (0, lspUtils_1.fromLSPAny)(completionItem.data);
+        const label = completionItem.label;
+        let autoImportText = '';
+        if (completionItemData.autoImportText) {
+            autoImportText = completionItemData.autoImportText;
+        }
+        const curIndex = CompletionProvider._mostRecentCompletions.findIndex((item) => item.label === label && item.autoImportText === autoImportText);
+        if (curIndex > 0) {
+            // If there's an existing entry with the same name that's not at the
+            // beginning of the array, remove it.
+            CompletionProvider._mostRecentCompletions = CompletionProvider._mostRecentCompletions.splice(curIndex, 1);
+        }
+        if (curIndex !== 0) {
+            // Add to the start of the array.
+            CompletionProvider._mostRecentCompletions.unshift({ label, autoImportText });
+        }
+        if (CompletionProvider._mostRecentCompletions.length > maxRecentCompletions) {
+            // Prevent the MRU list from growing indefinitely.
+            CompletionProvider._mostRecentCompletions.pop();
+        }
+        if (completionItemData.symbolLabel) {
+            this._itemToResolve = completionItem;
+            if (!completionItemData.autoImportText) {
+                // Rerun the completion lookup. It will fill in additional information
+                // about the item to be resolved. We'll ignore the rest of the returned
+                // list. This is a bit wasteful, but all of that information should be
+                // cached, so it's not as bad as it might seem.
+                this.getCompletionsForPosition();
+            }
+            else if (!completionItem.additionalTextEdits) {
+                const completionMap = new CompletionMap();
+                const completionResults = { completionMap };
+                this._addAutoImportCompletions(completionItemData.symbolLabel, 
+                /* similarityLimit */ 1, 
+                /* lazyEdit */ false, completionResults);
+            }
+        }
+    }
+    // This method will return false if it wants
+    // caller to walk up the tree. it will return
+    // CompletionResults or undefined if it wants caller
+    // to return.
+    _tryGetNameCompletions(curNode, offset, priorWord, priorText, postText) {
+        var _a, _b, _c;
+        if (!curNode.parent) {
+            return false;
+        }
+        if (curNode.parent.nodeType === 21 /* ImportAs */ && curNode.parent.alias === curNode) {
+            // Are we within a "import Y as [Z]"?
+            return undefined;
+        }
+        if (curNode.parent.nodeType === 37 /* ModuleName */) {
+            // Are we within a "import Y as [<empty>]"?
+            if (curNode.parent.parent &&
+                curNode.parent.parent.nodeType === 21 /* ImportAs */ &&
+                !curNode.parent.parent.alias &&
+                textRange_2.TextRange.getEnd(curNode.parent.parent) < offset) {
+                return undefined;
+            }
+            // Are we within a "from X import Y as Z" statement and
+            // more specifically within the "Y"?
+            return this._getImportModuleCompletions(curNode.parent);
+        }
+        if (curNode.parent.nodeType === 23 /* ImportFromAs */) {
+            if (curNode.parent.alias === curNode) {
+                // Are we within a "from X import Y as [Z]"?
+                return undefined;
+            }
+            const parentNode = curNode.parent.parent;
+            if (parentNode && parentNode.nodeType === 22 /* ImportFrom */) {
+                // Are we within a "from X import Y as [<empty>]"?
+                if (!curNode.parent.alias && textRange_2.TextRange.getEnd(curNode.parent) < offset) {
+                    return undefined;
+                }
+                if (curNode.parent.name === curNode) {
+                    return this._getImportFromCompletions(parentNode, priorWord);
+                }
+                return this._getImportFromCompletions(parentNode, '');
+            }
+            return false;
+        }
+        if (curNode.parent.nodeType === 35 /* MemberAccess */ && curNode === curNode.parent.memberName) {
+            return this._getMemberAccessCompletions(curNode.parent.leftExpression, priorWord);
+        }
+        if (curNode.parent.nodeType === 25 /* Except */ && curNode === curNode.parent.name) {
+            return undefined;
+        }
+        if (curNode.parent.nodeType === 28 /* Function */ && curNode === curNode.parent.name) {
+            if ((_a = curNode.parent.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
+                return this._getMethodOverloadsCompletions(priorWord, curNode);
+            }
+            return undefined;
+        }
+        if (curNode.parent.nodeType === 41 /* Parameter */ && curNode === curNode.parent.name) {
+            return undefined;
+        }
+        if (curNode.parent.nodeType === 10 /* Class */ && curNode === curNode.parent.name) {
+            return undefined;
+        }
+        if (curNode.parent.nodeType === 26 /* For */ &&
+            textRange_2.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
+            return undefined;
+        }
+        if (curNode.parent.nodeType === 33 /* ListComprehensionFor */ &&
+            textRange_2.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
+            return undefined;
+        }
+        // For assignments that implicitly declare variables, remove itself (var decl) from completion.
+        if (curNode.parent.nodeType === 3 /* Assignment */ ||
+            curNode.parent.nodeType === 4 /* AssignmentExpression */) {
+            const leftNode = curNode.parent.nodeType === 4 /* AssignmentExpression */
+                ? curNode.parent.name
+                : curNode.parent.leftExpression;
+            if (leftNode !== curNode || priorWord.length === 0) {
+                return false;
+            }
+            const decls = this._evaluator.getDeclarationsForNameNode(curNode);
+            if ((decls === null || decls === void 0 ? void 0 : decls.length) !== 1 || !(0, declaration_1.isVariableDeclaration)(decls[0]) || decls[0].node !== curNode) {
+                return false;
+            }
+            const completionList = this._getExpressionCompletions(curNode, priorWord, priorText, postText);
+            if (completionList === null || completionList === void 0 ? void 0 : completionList.completionMap) {
+                completionList.completionMap.delete(curNode.value);
+            }
+            return completionList;
+        }
+        // Defining class variables.
+        // ex) class A:
+        //         variable = 1
+        if (curNode.parent.nodeType === 47 /* StatementList */ &&
+            ((_b = curNode.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* Suite */ &&
+            ((_c = curNode.parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+            const completionList = this._getClassVariableCompletions(priorWord, curNode);
+            if (completionList) {
+                return completionList;
+            }
+        }
+        return false;
+    }
+    _isWithinComment(offset) {
+        var _a, _b;
+        const token = getTokenAfter(offset, this._parseResults.tokenizerOutput.tokens);
+        if (!token) {
+            // If we're in the middle of a token, we're not in a comment.
+            return false;
+        }
+        return (_b = (_a = token.comments) === null || _a === void 0 ? void 0 : _a.some((c) => textRange_2.TextRange.overlaps(c, offset))) !== null && _b !== void 0 ? _b : false;
+        function getTokenAfter(offset, tokens) {
+            const tokenIndex = tokens.getItemAtPosition(offset);
+            if (tokenIndex < 0) {
+                return undefined;
+            }
+            let token = tokens.getItemAt(tokenIndex);
+            // If we're in the middle of a token, we can't be within a comment.
+            if (offset > token.start && offset < token.start + token.length) {
+                return undefined;
+            }
+            // Multiple zero length tokens can occupy same position.
+            // But comment is associated with the first one. loop
+            // backward to find the first token if position is same.
+            for (let i = tokenIndex - 1; i >= 0; i--) {
+                const prevToken = tokens.getItemAt(i);
+                if (token.start !== prevToken.start) {
+                    break;
+                }
+                token = prevToken;
+            }
+            if (offset <= token.start) {
+                return token;
+            }
+            // If offset > token.start, tokenIndex + 1 < tokens.length
+            // should be always true.
+            debug.assert(tokenIndex + 1 < tokens.length);
+            return tokens.getItemAt(tokenIndex + 1);
+        }
+    }
+    _getExpressionErrorCompletions(node, 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
+        // to determine its type and offer suggestions based on it.
+        switch (node.category) {
+            case 0 /* MissingIn */: {
+                return this._createSingleKeywordCompletion('in');
+            }
+            case 1 /* MissingElse */: {
+                return this._createSingleKeywordCompletion('else');
+            }
+            case 2 /* MissingExpression */:
+            case 4 /* MissingDecoratorCallName */: {
+                return this._getExpressionCompletions(node, priorWord, priorText, postText);
+            }
+            case 3 /* MissingIndexOrSlice */: {
+                let completionResults = this._getLiteralCompletions(node, priorWord, priorText, postText);
+                if (!completionResults || !completionResults.completionMap) {
+                    completionResults = this._getExpressionCompletions(node, priorWord, priorText, postText);
+                }
+                return completionResults;
+            }
+            case 7 /* MissingMemberAccessName */: {
+                if (node.child && (0, parseNodes_1.isExpressionNode)(node.child)) {
+                    return this._getMemberAccessCompletions(node.child, priorWord);
+                }
+                break;
+            }
+            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))) {
+                        return this._getMethodOverloadsCompletions(priorWord, node.child);
+                    }
+                    // Determine if the partial name is a method that's overriding
+                    // a method in a base class.
+                    return this._getMethodOverrideCompletions(priorWord, node.child, node.decorators);
+                }
+                break;
+            }
+        }
+        return undefined;
+    }
+    _isOverload(node) {
+        return this._checkDecorator(node, 'overload');
+    }
+    _checkDecorator(node, value) {
+        return node.expression.nodeType === 38 /* Name */ && node.expression.value === value;
+    }
+    _createSingleKeywordCompletion(keyword) {
+        const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
+        completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
+        completionItem.sortText = this._makeSortText(SortCategory.LikelyKeyword, keyword);
+        const completionMap = new CompletionMap();
+        completionMap.set(completionItem);
+        return { completionMap };
+    }
+    _getClassVariableCompletions(priorWord, partialName) {
+        const enclosingClass = ParseTreeUtils.getEnclosingClass(partialName, false);
+        if (!enclosingClass) {
+            return undefined;
+        }
+        const classResults = this._evaluator.getTypeOfClass(enclosingClass);
+        if (!classResults) {
+            return undefined;
+        }
+        const symbolTable = new Map();
+        for (const mroClass of classResults.classType.details.mro) {
+            if ((0, types_1.isInstantiableClass)(mroClass)) {
+                (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
+            }
+        }
+        const printFlags = (0, sourceMapper_1.isStubFile)(this._filePath)
+            ? 1 /* ForwardDeclarations */ |
+                2 /* DoNotLimitStringLength */
+            : 2 /* DoNotLimitStringLength */;
+        const completionMap = new CompletionMap();
+        symbolTable.forEach((symbol, name) => {
+            if (SymbolNameUtils.isPrivateName(name) ||
+                symbol.isPrivateMember() ||
+                symbol.isExternallyHidden() ||
+                !StringUtils.isPatternInSymbol(partialName.value, name)) {
+                return;
+            }
+            const decls = symbol
+                .getDeclarations()
+                .filter((d) => (0, declaration_1.isVariableDeclaration)(d) && d.moduleName !== 'builtins');
+            // Skip any symbols invalid such as defined in the same class.
+            if (decls.length === 0 ||
+                decls.some((d) => d.node && ParseTreeUtils.getEnclosingClass(d.node, false) === enclosingClass)) {
+                return;
+            }
+            let edits;
+            const declWithTypeAnnotations = decls.filter((d) => d.typeAnnotationNode);
+            if (declWithTypeAnnotations.length > 0) {
+                const text = `${name}: ${ParseTreeUtils.printExpression(declWithTypeAnnotations[declWithTypeAnnotations.length - 1].typeAnnotationNode, printFlags)}`;
+                edits = {
+                    textEdit: this._createReplaceEdits(priorWord, partialName, text),
+                };
+            }
+            this._addSymbol(name, symbol, partialName.value, completionMap, { edits });
+        });
+        return completionMap.size > 0 ? { completionMap } : undefined;
+    }
+    _getMethodOverloadsCompletions(priorWord, partialName) {
+        var _a;
+        const symbolTable = getSymbolTable(this._evaluator, partialName);
+        if (!symbolTable) {
+            return undefined;
+        }
+        const funcParensDisabled = ((_a = partialName.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 28 /* Function */ ? true : undefined;
+        const completionMap = new CompletionMap();
+        const enclosingFunc = ParseTreeUtils.getEnclosingFunction(partialName);
+        symbolTable.forEach((symbol, name) => {
+            const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (!decl || decl.type !== 3 /* Function */) {
+                return;
+            }
+            if (!decl.node.decorators.some((d) => this._isOverload(d))) {
+                // Only consider ones that have overload decorator.
+                return;
+            }
+            const decls = symbol.getDeclarations();
+            if (decls.length === 1 && decls.some((d) => d.node === enclosingFunc)) {
+                // Don't show itself.
+                return;
+            }
+            if (StringUtils.isPatternInSymbol(partialName.value, name)) {
+                const textEdit = this._createReplaceEdits(priorWord, partialName, decl.node.name.value);
+                this._addSymbol(name, symbol, partialName.value, completionMap, {
+                    funcParensDisabled,
+                    edits: { textEdit },
+                });
+            }
+        });
+        return { completionMap };
+        function getSymbolTable(evaluator, partialName) {
+            const enclosingClass = ParseTreeUtils.getEnclosingClass(partialName, false);
+            if (enclosingClass) {
+                const classResults = evaluator.getTypeOfClass(enclosingClass);
+                if (!classResults) {
+                    return undefined;
+                }
+                const symbolTable = new Map();
+                for (const mroClass of classResults.classType.details.mro) {
+                    if ((0, types_1.isInstantiableClass)(mroClass)) {
+                        (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
+                    }
+                }
+                return symbolTable;
+            }
+            // For function overload, we only care about top level functions
+            const moduleNode = ParseTreeUtils.getEnclosingModule(partialName);
+            if (moduleNode) {
+                const moduleScope = AnalyzerNodeInfo.getScope(moduleNode);
+                return moduleScope === null || moduleScope === void 0 ? void 0 : moduleScope.symbolTable;
+            }
+            return undefined;
+        }
+    }
+    _getMethodOverrideCompletions(priorWord, partialName, decorators) {
+        var _a, _b;
+        const enclosingClass = ParseTreeUtils.getEnclosingClass(partialName, /* stopAtFunction */ true);
+        if (!enclosingClass) {
+            return undefined;
+        }
+        const classResults = this._evaluator.getTypeOfClass(enclosingClass);
+        if (!classResults) {
+            return undefined;
+        }
+        const symbolTable = new Map();
+        for (let i = 1; i < classResults.classType.details.mro.length; i++) {
+            const mroClass = classResults.classType.details.mro[i];
+            if ((0, types_1.isInstantiableClass)(mroClass)) {
+                (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
+            }
+        }
+        const staticmethod = (_a = decorators === null || decorators === void 0 ? void 0 : decorators.some((d) => this._checkDecorator(d, 'staticmethod'))) !== null && _a !== void 0 ? _a : false;
+        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) => {
+            let decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (decl && decl.type === 3 /* Function */) {
+                if (StringUtils.isPatternInSymbol(partialName.value, name)) {
+                    const declaredType = this._evaluator.getTypeForDeclaration(decl);
+                    if (!declaredType) {
+                        return;
+                    }
+                    let isProperty = (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isPropertyClass(declaredType);
+                    if (SymbolNameUtils.isDunderName(name)) {
+                        // Don't offer suggestions for built-in properties like "__class__", etc.
+                        isProperty = false;
+                    }
+                    if (!(0, types_1.isFunction)(declaredType) && !isProperty) {
+                        return;
+                    }
+                    if (isProperty) {
+                        // For properties, we should override the "getter", which is typically
+                        // the first declaration.
+                        const typedDecls = symbol.getTypedDeclarations();
+                        if (typedDecls.length > 0 && typedDecls[0].type === 3 /* Function */) {
+                            decl = typedDecls[0];
+                        }
+                    }
+                    const isDeclaredStaticMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isStaticMethod(declaredType);
+                    // Special-case the "__init__subclass__" method because it's an implicit
+                    // classmethod that the type evaluator flags as a real classmethod.
+                    const isDeclaredClassMethod = (0, types_1.isFunction)(declaredType) &&
+                        types_1.FunctionType.isClassMethod(declaredType) &&
+                        name !== '__init_subclass__';
+                    if (staticmethod !== isDeclaredStaticMethod || classmethod !== isDeclaredClassMethod) {
+                        return;
+                    }
+                    const methodSignature = this._printMethodSignature(classResults.classType, decl);
+                    let text;
+                    if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
+                        text = `${methodSignature}: ...`;
+                    }
+                    else {
+                        const methodBody = this._printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl);
+                        text = `${methodSignature}:\n${methodBody}`;
+                    }
+                    const textEdit = this._createReplaceEdits(priorWord, partialName, text);
+                    this._addSymbol(name, symbol, partialName.value, completionMap, {
+                        // method signature already contains ()
+                        funcParensDisabled: true,
+                        edits: {
+                            format: this._options.snippet ? vscode_languageserver_1.InsertTextFormat.Snippet : undefined,
+                            textEdit,
+                        },
+                    });
+                }
+            }
+        });
+        return { completionMap };
+    }
+    _createReplaceEdits(priorWord, node, text) {
+        const replaceOrInsertEndChar = (node === null || node === void 0 ? void 0 : node.nodeType) === 38 /* Name */
+            ? this._position.character - priorWord.length + node.value.length
+            : this._position.character;
+        const range = {
+            start: { line: this._position.line, character: this._position.character - priorWord.length },
+            end: { line: this._position.line, character: replaceOrInsertEndChar },
+        };
+        return vscode_languageserver_1.TextEdit.replace(range, text);
+    }
+    _printMethodSignature(classType, decl) {
+        const node = decl.node;
+        let ellipsisForDefault;
+        if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
+            // In stubs, always use "...".
+            ellipsisForDefault = true;
+        }
+        else if (classType.details.moduleName === decl.moduleName) {
+            // In the same file, always print the full default.
+            ellipsisForDefault = false;
+        }
+        const printFlags = (0, sourceMapper_1.isStubFile)(this._filePath)
+            ? 1 /* ForwardDeclarations */ |
+                2 /* DoNotLimitStringLength */
+            : 2 /* DoNotLimitStringLength */;
+        const paramList = node.parameters
+            .map((param, index) => {
+            let paramString = '';
+            if (param.category === 1 /* VarArgList */) {
+                paramString += '*';
+            }
+            else if (param.category === 2 /* VarArgDictionary */) {
+                paramString += '**';
+            }
+            if (param.name) {
+                paramString += param.name.value;
+            }
+            // Currently, we don't automatically add import if the type used in the annotation is not imported
+            // in current file.
+            const paramTypeAnnotation = ParseTreeUtils.getTypeAnnotationForParameter(node, index);
+            if (paramTypeAnnotation) {
+                paramString += ': ' + ParseTreeUtils.printExpression(paramTypeAnnotation, printFlags);
+            }
+            if (param.defaultValue) {
+                paramString += paramTypeAnnotation ? ' = ' : '=';
+                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !isSimpleDefault(param.defaultValue);
+                paramString += useEllipsis ? '...' : ParseTreeUtils.printExpression(param.defaultValue, printFlags);
+            }
+            if (!paramString && !param.name && param.category === 0 /* Simple */) {
+                return '/';
+            }
+            return paramString;
+        })
+            .join(', ');
+        let methodSignature = node.name.value + '(' + paramList + ')';
+        if (node.returnTypeAnnotation) {
+            methodSignature += ' -> ' + ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
+        }
+        else if (node.functionAnnotationComment) {
+            methodSignature +=
+                ' -> ' +
+                    ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
+        }
+        return methodSignature;
+        function isSimpleDefault(node) {
+            switch (node.nodeType) {
+                case 40 /* Number */:
+                case 11 /* Constant */:
+                    return true;
+                case 49 /* String */:
+                    return (node.token.flags & 64 /* Format */) === 0;
+                case 48 /* StringList */:
+                    return node.strings.every(isSimpleDefault);
+                case 55 /* UnaryOperation */:
+                    return isSimpleDefault(node.expression);
+                case 7 /* BinaryOperation */:
+                    return isSimpleDefault(node.leftExpression) && isSimpleDefault(node.rightExpression);
+                default:
+                    return false;
+            }
+        }
+    }
+    _printOverriddenMethodBody(classType, isStaticMethod, isProperty, decl) {
+        let sb = this._parseResults.tokenizerOutput.predominantTabSequence;
+        if (classType.details.baseClasses.length === 1 &&
+            (0, types_1.isClass)(classType.details.baseClasses[0]) &&
+            classType.details.baseClasses[0].details.fullName === 'builtins.object') {
+            sb += this._options.snippet ? '${0:pass}' : 'pass';
+            return sb;
+        }
+        if (decl.node.parameters.length === 0) {
+            sb += this._options.snippet ? '${0:pass}' : 'pass';
+            return sb;
+        }
+        const parameters = getParameters(isStaticMethod ? decl.node.parameters : decl.node.parameters.slice(1));
+        if (decl.node.name.value !== '__init__') {
+            sb += 'return ';
+        }
+        if (decl.node.isAsync) {
+            sb += 'await ';
+        }
+        if (isProperty) {
+            return sb + `super().${decl.node.name.value}`;
+        }
+        return sb + `super().${decl.node.name.value}(${parameters.map(convertToString).join(', ')})`;
+        function getParameters(parameters) {
+            const results = [];
+            let keywordOnly = false;
+            for (const parameter of parameters) {
+                if (parameter.name) {
+                    results.push([parameter, keywordOnly]);
+                }
+                keywordOnly =
+                    parameter.category === 1 /* VarArgList */ ||
+                        parameter.category === 2 /* VarArgDictionary */;
+            }
+            return results;
+        }
+        function convertToString(parameter) {
+            var _a;
+            const name = (_a = parameter[0].name) === null || _a === void 0 ? void 0 : _a.value;
+            if (parameter[0].category === 1 /* VarArgList */) {
+                return `*${name}`;
+            }
+            if (parameter[0].category === 2 /* VarArgDictionary */) {
+                return `**${name}`;
+            }
+            return parameter[1] ? `${name}=${name}` : name;
+        }
+    }
+    _getMemberAccessCompletions(leftExprNode, priorWord) {
+        const symbolTable = new Map();
+        const completionMap = new CompletionMap();
+        let memberAccessInfo = {};
+        let leftType = this._evaluator.getType(leftExprNode);
+        if (leftType) {
+            leftType = this._evaluator.makeTopLevelTypeVarsConcrete(leftType);
+            (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
+                subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+                if ((0, types_1.isClass)(subtype)) {
+                    // Handle LiteralString specially. Treat it like a 'str' for purposes
+                    // of completion suggestions.
+                    if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
+                        const strObject = this._evaluator.getBuiltInObject(leftExprNode, 'str');
+                        if (strObject && (0, types_1.isClassInstance)(strObject)) {
+                            subtype = strObject;
+                        }
+                    }
+                    (0, typeUtils_1.getMembersForClass)(subtype, symbolTable, /* includeInstanceVars */ types_1.TypeBase.isInstance(subtype));
+                }
+                else if ((0, types_1.isModule)(subtype)) {
+                    (0, typeUtils_1.getMembersForModule)(subtype, symbolTable);
+                }
+                else if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloadedFunction)(subtype)) {
+                    const functionClass = this._evaluator.getBuiltInType(leftExprNode, 'function');
+                    if (functionClass && (0, types_1.isInstantiableClass)(functionClass)) {
+                        (0, typeUtils_1.getMembersForClass)(functionClass, symbolTable, /* includeInstanceVars */ true);
+                    }
+                }
+                else if ((0, types_1.isNoneInstance)(subtype)) {
+                    const objectClass = this._evaluator.getBuiltInType(leftExprNode, 'object');
+                    if (objectClass && (0, types_1.isInstantiableClass)(objectClass)) {
+                        (0, typeUtils_1.getMembersForClass)(objectClass, symbolTable, types_1.TypeBase.isInstance(subtype));
+                    }
+                }
+                this._addSymbolsForSymbolTable(symbolTable, () => true, priorWord, 
+                /* 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);
+        }
+        return { completionMap, memberAccessInfo };
+    }
+    _getLastKnownModule(leftExprNode, leftType) {
+        var _a;
+        let curNode = leftExprNode;
+        let curType = leftType;
+        let unknownMemberName = leftExprNode.nodeType === 35 /* MemberAccess */ ? leftExprNode === null || leftExprNode === void 0 ? void 0 : leftExprNode.memberName.value : undefined;
+        // Walk left of the expression scope till we find a known type. A.B.Unknown.<-- return B.
+        while (curNode) {
+            if (curNode.nodeType === 9 /* Call */ || curNode.nodeType === 35 /* MemberAccess */) {
+                // Move left
+                curNode = curNode.leftExpression;
+                // First time in the loop remember the name of the unknown type.
+                if (unknownMemberName === undefined) {
+                    unknownMemberName =
+                        curNode.nodeType === 35 /* MemberAccess */ ? (_a = curNode === null || curNode === void 0 ? void 0 : curNode.memberName.value) !== null && _a !== void 0 ? _a : '' : '';
+                }
+            }
+            else {
+                curNode = undefined;
+            }
+            if (curNode) {
+                curType = this._evaluator.getType(curNode);
+                // Breakout if we found a known type.
+                if (curType !== undefined && !(0, types_1.isUnknown)(curType) && !(0, types_1.isUnbound)(curType)) {
+                    break;
+                }
+            }
+        }
+        const memberAccessInfo = {};
+        if (curType && !(0, types_1.isUnknown)(curType) && !(0, types_1.isUnbound)(curType) && curNode) {
+            const moduleNamesForType = (0, typeUtils_1.getDeclaringModulesForType)(curType);
+            // For union types we only care about non 'typing' modules.
+            memberAccessInfo.lastKnownModule = moduleNamesForType.find((n) => n !== 'typing');
+            if (curNode.nodeType === 35 /* MemberAccess */) {
+                memberAccessInfo.lastKnownMemberName = curNode.memberName.value;
+            }
+            else if (curNode.nodeType === 38 /* Name */ && (0, types_1.isInstantiableClass)(curType)) {
+                memberAccessInfo.lastKnownMemberName = curType.details.name;
+            }
+            else if (curNode.nodeType === 38 /* Name */ && (0, types_1.isClassInstance)(curType)) {
+                memberAccessInfo.lastKnownMemberName = curType.details.name;
+            }
+            memberAccessInfo.unknownMemberName = unknownMemberName;
+        }
+        return memberAccessInfo;
+    }
+    _getStatementCompletions(parseNode, priorWord, priorText, postText) {
+        // For now, use the same logic for expressions and statements.
+        return this._getExpressionCompletions(parseNode, priorWord, priorText, postText);
+    }
+    _getExpressionCompletions(parseNode, priorWord, priorText, postText) {
+        var _a, _b, _c, _d;
+        const isIndexArgument = this._isIndexArgument(parseNode);
+        // If the user typed a "." as part of a number, don't present
+        // any completion options.
+        if (!isIndexArgument && parseNode.nodeType === 40 /* Number */) {
+            return undefined;
+        }
+        // Are we within a "with Y as []"?
+        // Don't add any completion options.
+        if (((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 59 /* WithItem */ &&
+            parseNode.parent === ((_b = parseNode.parent.target) === null || _b === void 0 ? void 0 : _b.parent)) {
+            return undefined;
+        }
+        const completionMap = new CompletionMap();
+        const completionResults = { completionMap };
+        // Return empty completionList for Ellipsis
+        if (priorText.slice(-2) === '..') {
+            return completionResults;
+        }
+        // Add call argument completions.
+        this._addCallArgumentCompletions(parseNode, priorWord, priorText, postText, 
+        /* atArgument */ false, completionMap);
+        // Add symbols that are in scope.
+        this._addSymbols(parseNode, priorWord, completionMap);
+        // Add keywords.
+        this._findMatchingKeywords(Keywords.forVersion(this._execEnv.pythonVersion), priorWord).map((keyword) => {
+            if (completionMap.has(keyword)) {
+                return;
+            }
+            const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
+            completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
+            completionItem.sortText = this._makeSortText(SortCategory.Keyword, keyword);
+            completionMap.set(completionItem);
+        });
+        // Add auto-import suggestions from other modules.
+        // Ignore this check for privates, since they are not imported.
+        if (!priorWord.startsWith('_') && !this._itemToResolve) {
+            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,
+                });
+            });
+        }
+        return completionResults;
+    }
+    _isIndexArgument(node) {
+        const currentNode = node.parent;
+        return (currentNode &&
+            currentNode.nodeType === 1 /* Argument */ &&
+            currentNode.argumentCategory === 0 /* Simple */ &&
+            currentNode.parent &&
+            currentNode.parent.nodeType === 24 /* Index */ &&
+            currentNode.parent.baseExpression &&
+            currentNode.parent.baseExpression.nodeType === 38 /* Name */);
+    }
+    _addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap) {
+        // If we're within the argument list of a call, add parameter names.
+        const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, this._parseResults.tokenizerOutput.lines);
+        const callInfo = (0, parseTreeUtils_1.getCallNodeAndActiveParameterIndex)(parseNode, offset, this._parseResults.tokenizerOutput.tokens);
+        if (!callInfo) {
+            return;
+        }
+        const signatureInfo = this._evaluator.getCallSignatureInfo(callInfo.callNode, callInfo.activeIndex, callInfo.activeOrFake);
+        if (signatureInfo) {
+            // Are we past the call expression and within the argument list?
+            const callNameEnd = (0, positionUtils_1.convertOffsetToPosition)(signatureInfo.callNode.leftExpression.start + signatureInfo.callNode.leftExpression.length, this._parseResults.tokenizerOutput.lines);
+            if ((0, textRange_1.comparePositions)(this._position, callNameEnd) > 0) {
+                if (!atArgument) {
+                    this._addNamedParameters(signatureInfo, priorWord, completionMap);
+                }
+                // Add literals that apply to this parameter.
+                this._addLiteralValuesForArgument(signatureInfo, priorText, priorWord, postText, completionMap);
+            }
+        }
+    }
+    _addLiteralValuesForArgument(signatureInfo, priorText, priorWord, postText, completionMap) {
+        signatureInfo.signatures.forEach((signature) => {
+            if (!signature.activeParam) {
+                return undefined;
+            }
+            const type = signature.type;
+            const paramIndex = type.details.parameters.indexOf(signature.activeParam);
+            if (paramIndex < 0) {
+                return undefined;
+            }
+            const paramType = type.details.parameters[paramIndex].type;
+            this._addLiteralValuesForTargetType(paramType, priorText, priorWord, postText, completionMap);
+            return undefined;
+        });
+    }
+    _addLiteralValuesForTargetType(type, priorText, priorWord, postText, completionMap) {
+        const quoteValue = this._getQuoteInfo(priorText);
+        this._getSubTypesWithLiteralValues(type).forEach((v) => {
+            if (types_1.ClassType.isBuiltIn(v, 'str')) {
+                const value = (0, typePrinter_1.printLiteralValue)(v, quoteValue.quoteCharacter);
+                if (quoteValue.stringValue === undefined) {
+                    this._addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
+                        sortText: this._makeSortText(SortCategory.LiteralValue, v.literalValue),
+                    });
+                }
+                else {
+                    this._addStringLiteralToCompletions(value.substr(1, value.length - 2), quoteValue.stringValue, postText, quoteValue.quoteCharacter, completionMap);
+                }
+            }
+        });
+    }
+    _getDictExpressionStringKeys(parseNode, excludeIds) {
+        const node = getDictionaryLikeNode(parseNode);
+        if (!node) {
+            return [];
+        }
+        return node.entries.flatMap((entry) => {
+            if (entry.nodeType !== 17 /* DictionaryKeyEntry */ || (excludeIds === null || excludeIds === void 0 ? void 0 : excludeIds.has(entry.keyExpression.id))) {
+                return [];
+            }
+            if (entry.keyExpression.nodeType === 48 /* StringList */) {
+                return [entry.keyExpression.strings.map((s) => s.value).join('')];
+            }
+            return [];
+        });
+        function getDictionaryLikeNode(parseNode) {
+            // this method assumes the given parseNode is either a child of a dictionary or a dictionary itself
+            if (parseNode.nodeType === 15 /* Dictionary */) {
+                return parseNode;
+            }
+            let curNode = parseNode;
+            while (curNode && curNode.nodeType !== 15 /* Dictionary */ && curNode.nodeType !== 45 /* Set */) {
+                curNode = curNode.parent;
+                if (!curNode) {
+                    return;
+                }
+            }
+            return curNode;
+        }
+    }
+    _getSubTypesWithLiteralValues(type) {
+        const values = [];
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) && (0, typeUtils_1.isLiteralType)(subtype)) {
+                values.push(subtype);
+            }
+        });
+        return values;
+    }
+    _getIndexerKeyType(baseType) {
+        var _a;
+        // 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) {
+                return baseType.typeArguments[0];
+            }
+        }
+        // Handle simple __getitem__
+        const member = (0, typeUtils_1.lookUpObjectMember)(baseType, '__getitem__');
+        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);
+                if (getItemType && (0, types_1.isFunction)(getItemType) && getItemType.details.parameters.length === 2) {
+                    return getItemType.details.parameters[1].type;
+                }
+            }
+        }
+        return undefined;
+    }
+    _getIndexerKeys(indexNode, invocationNode) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (indexNode.baseExpression.nodeType !== 38 /* Name */) {
+            // This completion only supports simple name case
+            return [];
+        }
+        const baseType = this._evaluator.getType(indexNode.baseExpression);
+        if (!baseType || !(0, types_1.isClassInstance)(baseType)) {
+            return [];
+        }
+        // See whether indexer key is typed using Literal types. If it is, return those literal keys.
+        const keyType = this._getIndexerKeyType(baseType);
+        if (keyType) {
+            const keys = [];
+            this._getSubTypesWithLiteralValues(keyType).forEach((v) => {
+                if (!types_1.ClassType.isBuiltIn(v, 'str') &&
+                    !types_1.ClassType.isBuiltIn(v, 'int') &&
+                    !types_1.ClassType.isBuiltIn(v, 'bool') &&
+                    !types_1.ClassType.isBuiltIn(v, 'bytes') &&
+                    !types_1.ClassType.isEnumClass(v)) {
+                    return;
+                }
+                keys.push((0, typePrinter_1.printLiteralValue)(v, this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter));
+            });
+            if (keys.length > 0) {
+                return keys;
+            }
+        }
+        // Must be local variable/parameter
+        const declarations = (_a = this._evaluator.getDeclarationsForNameNode(indexNode.baseExpression)) !== null && _a !== void 0 ? _a : [];
+        const declaration = declarations.length > 0 ? declarations[0] : undefined;
+        if (!declaration ||
+            (declaration.type !== 1 /* Variable */ && declaration.type !== 2 /* Parameter */)) {
+            return [];
+        }
+        if (declaration.path !== this._filePath) {
+            return [];
+        }
+        let startingNode = indexNode.baseExpression;
+        if (declaration.node) {
+            const scopeRoot = ParseTreeUtils.getEvaluationScopeNode(declaration.node);
+            // Find the lowest tree to search the symbol.
+            if (((_b = ParseTreeUtils.getFileInfoFromNode(startingNode)) === null || _b === void 0 ? void 0 : _b.filePath) ===
+                ((_c = ParseTreeUtils.getFileInfoFromNode(scopeRoot)) === null || _c === void 0 ? void 0 : _c.filePath)) {
+                startingNode = scopeRoot;
+            }
+        }
+        const results = documentSymbolCollector_1.DocumentSymbolCollector.collectFromNode(indexNode.baseExpression, this._evaluator, this._cancellationToken, startingNode);
+        const keys = new Set();
+        for (const result of results) {
+            const node = ((_d = result.node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* TypeAnnotation */ ? result.node.parent : result.node;
+            if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 3 /* Assignment */ ||
+                ((_f = node.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 4 /* AssignmentExpression */) {
+                if (node.parent.rightExpression.nodeType === 15 /* Dictionary */) {
+                    const dictionary = node.parent.rightExpression;
+                    for (const entry of dictionary.entries.filter((e) => e.nodeType === 17 /* DictionaryKeyEntry */)) {
+                        const key = this._parseResults.text
+                            .substr(entry.keyExpression.start, entry.keyExpression.length)
+                            .trim();
+                        if (key.length > 0)
+                            keys.add(key);
+                    }
+                }
+                if (node.parent.rightExpression.nodeType === 9 /* Call */) {
+                    const call = node.parent.rightExpression;
+                    const type = this._evaluator.getType(call.leftExpression);
+                    if (!type || !(0, types_1.isInstantiableClass)(type) || !types_1.ClassType.isBuiltIn(type, 'dict')) {
+                        continue;
+                    }
+                    for (const arg of call.arguments) {
+                        const key = (_h = (_g = arg.name) === null || _g === void 0 ? void 0 : _g.value.trim()) !== null && _h !== void 0 ? _h : '';
+                        const quote = this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter;
+                        if (key.length > 0) {
+                            keys.add(`${quote}${key}${quote}`);
+                        }
+                    }
+                }
+            }
+            if (((_j = node.parent) === null || _j === void 0 ? void 0 : _j.nodeType) === 24 /* Index */ &&
+                node.parent.items.length === 1 &&
+                node.parent.items[0].valueExpression.nodeType !== 0 /* Error */ &&
+                !textRange_2.TextRange.containsRange(node.parent, invocationNode)) {
+                const indexArgument = node.parent.items[0];
+                const key = this._parseResults.text
+                    .substr(indexArgument.valueExpression.start, indexArgument.valueExpression.length)
+                    .trim();
+                if (key.length > 0)
+                    keys.add(key);
+            }
+        }
+        return [...keys];
+    }
+    _getLiteralCompletions(parseNode, priorWord, priorText, postText) {
+        var _a, _b, _c;
+        let parentNode = parseNode.parent;
+        if (!parentNode) {
+            return undefined;
+        }
+        const completionMap = new CompletionMap();
+        // 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);
+            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 };
+                    }
+                }
+            }
+        }
+        if (parentNode.nodeType !== 1 /* Argument */) {
+            if (parentNode.nodeType !== 48 /* StringList */ || parentNode.strings.length > 1) {
+                return undefined;
+            }
+            parentNode = parentNode.parent;
+            if (!parentNode) {
+                return undefined;
+            }
+        }
+        if (parentNode.nodeType === 1 /* Argument */ && ((_c = parentNode.parent) === null || _c === void 0 ? void 0 : _c.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 (completionMap.size === 0) {
+                    return undefined;
+                }
+            }
+        }
+        else {
+            debug.assert(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);
+            this._addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap);
+        }
+        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;
+        }
+        let typedDicts = [];
+        (0, typeUtils_1.doForEachSubtype)(expectedTypeResult.type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+                typedDicts.push(subtype);
+            }
+        });
+        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.forEach((typedDict) => {
+            (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, typedDict, /* allowNarrowed */ true).forEach((_, key) => {
+                // Unions of TypedDicts may define the same key.
+                if (excludes.has(key) || completionMap.has(key)) {
+                    return;
+                }
+                excludes.add(key);
+                this._addStringLiteralToCompletions(key, quoteValue ? quoteValue.stringValue : undefined, postText, quoteValue
+                    ? quoteValue.quoteCharacter
+                    : this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter, completionMap);
+            });
+        });
+        return true;
+    }
+    _tryNarrowTypedDicts(types, keys) {
+        const newTypes = types.flatMap((type) => {
+            const entries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, type, /* allowNarrowed */ true);
+            for (let index = 0; index < keys.length; index++) {
+                if (!entries.has(keys[index])) {
+                    return [];
+                }
+            }
+            return [type];
+        });
+        if (newTypes.length === 0) {
+            // Couldn't narrow to any typed dicts. Just include all.
+            return types;
+        }
+        return newTypes;
+    }
+    // Find out quotation and string prefix to use for string literals
+    // completion under current context.
+    _getQuoteInfo(priorText) {
+        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 };
+        }
+        const singleQuote = "'";
+        const doubleQuote = '"';
+        // If completion is inside of string literal and has prior text
+        // ex) typedDict["key |<= here
+        // find quotation user has used (ex, ") and string prefix (ex, key)
+        if (priorText !== undefined) {
+            const lastSingleQuote = priorText.lastIndexOf(singleQuote);
+            const lastDoubleQuote = priorText.lastIndexOf(doubleQuote);
+            if (lastSingleQuote > lastDoubleQuote) {
+                stringValue = priorText.substr(lastSingleQuote + 1);
+                quoteCharacter = singleQuote;
+            }
+            else if (lastDoubleQuote > lastSingleQuote) {
+                stringValue = priorText.substr(lastDoubleQuote + 1);
+                quoteCharacter = doubleQuote;
+            }
+        }
+        // If the string literal that completion is invoked in is f-string,
+        // quotation must be the other one than one that is used for f-string.
+        // ex) f"....{typedDict[|<= here ]}"
+        // then quotation must be "'"
+        //
+        // for f-string, this code path will be only taken when completion is inside
+        // of f-string segment.
+        // ex) f"..{|<= here }"
+        if (this._insideStringLiteral.flags & 64 /* Format */) {
+            quoteCharacter = this._insideStringLiteral.flags & 1 /* SingleQuote */ ? doubleQuote : singleQuote;
+        }
+        return { stringValue, quoteCharacter };
+    }
+    _tryAddTypedDictStringLiteral(indexNode, priorText, postText, completionMap) {
+        if (!indexNode) {
+            return false;
+        }
+        const baseType = this._evaluator.getType(indexNode.baseExpression);
+        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;
+    }
+    _addStringLiteralToCompletions(value, priorString, postText, quoteCharacter, completionMap, detail) {
+        if (StringUtils.isPatternInSymbol(priorString || '', value)) {
+            const valueWithQuotes = `${quoteCharacter}${value}${quoteCharacter}`;
+            if (completionMap.has(valueWithQuotes)) {
+                return;
+            }
+            const completionItem = vscode_languageserver_1.CompletionItem.create(valueWithQuotes);
+            completionItem.kind = vscode_languageserver_1.CompletionItemKind.Constant;
+            completionItem.sortText = this._makeSortText(SortCategory.LiteralValue, valueWithQuotes);
+            let rangeStartCol = this._position.character;
+            if (priorString !== undefined) {
+                rangeStartCol -= priorString.length + 1;
+            }
+            // 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)) {
+                    rangeEndCol++;
+                }
+            }
+            const range = {
+                start: { line: this._position.line, character: rangeStartCol },
+                end: { line: this._position.line, character: rangeEndCol },
+            };
+            completionItem.textEdit = vscode_languageserver_1.TextEdit.replace(range, valueWithQuotes);
+            completionItem.detail = detail;
+            completionMap.set(completionItem);
+        }
+    }
+    _addAutoImportCompletions(priorWord, similarityLimit, lazyEdit, completionResults) {
+        var _a, _b, _c;
+        if (!completionResults.completionMap ||
+            !this._configOptions.autoImportCompletions ||
+            !this._options.autoImport) {
+            // If auto import on the server is turned off or this particular invocation
+            // is turned off (ex, notebook), don't do any thing.
+            return;
+        }
+        const moduleSymbolMap = this._autoImportMaps.getModuleSymbolsMap();
+        const autoImporter = new autoImporter_1.AutoImporter(this._execEnv, this._importResolver, this._parseResults, this._position, completionResults.completionMap, moduleSymbolMap, { libraryMap: this._autoImportMaps.libraryMap, lazyEdit });
+        const results = [];
+        const info = (_a = this._autoImportMaps.nameMap) === null || _a === void 0 ? void 0 : _a.get(priorWord);
+        if (info && priorWord.length > 1 && !completionResults.completionMap.has(priorWord)) {
+            (0, collectionUtils_1.appendArray)(results, autoImporter.getAutoImportCandidatesForAbbr(priorWord, info, this._cancellationToken));
+        }
+        results.push(...autoImporter.getAutoImportCandidates(priorWord, similarityLimit, 
+        /* abbrFromUsers */ undefined, this._cancellationToken));
+        const perfInfo = autoImporter.getPerfInfo();
+        const additionDuration = new timing_1.Duration();
+        for (const result of results) {
+            if (result.symbol) {
+                this._addSymbol(result.name, result.symbol, priorWord, completionResults.completionMap, {
+                    autoImportSource: result.source,
+                    autoImportAlias: result.alias,
+                    edits: {
+                        textEdit: this._createReplaceEdits(priorWord, /* node */ undefined, result.insertionText),
+                        additionalTextEdits: result.edits,
+                    },
+                });
+            }
+            else {
+                this._addNameToCompletions((_b = result.alias) !== null && _b !== void 0 ? _b : result.name, (_c = result.kind) !== null && _c !== void 0 ? _c : vscode_languageserver_1.CompletionItemKind.Module, priorWord, completionResults.completionMap, {
+                    autoImportText: this._getAutoImportText(result.name, result.source, result.alias),
+                    edits: {
+                        textEdit: this._createReplaceEdits(priorWord, /* node */ undefined, result.insertionText),
+                        additionalTextEdits: result.edits,
+                    },
+                });
+            }
+        }
+        completionResults.autoImportInfo = {
+            indexUsed: perfInfo.indexUsed,
+            totalTimeInMS: perfInfo.totalInMs,
+            moduleTimeInMS: perfInfo.moduleTimeInMS,
+            indexTimeInMS: perfInfo.indexTimeInMS,
+            importAliasTimeInMS: perfInfo.importAliasTimeInMS,
+            itemCount: results.length,
+            symbolCount: perfInfo.symbolCount,
+            indexCount: perfInfo.indexCount,
+            importAliasCount: perfInfo.importAliasCount,
+            additionTimeInMS: additionDuration.getDurationInMilliseconds(),
+        };
+    }
+    _getImportFromCompletions(importFromNode, priorWord) {
+        // Don't attempt to provide completions for "from X import *".
+        if (importFromNode.isWildcardImport) {
+            return undefined;
+        }
+        // Access the imported module information, which is hanging
+        // off the ImportFromNode.
+        const importInfo = AnalyzerNodeInfo.getImportInfo(importFromNode.module);
+        if (!importInfo) {
+            return undefined;
+        }
+        const completionMap = new CompletionMap();
+        const resolvedPath = importInfo.resolvedPaths.length > 0 ? importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1] : '';
+        const lookupResults = this._importLookup(resolvedPath);
+        if (lookupResults) {
+            this._addSymbolsForSymbolTable(lookupResults.symbolTable, (symbol, name) => {
+                // Don't suggest built in symbols or ones that have already been imported.
+                return (symbol.getDeclarations().some((d) => !(0, declaration_1.isIntrinsicDeclaration)(d)) &&
+                    !importFromNode.imports.find((imp) => imp.name.value === name));
+            }, priorWord, 
+            /* isInImport */ true, 
+            /* boundObject */ undefined, completionMap);
+        }
+        // Add the implicit imports.
+        importInfo.implicitImports.forEach((implImport) => {
+            if (!importFromNode.imports.find((imp) => imp.name.value === implImport.name)) {
+                this._addNameToCompletions(implImport.name, vscode_languageserver_1.CompletionItemKind.Module, priorWord, completionMap);
+            }
+        });
+        return { completionMap };
+    }
+    _findMatchingKeywords(keywordList, partialMatch) {
+        return keywordList.filter((keyword) => {
+            if (partialMatch) {
+                return StringUtils.isPatternInSymbol(partialMatch, keyword);
+            }
+            else {
+                return true;
+            }
+        });
+    }
+    _addNamedParameters(signatureInfo, priorWord, completionMap) {
+        const argNameMap = new Map();
+        signatureInfo.signatures.forEach((signature) => {
+            this._addNamedParametersToMap(signature.type, argNameMap);
+        });
+        // Remove any named parameters that are already provided.
+        signatureInfo.callNode.arguments.forEach((arg) => {
+            if (arg.name) {
+                argNameMap.delete(arg.name.value);
+            }
+        });
+        // Add the remaining unique parameter names to the completion list.
+        argNameMap.forEach((argName) => {
+            if (StringUtils.isPatternInSymbol(priorWord, argName)) {
+                const label = argName + '=';
+                if (completionMap.has(label)) {
+                    return;
+                }
+                const completionItem = vscode_languageserver_1.CompletionItem.create(label);
+                completionItem.kind = vscode_languageserver_1.CompletionItemKind.Variable;
+                const completionItemData = {
+                    workspacePath: this._workspacePath,
+                    filePath: this._filePath,
+                    position: this._position,
+                };
+                completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
+                completionItem.sortText = this._makeSortText(SortCategory.NamedParameter, argName);
+                completionItem.filterText = argName;
+                completionMap.set(completionItem);
+            }
+        });
+    }
+    _addNamedParametersToMap(type, paramMap) {
+        type.details.parameters.forEach((param) => {
+            if (param.name && !param.isNameSynthesized) {
+                // Don't add private or protected names. These are assumed
+                // not to be named parameters.
+                if (!SymbolNameUtils.isPrivateOrProtectedName(param.name)) {
+                    paramMap.set(param.name, param.name);
+                }
+            }
+        });
+    }
+    _addSymbols(node, priorWord, completionMap) {
+        let curNode = node;
+        while (curNode) {
+            // Does this node have a scope associated with it?
+            let scope = (0, scopeUtils_1.getScopeForNode)(curNode);
+            if (scope) {
+                while (scope) {
+                    this._addSymbolsForSymbolTable(scope.symbolTable, () => true, priorWord, 
+                    /* isInImport */ false, 
+                    /* boundObject */ undefined, completionMap);
+                    scope = scope.parent;
+                }
+                // If this is a class scope, add symbols from parent classes.
+                if (curNode.nodeType === 10 /* Class */) {
+                    const classType = this._evaluator.getTypeOfClass(curNode);
+                    if (classType && (0, types_1.isInstantiableClass)(classType.classType)) {
+                        classType.classType.details.mro.forEach((baseClass, index) => {
+                            if ((0, types_1.isInstantiableClass)(baseClass)) {
+                                this._addSymbolsForSymbolTable(baseClass.details.fields, (symbol) => {
+                                    if (!symbol.isClassMember()) {
+                                        return false;
+                                    }
+                                    // Return only variables, not methods or classes.
+                                    return symbol
+                                        .getDeclarations()
+                                        .some((decl) => decl.type === 1 /* Variable */);
+                                }, priorWord, 
+                                /* isInImport */ false, 
+                                /* boundObject */ undefined, completionMap);
+                            }
+                        });
+                    }
+                }
+                break;
+            }
+            curNode = curNode.parent;
+        }
+    }
+    _addSymbolsForSymbolTable(symbolTable, includeSymbolCallback, priorWord, isInImport, boundObjectOrClass, completionMap) {
+        symbolTable.forEach((symbol, name) => {
+            // If there are no declarations or the symbol is not
+            // exported from this scope, don't include it in the
+            // suggestion list unless we are in the same file.
+            const hidden = symbol.isExternallyHidden() &&
+                !symbol.getDeclarations().some((d) => (0, declarationUtils_1.isDefinedInFile)(d, this._filePath));
+            if (!hidden && includeSymbolCallback(symbol, name)) {
+                // Don't add a symbol more than once. It may have already been
+                // added from an inner scope's symbol table.
+                if (!completionMap.has(name)) {
+                    this._addSymbol(name, symbol, priorWord, completionMap, {
+                        boundObjectOrClass,
+                        funcParensDisabled: isInImport,
+                    });
+                }
+            }
+        });
+    }
+    _addSymbol(name, symbol, priorWord, completionMap, detail) {
+        var _a, _b, _c;
+        // If the symbol is a py.typed import that is not supposed to be re-exported,
+        // don't offer it as a completion suggestion.
+        if (symbol.isPrivatePyTypedImport()) {
+            return;
+        }
+        let primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+        if (!primaryDecl) {
+            const declarations = symbol.getDeclarations();
+            if (declarations.length > 0) {
+                primaryDecl = declarations[declarations.length - 1];
+            }
+        }
+        if (primaryDecl) {
+            let itemKind = vscode_languageserver_1.CompletionItemKind.Variable;
+            primaryDecl = this._evaluator.resolveAliasDeclaration(primaryDecl, /* resolveLocalNames */ true);
+            if (primaryDecl) {
+                itemKind = this._convertDeclarationTypeToItemKind(primaryDecl);
+                // Handle enum members specially. Enum members normally look like
+                // variables, but the are declared using assignment expressions
+                // within an enum class.
+                if (primaryDecl.type === 1 /* Variable */ &&
+                    detail.boundObjectOrClass &&
+                    (0, types_1.isInstantiableClass)(detail.boundObjectOrClass) &&
+                    types_1.ClassType.isEnumClass(detail.boundObjectOrClass) &&
+                    ((_a = primaryDecl.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+                    itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
+                }
+                // Are we resolving a completion item? If so, see if this symbol
+                // is the one that we're trying to match.
+                if (this._itemToResolve) {
+                    const completionItemData = (0, lspUtils_1.fromLSPAny)(this._itemToResolve.data);
+                    if (completionItemData.symbolLabel === name && !completionItemData.autoImportText) {
+                        // This call can be expensive to perform on every completion item
+                        // that we return, so we do it lazily in the "resolve" callback.
+                        const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+                        if (type) {
+                            let typeDetail;
+                            let documentation;
+                            switch (primaryDecl.type) {
+                                case 0 /* Intrinsic */:
+                                case 1 /* Variable */:
+                                case 2 /* Parameter */: {
+                                    let expandTypeAlias = false;
+                                    if (type && types_1.TypeBase.isInstantiable(type)) {
+                                        const typeAliasInfo = (0, types_1.getTypeAliasInfo)(type);
+                                        if (typeAliasInfo) {
+                                            if (typeAliasInfo.name === name) {
+                                                expandTypeAlias = true;
+                                            }
+                                        }
+                                    }
+                                    typeDetail = name + ': ' + this._evaluator.printType(type, expandTypeAlias);
+                                    break;
+                                }
+                                case 3 /* Function */: {
+                                    const functionType = detail.boundObjectOrClass && ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type))
+                                        ? this._evaluator.bindFunctionToClassOrObject(detail.boundObjectOrClass, type)
+                                        : type;
+                                    if (functionType) {
+                                        if ((0, typeUtils_1.isProperty)(functionType) &&
+                                            detail.boundObjectOrClass &&
+                                            (0, types_1.isClassInstance)(detail.boundObjectOrClass)) {
+                                            const propertyType = this._evaluator.getGetterTypeFromProperty(functionType, 
+                                            /* inferTypeIfNeeded */ true) || types_1.UnknownType.create();
+                                            typeDetail =
+                                                name +
+                                                    ': ' +
+                                                    this._evaluator.printType(propertyType, /* expandTypeAlias */ false) +
+                                                    ' (property)';
+                                        }
+                                        else if ((0, types_1.isOverloadedFunction)(functionType)) {
+                                            // 35 is completion tooltip's default width size
+                                            typeDetail = (0, tooltipUtils_1.getOverloadedFunctionTooltip)(functionType, this._evaluator, 
+                                            /* columnThreshold */ 35);
+                                        }
+                                        else {
+                                            typeDetail =
+                                                name +
+                                                    ': ' +
+                                                    this._evaluator.printType(functionType, /* expandTypeAlias */ false);
+                                        }
+                                    }
+                                    break;
+                                }
+                                case 4 /* Class */:
+                                case 5 /* SpecialBuiltInClass */: {
+                                    typeDetail = 'class ' + name + '()';
+                                    break;
+                                }
+                                case 6 /* Alias */: {
+                                    typeDetail = name;
+                                    if (primaryDecl.path) {
+                                        const lookupResults = this._importLookup(primaryDecl.path);
+                                        if (lookupResults) {
+                                            documentation = lookupResults.docString;
+                                        }
+                                    }
+                                    break;
+                                }
+                                default: {
+                                    typeDetail = name;
+                                    break;
+                                }
+                            }
+                            if (primaryDecl.type === 1 /* Variable */ &&
+                                primaryDecl.typeAliasName &&
+                                primaryDecl.docString) {
+                                documentation = primaryDecl.docString;
+                            }
+                            else if ((0, types_1.isModule)(type)) {
+                                documentation = (0, typeDocStringUtils_1.getModuleDocString)(type, primaryDecl, this._sourceMapper);
+                            }
+                            else if ((0, types_1.isInstantiableClass)(type)) {
+                                documentation = (0, typeDocStringUtils_1.getClassDocString)(type, primaryDecl, this._sourceMapper);
+                            }
+                            else if ((0, types_1.isFunction)(type)) {
+                                const functionType = detail.boundObjectOrClass
+                                    ? this._evaluator.bindFunctionToClassOrObject(detail.boundObjectOrClass, type)
+                                    : type;
+                                if (functionType && (0, types_1.isFunction)(functionType)) {
+                                    documentation = (0, tooltipUtils_1.getFunctionDocStringFromType)(functionType, this._sourceMapper, this._evaluator);
+                                }
+                            }
+                            else if ((0, types_1.isOverloadedFunction)(type)) {
+                                const functionType = detail.boundObjectOrClass
+                                    ? this._evaluator.bindFunctionToClassOrObject(detail.boundObjectOrClass, type)
+                                    : type;
+                                if (functionType && (0, types_1.isOverloadedFunction)(functionType)) {
+                                    documentation = (0, tooltipUtils_1.getOverloadedFunctionDocStringsFromType)(functionType, this._sourceMapper, this._evaluator).find((doc) => doc);
+                                }
+                            }
+                            else if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 3 /* Function */) {
+                                // @property functions
+                                documentation = (0, typeDocStringUtils_1.getPropertyDocStringInherited)(primaryDecl, this._sourceMapper, this._evaluator);
+                            }
+                            else if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */) {
+                                const decl = ((_b = symbol
+                                    .getDeclarations()
+                                    .find((d) => d.type === 1 /* Variable */ && !!d.docString)) !== null && _b !== void 0 ? _b : primaryDecl);
+                                documentation = (0, typeDocStringUtils_1.getVariableDocString)(decl, this._sourceMapper);
+                            }
+                            if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+                                let markdownString = '```python\n' + typeDetail + '\n```\n';
+                                if (documentation) {
+                                    markdownString += '---\n';
+                                    markdownString += (0, docStringConversion_1.convertDocStringToMarkdown)(documentation);
+                                }
+                                markdownString = markdownString.trimEnd();
+                                this._itemToResolve.documentation = {
+                                    kind: vscode_languageserver_1.MarkupKind.Markdown,
+                                    value: markdownString,
+                                };
+                            }
+                            else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+                                let plainTextString = typeDetail + '\n';
+                                if (documentation) {
+                                    plainTextString += '\n';
+                                    plainTextString += (0, docStringConversion_1.convertDocStringToPlainText)(documentation);
+                                }
+                                plainTextString = plainTextString.trimEnd();
+                                this._itemToResolve.documentation = {
+                                    kind: vscode_languageserver_1.MarkupKind.PlainText,
+                                    value: plainTextString,
+                                };
+                            }
+                            else {
+                                (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
+                            }
+                        }
+                    }
+                }
+            }
+            const autoImportText = detail.autoImportSource
+                ? this._getAutoImportText(name, detail.autoImportSource, detail.autoImportAlias)
+                : undefined;
+            this._addNameToCompletions((_c = detail.autoImportAlias) !== null && _c !== void 0 ? _c : name, itemKind, priorWord, completionMap, {
+                autoImportText,
+                funcParensDisabled: detail.funcParensDisabled,
+                edits: detail.edits,
+            });
+        }
+        else {
+            // Does the symbol have no declaration but instead has a synthesized type?
+            const synthesizedType = symbol.getSynthesizedType();
+            if (synthesizedType) {
+                const itemKind = vscode_languageserver_1.CompletionItemKind.Variable;
+                this._addNameToCompletions(name, itemKind, priorWord, completionMap, {
+                    funcParensDisabled: detail.funcParensDisabled,
+                    edits: detail.edits,
+                });
+            }
+        }
+    }
+    _getAutoImportText(importName, importFrom, importAlias) {
+        const autoImportText = (0, tooltipUtils_1.getAutoImportText)(importName, importFrom, importAlias);
+        let importText = '';
+        if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+            importText = `\`\`\`\n${autoImportText}\n\`\`\``;
+        }
+        else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+            importText = autoImportText;
+        }
+        else {
+            (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
+        }
+        return {
+            source: importFrom !== null && importFrom !== void 0 ? importFrom : '',
+            importText,
+        };
+    }
+    _addNameToCompletions(name, itemKind, filter, completionMap, detail) {
+        var _a, _b, _c, _d;
+        // Auto importer already filtered out unnecessary ones. No need to do it again.
+        const similarity = (detail === null || detail === void 0 ? void 0 : detail.autoImportText) ? true : StringUtils.isPatternInSymbol(filter, name);
+        if (!similarity) {
+            return;
+        }
+        if (completionMap.has(name, CompletionMap.matchKindAndImportText, itemKind, (_a = detail === null || detail === void 0 ? void 0 : detail.autoImportText) === null || _a === void 0 ? void 0 : _a.importText)) {
+            return;
+        }
+        const completionItem = vscode_languageserver_1.CompletionItem.create(name);
+        completionItem.kind = itemKind;
+        const completionItemData = {
+            workspacePath: this._workspacePath,
+            filePath: this._filePath,
+            position: this._position,
+        };
+        if (detail === null || detail === void 0 ? void 0 : detail.funcParensDisabled) {
+            completionItemData.funcParensDisabled = true;
+        }
+        completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
+        if ((detail === null || detail === void 0 ? void 0 : detail.sortText) || (detail === null || detail === void 0 ? void 0 : detail.itemDetail)) {
+            completionItem.sortText = detail.sortText;
+            completionItem.detail = detail.itemDetail;
+        }
+        else if (detail === null || detail === void 0 ? void 0 : detail.autoImportText) {
+            // Force auto-import entries to the end.
+            completionItem.sortText = this._makeSortText(SortCategory.AutoImport, name, detail.autoImportText.importText);
+            completionItemData.autoImportText = detail.autoImportText.importText;
+            completionItem.detail = exports.autoImportDetail;
+            if (detail.autoImportText.source) {
+                completionItem.labelDetails = { description: detail.autoImportText.source };
+            }
+        }
+        else if (itemKind === vscode_languageserver_1.CompletionItemKind.EnumMember) {
+            // Handle enum members separately so they are sorted above other symbols.
+            completionItem.sortText = this._makeSortText(SortCategory.EnumMember, name);
+        }
+        else if (SymbolNameUtils.isDunderName(name)) {
+            // Force dunder-named symbols to appear after all other symbols.
+            completionItem.sortText = this._makeSortText(SortCategory.DunderSymbol, name);
+        }
+        else if (filter === '' && SymbolNameUtils.isPrivateOrProtectedName(name)) {
+            // Distinguish between normal and private symbols only if there is
+            // currently no filter text. Once we get a single character to filter
+            // upon, we'll no longer differentiate.
+            completionItem.sortText = this._makeSortText(SortCategory.PrivateSymbol, name);
+        }
+        else {
+            completionItem.sortText = this._makeSortText(SortCategory.NormalSymbol, name);
+        }
+        completionItemData.symbolLabel = name;
+        if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+            let markdownString = '';
+            if (detail === null || detail === void 0 ? void 0 : detail.autoImportText) {
+                markdownString += detail.autoImportText.importText;
+                if (detail.typeDetail || detail.documentation) {
+                    // Micro perf optimization to not create new string from trimEnd.
+                    markdownString += '\n\n';
+                }
+            }
+            if (detail === null || detail === void 0 ? void 0 : detail.typeDetail) {
+                markdownString += '```python\n' + detail.typeDetail + '\n```\n';
+            }
+            if (detail === null || detail === void 0 ? void 0 : detail.documentation) {
+                markdownString += '---\n';
+                markdownString += (0, docStringConversion_1.convertDocStringToMarkdown)(detail.documentation);
+            }
+            markdownString = markdownString.trimEnd();
+            if (markdownString) {
+                completionItem.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.Markdown,
+                    value: markdownString,
+                };
+            }
+        }
+        else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+            let plainTextString = '';
+            if (detail === null || detail === void 0 ? void 0 : detail.autoImportText) {
+                plainTextString += detail.autoImportText.importText;
+                if (detail.typeDetail || detail.documentation) {
+                    // Micro perf optimization to not create new string from trimEnd.
+                    plainTextString += '\n\n';
+                }
+            }
+            if (detail === null || detail === void 0 ? void 0 : detail.typeDetail) {
+                plainTextString += detail.typeDetail + '\n';
+            }
+            if (detail === null || detail === void 0 ? void 0 : detail.documentation) {
+                plainTextString += '\n' + (0, docStringConversion_1.convertDocStringToPlainText)(detail.documentation);
+            }
+            plainTextString = plainTextString.trimEnd();
+            if (plainTextString) {
+                completionItem.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.PlainText,
+                    value: plainTextString,
+                };
+            }
+        }
+        else {
+            (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
+        }
+        if ((_b = detail === null || detail === void 0 ? void 0 : detail.edits) === null || _b === void 0 ? void 0 : _b.format) {
+            completionItem.insertTextFormat = detail.edits.format;
+        }
+        if ((_c = detail === null || detail === void 0 ? void 0 : detail.edits) === null || _c === void 0 ? void 0 : _c.textEdit) {
+            completionItem.textEdit = detail.edits.textEdit;
+        }
+        if ((_d = detail === null || detail === void 0 ? void 0 : detail.edits) === null || _d === void 0 ? void 0 : _d.additionalTextEdits) {
+            completionItem.additionalTextEdits = detail.edits.additionalTextEdits.map((te) => {
+                const textEdit = {
+                    range: {
+                        start: { line: te.range.start.line, character: te.range.start.character },
+                        end: { line: te.range.end.line, character: te.range.end.character },
+                    },
+                    newText: te.replacementText,
+                };
+                return textEdit;
+            });
+            if (this._itemToResolve) {
+                const data = (0, lspUtils_1.fromLSPAny)(this._itemToResolve.data);
+                if (data.autoImportText === completionItemData.autoImportText) {
+                    this._itemToResolve.additionalTextEdits = completionItem.additionalTextEdits;
+                }
+            }
+        }
+        completionMap.set(completionItem);
+    }
+    _getRecentListIndex(name, autoImportText) {
+        return CompletionProvider._mostRecentCompletions.findIndex((item) => item.label === name && item.autoImportText === autoImportText);
+    }
+    _makeSortText(sortCategory, name, autoImportText = '') {
+        const recentListIndex = this._getRecentListIndex(name, autoImportText);
+        // If the label is in the recent list, modify the category
+        // so it appears higher in our list.
+        if (recentListIndex >= 0) {
+            if (sortCategory === SortCategory.AutoImport) {
+                sortCategory = SortCategory.RecentAutoImport;
+            }
+            else if (sortCategory === SortCategory.ImportModuleName) {
+                sortCategory = SortCategory.RecentImportModuleName;
+            }
+            else if (sortCategory === SortCategory.Keyword ||
+                sortCategory === SortCategory.NormalSymbol ||
+                sortCategory === SortCategory.PrivateSymbol ||
+                sortCategory === SortCategory.DunderSymbol) {
+                sortCategory = SortCategory.RecentKeywordOrSymbol;
+            }
+        }
+        // Generate a sort string of the format
+        //    XX.YYYY.name
+        // where XX is the sort category
+        // and YYYY is the index of the item in the MRU list
+        return this._formatInteger(sortCategory, 2) + '.' + this._formatInteger(recentListIndex, 4) + '.' + name;
+    }
+    _formatInteger(val, digits) {
+        const charCodeZero = '0'.charCodeAt(0);
+        let result = '';
+        for (let i = 0; i < digits; i++) {
+            // Prepend the next digit.
+            let digit = Math.floor(val % 10);
+            if (digit < 0) {
+                digit = 9;
+            }
+            result = String.fromCharCode(digit + charCodeZero) + result;
+            val = Math.floor(val / 10);
+        }
+        return result;
+    }
+    _convertDeclarationTypeToItemKind(declaration) {
+        const resolvedDeclaration = this._evaluator.resolveAliasDeclaration(declaration, /* resolveLocalNames */ true);
+        if (!resolvedDeclaration) {
+            return vscode_languageserver_1.CompletionItemKind.Variable;
+        }
+        switch (resolvedDeclaration.type) {
+            case 0 /* Intrinsic */:
+                return resolvedDeclaration.intrinsicType === 'class'
+                    ? vscode_languageserver_1.CompletionItemKind.Class
+                    : vscode_languageserver_1.CompletionItemKind.Variable;
+            case 2 /* Parameter */:
+                return vscode_languageserver_1.CompletionItemKind.Variable;
+            case 1 /* Variable */:
+                return resolvedDeclaration.isConstant || resolvedDeclaration.isFinal
+                    ? vscode_languageserver_1.CompletionItemKind.Constant
+                    : vscode_languageserver_1.CompletionItemKind.Variable;
+            case 3 /* Function */: {
+                if (this._isPossiblePropertyDeclaration(resolvedDeclaration)) {
+                    const functionType = this._evaluator.getTypeOfFunction(resolvedDeclaration.node);
+                    if (functionType && (0, typeUtils_1.isProperty)(functionType.decoratedType)) {
+                        return vscode_languageserver_1.CompletionItemKind.Property;
+                    }
+                }
+                return resolvedDeclaration.isMethod ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Function;
+            }
+            case 4 /* Class */:
+            case 5 /* SpecialBuiltInClass */:
+                return vscode_languageserver_1.CompletionItemKind.Class;
+            case 6 /* Alias */:
+                return vscode_languageserver_1.CompletionItemKind.Module;
+        }
+    }
+    _getImportModuleCompletions(node) {
+        const moduleDescriptor = {
+            leadingDots: node.leadingDots,
+            hasTrailingDot: node.hasTrailingDot || false,
+            nameParts: node.nameParts.map((part) => part.value),
+            importedSymbols: [],
+        };
+        const completions = this._importResolver.getCompletionSuggestions(this._filePath, this._execEnv, moduleDescriptor);
+        const completionMap = new CompletionMap();
+        // If we're in the middle of a "from X import Y" statement, offer
+        // the "import" keyword as a completion.
+        if (!node.hasTrailingDot &&
+            node.parent &&
+            node.parent.nodeType === 22 /* ImportFrom */ &&
+            node.parent.missingImportKeyword) {
+            const keyword = 'import';
+            const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
+            completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
+            completionItem.sortText = this._makeSortText(SortCategory.Keyword, keyword);
+            completionMap.set(completionItem);
+        }
+        completions.forEach((completionName) => {
+            if (completionMap.has(completionName)) {
+                return;
+            }
+            const completionItem = vscode_languageserver_1.CompletionItem.create(completionName);
+            completionItem.kind = vscode_languageserver_1.CompletionItemKind.Module;
+            completionItem.sortText = this._makeSortText(SortCategory.ImportModuleName, completionName);
+            completionMap.set(completionItem);
+        });
+        return { completionMap };
+    }
+    _isPossiblePropertyDeclaration(decl) {
+        // Do cheap check using only nodes that will cover 99.9% cases
+        // before doing more expensive type evaluation.
+        return decl.isMethod && decl.node.decorators.length > 0;
+    }
+}
+exports.CompletionProvider = CompletionProvider;
+CompletionProvider._mostRecentCompletions = [];
+class CompletionMap {
+    constructor() {
+        this._completions = new Map();
+    }
+    get size() {
+        return this._completions.size;
+    }
+    set(value) {
+        const existing = this._completions.get(value.label);
+        if (!existing) {
+            this._completions.set(value.label, value);
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            this._completions.set(value.label, [existing, value]);
+        }
+    }
+    get(key) {
+        return this._completions.get(key);
+    }
+    has(label, predicate, kind, autImportText) {
+        const existing = this._completions.get(label);
+        if (!existing) {
+            return false;
+        }
+        if (predicate) {
+            return predicate(existing, kind, autImportText);
+        }
+        return true;
+    }
+    clear() {
+        this._completions.clear();
+    }
+    delete(key) {
+        return this._completions.delete(key);
+    }
+    toArray() {
+        var _a;
+        const items = [];
+        (_a = this._completions) === null || _a === void 0 ? void 0 : _a.forEach((value) => {
+            if (Array.isArray(value)) {
+                value.forEach((item) => {
+                    items.push(item);
+                });
+            }
+            else {
+                items.push(value);
+            }
+        });
+        return items;
+    }
+    static matchKindAndImportText(completionItemOrItems, kind, autoImportText) {
+        var _a;
+        if (!Array.isArray(completionItemOrItems)) {
+            return (completionItemOrItems.kind === kind &&
+                ((_a = _getCompletionData(completionItemOrItems)) === null || _a === void 0 ? void 0 : _a.autoImportText) === autoImportText);
+        }
+        else {
+            return !!completionItemOrItems.find((c) => { var _a; return c.kind === kind && ((_a = _getCompletionData(c)) === null || _a === void 0 ? void 0 : _a.autoImportText) === autoImportText; });
+        }
+    }
+    static labelOnlyIgnoringAutoImports(completionItemOrItems) {
+        var _a;
+        if (!Array.isArray(completionItemOrItems)) {
+            if (!((_a = _getCompletionData(completionItemOrItems)) === null || _a === void 0 ? void 0 : _a.autoImportText)) {
+                return true;
+            }
+        }
+        else {
+            if (completionItemOrItems.find((c) => { var _a; return !((_a = _getCompletionData(c)) === null || _a === void 0 ? void 0 : _a.autoImportText); })) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.CompletionMap = CompletionMap;
+function _getCompletionData(completionItem) {
+    return (0, lspUtils_1.fromLSPAny)(completionItem.data);
+}
+//# sourceMappingURL=completionProvider.js.map