@zzzen/pyright-internal 1.2.0-dev.20230507 → 1.2.0-dev.20230521

package/dist/languageService/completionProvider.js

@@ -37,7 +37,6 @@ const docStringConversion_1 = require("../analyzer/docStringConversion");
 const parameterUtils_1 = require("../analyzer/parameterUtils");
 const ParseTreeUtils = __importStar(require("../analyzer/parseTreeUtils"));
 const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
-const pythonPathUtils_1 = require("../analyzer/pythonPathUtils");
 const scopeUtils_1 = require("../analyzer/scopeUtils");
 const sourceMapper_1 = require("../analyzer/sourceMapper");
 const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
@@ -52,19 +51,15 @@ 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 pathUtils_1 = require("../common/pathUtils");
 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 workspaceEditUtils_1 = require("../common/workspaceEditUtils");
 const parseNodes_1 = require("../parser/parseNodes");
 const autoImporter_1 = require("./autoImporter");
 const completionProviderUtils_1 = require("./completionProviderUtils");
 const documentSymbolCollector_1 = require("./documentSymbolCollector");
-const importAdder_1 = require("./importAdder");
 const tooltipUtils_1 = require("./tooltipUtils");
 var Keywords;
 (function (Keywords) {
@@ -158,38 +153,455 @@ const similarityLimit = 0.25;
 // We'll remember this many completions in the MRU list.
 const maxRecentCompletions = 128;
 class CompletionProvider {
-    constructor(_program, _workspacePath, _filePath, _position, _importLookup, _options, _autoImportMaps, _cancellationToken) {
-        this._program = _program;
+    constructor(program, _workspacePath, filePath, position, options, cancellationToken) {
+        this.program = program;
         this._workspacePath = _workspacePath;
-        this._filePath = _filePath;
-        this._position = _position;
-        this._importLookup = _importLookup;
-        this._options = _options;
-        this._autoImportMaps = _autoImportMaps;
-        this._cancellationToken = _cancellationToken;
-        // Indicate whether invocation is inside of string literal.
-        this._insideStringLiteral = undefined;
-        this._execEnv = this._configOptions.findExecEnvironment(this._filePath);
-        this._parseResults = this._program.getParseResults(this._filePath);
-        this._sourceMapper = this._program.getSourceMapper(this._filePath, this._cancellationToken, 
-        /* mapCompiled */ true);
-    }
-    getCompletionsForPosition() {
+        this.filePath = filePath;
+        this.position = position;
+        this.options = options;
+        this.cancellationToken = cancellationToken;
+        // Indicates whether invocation position is inside of string literal
+        // token or an f-string expression.
+        this._stringLiteralContainer = undefined;
+        this.execEnv = this.configOptions.findExecEnvironment(this.filePath);
+        this.parseResults = this.program.getParseResults(this.filePath);
+        this.sourceMapper = this.program.getSourceMapper(this.filePath, this.cancellationToken, /* mapCompiled */ true);
+    }
+    getCompletions() {
+        if (!this.program.getSourceFileInfo(this.filePath)) {
+            return null;
+        }
+        const completionMap = this._getCompletions();
+        return vscode_languageserver_1.CompletionList.create(completionMap === null || completionMap === void 0 ? void 0 : completionMap.toArray());
+    }
+    // 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) {
+            return;
+        }
+        if (completionItemData.modulePath) {
+            const documentation = (0, typeDocStringUtils_1.getModuleDocStringFromPaths)([completionItemData.modulePath], this.sourceMapper);
+            if (!documentation) {
+                return;
+            }
+            if (this.options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+                const markdownString = (0, docStringConversion_1.convertDocStringToMarkdown)(documentation);
+                completionItem.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.Markdown,
+                    value: markdownString,
+                };
+            }
+            else if (this.options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+                const plainTextString = (0, docStringConversion_1.convertDocStringToPlainText)(documentation);
+                completionItem.documentation = {
+                    kind: vscode_languageserver_1.MarkupKind.PlainText,
+                    value: plainTextString,
+                };
+            }
+            return;
+        }
+        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.getCompletions();
+        }
+        else if (!completionItem.additionalTextEdits) {
+            const completionMap = new CompletionMap();
+            this.addAutoImportCompletions(completionItemData.symbolLabel, 
+            /* similarityLimit */ 1, 
+            /* lazyEdit */ false, completionMap);
+        }
+    }
+    get evaluator() {
+        return this.program.evaluator;
+    }
+    get importResolver() {
+        return this.program.importResolver;
+    }
+    get configOptions() {
+        return this.program.configOptions;
+    }
+    isSimpleDefault(node) {
+        switch (node.nodeType) {
+            case 40 /* Number */:
+            case 11 /* Constant */:
+            case 35 /* MemberAccess */:
+                return true;
+            case 49 /* String */:
+                return (node.token.flags & 64 /* Format */) === 0;
+            case 48 /* StringList */:
+                return node.strings.every(this.isSimpleDefault);
+            case 55 /* UnaryOperation */:
+                return this.isSimpleDefault(node.expression);
+            case 7 /* BinaryOperation */:
+                return this.isSimpleDefault(node.leftExpression) && this.isSimpleDefault(node.rightExpression);
+            default:
+                return false;
+        }
+    }
+    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) => {
+            var _a;
+            let decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (decl && decl.type === 5 /* Function */) {
+                if (StringUtils.isPatternInSymbol(partialName.value, name)) {
+                    const declaredType = (_a = this.evaluator.getTypeForDeclaration(decl)) === null || _a === void 0 ? void 0 : _a.type;
+                    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 === 5 /* 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;
+    }
+    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 sawKeywordOnlySeparator = false;
+            for (const parameter of parameters) {
+                if (parameter.name) {
+                    results.push([
+                        parameter,
+                        parameter.category === 0 /* Simple */ && !!parameter.name && sawKeywordOnlySeparator,
+                    ]);
+                }
+                // All simple parameters after a `*` or `*args` parameter
+                // are considered keyword only.
+                if (parameter.category === 1 /* VarArgList */) {
+                    sawKeywordOnlySeparator = true;
+                }
+            }
+            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;
+        }
+    }
+    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);
+    }
+    addSymbol(name, symbol, priorWord, completionMap, detail) {
+        var _a, _b, _c, _d;
+        let primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+        if (!primaryDecl) {
+            const declarations = symbol.getDeclarations();
+            if (declarations.length > 0) {
+                primaryDecl = declarations[declarations.length - 1];
+            }
+        }
+        primaryDecl = primaryDecl
+            ? (_a = this.evaluator.resolveAliasDeclaration(primaryDecl, /* resolveLocalNames */ true)) !== null && _a !== void 0 ? _a : primaryDecl
+            : undefined;
+        const autoImportText = detail.autoImportSource
+            ? this._getAutoImportText(name, detail.autoImportSource, detail.autoImportAlias)
+            : undefined;
+        // 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) {
+                // It's not what we are looking for.
+                return;
+            }
+            if (completionItemData.autoImportText) {
+                if (completionItemData.autoImportText === (autoImportText === null || autoImportText === void 0 ? void 0 : autoImportText.importText) &&
+                    ((_b = detail.edits) === null || _b === void 0 ? void 0 : _b.additionalTextEdits)) {
+                    this._itemToResolve.additionalTextEdits = (0, workspaceEditUtils_1.convertToTextEdits)(detail.edits.additionalTextEdits);
+                }
+                return;
+            }
+            // 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) {
+                // Can't resolve. so bail out.
+                return;
+            }
+            const typeDetail = (0, completionProviderUtils_1.getTypeDetail)(this.evaluator, primaryDecl, type, name, detail, this.configOptions.functionSignatureDisplay);
+            const documentation = (0, tooltipUtils_1.getDocumentationPartsForTypeAndDecl)(this.sourceMapper, type, primaryDecl, this.evaluator, {
+                name,
+                symbol,
+                boundObjectOrClass: detail.boundObjectOrClass,
+            });
+            if (this.options.format === vscode_languageserver_1.MarkupKind.Markdown || this.options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+                this._itemToResolve.documentation = (0, completionProviderUtils_1.getCompletionItemDocumentation)(typeDetail, documentation, this.options.format);
+            }
+            else {
+                (0, debug_1.fail)(`Unsupported markup type: ${this.options.format}`);
+            }
+            // Bail out. We don't need to add items to completion.
+            return;
+        }
+        if (primaryDecl) {
+            let 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) &&
+                ((_c = primaryDecl.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
+            }
+            this._addNameToCompletions((_d = detail.autoImportAlias) !== null && _d !== void 0 ? _d : name, itemKind, priorWord, completionMap, {
+                autoImportText,
+                extraCommitChars: detail.extraCommitChars,
+                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 = this._convertTypeToItemKind(synthesizedType);
+                this._addNameToCompletions(name, itemKind, priorWord, completionMap, {
+                    extraCommitChars: detail.extraCommitChars,
+                    funcParensDisabled: detail.funcParensDisabled,
+                    edits: detail.edits,
+                });
+            }
+        }
+    }
+    getMemberAccessCompletions(leftExprNode, priorWord) {
+        const symbolTable = new Map();
+        const completionMap = new CompletionMap();
+        let leftType = this.evaluator.getType(leftExprNode);
+        if (!leftType) {
+            return completionMap;
+        }
+        leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType);
+        // If this is an unknown type with a "possible type" associated with
+        // it, use the possible type.
+        if ((0, types_1.isUnknown)(leftType) && leftType.possibleType) {
+            leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType.possibleType);
+        }
+        (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
+            subtype = this.evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            if ((0, types_1.isClass)(subtype)) {
+                (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, leftExprNode, 
+            /* isInImport */ false, (0, types_1.isClass)(subtype) ? subtype : undefined, completionMap);
+        });
+        return completionMap;
+    }
+    addAutoImportCompletions(priorWord, similarityLimit, lazyEdit, completionMap) {
+        if (!this.configOptions.autoImportCompletions) {
+            // 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 currentFile = this.program.getSourceFileInfo(this.filePath);
+        const moduleSymbolMap = (0, autoImporter_1.buildModuleSymbolsMap)(this.program.getSourceFileInfoList().filter((s) => s !== currentFile));
+        const autoImporter = new autoImporter_1.AutoImporter(this.execEnv, this.importResolver, this.parseResults, this.position, completionMap, moduleSymbolMap, {
+            lazyEdit,
+        });
+        const results = [];
+        (0, collectionUtils_1.appendArray)(results, autoImporter.getAutoImportCandidates(priorWord, similarityLimit, 
+        /* abbrFromUsers */ undefined, this.cancellationToken));
+        this.addImportResults(results, priorWord, completionMap);
+    }
+    addImportResults(results, priorWord, completionMap) {
         var _a, _b;
-        const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, this._parseResults.tokenizerOutput.lines);
+        for (const result of results) {
+            if (result.symbol) {
+                this.addSymbol(result.name, result.symbol, priorWord, completionMap, {
+                    extraCommitChars: true,
+                    autoImportSource: result.source,
+                    autoImportAlias: result.alias,
+                    edits: {
+                        textEdit: this.createReplaceEdits(priorWord, /* node */ undefined, result.insertionText),
+                        additionalTextEdits: result.edits,
+                    },
+                });
+            }
+            else {
+                this._addNameToCompletions((_a = result.alias) !== null && _a !== void 0 ? _a : result.name, (_b = result.kind) !== null && _b !== void 0 ? _b : vscode_languageserver_1.CompletionItemKind.Module, priorWord, completionMap, {
+                    extraCommitChars: true,
+                    autoImportText: this._getAutoImportText(result.name, result.source, result.alias),
+                    edits: {
+                        textEdit: this.createReplaceEdits(priorWord, /* node */ undefined, result.insertionText),
+                        additionalTextEdits: result.edits,
+                    },
+                });
+            }
+        }
+    }
+    checkDecorator(node, value) {
+        return node.expression.nodeType === 38 /* Name */ && node.expression.value === value;
+    }
+    addExtraCommitChar(item) {
+        // extra commit char is not supported.
+    }
+    get _fileContents() {
+        var _a, _b;
+        return (_b = (_a = this.parseResults) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
+    }
+    _getCompletions() {
+        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);
+        let node = ParseTreeUtils.findNodeByOffset(this.parseResults.parseTree, offset);
+        // See if we're inside a string literal or an f-string statement.
+        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)
+            this._stringLiteralContainer = textRange_1.TextRange.contains(stringToken, offset)
                 ? stringToken
                 : stringToken.flags & 65536 /* Unterminated */
                     ? stringToken
                     : undefined;
         }
-        let node = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, offset);
+        else if (node) {
+            const fStringContainer = ParseTreeUtils.getParentNodeOfType(node, 27 /* FormatString */);
+            if (fStringContainer) {
+                this._stringLiteralContainer = fStringContainer.token;
+            }
+        }
         // 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.
@@ -208,7 +620,7 @@ class CompletionProvider {
                 if (curChar === ',') {
                     sawComma = true;
                 }
-                const curNode = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, curOffset);
+                const curNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parseTree, curOffset);
                 if (curNode && curNode !== initialNode) {
                     if (ParseTreeUtils.getNodeDepth(curNode) > initialDepth) {
                         node = curNode;
@@ -226,10 +638,10 @@ class CompletionProvider {
             return undefined;
         }
         // Get the text on that line prior to the insertion point.
-        const lineTextRange = this._parseResults.tokenizerOutput.lines.getItemAt(this._position.line);
+        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 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.
@@ -249,7 +661,7 @@ class CompletionProvider {
         // that of its ancestors.
         let curNode = errorNode || node;
         while (true) {
-            (0, cancellationUtils_1.throwIfCancellationRequested)(this._cancellationToken);
+            (0, cancellationUtils_1.throwIfCancellationRequested)(this.cancellationToken);
             if (curNode.nodeType === 49 /* String */) {
                 return this._getLiteralCompletions(curNode, offset, priorWord, priorText, postText);
             }
@@ -263,13 +675,13 @@ class CompletionProvider {
                 return this._getExpressionErrorCompletions(curNode, offset, priorWord, priorText, postText);
             }
             if (curNode.nodeType === 35 /* MemberAccess */) {
-                return this._getMemberAccessCompletions(curNode.leftExpression, priorWord);
+                return this.getMemberAccessCompletions(curNode.leftExpression, priorWord);
             }
             if (curNode.nodeType === 15 /* Dictionary */) {
                 const completionMap = new CompletionMap();
                 if (this._tryAddTypedDictKeysFromDictionary(curNode, 
                 /* stringNode */ undefined, priorWord, priorText, postText, completionMap)) {
-                    return { completionMap };
+                    return completionMap;
                 }
             }
             const dictionaryEntry = ParseTreeUtils.getFirstAncestorOrSelfOfKind(curNode, 17 /* DictionaryKeyEntry */);
@@ -280,7 +692,7 @@ class CompletionProvider {
                         const completionMap = new CompletionMap();
                         if (this._tryAddTypedDictKeysFromDictionary(dictionaryNode, 
                         /* stringNode */ undefined, priorWord, priorText, postText, completionMap)) {
-                            return { completionMap };
+                            return completionMap;
                         }
                     }
                 }
@@ -294,7 +706,7 @@ class CompletionProvider {
                     return result;
                 }
             }
-            if (curNode.nodeType === 31 /* List */ && this._options.triggerCharacter === '[') {
+            if (curNode.nodeType === 31 /* List */ && this.options.triggerCharacter === '[') {
                 // If this is an empty list, don't start putting completions up yet.
                 return undefined;
             }
@@ -309,7 +721,7 @@ class CompletionProvider {
                     curNode.parent.nodeType === 25 /* Except */ &&
                     !curNode.parent.name &&
                     curNode.parent.typeExpression &&
-                    textRange_2.TextRange.getEnd(curNode.parent.typeExpression) < offset &&
+                    textRange_1.TextRange.getEnd(curNode.parent.typeExpression) < offset &&
                     offset <= curNode.parent.exceptSuite.start) {
                     // except Exception as [<empty>]
                     return undefined;
@@ -341,84 +753,6 @@ class CompletionProvider {
         }
         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) {
-            return;
-        }
-        if (completionItemData.modulePath) {
-            const documentation = (0, typeDocStringUtils_1.getModuleDocStringFromPaths)([completionItemData.modulePath], this._sourceMapper);
-            if (!documentation) {
-                return;
-            }
-            if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
-                const markdownString = (0, docStringConversion_1.convertDocStringToMarkdown)(documentation);
-                completionItem.documentation = {
-                    kind: vscode_languageserver_1.MarkupKind.Markdown,
-                    value: markdownString,
-                };
-            }
-            else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
-                const plainTextString = (0, docStringConversion_1.convertDocStringToPlainText)(documentation);
-                completionItem.documentation = {
-                    kind: vscode_languageserver_1.MarkupKind.PlainText,
-                    value: plainTextString,
-                };
-            }
-            return;
-        }
-        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);
-        }
-    }
-    get _importResolver() {
-        return this._program.importResolver;
-    }
-    get _configOptions() {
-        return this._program.configOptions;
-    }
-    get _evaluator() {
-        return this._program.evaluator;
-    }
-    get _fileContents() {
-        var _a, _b;
-        return (_b = (_a = this._parseResults) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
-    }
     // This method will return false if it wants1
     // caller to walk up the tree. it will return
     // CompletionResults or undefined if it wants caller
@@ -437,7 +771,7 @@ class CompletionProvider {
             if (curNode.parent.parent &&
                 curNode.parent.parent.nodeType === 21 /* ImportAs */ &&
                 !curNode.parent.parent.alias &&
-                textRange_2.TextRange.getEnd(curNode.parent.parent) < offset) {
+                textRange_1.TextRange.getEnd(curNode.parent.parent) < offset) {
                 return undefined;
             }
             // Are we within a "from X import Y as Z" statement and
@@ -452,7 +786,7 @@ class CompletionProvider {
             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) {
+                if (!curNode.parent.alias && textRange_1.TextRange.getEnd(curNode.parent) < offset) {
                     return undefined;
                 }
                 if (curNode.parent.name === curNode) {
@@ -463,7 +797,7 @@ class CompletionProvider {
             return false;
         }
         if (curNode.parent.nodeType === 35 /* MemberAccess */ && curNode === curNode.parent.memberName) {
-            return this._getMemberAccessCompletions(curNode.parent.leftExpression, priorWord);
+            return this.getMemberAccessCompletions(curNode.parent.leftExpression, priorWord);
         }
         if (curNode.parent.nodeType === 25 /* Except */ && curNode === curNode.parent.name) {
             return undefined;
@@ -481,11 +815,11 @@ class CompletionProvider {
             return undefined;
         }
         if (curNode.parent.nodeType === 26 /* For */ &&
-            textRange_2.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
+            textRange_1.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
             return undefined;
         }
         if (curNode.parent.nodeType === 33 /* ListComprehensionFor */ &&
-            textRange_2.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
+            textRange_1.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
             return undefined;
         }
         // For assignments that implicitly declare variables, remove itself (var decl) from completion.
@@ -497,15 +831,15 @@ class CompletionProvider {
             if (leftNode !== curNode || priorWord.length === 0) {
                 return false;
             }
-            const decls = this._evaluator.getDeclarationsForNameNode(curNode);
+            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) {
-                completionList.completionMap.delete(curNode.value);
+            const completionMap = this._getExpressionCompletions(curNode, priorWord, priorText, postText);
+            if (completionMap) {
+                completionMap.delete(curNode.value);
             }
-            return completionList;
+            return completionMap;
         }
         // Defining class variables.
         // ex) class A:
@@ -522,12 +856,12 @@ class CompletionProvider {
     }
     _isWithinComment(offset) {
         var _a, _b;
-        const token = getTokenAfter(offset, this._parseResults.tokenizerOutput.tokens);
+        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;
+        return (_b = (_a = token.comments) === null || _a === void 0 ? void 0 : _a.some((c) => textRange_1.TextRange.overlaps(c, offset))) !== null && _b !== void 0 ? _b : false;
         function getTokenAfter(offset, tokens) {
             const tokenIndex = tokens.getItemAtPosition(offset);
             if (tokenIndex < 0) {
@@ -572,8 +906,8 @@ class CompletionProvider {
             case 7 /* MissingMemberAccessName */:
             case 2 /* MissingExpression */: {
                 // Don't show completion after random dots.
-                const tokenizerOutput = this._parseResults.tokenizerOutput;
-                const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, tokenizerOutput.lines);
+                const tokenizerOutput = this.parseResults.tokenizerOutput;
+                const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, tokenizerOutput.lines);
                 const index = ParseTreeUtils.getTokenIndexAtLeft(tokenizerOutput.tokens, offset);
                 const token = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index);
                 const prevToken = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index - 1);
@@ -591,14 +925,14 @@ class CompletionProvider {
                     // since parser won't see "is" as partially written member name instead it will see it as
                     // expression statement with missing expression after "is" keyword.
                     // In such case, use "MyType." to get completion.
-                    if ((token === null || token === void 0 ? void 0 : token.type) !== 8 /* Keyword */ || textRange_2.TextRange.getEnd(token) !== offset) {
+                    if ((token === null || token === void 0 ? void 0 : token.type) !== 8 /* Keyword */ || textRange_1.TextRange.getEnd(token) !== offset) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
                     if ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) !== 20 /* Dot */) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
-                    const previousOffset = textRange_2.TextRange.getEnd(prevToken);
-                    const previousNode = ParseTreeUtils.findNodeByOffset(this._parseResults.parseTree, previousOffset);
+                    const previousOffset = textRange_1.TextRange.getEnd(prevToken);
+                    const previousNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parseTree, previousOffset);
                     if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.nodeType) !== 0 /* Error */ ||
                         previousNode.category !== 7 /* MissingMemberAccessName */) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
@@ -635,7 +969,7 @@ class CompletionProvider {
                     }
                     // 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);
+                    return this.getMethodOverrideCompletions(priorWord, node.child, node.decorators);
                 }
                 break;
             }
@@ -646,13 +980,10 @@ class CompletionProvider {
         if (!node.child || !(0, parseNodes_1.isExpressionNode)(node.child)) {
             return undefined;
         }
-        return this._getMemberAccessCompletions(node.child, priorWord);
+        return this.getMemberAccessCompletions(node.child, priorWord);
     }
     _isOverload(node) {
-        return this._checkDecorator(node, 'overload');
-    }
-    _checkDecorator(node, value) {
-        return node.expression.nodeType === 38 /* Name */ && node.expression.value === value;
+        return this.checkDecorator(node, 'overload');
     }
     _createSingleKeywordCompletion(keyword) {
         const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
@@ -660,7 +991,7 @@ class CompletionProvider {
         completionItem.sortText = this._makeSortText(SortCategory.LikelyKeyword, keyword);
         const completionMap = new CompletionMap();
         completionMap.set(completionItem);
-        return { completionMap };
+        return completionMap;
     }
     _addClassVariableTypeAnnotationCompletions(priorWord, parseNode, completionMap) {
         var _a, _b, _c, _d;
@@ -679,7 +1010,7 @@ class CompletionProvider {
         if (!enclosingClass) {
             return;
         }
-        const classResults = this._evaluator.getTypeOfClass(enclosingClass);
+        const classResults = this.evaluator.getTypeOfClass(enclosingClass);
         if (!classResults) {
             return undefined;
         }
@@ -687,8 +1018,8 @@ class CompletionProvider {
         const classMember = (0, typeUtils_1.lookUpClassMember)(classResults.classType, classVariableName, 8 /* SkipInstanceVariables */ | 1 /* SkipOriginalClass */);
         // First, see whether we can use semantic info to get variable type.
         if (classMember) {
-            const memberType = this._evaluator.getTypeOfMember(classMember);
-            const text = this._evaluator.printType(memberType, {
+            const memberType = this.evaluator.getTypeOfMember(classMember);
+            const text = this.evaluator.printType(memberType, {
                 enforcePythonSyntax: true,
                 expandTypeAlias: false,
             });
@@ -724,7 +1055,7 @@ class CompletionProvider {
         if (declWithTypeAnnotations.length === 0) {
             return;
         }
-        const printFlags = (0, sourceMapper_1.isStubFile)(this._filePath)
+        const printFlags = (0, sourceMapper_1.isStubFile)(this.filePath)
             ? 1 /* ForwardDeclarations */ |
                 2 /* DoNotLimitStringLength */
             : 2 /* DoNotLimitStringLength */;
@@ -738,7 +1069,7 @@ class CompletionProvider {
         if (!enclosingClass) {
             return undefined;
         }
-        const classResults = this._evaluator.getTypeOfClass(enclosingClass);
+        const classResults = this.evaluator.getTypeOfClass(enclosingClass);
         if (!classResults) {
             return undefined;
         }
@@ -764,13 +1095,13 @@ class CompletionProvider {
                 decls.some((d) => d.node && ParseTreeUtils.getEnclosingClass(d.node, false) === enclosingClass)) {
                 return;
             }
-            this._addSymbol(name, symbol, partialName.value, completionMap, {});
+            this.addSymbol(name, symbol, partialName.value, completionMap, {});
         });
-        return completionMap.size > 0 ? { completionMap } : undefined;
+        return completionMap.size > 0 ? completionMap : undefined;
     }
     _getMethodOverloadsCompletions(priorWord, partialName) {
         var _a;
-        const symbolTable = getSymbolTable(this._evaluator, partialName);
+        const symbolTable = getSymbolTable(this.evaluator, partialName);
         if (!symbolTable) {
             return undefined;
         }
@@ -792,14 +1123,14 @@ class CompletionProvider {
                 return;
             }
             if (StringUtils.isPatternInSymbol(partialName.value, name)) {
-                const textEdit = this._createReplaceEdits(priorWord, partialName, decl.node.name.value);
-                this._addSymbol(name, symbol, partialName.value, completionMap, {
+                const textEdit = this.createReplaceEdits(priorWord, partialName, decl.node.name.value);
+                this.addSymbol(name, symbol, partialName.value, completionMap, {
                     funcParensDisabled,
                     edits: { textEdit },
                 });
             }
         });
-        return { completionMap };
+        return completionMap;
         function getSymbolTable(evaluator, partialName) {
             const enclosingClass = ParseTreeUtils.getEnclosingClass(partialName, false);
             if (enclosingClass) {
@@ -808,155 +1139,39 @@ class CompletionProvider {
                     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 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 fallbackPath = (0, pythonPathUtils_1.getTypeShedFallbackPath)(this._importResolver.fileSystem);
-        const typingFilePath = fallbackPath ? (0, pathUtils_1.combinePaths)(fallbackPath, 'stdlib/typing.pyi') : undefined;
-        const appendMember = (map, member, name) => {
-            if (!(0, types_1.isInstantiableClass)(member.classType) ||
-                member.classType.details === classResults.classType.details ||
-                !StringUtils.isPatternInSymbol(partialName.value, name)) {
-                // Quick bail out if member is something we don't want to override.
-                return;
-            }
-            const symbol = member.symbol;
-            const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-            if (!decl || decl.type !== 5 /* Function */) {
-                return;
-            }
-            const declaredType = this._evaluator.getTypeOfMember(member);
-            if (!declaredType) {
-                return;
-            }
-            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;
-            }
-            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;
-            }
-            let funcType = undefined;
-            if ((0, types_1.isFunction)(declaredType)) {
-                funcType = declaredType;
-            }
-            else if (isProperty) {
-                const getter = (0, typeUtils_1.lookUpClassMember)(declaredType, 'fget');
-                if (!getter) {
-                    return;
-                }
-                const member = this._evaluator.getTypeOfMember(getter);
-                if (!(0, types_1.isFunction)(member)) {
-                    return;
+                for (const mroClass of classResults.classType.details.mro) {
+                    if ((0, types_1.isInstantiableClass)(mroClass)) {
+                        (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
+                    }
                 }
-                funcType = member;
-            }
-            if (!funcType || !funcType.details.declaration) {
-                return;
+                return symbolTable;
             }
-            const importAdder = new importAdder_1.ImportAdder(this._configOptions, this._importResolver, this._evaluator);
-            const result = this._printMethodSignature(importAdder, classResults.classType, funcType, typingFilePath);
-            let text;
-            if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
-                text = `${result.methodSignature}: ...`;
+            // 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;
             }
-            else {
-                const methodBody = this._printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl);
-                text = `${result.methodSignature}:\n${methodBody}`;
-            }
-            const textEdit = this._createReplaceEdits(priorWord, partialName, text);
-            // This will add new import statements, but for now, it won't add new
-            // `TypeVar` statement such as TypeVar, TypeVarTuple, ParamSpec even if
-            // the overridden method uses them.
-            const additionalTextEdits = importAdder.applyImports(result.importData, this._filePath, this._parseResults, this._parseResults.parseTree.length, "absolute" /* Absolute */, this._cancellationToken);
-            this._addSymbol(name, symbol, partialName.value, map, {
-                // method signature already contains ()
-                funcParensDisabled: true,
-                edits: {
-                    format: this._options.snippet ? vscode_languageserver_1.InsertTextFormat.Snippet : undefined,
-                    textEdit,
-                    additionalTextEdits,
-                },
-            });
-        };
-        const completionMap = new CompletionMap();
-        const classMemberMap = (0, typeUtils_1.getClassFieldsRecursive)(classResults.classType);
-        classMemberMap.forEach((member, name) => appendMember(completionMap, member, name));
-        if (classResults.classType.details.effectiveMetaclass &&
-            !(0, types_1.isUnknown)(classResults.classType.details.effectiveMetaclass)) {
-            const metaClassMemberMap = (0, typeUtils_1.getClassFieldsRecursive)(classResults.classType.details.effectiveMetaclass);
-            metaClassMemberMap.forEach((member, name) => appendMember(completionMap, member, name));
+            return undefined;
         }
-        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(importAdder, classType, funcType, typingFilePath) {
-        const declaration = funcType.details.declaration;
+    _printMethodSignature(classType, decl) {
+        const node = decl.node;
         let ellipsisForDefault;
-        if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
+        if ((0, sourceMapper_1.isStubFile)(this.filePath)) {
             // In stubs, always use "...".
             ellipsisForDefault = true;
         }
-        else if (classType.details.moduleName === declaration.moduleName) {
+        else if (classType.details.moduleName === decl.moduleName) {
             // In the same file, always print the full default.
             ellipsisForDefault = false;
         }
-        const printOptionsUsingSyntax = (0, sourceMapper_1.isStubFile)(this._filePath)
+        const printFlags = (0, sourceMapper_1.isStubFile)(this.filePath)
             ? 1 /* ForwardDeclarations */ |
                 2 /* DoNotLimitStringLength */
             : 2 /* DoNotLimitStringLength */;
-        const printOptionsUsingType = {
-            enforcePythonSyntax: true,
-            expandTypeAlias: false,
-            omitTypeArgumentsIfUnknown: true,
-            printUnknownWithAny: true,
-        };
-        const getTypeToPrint = (mainType, fallbackType) => {
-            return mainType && (!(0, types_1.isUnknown)(mainType) || (fallbackType === null || fallbackType === void 0 ? void 0 : fallbackType.category) === 10 /* TypeVar */)
-                ? mainType
-                : fallbackType;
-        };
-        const importData = createImportData(importAdder, funcType, declaration, typingFilePath, (t) => this._sourceMapper.findClassDeclarationsByType(this._filePath, t), this._cancellationToken);
-        const paramList = funcType.details.parameters.map((param, index) => {
+        const paramList = node.parameters
+            .map((param, index) => {
             let paramString = '';
             if (param.category === 1 /* VarArgList */) {
                 paramString += '*';
@@ -965,325 +1180,35 @@ class CompletionProvider {
                 paramString += '**';
             }
             if (param.name) {
-                paramString += param.name;
-            }
-            if (param.typeAnnotation) {
-                const originalType = funcType.details.parameters[index].type;
-                const typeToPrint = getTypeToPrint(types_1.FunctionType.getEffectiveParameterType(funcType, index), originalType);
-                // If we have actual type, then use type to generate string representation of the type, otherwise, use syntax (text).
-                const strType = isTypeUsableForPrint(typeToPrint, originalType)
-                    ? this._evaluator.printType(typeToPrint, printOptionsUsingType)
-                    : ParseTreeUtils.printExpression(param.typeAnnotation, printOptionsUsingSyntax);
-                paramString += ': ' + strType;
-            }
-            if (param.defaultValueExpression) {
-                paramString += param.typeAnnotation ? ' = ' : '=';
-                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !isSimpleDefault(param.defaultValueExpression);
-                paramString += useEllipsis
-                    ? '...'
-                    : ParseTreeUtils.printExpression(param.defaultValueExpression, printOptionsUsingSyntax);
-            }
-            if (!paramString &&
-                !param.name &&
-                param.category === 0 /* Simple */ &&
-                index < funcType.details.parameters.length - 1) {
-                return '/';
-            }
-            return paramString;
-        });
-        // Remove empty parameters at the end.
-        for (let i = paramList.length - 1; i >= 0; i--) {
-            if (paramList[i] !== '') {
-                break;
-            }
-            paramList.pop();
-        }
-        let methodSignature = funcType.details.name + '(' + paramList.join(', ') + ')';
-        const strReturnType = getReturnTypeStr(this._evaluator, funcType, printOptionsUsingSyntax);
-        if (strReturnType) {
-            methodSignature += ' -> ' + strReturnType;
-        }
-        return { methodSignature, importData };
-        function createImportData(importAdder, funcType, declaration, typingFilePath, declarationGetter, token) {
-            var _a, _b;
-            // Handle regular case. In this case, we can get import info from
-            // import used in the file where the function is declared.
-            const ranges = [];
-            (0, collectionUtils_1.addIfNotNull)(ranges, textRange_2.TextRange.combine(declaration.node.parameters));
-            (0, collectionUtils_1.addIfNotNull)(ranges, declaration.node.returnTypeAnnotation);
-            (0, collectionUtils_1.addIfNotNull)(ranges, declaration.node.functionAnnotationComment);
-            const moduleNode = ParseTreeUtils.getModuleNode(declaration.node);
-            const importData = importAdder.collectImportsForSymbolsUsed(moduleNode, ranges, token);
-            // Handle special case where function has type arguments. In this case,
-            // we can't use the file the function is declared in because it doesn't
-            // have those type arguments. It just has the type vars.
-            // We could walk the mro to discover imports for the type arguments, but
-            // for now, instead, this creates import statement out of type arguments itself.
-            const effectiveTypes = [];
-            funcType.details.parameters.forEach((param, index) => {
-                if (!param.typeAnnotation) {
-                    return;
-                }
-                const originalType = funcType.details.parameters[index].type;
-                if (!(0, types_1.isTypeVar)(originalType)) {
-                    return;
-                }
-                const effectiveType = types_1.FunctionType.getEffectiveParameterType(funcType, index);
-                effectiveTypes.push([effectiveType, param.typeAnnotation]);
-            });
-            const node = declaration.node;
-            const originalType = funcType.details.declaredReturnType;
-            if (originalType &&
-                (0, types_1.isTypeVar)(originalType) &&
-                (node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation))) {
-                effectiveTypes.push([
-                    types_1.FunctionType.getSpecializedReturnType(funcType),
-                    (_b = node.returnTypeAnnotation) !== null && _b !== void 0 ? _b : node.functionAnnotationComment.returnTypeAnnotation,
-                ]);
-            }
-            const visited = new Set();
-            const addImport = (t, n) => {
-                var _a, _b;
-                if (visited.has(t)) {
-                    return;
-                }
-                visited.add(t);
-                // We need to special case `Any` since we can't get decl from `Any`.
-                if ((0, types_1.isAny)(t)) {
-                    if (!typingFilePath) {
-                        return;
-                    }
-                    importAdder.addImportInfo({ filePath: typingFilePath, nameInfo: { name: 'Any' } }, importData);
-                }
-                if (!(0, types_1.isClass)(t)) {
-                    return;
-                }
-                // We need to special case `List`, `Dict` and `Tuple` since user might have
-                // used typing.List or typing.Dict in the code, but we internally already
-                // converted them to built-in `list` and `dict`.
-                // We could avoid doing this if class type holds onto decl it was created from
-                // if it is not synthesized like func type.
-                if (typingFilePath && types_1.ClassType.isBuiltIn(t)) {
-                    const name = (_a = t.aliasName) !== null && _a !== void 0 ? _a : t.details.name;
-                    if (t.details.moduleName === 'typing' && name) {
-                        importAdder.addImportInfo({
-                            filePath: typingFilePath,
-                            nameInfo: { name },
-                        }, importData);
-                    }
-                    else if (t.details.moduleName === 'builtins' && t.aliasName) {
-                        importAdder.addImportInfo({
-                            filePath: typingFilePath,
-                            nameInfo: { name },
-                        }, importData);
-                    }
-                }
-                else {
-                    const decls = declarationGetter(t);
-                    if (decls.length === 0) {
-                        return;
-                    }
-                    importAdder.addDeclaration(decls[0], n, importData);
-                }
-                if (t.isTypeArgumentExplicit) {
-                    (_b = t.typeArguments) === null || _b === void 0 ? void 0 : _b.forEach((ta) => {
-                        addImport(ta, n);
-                        (0, typeUtils_1.doForEachSubtype)(ta, (subtype) => {
-                            addImport(subtype, n);
-                        });
-                    });
-                }
-            };
-            effectiveTypes.forEach(([t, n]) => {
-                addImport(t, n);
-                (0, typeUtils_1.doForEachSubtype)(t, (subtype) => {
-                    addImport(subtype, n);
-                });
-            });
-            return importData;
-        }
-        function getReturnTypeStr(evaluator, funcType, printFlags) {
-            var _a;
-            const originalType = funcType.details.declaredReturnType;
-            const typeToPrint = getTypeToPrint(types_1.FunctionType.getSpecializedReturnType(funcType), originalType);
-            const node = funcType.details.declaration.node;
-            if (!node.returnTypeAnnotation && !((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation)) {
-                return undefined;
-            }
-            if (typeToPrint && isTypeUsableForPrint(typeToPrint, originalType)) {
-                return evaluator.printType(typeToPrint, printOptionsUsingType);
-            }
-            if (node.returnTypeAnnotation) {
-                return ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
-            }
-            if (node.functionAnnotationComment) {
-                return ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
-            }
-            return undefined;
-        }
-        function isTypeUsableForPrint(effectiveType, originalType) {
-            if (!effectiveType) {
-                return false;
-            }
-            // If original type was `TypeVar`, we want to use `Unknown` as `Any`
-            return !(0, types_1.isUnknown)(effectiveType) || (originalType === null || originalType === void 0 ? void 0 : originalType.category) === 10 /* TypeVar */;
-        }
-        function isSimpleDefault(node) {
-            switch (node.nodeType) {
-                case 40 /* Number */:
-                case 11 /* Constant */:
-                case 35 /* MemberAccess */:
-                    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 sawKeywordOnlySeparator = false;
-            for (const parameter of parameters) {
-                if (parameter.name) {
-                    results.push([
-                        parameter,
-                        parameter.category === 0 /* Simple */ && !!parameter.name && sawKeywordOnlySeparator,
-                    ]);
-                }
-                // All simple parameters after a `*` or `*args` parameter
-                // are considered keyword only.
-                if (parameter.category === 1 /* VarArgList */) {
-                    sawKeywordOnlySeparator = true;
-                }
-            }
-            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}`;
+                paramString += param.name.value;
             }
-            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);
-            // If this is an unknown type with a "possible type" associated with
-            // it, use the possible type.
-            if ((0, types_1.isUnknown)(leftType) && leftType.possibleType) {
-                leftType = this._evaluator.makeTopLevelTypeVarsConcrete(leftType.possibleType);
-            }
-            (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
-                subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-                if ((0, types_1.isClass)(subtype)) {
-                    (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, leftExprNode, 
-                /* isInImport */ false, (0, types_1.isClass)(subtype) ? subtype : undefined, completionMap);
-            });
-        }
-        // Save member access info for every request
-        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 : '' : '';
-                }
+            // 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);
             }
-            else {
-                break;
+            if (param.defaultValue) {
+                paramString += paramTypeAnnotation ? ' = ' : '=';
+                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !this.isSimpleDefault(param.defaultValue);
+                paramString += useEllipsis ? '...' : ParseTreeUtils.printExpression(param.defaultValue, printFlags);
             }
-            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;
-                }
+            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);
         }
-        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;
+        else if (node.functionAnnotationComment) {
+            methodSignature +=
+                ' -> ' +
+                    ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
         }
-        return memberAccessInfo;
+        return methodSignature;
     }
     _getStatementCompletions(parseNode, priorWord, priorText, postText) {
         // For now, use the same logic for expressions and statements.
@@ -1304,10 +1229,9 @@ class CompletionProvider {
             return undefined;
         }
         const completionMap = new CompletionMap();
-        const completionResults = { completionMap };
         // Return empty completionList for Ellipsis
         if (priorText.slice(-2) === '..') {
-            return completionResults;
+            return completionMap;
         }
         // Defining type annotation for class variables.
         // ex) class A:
@@ -1319,7 +1243,7 @@ class CompletionProvider {
         // Add symbols that are in scope.
         this._addSymbols(parseNode, priorWord, completionMap);
         // Add keywords.
-        this._findMatchingKeywords(Keywords.forVersion(this._execEnv.pythonVersion), priorWord).map((keyword) => {
+        this._findMatchingKeywords(Keywords.forVersion(this.execEnv.pythonVersion), priorWord).map((keyword) => {
             if (completionMap.has(keyword)) {
                 return;
             }
@@ -1331,11 +1255,11 @@ class CompletionProvider {
         // 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);
+            this.addAutoImportCompletions(priorWord, similarityLimit, this.options.lazyEdit, completionMap);
         }
         // Add literal values if appropriate.
         this._tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap);
-        return completionResults;
+        return completionMap;
     }
     _isIndexArgument(node) {
         const currentNode = node.parent;
@@ -1349,16 +1273,16 @@ class CompletionProvider {
     }
     _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);
+        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);
+        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) {
+            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);
                 }
@@ -1449,7 +1373,7 @@ class CompletionProvider {
         if (member === null || member === void 0 ? void 0 : member.symbol.hasDeclarations()) {
             const declaration = member.symbol.getDeclarations()[0];
             if ((0, declaration_1.isFunctionDeclaration)(declaration) && declaration.isMethod) {
-                const getItemType = (_b = this._evaluator.getTypeForDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.type;
+                const getItemType = (_b = this.evaluator.getTypeForDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.type;
                 if (getItemType && (0, types_1.isFunction)(getItemType) && getItemType.details.parameters.length === 2) {
                     return getItemType.details.parameters[1].type;
                 }
@@ -1459,7 +1383,7 @@ class CompletionProvider {
     }
     _getIndexerKeys(indexNode, invocationNode) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const baseType = this._evaluator.getType(indexNode.baseExpression);
+        const baseType = this.evaluator.getType(indexNode.baseExpression);
         if (!baseType || !(0, types_1.isClassInstance)(baseType)) {
             return [];
         }
@@ -1475,7 +1399,7 @@ class CompletionProvider {
                     !types_1.ClassType.isEnumClass(v)) {
                     return;
                 }
-                keys.push((0, typePrinter_1.printLiteralValue)(v, this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter));
+                keys.push((0, typePrinter_1.printLiteralValue)(v, this.parseResults.tokenizerOutput.predominantSingleQuoteCharacter));
             });
             if (keys.length > 0) {
                 return keys;
@@ -1486,13 +1410,13 @@ class CompletionProvider {
             return [];
         }
         // Must be local variable/parameter
-        const declarations = (_a = this._evaluator.getDeclarationsForNameNode(indexNode.baseExpression)) !== null && _a !== void 0 ? _a : [];
+        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) {
+        if (declaration.path !== this.filePath) {
             return [];
         }
         let startingNode = indexNode.baseExpression;
@@ -1504,7 +1428,7 @@ class CompletionProvider {
                 startingNode = scopeRoot;
             }
         }
-        const results = documentSymbolCollector_1.DocumentSymbolCollector.collectFromNode(this._program, indexNode.baseExpression, this._cancellationToken, startingNode);
+        const results = documentSymbolCollector_1.DocumentSymbolCollector.collectFromNode(this.program, indexNode.baseExpression, 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;
@@ -1513,7 +1437,7 @@ class CompletionProvider {
                 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
+                        const key = this.parseResults.text
                             .substr(entry.keyExpression.start, entry.keyExpression.length)
                             .trim();
                         if (key.length > 0)
@@ -1522,13 +1446,13 @@ class CompletionProvider {
                 }
                 if (node.parent.rightExpression.nodeType === 9 /* Call */) {
                     const call = node.parent.rightExpression;
-                    const type = this._evaluator.getType(call.leftExpression);
+                    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;
+                        const quote = this.parseResults.tokenizerOutput.predominantSingleQuoteCharacter;
                         if (key.length > 0) {
                             keys.add(`${quote}${key}${quote}`);
                         }
@@ -1538,19 +1462,19 @@ class CompletionProvider {
             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)) {
+                !textRange_1.TextRange.containsRange(node.parent, invocationNode)) {
                 const indexArgument = node.parent.items[0];
-                const key = this._parseResults.text
+                const key = this.parseResults.text
                     .substr(indexArgument.valueExpression.start, indexArgument.valueExpression.length)
                     .trim();
                 if (key.length > 0)
                     keys.add(key);
             }
         }
-        return [...keys];
+        return Array.from(keys);
     }
     _getLiteralCompletions(parseNode, offset, priorWord, priorText, postText) {
-        if (this._options.triggerCharacter === '"' || this._options.triggerCharacter === "'") {
+        if (this.options.triggerCharacter === '"' || this.options.triggerCharacter === "'") {
             if (parseNode.start !== offset - 1) {
                 // If completion is triggered by typing " or ', it must be the one that starts a string
                 // literal. In another word, it can't be something inside of another string or comment
@@ -1561,7 +1485,7 @@ class CompletionProvider {
         if (!this._tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap)) {
             return undefined;
         }
-        return { completionMap };
+        return completionMap;
     }
     _tryAddLiterals(parseNode, priorWord, priorText, postText, completionMap) {
         var _a, _b, _c, _d, _e, _f;
@@ -1579,7 +1503,7 @@ class CompletionProvider {
                 ? parentAndChild.child
                 : undefined;
         if (nodeForExpectedType) {
-            const expectedTypeResult = this._evaluator.getExpectedType(nodeForExpectedType);
+            const expectedTypeResult = this.evaluator.getExpectedType(nodeForExpectedType);
             if (expectedTypeResult && (0, typeUtils_1.isLiteralTypeOrUnion)(expectedTypeResult.type)) {
                 this._addLiteralValuesForTargetType(expectedTypeResult.type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1648,7 +1572,7 @@ class CompletionProvider {
         const comparison = parentAndChild.parent;
         const supportedOperators = [2 /* Assign */, 12 /* Equals */, 28 /* NotEquals */];
         if (comparison.nodeType === 7 /* BinaryOperation */ && supportedOperators.includes(comparison.operator)) {
-            const type = this._evaluator.getType(comparison.leftExpression);
+            const type = this.evaluator.getType(comparison.leftExpression);
             if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1658,7 +1582,7 @@ class CompletionProvider {
         const assignmentExpression = parentAndChild.parent;
         if (assignmentExpression.nodeType === 4 /* AssignmentExpression */ &&
             assignmentExpression.rightExpression === parentAndChild.child) {
-            const type = this._evaluator.getType(assignmentExpression.name);
+            const type = this.evaluator.getType(assignmentExpression.name);
             if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1673,7 +1597,7 @@ class CompletionProvider {
             caseNode.pattern.category === 11 /* MissingPattern */ &&
             caseNode.suite === parentAndChild.child &&
             ((_c = caseNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 63 /* Match */) {
-            const type = this._evaluator.getType(caseNode.parent.subjectExpression);
+            const type = this.evaluator.getType(caseNode.parent.subjectExpression);
             if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1688,15 +1612,15 @@ class CompletionProvider {
             ((_d = patternLiteral.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 66 /* PatternAs */ &&
             ((_e = patternLiteral.parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 64 /* Case */ &&
             ((_f = patternLiteral.parent.parent.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 63 /* Match */) {
-            const type = this._evaluator.getType(patternLiteral.parent.parent.parent.subjectExpression);
+            const type = this.evaluator.getType(patternLiteral.parent.parent.parent.subjectExpression);
             if (type && (0, typeUtils_1.isLiteralTypeOrUnion)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
             }
         }
         if (parseNode.nodeType === 49 /* String */) {
-            const offset = (0, positionUtils_1.convertPositionToOffset)(this._position, this._parseResults.tokenizerOutput.lines);
-            const atArgument = parseNode.parent.start < offset && offset < textRange_2.TextRange.getEnd(parseNode);
+            const offset = (0, positionUtils_1.convertPositionToOffset)(this.position, this.parseResults.tokenizerOutput.lines);
+            const atArgument = parseNode.parent.start < offset && offset < textRange_1.TextRange.getEnd(parseNode);
             this._addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap);
             return true;
         }
@@ -1732,7 +1656,7 @@ class CompletionProvider {
         const quoteInfo = this._getQuoteInfo(priorWord, priorText);
         const excludes = new Set(existingKeys);
         typedDicts.forEach((typedDict) => {
-            (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, typedDict, /* allowNarrowed */ true).forEach((_, key) => {
+            (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;
@@ -1745,7 +1669,7 @@ class CompletionProvider {
     }
     _tryAddTypedDictKeysFromDictionary(dictionaryNode, stringNode, priorWord, priorText, postText, completionMap) {
         var _a;
-        const expectedTypeResult = this._evaluator.getExpectedType(dictionaryNode);
+        const expectedTypeResult = this.evaluator.getExpectedType(dictionaryNode);
         if (!expectedTypeResult) {
             return false;
         }
@@ -1759,7 +1683,7 @@ class CompletionProvider {
     }
     _tryNarrowTypedDicts(types, keys) {
         const newTypes = types.flatMap((type) => {
-            const entries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, type, /* allowNarrowed */ true);
+            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 [];
@@ -1773,16 +1697,16 @@ class CompletionProvider {
         }
         return newTypes;
     }
-    // Find out quotation and string prefix to use for string literals
+    // Find quotation and string prefix to use for string literals
     // completion under current context.
     _getQuoteInfo(priorWord, priorText) {
         let filterText = priorWord;
         let stringValue = undefined;
-        let quoteCharacter = this._parseResults.tokenizerOutput.predominantSingleQuoteCharacter;
+        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) {
+        if (!this._stringLiteralContainer) {
             return { priorWord, priorText, filterText, stringValue, quoteCharacter };
         }
         const singleQuote = "'";
@@ -1802,16 +1726,15 @@ class CompletionProvider {
                 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;
+        // If the invocation position is within an f-string, use a double or
+        // single quote that doesn't match the f-string. Prior to Python 3.12,
+        // using the same quotation mark nested within an f-string was not
+        // permitted. For example, f"..{typedDict[|<= here ]}", we need to use
+        // single quotes. Note that this doesn't account for deeper nested
+        // f-strings.
+        if (this._stringLiteralContainer.flags & 64 /* Format */) {
+            quoteCharacter =
+                this._stringLiteralContainer.flags & 1 /* SingleQuote */ ? doubleQuote : singleQuote;
         }
         if (stringValue) {
             filterText = stringValue;
@@ -1822,7 +1745,7 @@ class CompletionProvider {
         if (!indexNode) {
             return false;
         }
-        const baseType = this._evaluator.getType(indexNode.baseExpression);
+        const baseType = this.evaluator.getType(indexNode.baseExpression);
         if (!baseType) {
             return false;
         }
@@ -1837,7 +1760,7 @@ class CompletionProvider {
             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;
+            let rangeStartCol = this.position.character;
             if (quoteInfo.stringValue !== undefined) {
                 rangeStartCol -= quoteInfo.stringValue.length + 1;
             }
@@ -1846,80 +1769,23 @@ class CompletionProvider {
             }
             // If the text after the insertion point is the closing quote,
             // replace it.
-            let rangeEndCol = this._position.character;
+            let rangeEndCol = this.position.character;
             if (postText !== undefined) {
                 if (postText.startsWith(quoteInfo.quoteCharacter)) {
                     rangeEndCol++;
                 }
             }
             const range = {
-                start: { line: this._position.line, character: rangeStartCol },
-                end: { line: this._position.line, character: rangeEndCol },
+                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 (!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,
-            importFormat: this._options.importFormat,
-        });
-        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, {
-                    extraCommitChars: true,
-                    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, {
-                    extraCommitChars: true,
-                    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) {
+        var _a;
         // Don't attempt to provide completions for "from X import *".
         if (importFromNode.isWildcardImport) {
             return undefined;
@@ -1932,16 +1798,21 @@ class CompletionProvider {
         }
         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, importFromNode, 
-            /* isInImport */ true, 
-            /* boundObject */ undefined, completionMap);
+        const parseResults = this.program.getParseResults(resolvedPath);
+        if (!parseResults) {
+            return completionMap;
         }
+        const symbolTable = (_a = AnalyzerNodeInfo.getScope(parseResults.parseTree)) === null || _a === void 0 ? void 0 : _a.symbolTable;
+        if (!symbolTable) {
+            return completionMap;
+        }
+        this._addSymbolsForSymbolTable(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, importFromNode, 
+        /* isInImport */ true, 
+        /* boundObject */ undefined, completionMap);
         // Add the implicit imports.
         importInfo.implicitImports.forEach((implImport) => {
             if (!importFromNode.imports.find((imp) => imp.name.value === implImport.name)) {
@@ -1950,7 +1821,7 @@ class CompletionProvider {
                 });
             }
         });
-        return { completionMap };
+        return completionMap;
     }
     _findMatchingKeywords(keywordList, partialMatch) {
         return keywordList.filter((keyword) => {
@@ -1984,8 +1855,8 @@ class CompletionProvider {
                 completionItem.kind = vscode_languageserver_1.CompletionItemKind.Variable;
                 const completionItemData = {
                     workspacePath: this._workspacePath,
-                    filePath: this._filePath,
-                    position: this._position,
+                    filePath: this.filePath,
+                    position: this.position,
                 };
                 completionItem.data = (0, lspUtils_1.toLSPAny)(completionItemData);
                 completionItem.sortText = this._makeSortText(SortCategory.NamedParameter, argName);
@@ -2024,7 +1895,7 @@ class CompletionProvider {
                 }
                 // If this is a class scope, add symbols from parent classes.
                 if (curNode.nodeType === 10 /* Class */) {
-                    const classType = this._evaluator.getTypeOfClass(curNode);
+                    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)) {
@@ -2056,14 +1927,14 @@ class CompletionProvider {
             // exported from this scope, don't include it in the
             // suggestion list unless we are in the same file.
             const hidden = !(0, symbolUtils_1.isVisibleExternally)(symbol) &&
-                !symbol.getDeclarations().some((d) => (0, declarationUtils_1.isDefinedInFile)(d, this._filePath));
+                !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)) {
                     // Skip func parens for classes when not a direct assignment or an argument (passed as a value)
                     const skipForClass = !this._shouldShowAutoParensForClass(symbol, node);
-                    this._addSymbol(name, symbol, priorWord, completionMap, {
+                    this.addSymbol(name, symbol, priorWord, completionMap, {
                         boundObjectOrClass,
                         funcParensDisabled: isInImport || insideTypeAnnotation || skipForClass,
                         extraCommitChars: !isInImport && !!priorWord,
@@ -2083,107 +1954,23 @@ class CompletionProvider {
             return true;
         }
         // Otherwise only show when the class is being assigned to a variable.
-        const nodeIndex = ParseTreeUtils.getTokenIndexAtLeft(this._parseResults.tokenizerOutput.tokens, node.start);
-        const prevToken = ParseTreeUtils.getTokenAtIndex(this._parseResults.tokenizerOutput.tokens, nodeIndex);
+        const nodeIndex = ParseTreeUtils.getTokenIndexAtLeft(this.parseResults.tokenizerOutput.tokens, node.start);
+        const prevToken = ParseTreeUtils.getTokenAtIndex(this.parseResults.tokenizerOutput.tokens, nodeIndex);
         return (prevToken &&
             prevToken.type === 9 /* Operator */ &&
             prevToken.operatorType === 2 /* Assign */);
     }
-    _addSymbol(name, symbol, priorWord, completionMap, detail) {
-        var _a, _b, _c, _d;
-        let primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-        if (!primaryDecl) {
-            const declarations = symbol.getDeclarations();
-            if (declarations.length > 0) {
-                primaryDecl = declarations[declarations.length - 1];
-            }
-        }
-        primaryDecl = primaryDecl
-            ? (_a = this._evaluator.resolveAliasDeclaration(primaryDecl, /* resolveLocalNames */ true)) !== null && _a !== void 0 ? _a : primaryDecl
-            : undefined;
-        const autoImportText = detail.autoImportSource
-            ? this._getAutoImportText(name, detail.autoImportSource, detail.autoImportAlias)
-            : undefined;
-        // 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) {
-                // It's not what we are looking for.
-                return;
-            }
-            if (completionItemData.autoImportText) {
-                if (completionItemData.autoImportText === (autoImportText === null || autoImportText === void 0 ? void 0 : autoImportText.importText) &&
-                    ((_b = detail.edits) === null || _b === void 0 ? void 0 : _b.additionalTextEdits)) {
-                    this._itemToResolve.additionalTextEdits = (0, workspaceEditUtils_1.convertToTextEdits)(detail.edits.additionalTextEdits);
-                }
-                return;
-            }
-            // 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) {
-                // Can't resolve. so bail out.
-                return;
-            }
-            const typeDetail = (0, completionProviderUtils_1.getTypeDetail)(this._evaluator, primaryDecl, type, name, detail, this._configOptions.functionSignatureDisplay);
-            const documentation = (0, tooltipUtils_1.getDocumentationPartsForTypeAndDecl)(this._sourceMapper, type, primaryDecl, this._evaluator, {
-                name,
-                symbol,
-                boundObjectOrClass: detail.boundObjectOrClass,
-            });
-            if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown || this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
-                this._itemToResolve.documentation = (0, completionProviderUtils_1.getCompletionItemDocumentation)(typeDetail, documentation, this._options.format);
-            }
-            else {
-                (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
-            }
-            // Bail out. We don't need to add items to completion.
-            return;
-        }
-        if (primaryDecl) {
-            let 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) &&
-                ((_c = primaryDecl.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
-                itemKind = vscode_languageserver_1.CompletionItemKind.EnumMember;
-            }
-            this._addNameToCompletions((_d = detail.autoImportAlias) !== null && _d !== void 0 ? _d : name, itemKind, priorWord, completionMap, {
-                autoImportText,
-                extraCommitChars: detail.extraCommitChars,
-                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 = this._convertTypeToItemKind(synthesizedType);
-                this._addNameToCompletions(name, itemKind, priorWord, completionMap, {
-                    extraCommitChars: detail.extraCommitChars,
-                    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) {
+        if (this.options.format === vscode_languageserver_1.MarkupKind.Markdown) {
             importText = `\`\`\`\n${autoImportText}\n\`\`\``;
         }
-        else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+        else if (this.options.format === vscode_languageserver_1.MarkupKind.PlainText) {
             importText = autoImportText;
         }
         else {
-            (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
+            (0, debug_1.fail)(`Unsupported markup type: ${this.options.format}`);
         }
         return {
             source: importFrom !== null && importFrom !== void 0 ? importFrom : '',
@@ -2203,14 +1990,14 @@ class CompletionProvider {
         const completionItem = vscode_languageserver_1.CompletionItem.create(name);
         completionItem.kind = itemKind;
         if (detail === null || detail === void 0 ? void 0 : detail.extraCommitChars) {
-            this._addExtraCommitChar(completionItem, ...this._getExtraCommitCharsForKind(itemKind));
+            this.addExtraCommitChar(completionItem);
         }
         const completionItemData = {
             workspacePath: this._workspacePath,
-            filePath: this._filePath,
-            position: this._position,
+            filePath: this.filePath,
+            position: this.position,
         };
-        if ((detail === null || detail === void 0 ? void 0 : detail.funcParensDisabled) || !this._options.snippet) {
+        if ((detail === null || detail === void 0 ? void 0 : detail.funcParensDisabled) || !this.options.snippet) {
             completionItemData.funcParensDisabled = true;
         }
         if (detail === null || detail === void 0 ? void 0 : detail.modulePath) {
@@ -2248,7 +2035,7 @@ class CompletionProvider {
             completionItem.sortText = this._makeSortText(SortCategory.NormalSymbol, name);
         }
         completionItemData.symbolLabel = name;
-        if (this._options.format === vscode_languageserver_1.MarkupKind.Markdown) {
+        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;
@@ -2272,7 +2059,7 @@ class CompletionProvider {
                 };
             }
         }
-        else if (this._options.format === vscode_languageserver_1.MarkupKind.PlainText) {
+        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;
@@ -2296,7 +2083,7 @@ class CompletionProvider {
             }
         }
         else {
-            (0, debug_1.fail)(`Unsupported markup type: ${this._options.format}`);
+            (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;
@@ -2358,7 +2145,7 @@ class CompletionProvider {
         return result;
     }
     _convertDeclarationTypeToItemKind(declaration) {
-        const resolvedDeclaration = this._evaluator.resolveAliasDeclaration(declaration, /* resolveLocalNames */ true);
+        const resolvedDeclaration = this.evaluator.resolveAliasDeclaration(declaration, /* resolveLocalNames */ true);
         if (!resolvedDeclaration) {
             return vscode_languageserver_1.CompletionItemKind.Variable;
         }
@@ -2379,7 +2166,7 @@ class CompletionProvider {
                 return vscode_languageserver_1.CompletionItemKind.Variable;
             case 5 /* Function */: {
                 if (this._isPossiblePropertyDeclaration(resolvedDeclaration)) {
-                    const functionType = this._evaluator.getTypeOfFunction(resolvedDeclaration.node);
+                    const functionType = this.evaluator.getTypeOfFunction(resolvedDeclaration.node);
                     if (functionType &&
                         (0, typeUtils_1.isMaybeDescriptorInstance)(functionType.decoratedType, /* requireSetter */ false)) {
                         return vscode_languageserver_1.CompletionItemKind.Property;
@@ -2417,9 +2204,9 @@ class CompletionProvider {
             leadingDots: node.leadingDots,
             hasTrailingDot: node.hasTrailingDot || false,
             nameParts: node.nameParts.map((part) => part.value),
-            importedSymbols: [],
+            importedSymbols: new Set(),
         };
-        const completions = this._importResolver.getCompletionSuggestions(this._filePath, this._execEnv, moduleDescriptor);
+        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.
@@ -2439,27 +2226,7 @@ class CompletionProvider {
                 modulePath,
             });
         });
-        return { completionMap };
-    }
-    _getExtraCommitCharsForKind(kind) {
-        switch (kind) {
-            case vscode_languageserver_1.CompletionItemKind.Class:
-                return ['.', '('];
-            case vscode_languageserver_1.CompletionItemKind.Function:
-            case vscode_languageserver_1.CompletionItemKind.Method:
-                return ['('];
-            case vscode_languageserver_1.CompletionItemKind.Module:
-            case vscode_languageserver_1.CompletionItemKind.Enum:
-                return ['.'];
-            default:
-                return [];
-        }
-    }
-    _addExtraCommitChar(item, ...commitChars) {
-        if (!this._options.extraCommitChars || commitChars.length === 0) {
-            return;
-        }
-        item.commitCharacters = commitChars;
+        return completionMap;
     }
     _isPossiblePropertyDeclaration(decl) {
         // Do cheap check using only nodes that will cover 99.9% cases