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

package/dist/languageService/autoImporter.d.ts

@@ -1,17 +1,14 @@
 import { CancellationToken, CompletionItemKind, SymbolKind } from 'vscode-languageserver';
-import { ImportResolver } from '../analyzer/importResolver';
-import { SourceFileInfo } from '../analyzer/program';
+import { ImportResolver, ModuleNameAndType } from '../analyzer/importResolver';
+import { ImportGroup } from '../analyzer/importStatementUtils';
 import { Symbol } from '../analyzer/symbol';
 import { ExecutionEnvironment } from '../common/configOptions';
 import { TextEditAction } from '../common/editAction';
 import { Position } from '../common/textRange';
 import { ParseResults } from '../parser/parser';
 import { CompletionMap } from './completionProvider';
-import { IndexAliasData, IndexResults } from './documentSymbolProvider';
-export declare const enum ImportFormat {
-    Absolute = "absolute",
-    Relative = "relative"
-}
+import { SourceFileInfo } from '../common/extensibility';
+import { IndexAliasData } from './symbolIndexer';
 export interface AutoImportSymbol {
     readonly importAlias?: IndexAliasData;
     readonly symbol?: Symbol;
@@ -22,59 +19,62 @@ export interface ModuleSymbolTable {
     forEach(callbackfn: (symbol: AutoImportSymbol, name: string, library: boolean) => void): void;
 }
 export declare type ModuleSymbolMap = Map<string, ModuleSymbolTable>;
-export interface AbbreviationInfo {
-    importFrom?: string;
-    importName: string;
-}
 export interface AutoImportResult {
-    name: string;
-    symbol?: Symbol;
-    source?: string;
-    insertionText: string;
-    edits?: TextEditAction[];
-    alias?: string;
-    kind?: CompletionItemKind;
+    readonly name: string;
+    readonly symbol?: Symbol;
+    readonly source?: string;
+    readonly insertionText: string;
+    readonly edits?: TextEditAction[];
+    readonly alias?: string;
+    readonly kind?: CompletionItemKind;
 }
 export interface AutoImportOptions {
-    libraryMap?: Map<string, IndexResults>;
-    patternMatcher?: (pattern: string, name: string) => boolean;
-    allowVariableInAll?: boolean;
-    lazyEdit?: boolean;
-    importFormat?: ImportFormat;
+    readonly patternMatcher?: (pattern: string, name: string) => boolean;
+    readonly allowVariableInAll?: boolean;
+    readonly lazyEdit?: boolean;
+}
+export interface ImportParts {
+    readonly importName: string;
+    readonly symbolName?: string;
+    readonly importFrom?: string;
+    readonly filePath: string;
+    readonly dotCount: number;
+    readonly moduleNameAndType: ModuleNameAndType;
+}
+export interface ImportAliasData {
+    readonly importParts: ImportParts;
+    readonly importGroup: ImportGroup;
+    readonly symbol?: Symbol;
+    readonly kind?: SymbolKind;
+    readonly itemKind?: CompletionItemKind;
 }
-export declare function buildModuleSymbolsMap(files: SourceFileInfo[], includeSymbolsFromIndices: boolean, token: CancellationToken): ModuleSymbolMap;
+export declare type AutoImportResultMap = Map<string, AutoImportResult[]>;
+export declare function buildModuleSymbolsMap(files: readonly SourceFileInfo[]): ModuleSymbolMap;
+export declare function addModuleSymbolsMap(files: readonly SourceFileInfo[], moduleSymbolMap: ModuleSymbolMap): void;
 export declare class AutoImporter {
-    private _execEnvironment;
-    private _importResolver;
-    private _parseResults;
-    private _invocationPosition;
+    protected readonly execEnvironment: ExecutionEnvironment;
+    protected readonly importResolver: ImportResolver;
+    protected readonly parseResults: ParseResults;
+    private readonly _invocationPosition;
     private readonly _excludes;
-    private _moduleSymbolMap;
-    private _options;
-    private readonly _filePath;
+    protected readonly moduleSymbolMap: ModuleSymbolMap;
+    protected readonly options: AutoImportOptions;
     private readonly _importStatements;
-    private readonly _stopWatch;
-    private readonly _perfInfo;
-    constructor(_execEnvironment: ExecutionEnvironment, _importResolver: ImportResolver, _parseResults: ParseResults, _invocationPosition: Position, _excludes: CompletionMap, _moduleSymbolMap: ModuleSymbolMap, _options: AutoImportOptions);
-    getAutoImportCandidatesForAbbr(abbr: string | undefined, abbrInfo: AbbreviationInfo, token: CancellationToken): AutoImportResult[];
+    constructor(execEnvironment: ExecutionEnvironment, importResolver: ImportResolver, parseResults: ParseResults, _invocationPosition: Position, _excludes: CompletionMap, moduleSymbolMap: ModuleSymbolMap, options: AutoImportOptions);
     getAutoImportCandidates(word: string, similarityLimit: number, abbrFromUsers: string | undefined, token: CancellationToken): AutoImportResult[];
-    getPerfInfo(): {
-        indexUsed: boolean;
-        totalInMs: number;
-        moduleTimeInMS: number;
-        indexTimeInMS: number;
-        importAliasTimeInMS: number;
-        symbolCount: number;
-        indexCount: number;
-        importAliasCount: number;
+    protected getCandidates(word: string, similarityLimit: number, abbrFromUsers: string | undefined, token: CancellationToken): Map<string, AutoImportResult[]>;
+    protected addImportsFromModuleMap(word: string, similarityLimit: number, abbrFromUsers: string | undefined, aliasMap: Map<string, Map<string, ImportAliasData>>, results: AutoImportResultMap, token: CancellationToken): void;
+    protected addImportsFromImportAliasMap(importAliasMap: Map<string, Map<string, ImportAliasData>>, abbrFromUsers: string | undefined, results: AutoImportResultMap, token: CancellationToken): void;
+    protected processModuleSymbolTable(topLevelSymbols: ModuleSymbolTable, moduleFilePath: string, word: string, similarityLimit: number, isStubOrHasInit: {
+        isStub: boolean;
+        hasInit: boolean;
+    }, abbrFromUsers: string | undefined, importAliasMap: Map<string, Map<string, ImportAliasData>>, results: AutoImportResultMap, token: CancellationToken): void;
+    protected getNameForImportFrom(library: boolean, moduleFilePath: string): string | undefined;
+    protected isStubFileOrHasInit<T>(map: Map<string, T>, filePath: string): {
+        isStub: boolean;
+        hasInit: boolean;
     };
-    private _getCandidates;
-    private _addImportsFromLibraryMap;
-    private _addImportsFromModuleMap;
-    private _isStubFileOrHasInit;
-    private _processModuleSymbolTable;
     private _shouldIncludeVariable;
-    private _addImportsFromImportAliasMap;
     private _addToImportAliasMap;
     private _compareImportAliasData;
     private _getImportPartsForSymbols;
@@ -84,7 +84,6 @@ export declare class AutoImporter {
     private _containsName;
     private _getModuleNameAndTypeFromFilePath;
     private _getTextEditsForAutoImportByFilePath;
-    private _perfIndexCount;
     private _addResult;
 }
-export declare function convertSymbolKindToCompletionItemKind(kind: SymbolKind | undefined): 2 | 22 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 12 | 13 | 17 | 19 | 20 | 21 | 23 | 24 | 25 | undefined;
+export declare function convertSymbolKindToCompletionItemKind(kind: SymbolKind | undefined): 2 | 22 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 12 | 13 | 17 | 19 | 20 | 21 | 24 | 23 | 25 | undefined;

package/dist/languageService/autoImporter.js

@@ -26,9 +26,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertSymbolKindToCompletionItemKind = exports.AutoImporter = exports.buildModuleSymbolsMap = exports.ImportFormat = void 0;
+exports.convertSymbolKindToCompletionItemKind = exports.AutoImporter = exports.addModuleSymbolsMap = exports.buildModuleSymbolsMap = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
-const analyzerNodeInfo_1 = require("../analyzer/analyzerNodeInfo");
 const importStatementUtils_1 = require("../analyzer/importStatementUtils");
 const sourceFileInfoUtils_1 = require("../analyzer/sourceFileInfoUtils");
 const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
@@ -37,18 +36,16 @@ 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");
-var ImportFormat;
-(function (ImportFormat) {
-    ImportFormat["Absolute"] = "absolute";
-    ImportFormat["Relative"] = "relative";
-})(ImportFormat = exports.ImportFormat || (exports.ImportFormat = {}));
 // 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, includeSymbolsFromIndices, token) {
-    const moduleSymbolMap = new Map();
-    (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+function buildModuleSymbolsMap(files) {
+    const map = new Map();
+    addModuleSymbolsMap(files, map);
+    return map;
+}
+exports.buildModuleSymbolsMap = buildModuleSymbolsMap;
+function addModuleSymbolsMap(files, moduleSymbolMap) {
     files.forEach((file) => {
         if (file.shadows.length > 0) {
             // There is corresponding stub file. Don't add
@@ -57,140 +54,126 @@ function buildModuleSymbolsMap(files, includeSymbolsFromIndices, token) {
         }
         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 (!(0, symbolUtils_1.isVisibleExternally)(symbol)) {
-                            return;
-                        }
-                        const declarations = symbol.getDeclarations();
-                        if (!declarations || declarations.length === 0) {
-                            return;
-                        }
-                        const declaration = declarations[0];
-                        if (!declaration) {
-                            return;
-                        }
-                        if (declaration.type === 8 /* Alias */ && (0, sourceFileInfoUtils_1.isUserCode)(file)) {
-                            // 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 */ !(0, sourceFileInfoUtils_1.isUserCode)(file));
-                    });
-                },
-            });
+        if (!symbolTable) {
             return;
         }
-        // Iterate through closed user files using indices if asked.
-        const indexResults = file.sourceFile.getCachedIndexResults();
-        if (indexResults && includeSymbolsFromIndices && !indexResults.privateOrProtected) {
-            moduleSymbolMap.set(filePath, createModuleSymbolTableFromIndexResult(indexResults, /* library */ false));
+        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 (!(0, symbolUtils_1.isVisibleExternally)(symbol)) {
+                        return;
+                    }
+                    const declarations = symbol.getDeclarations();
+                    if (!declarations || declarations.length === 0) {
+                        return;
+                    }
+                    const declaration = declarations[0];
+                    if (!declaration) {
+                        return;
+                    }
+                    if (declaration.type === 8 /* Alias */ && (0, sourceFileInfoUtils_1.isUserCode)(file)) {
+                        // 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 */ !(0, sourceFileInfoUtils_1.isUserCode)(file));
+                });
+            },
+        });
+        return;
     });
-    return moduleSymbolMap;
 }
-exports.buildModuleSymbolsMap = buildModuleSymbolsMap;
+exports.addModuleSymbolsMap = addModuleSymbolsMap;
 class AutoImporter {
-    constructor(_execEnvironment, _importResolver, _parseResults, _invocationPosition, _excludes, _moduleSymbolMap, _options) {
-        this._execEnvironment = _execEnvironment;
-        this._importResolver = _importResolver;
-        this._parseResults = _parseResults;
+    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._filePath = (0, analyzerNodeInfo_1.getFileInfo)(_parseResults.parseTree).filePath;
-        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);
+        this.moduleSymbolMap = moduleSymbolMap;
+        this.options = options;
+        this._importStatements = (0, importStatementUtils_1.getTopLevelImports)(this.parseResults.parseTree, /* includeImplicitImports */ true);
     }
     getAutoImportCandidates(word, similarityLimit, abbrFromUsers, token) {
         const results = [];
-        const map = this._getCandidates(word, similarityLimit, abbrFromUsers, token);
+        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) {
+    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);
+        this.addImportsFromModuleMap(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;
-            }
+    addImportsFromModuleMap(word, similarityLimit, abbrFromUsers, aliasMap, results, token) {
+        this.moduleSymbolMap.forEach((topLevelSymbols, filePath) => {
             // 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);
+            const isStubFileOrHasInit = this.isStubFileOrHasInit(this.moduleSymbolMap, filePath);
+            this.processModuleSymbolTable(topLevelSymbols, 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);
+    addImportsFromImportAliasMap(importAliasMap, abbrFromUsers, results, token) {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+        importAliasMap.forEach((mapPerSymbolName) => {
+            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({ name: importAliasData.importParts.symbolName, alias: abbrFromUsers }, {
+                    name: (_a = importAliasData.importParts.importFrom) !== null && _a !== void 0 ? _a : importAliasData.importParts.importName,
+                }, 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.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, moduleFilePath, word, similarityLimit, isStubOrHasInit, abbrFromUsers, importAliasMap, results, token) {
+    processModuleSymbolTable(topLevelSymbols, moduleFilePath, word, similarityLimit, isStubOrHasInit, abbrFromUsers, importAliasMap, results, token) {
         (0, cancellationUtils_1.throwIfCancellationRequested)(token);
         const [importSource, importGroup, moduleNameAndType] = this._getImportPartsForSymbols(moduleFilePath);
         if (!importSource) {
@@ -199,7 +182,6 @@ class AutoImporter {
         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;
             }
@@ -232,9 +214,7 @@ class AutoImporter {
                 }, importAliasMap);
                 return;
             }
-            const nameForImportFrom = this._options.importFormat === "relative" /* Relative */ && !library
-                ? (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._filePath, moduleFilePath)
-                : undefined;
+            const nameForImportFrom = this.getNameForImportFrom(library, moduleFilePath);
             const autoImportTextEdits = this._getTextEditsForAutoImportByFilePath({ name, alias: abbrFromUsers }, { name: importSource, nameForImportFrom }, name, importGroup, moduleFilePath);
             this._addResult(results, {
                 name,
@@ -271,6 +251,17 @@ class AutoImporter {
             itemKind: vscode_languageserver_1.CompletionItemKind.Module,
         }, { importParts, importGroup, kind: vscode_languageserver_1.SymbolKind.Module, itemKind: vscode_languageserver_1.CompletionItemKind.Module }, importAliasMap);
     }
+    getNameForImportFrom(library, moduleFilePath) {
+        return undefined;
+    }
+    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 };
+    }
     _shouldIncludeVariable(autoImportSymbol, name, isStub, library) {
         var _a;
         // If it is not a stub file and symbol is Variable, we only include it if
@@ -278,63 +269,11 @@ class AutoImporter {
         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())) {
+        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({ name: importAliasData.importParts.symbolName, alias: abbrFromUsers }, {
-                    name: (_a = importAliasData.importParts.importFrom) !== null && _a !== void 0 ? _a : importAliasData.importParts.importName,
-                }, 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
@@ -430,14 +369,14 @@ class AutoImporter {
         if (word.length <= 0 || name.length <= 0) {
             return false;
         }
-        if (!this._options.patternMatcher) {
+        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);
+        return this.options.patternMatcher(word, name);
     }
     _shouldExclude(name) {
         return this._excludes.has(name, completionProvider_1.CompletionMap.labelOnlyIgnoringAutoImports);
@@ -456,7 +395,7 @@ class AutoImporter {
     // convert to a module name that can be used in an
     // 'import from' statement.
     _getModuleNameAndTypeFromFilePath(filePath) {
-        return this._importResolver.getModuleNameForImport(filePath, this._execEnvironment);
+        return this.importResolver.getModuleNameForImport(filePath, this.execEnvironment);
     }
     _getTextEditsForAutoImportByFilePath(importNameInfo, moduleNameInfo, insertionText, importGroup, filePath) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
@@ -506,9 +445,9 @@ class AutoImporter {
                 if (moduleNameInfo.name === importStatement.moduleName) {
                     return {
                         insertionText: (_d = importNameInfo.alias) !== null && _d !== void 0 ? _d : insertionText,
-                        edits: this._options.lazyEdit
+                        edits: this.options.lazyEdit
                             ? undefined
-                            : (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)(importNameInfo, importStatement, this._parseResults),
+                            : (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)(importNameInfo, importStatement, this.parseResults),
                     };
                 }
             }
@@ -534,9 +473,9 @@ class AutoImporter {
                     // If not, add what we want at the existing import from statement.
                     return {
                         insertionText: (_f = importNameInfo.alias) !== null && _f !== void 0 ? _f : insertionText,
-                        edits: this._options.lazyEdit
+                        edits: this.options.lazyEdit
                             ? undefined
-                            : (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)(importNameInfo, imported, this._parseResults),
+                            : (0, importStatementUtils_1.getTextEditsForAutoImportSymbolAddition)(importNameInfo, imported, this.parseResults),
                     };
                 }
             }
@@ -554,19 +493,11 @@ class AutoImporter {
         }
         return {
             insertionText: (_j = importNameInfo.alias) !== null && _j !== void 0 ? _j : insertionText,
-            edits: this._options.lazyEdit
+            edits: this.options.lazyEdit
                 ? undefined
-                : (0, importStatementUtils_1.getTextEditsForAutoImportInsertion)(importNameInfo, moduleNameInfo, this._importStatements, importGroup, this._parseResults, this._invocationPosition),
+                : (0, importStatementUtils_1.getTextEditsForAutoImportInsertion)(importNameInfo, moduleNameInfo, this._importStatements, 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) {
@@ -577,22 +508,6 @@ class AutoImporter {
     }
 }
 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: