@zzzen/pyright-internal 1.1.254

package/dist/languageService/autoImporter.js

@@ -0,0 +1,635 @@
+"use strict";
+/*
+ * autoImporter.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertSymbolKindToCompletionItemKind = exports.AutoImporter = exports.buildModuleSymbolsMap = void 0;
+const vscode_languageserver_1 = require("vscode-languageserver");
+const importStatementUtils_1 = require("../analyzer/importStatementUtils");
+const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const collectionUtils_1 = require("../common/collectionUtils");
+const pathUtils_1 = require("../common/pathUtils");
+const StringUtils = __importStar(require("../common/stringUtils"));
+const timing_1 = require("../common/timing");
+const completionProvider_1 = require("./completionProvider");
+// Build a map of all modules within this program and the module-
+// level scope that contains the symbol table for the module.
+function buildModuleSymbolsMap(files, includeIndexUserSymbols, token) {
+    const moduleSymbolMap = new Map();
+    (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+    files.forEach((file) => {
+        if (file.shadows.length > 0) {
+            // There is corresponding stub file. Don't add
+            // duplicated files in the map.
+            return;
+        }
+        const filePath = file.sourceFile.getFilePath();
+        const symbolTable = file.sourceFile.getModuleSymbolTable();
+        if (symbolTable) {
+            const fileName = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
+            // Don't offer imports from files that are named with private
+            // naming semantics like "_ast.py".
+            if (SymbolNameUtils.isPrivateOrProtectedName(fileName)) {
+                return;
+            }
+            moduleSymbolMap.set(filePath, {
+                forEach(callbackfn) {
+                    symbolTable.forEach((symbol, name) => {
+                        if (symbol.isExternallyHidden()) {
+                            return;
+                        }
+                        const declarations = symbol.getDeclarations();
+                        if (!declarations || declarations.length === 0) {
+                            return;
+                        }
+                        const declaration = declarations[0];
+                        if (!declaration) {
+                            return;
+                        }
+                        if (declaration.type === 6 /* Alias */) {
+                            // We don't include import alias in auto import
+                            // for workspace files.
+                            return;
+                        }
+                        const variableKind = declaration.type === 1 /* Variable */ &&
+                            !declaration.isConstant &&
+                            !declaration.isFinal
+                            ? vscode_languageserver_1.SymbolKind.Variable
+                            : undefined;
+                        callbackfn({ symbol, kind: variableKind }, name, /* library */ false);
+                    });
+                },
+            });
+            return;
+        }
+        // Iterate through closed user files using indices if asked.
+        const indexResults = file.sourceFile.getCachedIndexResults();
+        if (indexResults && includeIndexUserSymbols && !indexResults.privateOrProtected) {
+            moduleSymbolMap.set(filePath, createModuleSymbolTableFromIndexResult(indexResults, /* library */ false));
+            return;
+        }
+    });
+    return moduleSymbolMap;
+}
+exports.buildModuleSymbolsMap = buildModuleSymbolsMap;
+class AutoImporter {
+    constructor(_execEnvironment, _importResolver, _parseResults, _invocationPosition, _excludes, _moduleSymbolMap, _options) {
+        this._execEnvironment = _execEnvironment;
+        this._importResolver = _importResolver;
+        this._parseResults = _parseResults;
+        this._invocationPosition = _invocationPosition;
+        this._excludes = _excludes;
+        this._moduleSymbolMap = _moduleSymbolMap;
+        this._options = _options;
+        // Track some auto import internal perf numbers.
+        this._stopWatch = new timing_1.Duration();
+        this._perfInfo = {
+            indexUsed: false,
+            totalInMs: 0,
+            moduleTimeInMS: 0,
+            indexTimeInMS: 0,
+            importAliasTimeInMS: 0,
+            symbolCount: 0,
+            indexCount: 0,
+            importAliasCount: 0,
+        };
+        this._importStatements = (0, importStatementUtils_1.getTopLevelImports)(this._parseResults.parseTree, /* includeImplicitImports */ true);
+        this._perfInfo.indexUsed = !!this._options.libraryMap;
+    }
+    getAutoImportCandidatesForAbbr(abbr, abbrInfo, token) {
+        const map = this._getCandidates(abbrInfo.importName, /* similarityLimit */ 1, abbr, token);
+        const result = map.get(abbrInfo.importName);
+        if (!result) {
+            return [];
+        }
+        return result.filter((r) => r.source === abbrInfo.importFrom);
+    }
+    getAutoImportCandidates(word, similarityLimit, abbrFromUsers, token) {
+        const results = [];
+        const map = this._getCandidates(word, similarityLimit, abbrFromUsers, token);
+        map.forEach((v) => (0, collectionUtils_1.appendArray)(results, v));
+        return results;
+    }
+    getPerfInfo() {
+        this._perfInfo.totalInMs = this._stopWatch.getDurationInMilliseconds();
+        return this._perfInfo;
+    }
+    _getCandidates(word, similarityLimit, abbrFromUsers, token) {
+        const resultMap = new Map();
+        const importAliasMap = new Map();
+        this._addImportsFromModuleMap(word, similarityLimit, abbrFromUsers, importAliasMap, resultMap, token);
+        this._addImportsFromLibraryMap(word, similarityLimit, abbrFromUsers, importAliasMap, resultMap, token);
+        this._addImportsFromImportAliasMap(importAliasMap, abbrFromUsers, resultMap, token);
+        return resultMap;
+    }
+    _addImportsFromLibraryMap(word, similarityLimit, abbrFromUsers, aliasMap, results, token) {
+        var _a;
+        const startTime = this._stopWatch.getDurationInMilliseconds();
+        (_a = this._options.libraryMap) === null || _a === void 0 ? void 0 : _a.forEach((indexResults, filePath) => {
+            if (indexResults.privateOrProtected) {
+                return;
+            }
+            if (this._moduleSymbolMap.has(filePath)) {
+                // Module map is already taking care of this file. this can happen if the module is used by
+                // user code.
+                return;
+            }
+            // See if this file should be offered as an implicit import.
+            const isStubFileOrHasInit = this._isStubFileOrHasInit(this._options.libraryMap, filePath);
+            this._processModuleSymbolTable(createModuleSymbolTableFromIndexResult(indexResults, /* library */ true), filePath, word, similarityLimit, isStubFileOrHasInit, abbrFromUsers, aliasMap, results, token);
+        });
+        this._perfInfo.indexTimeInMS = this._stopWatch.getDurationInMilliseconds() - startTime;
+    }
+    _addImportsFromModuleMap(word, similarityLimit, abbrFromUsers, aliasMap, results, token) {
+        const startTime = this._stopWatch.getDurationInMilliseconds();
+        this._moduleSymbolMap.forEach((topLevelSymbols, filePath) => {
+            // See if this file should be offered as an implicit import.
+            const isStubFileOrHasInit = this._isStubFileOrHasInit(this._moduleSymbolMap, filePath);
+            this._processModuleSymbolTable(topLevelSymbols, filePath, word, similarityLimit, isStubFileOrHasInit, abbrFromUsers, aliasMap, results, token);
+        });
+        this._perfInfo.moduleTimeInMS = this._stopWatch.getDurationInMilliseconds() - startTime;
+    }
+    _isStubFileOrHasInit(map, filePath) {
+        const fileDir = (0, pathUtils_1.getDirectoryPath)(filePath);
+        const initPathPy = (0, pathUtils_1.combinePaths)(fileDir, '__init__.py');
+        const initPathPyi = initPathPy + 'i';
+        const isStub = filePath.endsWith('.pyi');
+        const hasInit = map.has(initPathPy) || map.has(initPathPyi);
+        return { isStub, hasInit };
+    }
+    _processModuleSymbolTable(topLevelSymbols, filePath, word, similarityLimit, isStubOrHasInit, abbrFromUsers, importAliasMap, results, token) {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+        const [importSource, importGroup, moduleNameAndType] = this._getImportPartsForSymbols(filePath);
+        if (!importSource) {
+            return;
+        }
+        const dotCount = StringUtils.getCharacterCount(importSource, '.');
+        topLevelSymbols.forEach((autoImportSymbol, name, library) => {
+            var _a;
+            this._perfIndexCount(autoImportSymbol, library);
+            if (!this._shouldIncludeVariable(autoImportSymbol, name, isStubOrHasInit.isStub, library)) {
+                return;
+            }
+            // For very short matching strings, we will require an exact match. Otherwise
+            // we will tend to return a list that's too long. Once we get beyond two
+            // characters, we can do a fuzzy match.
+            const isSimilar = this._isSimilar(word, name, similarityLimit);
+            if (!isSimilar) {
+                return;
+            }
+            const alreadyIncluded = this._containsName(name, importSource, results);
+            if (alreadyIncluded) {
+                return;
+            }
+            // We will collect all aliases and then process it later
+            if (autoImportSymbol.importAlias) {
+                this._addToImportAliasMap(autoImportSymbol.importAlias, {
+                    importParts: {
+                        symbolName: name,
+                        importName: name,
+                        importFrom: importSource,
+                        filePath,
+                        dotCount,
+                        moduleNameAndType,
+                    },
+                    importGroup,
+                    symbol: autoImportSymbol.symbol,
+                    kind: autoImportSymbol.importAlias.kind,
+                    itemKind: autoImportSymbol.importAlias.itemKind,
+                }, importAliasMap);
+                return;
+            }
+            const autoImportTextEdits = this._getTextEditsForAutoImportByFilePath(importSource, name, abbrFromUsers, name, importGroup, filePath);
+            this._addResult(results, {
+                name,
+                alias: abbrFromUsers,
+                symbol: autoImportSymbol.symbol,
+                source: importSource,
+                kind: (_a = autoImportSymbol.itemKind) !== null && _a !== void 0 ? _a : convertSymbolKindToCompletionItemKind(autoImportSymbol.kind),
+                insertionText: autoImportTextEdits.insertionText,
+                edits: autoImportTextEdits.edits,
+            });
+        });
+        // If the current file is in a directory that also contains an "__init__.py[i]"
+        // file, we can use that directory name as an implicit import target.
+        // Or if the file is a stub file, we can use it as import target.
+        if (!isStubOrHasInit.isStub && !isStubOrHasInit.hasInit) {
+            return;
+        }
+        const importParts = this._getImportParts(filePath);
+        if (!importParts) {
+            return;
+        }
+        const isSimilar = this._isSimilar(word, importParts.importName, similarityLimit);
+        if (!isSimilar) {
+            return;
+        }
+        const alreadyIncluded = this._containsName(importParts.importName, importParts.importFrom, results);
+        if (alreadyIncluded) {
+            return;
+        }
+        this._addToImportAliasMap({
+            modulePath: filePath,
+            originalName: importParts.importName,
+            kind: vscode_languageserver_1.SymbolKind.Module,
+            itemKind: vscode_languageserver_1.CompletionItemKind.Module,
+        }, { importParts, importGroup, kind: vscode_languageserver_1.SymbolKind.Module, itemKind: vscode_languageserver_1.CompletionItemKind.Module }, importAliasMap);
+    }
+    _shouldIncludeVariable(autoImportSymbol, name, isStub, library) {
+        var _a;
+        // If it is not a stub file and symbol is Variable, we only include it if
+        // name is public constant or type alias unless it is in __all__ for user files.
+        if (isStub || autoImportSymbol.kind !== vscode_languageserver_1.SymbolKind.Variable) {
+            return true;
+        }
+        if (this._options.allowVariableInAll && !library && ((_a = autoImportSymbol.symbol) === null || _a === void 0 ? void 0 : _a.isInDunderAll())) {
+            return true;
+        }
+        return SymbolNameUtils.isPublicConstantOrTypeAlias(name);
+    }
+    _addImportsFromImportAliasMap(importAliasMap, abbrFromUsers, results, token) {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+        const startTime = this._stopWatch.getDurationInMilliseconds();
+        importAliasMap.forEach((mapPerSymbolName) => {
+            this._perfInfo.importAliasCount += mapPerSymbolName.size;
+            mapPerSymbolName.forEach((importAliasData) => {
+                var _a, _b;
+                if (abbrFromUsers) {
+                    // When alias name is used, our regular exclude mechanism would not work. we need to check
+                    // whether import, the alias is referring to, already exists.
+                    // ex) import numpy
+                    //     np| <= auto-import here.
+                    // or
+                    //     from scipy import io as spio
+                    //     io| <= auto-import here
+                    // If import statement for the module already exist, then bail out.
+                    // ex) import module[.submodule] or from module[.submodule] import symbol
+                    if (this._importStatements.mapByFilePath.has(importAliasData.importParts.filePath)) {
+                        return;
+                    }
+                    // If it is the module itself that got imported, make sure we don't import it again.
+                    // ex) from module import submodule as ss
+                    //     submodule <= auto-import here
+                    if (importAliasData.importParts.importFrom) {
+                        const imported = this._importStatements.orderedImports.find((i) => i.moduleName === importAliasData.importParts.importFrom);
+                        if (imported &&
+                            imported.node.nodeType === 22 /* ImportFrom */ &&
+                            imported.node.imports.some((i) => i.name.value === importAliasData.importParts.symbolName)) {
+                            return;
+                        }
+                    }
+                }
+                const alreadyIncluded = this._containsName(importAliasData.importParts.importName, importAliasData.importParts.importFrom, results);
+                if (alreadyIncluded) {
+                    return;
+                }
+                const autoImportTextEdits = this._getTextEditsForAutoImportByFilePath((_a = importAliasData.importParts.importFrom) !== null && _a !== void 0 ? _a : importAliasData.importParts.importName, importAliasData.importParts.symbolName, abbrFromUsers, importAliasData.importParts.importName, importAliasData.importGroup, importAliasData.importParts.filePath);
+                this._addResult(results, {
+                    name: importAliasData.importParts.importName,
+                    alias: abbrFromUsers,
+                    symbol: importAliasData.symbol,
+                    kind: (_b = importAliasData.itemKind) !== null && _b !== void 0 ? _b : convertSymbolKindToCompletionItemKind(importAliasData.kind),
+                    source: importAliasData.importParts.importFrom,
+                    insertionText: autoImportTextEdits.insertionText,
+                    edits: autoImportTextEdits.edits,
+                });
+            });
+        });
+        this._perfInfo.importAliasTimeInMS = this._stopWatch.getDurationInMilliseconds() - startTime;
+    }
+    _addToImportAliasMap(alias, data, importAliasMap) {
+        // Since we don't resolve alias declaration using type evaluator, there is still a chance
+        // where we show multiple aliases for same symbols. but this should still reduce number of
+        // such cases.
+        if (!importAliasMap.has(alias.modulePath)) {
+            const map = new Map();
+            map.set(alias.originalName, data);
+            importAliasMap.set(alias.modulePath, map);
+            return;
+        }
+        const map = importAliasMap.get(alias.modulePath);
+        if (!map.has(alias.originalName)) {
+            map.set(alias.originalName, data);
+            return;
+        }
+        const existingData = map.get(alias.originalName);
+        const comparison = this._compareImportAliasData(existingData, data);
+        if (comparison <= 0) {
+            // Existing data is better than new one.
+            return;
+        }
+        // Keep the new data.
+        map.set(alias.originalName, data);
+    }
+    _compareImportAliasData(left, right) {
+        const groupComparison = left.importGroup - right.importGroup;
+        if (groupComparison !== 0) {
+            return groupComparison;
+        }
+        const dotComparison = left.importParts.dotCount - right.importParts.dotCount;
+        if (dotComparison !== 0) {
+            return dotComparison;
+        }
+        if (left.symbol && !right.symbol) {
+            return -1;
+        }
+        if (!left.symbol && right.symbol) {
+            return 1;
+        }
+        return StringUtils.getStringComparer()(left.importParts.importName, right.importParts.importName);
+    }
+    _getImportPartsForSymbols(filePath) {
+        const localImport = this._importStatements.mapByFilePath.get(filePath);
+        if (localImport) {
+            return [
+                localImport.moduleName,
+                (0, importStatementUtils_1.getImportGroup)(localImport),
+                {
+                    importType: 2 /* Local */,
+                    isLocalTypingsFile: false,
+                    moduleName: localImport.moduleName,
+                },
+            ];
+        }
+        else {
+            const moduleNameAndType = this._getModuleNameAndTypeFromFilePath(filePath);
+            return [
+                moduleNameAndType.moduleName,
+                (0, importStatementUtils_1.getImportGroupFromModuleNameAndType)(moduleNameAndType),
+                moduleNameAndType,
+            ];
+        }
+    }
+    _getImportParts(filePath) {
+        const name = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
+        // See if we can import module as "import xxx"
+        if (name === '__init__') {
+            return createImportParts(this._getModuleNameAndTypeFromFilePath((0, pathUtils_1.getDirectoryPath)(filePath)));
+        }
+        return createImportParts(this._getModuleNameAndTypeFromFilePath(filePath));
+        function createImportParts(module) {
+            const moduleName = module.moduleName;
+            if (!moduleName) {
+                return undefined;
+            }
+            const index = moduleName.lastIndexOf('.');
+            const importNamePart = index > 0 ? moduleName.substring(index + 1) : undefined;
+            const importFrom = index > 0 ? moduleName.substring(0, index) : undefined;
+            return {
+                symbolName: importNamePart,
+                importName: importNamePart !== null && importNamePart !== void 0 ? importNamePart : moduleName,
+                importFrom,
+                filePath,
+                dotCount: StringUtils.getCharacterCount(moduleName, '.'),
+                moduleNameAndType: module,
+            };
+        }
+    }
+    _isSimilar(word, name, similarityLimit) {
+        if (similarityLimit === 1) {
+            return word === name;
+        }
+        if (word.length <= 0 || name.length <= 0) {
+            return false;
+        }
+        if (!this._options.patternMatcher) {
+            const index = word[0] !== '_' && name[0] === '_' && name.length > 1 ? 1 : 0;
+            if (word[0].toLocaleLowerCase() !== name[index].toLocaleLowerCase()) {
+                return false;
+            }
+            return StringUtils.isPatternInSymbol(word, name);
+        }
+        return this._options.patternMatcher(word, name);
+    }
+    _shouldExclude(name) {
+        return this._excludes.has(name, completionProvider_1.CompletionMap.labelOnlyIgnoringAutoImports);
+    }
+    _containsName(name, source, results) {
+        if (this._shouldExclude(name)) {
+            return true;
+        }
+        const match = results.get(name);
+        if (match === null || match === void 0 ? void 0 : match.some((r) => r.source === source)) {
+            return true;
+        }
+        return false;
+    }
+    // Given the file path of a module that we want to import,
+    // convert to a module name that can be used in an
+    // 'import from' statement.
+    _getModuleNameAndTypeFromFilePath(filePath) {
+        return this._importResolver.getModuleNameForImport(filePath, this._execEnvironment);
+    }
+    _getTextEditsForAutoImportByFilePath(moduleName, importName, abbrFromUsers, insertionText, importGroup, filePath) {
+        var _a, _b, _c, _d, _e, _f;
+        // If there is no symbolName, there can't be existing import statement.
+        const importStatement = this._importStatements.mapByFilePath.get(filePath);
+        if (importStatement) {
+            // Found import for given module. See whether we can use the module as it is.
+            if (importStatement.node.nodeType === 20 /* Import */) {
+                // For now, we don't check whether alias or moduleName got overwritten at
+                // given position
+                const importAlias = (_b = (_a = importStatement.subnode) === null || _a === void 0 ? void 0 : _a.alias) === null || _b === void 0 ? void 0 : _b.value;
+                if (importName) {
+                    // ex) import module
+                    //     method | <= auto-import
+                    return {
+                        insertionText: `${importAlias !== null && importAlias !== void 0 ? importAlias : importStatement.moduleName}.${importName}`,
+                        edits: [],
+                    };
+                }
+                else if (importAlias) {
+                    // ex) import module as m
+                    //     m | <= auto-import
+                    return {
+                        insertionText: `${importAlias}`,
+                        edits: [],
+                    };
+                }
+            }
+            // Does an 'import from' statement already exist?
+            if (importName &&
+                importStatement.node.nodeType === 22 /* ImportFrom */ &&
+                !importStatement.node.isWildcardImport) {
+                // If so, see whether what we want already exist.
+                const importNode = importStatement.node.imports.find((i) => i.name.value === importName);
+                if (importNode) {
+                    // For now, we don't check whether alias or moduleName got overwritten at
+                    // given position
+                    const importAlias = (_c = importNode.alias) === null || _c === void 0 ? void 0 : _c.value;
+                    return {
+                        insertionText: `${importAlias !== null && importAlias !== void 0 ? importAlias : importName}`,
+                        edits: [],
+                    };
+                }
+                // If not, add what we want at the existing 'import from' statement as long as
+                // what is imported is not module itself.
+                // ex) don't add "path" to existing "from os.path import dirname" statement.
+                if (moduleName === importStatement.moduleName) {
+                    return {
+                        insertionText: abbrFromUsers !== null && abbrFromUsers !== void 0 ? abbrFromUsers : insertionText,
+                        edits: this._options.lazyEdit
+                            ? undefined
+                            : (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)({ name: importName, alias: abbrFromUsers }, importStatement, this._parseResults),
+                    };
+                }
+            }
+        }
+        else if (importName) {
+            // If it is the module itself that got imported, make sure we don't import it again.
+            // ex) from module import submodule
+            const imported = this._importStatements.orderedImports.find((i) => i.moduleName === moduleName);
+            if (imported && imported.node.nodeType === 22 /* ImportFrom */ && !imported.node.isWildcardImport) {
+                const importFrom = imported.node.imports.find((i) => i.name.value === importName);
+                if (importFrom) {
+                    // For now, we don't check whether alias or moduleName got overwritten at
+                    // given position. only move to alias, but not the other way around
+                    const importAlias = (_d = importFrom.alias) === null || _d === void 0 ? void 0 : _d.value;
+                    if (importAlias) {
+                        return {
+                            insertionText: `${importAlias}`,
+                            edits: [],
+                        };
+                    }
+                }
+                else {
+                    // If not, add what we want at the existing import from statement.
+                    return {
+                        insertionText: abbrFromUsers !== null && abbrFromUsers !== void 0 ? abbrFromUsers : insertionText,
+                        edits: this._options.lazyEdit
+                            ? undefined
+                            : (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)({ name: importName, alias: abbrFromUsers }, imported, this._parseResults),
+                    };
+                }
+            }
+            // Check whether it is one of implicit imports
+            const importFrom = (_e = this._importStatements.implicitImports) === null || _e === void 0 ? void 0 : _e.get(filePath);
+            if (importFrom) {
+                // For now, we don't check whether alias or moduleName got overwritten at
+                // given position
+                const importAlias = (_f = importFrom.alias) === null || _f === void 0 ? void 0 : _f.value;
+                return {
+                    insertionText: `${importAlias !== null && importAlias !== void 0 ? importAlias : importFrom.name.value}.${importName}`,
+                    edits: [],
+                };
+            }
+        }
+        return {
+            insertionText: abbrFromUsers !== null && abbrFromUsers !== void 0 ? abbrFromUsers : insertionText,
+            edits: this._options.lazyEdit
+                ? undefined
+                : (0, importStatementUtils_1.getTextEditsForAutoImportInsertion)({ name: importName, alias: abbrFromUsers }, this._importStatements, moduleName, importGroup, this._parseResults, this._invocationPosition),
+        };
+    }
+    _perfIndexCount(autoImportSymbol, library) {
+        if (autoImportSymbol.symbol) {
+            this._perfInfo.symbolCount++;
+        }
+        else if (library) {
+            this._perfInfo.indexCount++;
+        }
+    }
+    _addResult(results, result) {
+        let entries = results.get(result.name);
+        if (!entries) {
+            entries = [];
+            results.set(result.name, entries);
+        }
+        entries.push(result);
+    }
+}
+exports.AutoImporter = AutoImporter;
+function createModuleSymbolTableFromIndexResult(indexResults, library) {
+    return {
+        forEach(callbackfn) {
+            indexResults.symbols.forEach((data) => {
+                if (!data.externallyVisible) {
+                    return;
+                }
+                callbackfn({
+                    importAlias: data.alias,
+                    kind: data.kind,
+                    itemKind: data.itemKind,
+                }, data.name, library);
+            });
+        },
+    };
+}
+function convertSymbolKindToCompletionItemKind(kind) {
+    switch (kind) {
+        case vscode_languageserver_1.SymbolKind.File:
+            return vscode_languageserver_1.CompletionItemKind.File;
+        case vscode_languageserver_1.SymbolKind.Module:
+        case vscode_languageserver_1.SymbolKind.Namespace:
+            return vscode_languageserver_1.CompletionItemKind.Module;
+        case vscode_languageserver_1.SymbolKind.Package:
+            return vscode_languageserver_1.CompletionItemKind.Folder;
+        case vscode_languageserver_1.SymbolKind.Class:
+            return vscode_languageserver_1.CompletionItemKind.Class;
+        case vscode_languageserver_1.SymbolKind.Method:
+            return vscode_languageserver_1.CompletionItemKind.Method;
+        case vscode_languageserver_1.SymbolKind.Property:
+            return vscode_languageserver_1.CompletionItemKind.Property;
+        case vscode_languageserver_1.SymbolKind.Field:
+            return vscode_languageserver_1.CompletionItemKind.Field;
+        case vscode_languageserver_1.SymbolKind.Constructor:
+            return vscode_languageserver_1.CompletionItemKind.Constructor;
+        case vscode_languageserver_1.SymbolKind.Enum:
+            return vscode_languageserver_1.CompletionItemKind.Enum;
+        case vscode_languageserver_1.SymbolKind.Interface:
+            return vscode_languageserver_1.CompletionItemKind.Interface;
+        case vscode_languageserver_1.SymbolKind.Function:
+            return vscode_languageserver_1.CompletionItemKind.Function;
+        case vscode_languageserver_1.SymbolKind.Variable:
+        case vscode_languageserver_1.SymbolKind.Array:
+            return vscode_languageserver_1.CompletionItemKind.Variable;
+        case vscode_languageserver_1.SymbolKind.String:
+            return vscode_languageserver_1.CompletionItemKind.Constant;
+        case vscode_languageserver_1.SymbolKind.Number:
+        case vscode_languageserver_1.SymbolKind.Boolean:
+            return vscode_languageserver_1.CompletionItemKind.Value;
+        case vscode_languageserver_1.SymbolKind.Constant:
+        case vscode_languageserver_1.SymbolKind.Null:
+            return vscode_languageserver_1.CompletionItemKind.Constant;
+        case vscode_languageserver_1.SymbolKind.Object:
+        case vscode_languageserver_1.SymbolKind.Key:
+            return vscode_languageserver_1.CompletionItemKind.Value;
+        case vscode_languageserver_1.SymbolKind.EnumMember:
+            return vscode_languageserver_1.CompletionItemKind.EnumMember;
+        case vscode_languageserver_1.SymbolKind.Struct:
+            return vscode_languageserver_1.CompletionItemKind.Struct;
+        case vscode_languageserver_1.SymbolKind.Event:
+            return vscode_languageserver_1.CompletionItemKind.Event;
+        case vscode_languageserver_1.SymbolKind.Operator:
+            return vscode_languageserver_1.CompletionItemKind.Operator;
+        case vscode_languageserver_1.SymbolKind.TypeParameter:
+            return vscode_languageserver_1.CompletionItemKind.TypeParameter;
+        default:
+            return undefined;
+    }
+}
+exports.convertSymbolKindToCompletionItemKind = convertSymbolKindToCompletionItemKind;
+//# sourceMappingURL=autoImporter.js.map