@zzzen/pyright-internal 1.1.254

package/dist/analyzer/program.js

@@ -0,0 +1,1902 @@
+"use strict";
+/*
+ * program.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * An object that tracks all of the source files being analyzed
+ * and all of their recursive imports.
+ */
+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.Program = exports.MaxWorkspaceIndexFileCount = void 0;
+const v8_1 = require("v8");
+const vscode_languageserver_1 = require("vscode-languageserver");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const collectionUtils_1 = require("../common/collectionUtils");
+const console_1 = require("../common/console");
+const debug_1 = require("../common/debug");
+const logTracker_1 = require("../common/logTracker");
+const pathUtils_1 = require("../common/pathUtils");
+const positionUtils_1 = require("../common/positionUtils");
+const stringUtils_1 = require("../common/stringUtils");
+const textRange_1 = require("../common/textRange");
+const timing_1 = require("../common/timing");
+const autoImporter_1 = require("../languageService/autoImporter");
+const callHierarchyProvider_1 = require("../languageService/callHierarchyProvider");
+const completionProvider_1 = require("../languageService/completionProvider");
+const documentSymbolCollector_1 = require("../languageService/documentSymbolCollector");
+const referencesProvider_1 = require("../languageService/referencesProvider");
+const renameModuleProvider_1 = require("../languageService/renameModuleProvider");
+const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const circularDependency_1 = require("./circularDependency");
+const parseTreeUtils_1 = require("./parseTreeUtils");
+const scopeUtils_1 = require("./scopeUtils");
+const sourceFile_1 = require("./sourceFile");
+const sourceMapper_1 = require("./sourceMapper");
+const symbolNameUtils_1 = require("./symbolNameUtils");
+const tracePrinter_1 = require("./tracePrinter");
+const typeEvaluatorWithTracker_1 = require("./typeEvaluatorWithTracker");
+const typeStubWriter_1 = require("./typeStubWriter");
+const _maxImportDepth = 256;
+exports.MaxWorkspaceIndexFileCount = 2000;
+// Container for all of the files that are being analyzed. Files
+// can fall into one or more of the following categories:
+//  Tracked - specified by the config options
+//  Referenced - part of the transitive closure
+//  Opened - temporarily opened in the editor
+//  Shadowed - implementation file that shadows a type stub file
+class Program {
+    constructor(initialImportResolver, initialConfigOptions, console, _extension, logTracker, _disableChecker) {
+        this._extension = _extension;
+        this._disableChecker = _disableChecker;
+        this._sourceFileList = [];
+        this._sourceFileMap = new Map();
+        this._parsedFileCount = 0;
+        this._lookUpImport = (filePathOrModule) => {
+            var _a;
+            let sourceFileInfo;
+            if (typeof filePathOrModule === 'string') {
+                sourceFileInfo = this._getSourceFileInfoFromPath(filePathOrModule);
+            }
+            else {
+                // Resolve the import.
+                const importResult = this._importResolver.resolveImport(filePathOrModule.importingFilePath, this._configOptions.findExecEnvironment(filePathOrModule.importingFilePath), {
+                    leadingDots: 0,
+                    nameParts: filePathOrModule.nameParts,
+                    importedSymbols: undefined,
+                });
+                if (importResult.isImportFound && !importResult.isNativeLib && importResult.resolvedPaths.length > 0) {
+                    let resolvedPath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+                    if (resolvedPath) {
+                        // See if the source file already exists in the program.
+                        sourceFileInfo = this._getSourceFileInfoFromPath(resolvedPath);
+                        if (!sourceFileInfo) {
+                            resolvedPath = (0, pathUtils_1.normalizePathCase)(this._fs, resolvedPath);
+                            // Start tracking the source file.
+                            this.addTrackedFile(resolvedPath);
+                            sourceFileInfo = this._getSourceFileInfoFromPath(resolvedPath);
+                        }
+                    }
+                }
+            }
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            if (sourceFileInfo.sourceFile.isBindingRequired()) {
+                // Bind the file if it's not already bound. Don't count this time
+                // against the type checker.
+                timing_1.timingStats.typeCheckerTime.subtractFromTime(() => {
+                    this._bindFile(sourceFileInfo);
+                });
+            }
+            const symbolTable = sourceFileInfo.sourceFile.getModuleSymbolTable();
+            if (!symbolTable) {
+                return undefined;
+            }
+            const parseResults = sourceFileInfo.sourceFile.getParseResults();
+            const moduleNode = parseResults.parseTree;
+            const dunderAllInfo = AnalyzerNodeInfo.getDunderAllInfo(parseResults.parseTree);
+            return {
+                symbolTable,
+                dunderAllNames: dunderAllInfo === null || dunderAllInfo === void 0 ? void 0 : dunderAllInfo.names,
+                usesUnsupportedDunderAllForm: (_a = dunderAllInfo === null || dunderAllInfo === void 0 ? void 0 : dunderAllInfo.usesUnsupportedDunderAllForm) !== null && _a !== void 0 ? _a : false,
+                get docString() {
+                    return (0, parseTreeUtils_1.getDocString)(moduleNode.statements);
+                },
+            };
+        };
+        this._console = console || new console_1.StandardConsole();
+        this._logTracker = logTracker !== null && logTracker !== void 0 ? logTracker : new logTracker_1.LogTracker(console, 'FG');
+        this._importResolver = initialImportResolver;
+        this._configOptions = initialConfigOptions;
+        this._createNewEvaluator();
+    }
+    get evaluator() {
+        return this._evaluator;
+    }
+    setConfigOptions(configOptions) {
+        this._configOptions = configOptions;
+        // Create a new evaluator with the updated config options.
+        this._createNewEvaluator();
+    }
+    setImportResolver(importResolver) {
+        this._importResolver = importResolver;
+        // Create a new evaluator with the updated import resolver.
+        // Otherwise, lookup import passed to type evaluator might use
+        // older import resolver when resolving imports after parsing.
+        this._createNewEvaluator();
+    }
+    // Sets the list of tracked files that make up the program.
+    setTrackedFiles(filePaths) {
+        if (this._sourceFileList.length > 0) {
+            // We need to determine which files to remove from the existing file list.
+            const newFileMap = new Map();
+            filePaths.forEach((path) => {
+                newFileMap.set((0, pathUtils_1.normalizePathCase)(this._fs, path), path);
+            });
+            // Files that are not in the tracked file list are
+            // marked as no longer tracked.
+            this._sourceFileList.forEach((oldFile) => {
+                const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, oldFile.sourceFile.getFilePath());
+                if (!newFileMap.has(filePath)) {
+                    oldFile.isTracked = false;
+                }
+            });
+        }
+        // Add the new files. Only the new items will be added.
+        this.addTrackedFiles(filePaths);
+        return this._removeUnneededFiles();
+    }
+    // Allows a caller to set a callback that is called right before
+    // a source file is type checked. It is intended for testing only.
+    setPreCheckCallback(preCheckCallback) {
+        this._preCheckCallback = preCheckCallback;
+    }
+    // By default, no third-party imports are allowed. This enables
+    // third-party imports for a specified import and its children.
+    // For example, if importNames is ['tensorflow'], then third-party
+    // (absolute) imports are allowed for 'import tensorflow',
+    // 'import tensorflow.optimizers', etc.
+    setAllowedThirdPartyImports(importNames) {
+        this._allowedThirdPartyImports = importNames;
+    }
+    addTrackedFiles(filePaths, isThirdPartyImport = false, isInPyTypedPackage = false) {
+        filePaths.forEach((filePath) => {
+            this.addTrackedFile(filePath, isThirdPartyImport, isInPyTypedPackage);
+        });
+    }
+    addTrackedFile(filePath, isThirdPartyImport = false, isInPyTypedPackage = false) {
+        let sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (sourceFileInfo) {
+            sourceFileInfo.isTracked = true;
+            return sourceFileInfo.sourceFile;
+        }
+        const importName = this._getImportNameForFile(filePath);
+        const sourceFile = new sourceFile_1.SourceFile(this._fs, filePath, importName, isThirdPartyImport, isInPyTypedPackage, this._console, this._logTracker);
+        sourceFileInfo = {
+            sourceFile,
+            isTracked: true,
+            isOpenByClient: false,
+            isTypeshedFile: false,
+            isThirdPartyImport,
+            isThirdPartyPyTypedPresent: isInPyTypedPackage,
+            diagnosticsVersion: undefined,
+            imports: [],
+            importedBy: [],
+            shadows: [],
+            shadowedBy: [],
+        };
+        this._addToSourceFileListAndMap(sourceFileInfo);
+        return sourceFile;
+    }
+    setFileOpened(filePath, version, contents, options) {
+        var _a, _b;
+        let sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            const importName = this._getImportNameForFile(filePath);
+            const sourceFile = new sourceFile_1.SourceFile(this._fs, filePath, importName, 
+            /* isThirdPartyImport */ false, 
+            /* isInPyTypedPackage */ false, this._console, this._logTracker, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : false);
+            const chainedFilePath = options === null || options === void 0 ? void 0 : options.chainedFilePath;
+            sourceFileInfo = {
+                sourceFile,
+                isTracked: (_b = options === null || options === void 0 ? void 0 : options.isTracked) !== null && _b !== void 0 ? _b : false,
+                chainedSourceFile: chainedFilePath ? this._getSourceFileInfoFromPath(chainedFilePath) : undefined,
+                isOpenByClient: true,
+                isTypeshedFile: false,
+                isThirdPartyImport: false,
+                isThirdPartyPyTypedPresent: false,
+                diagnosticsVersion: undefined,
+                imports: [],
+                importedBy: [],
+                shadows: [],
+                shadowedBy: [],
+            };
+            this._addToSourceFileListAndMap(sourceFileInfo);
+        }
+        else {
+            sourceFileInfo.isOpenByClient = true;
+            // Reset the diagnostic version so we force an update to the
+            // diagnostics, which can change based on whether the file is open.
+            // We do not set the version to undefined here because that implies
+            // there are no diagnostics currently reported for this file.
+            sourceFileInfo.diagnosticsVersion = 0;
+        }
+        sourceFileInfo.sourceFile.setClientVersion(version, contents);
+    }
+    updateChainedFilePath(filePath, chainedFilePath) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (sourceFileInfo) {
+            sourceFileInfo.chainedSourceFile = chainedFilePath
+                ? this._getSourceFileInfoFromPath(chainedFilePath)
+                : undefined;
+            sourceFileInfo.sourceFile.markDirty();
+            this._markFileDirtyRecursive(sourceFileInfo, new Map());
+        }
+    }
+    setFileClosed(filePath) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (sourceFileInfo) {
+            sourceFileInfo.isOpenByClient = false;
+            sourceFileInfo.sourceFile.setClientVersion(null, []);
+            // There is no guarantee that content is saved before the file is closed.
+            // We need to mark the file dirty so we can re-analyze next time.
+            // This won't matter much for OpenFileOnly users, but it will matter for
+            // people who use diagnosticMode Workspace.
+            if (sourceFileInfo.sourceFile.didContentsChangeOnDisk()) {
+                sourceFileInfo.sourceFile.markDirty();
+                this._markFileDirtyRecursive(sourceFileInfo, new Map());
+            }
+        }
+        return this._removeUnneededFiles();
+    }
+    markAllFilesDirty(evenIfContentsAreSame, indexingNeeded = true) {
+        const markDirtyMap = new Map();
+        this._sourceFileList.forEach((sourceFileInfo) => {
+            if (evenIfContentsAreSame) {
+                sourceFileInfo.sourceFile.markDirty(indexingNeeded);
+            }
+            else if (sourceFileInfo.sourceFile.didContentsChangeOnDisk()) {
+                sourceFileInfo.sourceFile.markDirty(indexingNeeded);
+                // Mark any files that depend on this file as dirty
+                // also. This will retrigger analysis of these other files.
+                this._markFileDirtyRecursive(sourceFileInfo, markDirtyMap);
+            }
+        });
+        if (markDirtyMap.size > 0) {
+            this._createNewEvaluator();
+        }
+    }
+    markFilesDirty(filePaths, evenIfContentsAreSame, indexingNeeded = true) {
+        const markDirtyMap = new Map();
+        filePaths.forEach((filePath) => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (sourceFileInfo) {
+                const fileName = (0, pathUtils_1.getFileName)(filePath);
+                // Handle builtins and __builtins__ specially. They are implicitly
+                // included by all source files.
+                if (fileName === 'builtins.pyi' || fileName === '__builtins__.pyi') {
+                    this.markAllFilesDirty(evenIfContentsAreSame, indexingNeeded);
+                    return;
+                }
+                // If !evenIfContentsAreSame, see if the on-disk contents have
+                // changed. If the file is open, the on-disk contents don't matter
+                // because we'll receive updates directly from the client.
+                if (evenIfContentsAreSame ||
+                    (!sourceFileInfo.isOpenByClient && sourceFileInfo.sourceFile.didContentsChangeOnDisk())) {
+                    sourceFileInfo.sourceFile.markDirty(indexingNeeded);
+                    // Mark any files that depend on this file as dirty
+                    // also. This will retrigger analysis of these other files.
+                    this._markFileDirtyRecursive(sourceFileInfo, markDirtyMap);
+                }
+            }
+        });
+        if (markDirtyMap.size > 0) {
+            this._createNewEvaluator();
+        }
+    }
+    getFileCount() {
+        return this._sourceFileList.length;
+    }
+    // Returns the number of files that are considered "user" files and therefore
+    // are checked.
+    getUserFileCount() {
+        return this._sourceFileList.filter((s) => this._isUserCode(s)).length;
+    }
+    getTracked() {
+        return this._sourceFileList.filter((s) => s.isTracked);
+    }
+    getOpened() {
+        return this._sourceFileList.filter((s) => s.isOpenByClient);
+    }
+    getFilesToAnalyzeCount() {
+        let sourceFileCount = 0;
+        if (this._disableChecker) {
+            return sourceFileCount;
+        }
+        this._sourceFileList.forEach((fileInfo) => {
+            if (fileInfo.sourceFile.isCheckingRequired()) {
+                if (this._shouldCheckFile(fileInfo)) {
+                    sourceFileCount++;
+                }
+            }
+        });
+        return sourceFileCount;
+    }
+    isCheckingOnlyOpenFiles() {
+        return this._configOptions.checkOnlyOpenFiles || false;
+    }
+    containsSourceFileIn(folder) {
+        const normalized = (0, pathUtils_1.normalizePathCase)(this._fs, folder);
+        return this._sourceFileList.some((i) => i.sourceFile.getFilePath().startsWith(normalized));
+    }
+    getSourceFile(filePath) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        return sourceFileInfo.sourceFile;
+    }
+    getBoundSourceFile(filePath) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        this._bindFile(sourceFileInfo);
+        return this.getSourceFile(filePath);
+    }
+    // Performs parsing and analysis of any source files in the program
+    // that require it. If a limit time is specified, the operation
+    // is interrupted when the time expires. The return value indicates
+    // whether the method needs to be called again to complete the
+    // analysis. In interactive mode, the timeout is always limited
+    // to the smaller value to maintain responsiveness.
+    analyze(maxTime, token = vscode_languageserver_1.CancellationToken.None) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const elapsedTime = new timing_1.Duration();
+            const openFiles = this._sourceFileList.filter((sf) => sf.isOpenByClient && sf.sourceFile.isCheckingRequired());
+            if (openFiles.length > 0) {
+                const effectiveMaxTime = maxTime ? maxTime.openFilesTimeInMs : Number.MAX_VALUE;
+                // Check the open files.
+                for (const sourceFileInfo of openFiles) {
+                    if (this._checkTypes(sourceFileInfo)) {
+                        if (elapsedTime.getDurationInMilliseconds() > effectiveMaxTime) {
+                            return true;
+                        }
+                    }
+                }
+                // If the caller specified a maxTime, return at this point
+                // since we've finalized all open files. We want to get
+                // the results to the user as quickly as possible.
+                if (maxTime !== undefined) {
+                    return true;
+                }
+            }
+            if (!this._configOptions.checkOnlyOpenFiles) {
+                const effectiveMaxTime = maxTime ? maxTime.noOpenFilesTimeInMs : Number.MAX_VALUE;
+                // Now do type parsing and analysis of the remaining.
+                for (const sourceFileInfo of this._sourceFileList) {
+                    if (!this._isUserCode(sourceFileInfo)) {
+                        continue;
+                    }
+                    if (this._checkTypes(sourceFileInfo)) {
+                        if (elapsedTime.getDurationInMilliseconds() > effectiveMaxTime) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        });
+    }
+    indexWorkspace(callback, token) {
+        if (!this._configOptions.indexing) {
+            return 0;
+        }
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            // Go through all workspace files to create indexing data.
+            // This will cause all files in the workspace to be parsed and bound. But
+            // _handleMemoryHighUsage will make sure we don't OOM and
+            // at the end of this method, we will drop all trees and symbol tables
+            // created due to indexing.
+            const initiallyParsedSet = new Set();
+            for (const sourceFileInfo of this._sourceFileList) {
+                if (!sourceFileInfo.sourceFile.isParseRequired()) {
+                    initiallyParsedSet.add(sourceFileInfo);
+                }
+            }
+            let count = 0;
+            for (const sourceFileInfo of this._sourceFileList) {
+                if (!this._isUserCode(sourceFileInfo) || !sourceFileInfo.sourceFile.isIndexingRequired()) {
+                    continue;
+                }
+                this._bindFile(sourceFileInfo);
+                const results = sourceFileInfo.sourceFile.index({ indexingForAutoImportMode: false }, token);
+                if (results) {
+                    if (++count > exports.MaxWorkspaceIndexFileCount) {
+                        this._console.warn(`Workspace indexing has hit its upper limit: 2000 files`);
+                        dropParseAndBindInfoCreatedForIndexing(this._sourceFileList, initiallyParsedSet);
+                        return count;
+                    }
+                    callback(sourceFileInfo.sourceFile.getFilePath(), results);
+                }
+                this._handleMemoryHighUsage();
+            }
+            dropParseAndBindInfoCreatedForIndexing(this._sourceFileList, initiallyParsedSet);
+            return count;
+        });
+        function dropParseAndBindInfoCreatedForIndexing(sourceFiles, initiallyParsedSet) {
+            for (const sourceFileInfo of sourceFiles) {
+                if (sourceFileInfo.sourceFile.isParseRequired() || initiallyParsedSet.has(sourceFileInfo)) {
+                    continue;
+                }
+                // Drop parse and bind info created during indexing.
+                sourceFileInfo.sourceFile.dropParseAndBindInfo();
+            }
+        }
+    }
+    // Prints a detailed list of files that have been checked and the times associated
+    // with each of them, sorted greatest to least.
+    printDetailedAnalysisTimes() {
+        const sortedFiles = this._sourceFileList
+            .filter((s) => s.sourceFile.getCheckTime() !== undefined)
+            .sort((a, b) => {
+            return b.sourceFile.getCheckTime() - a.sourceFile.getCheckTime();
+        });
+        this._console.info('');
+        this._console.info('Analysis time by file');
+        sortedFiles.forEach((sfInfo) => {
+            const checkTimeInMs = sfInfo.sourceFile.getCheckTime();
+            this._console.info(`${checkTimeInMs}ms: ${sfInfo.sourceFile.getFilePath()}`);
+        });
+    }
+    // Prints import dependency information for each of the files in
+    // the program, skipping any typeshed files.
+    printDependencies(projectRootDir, verbose) {
+        const fs = this._importResolver.fileSystem;
+        const sortedFiles = this._sourceFileList
+            .filter((s) => !s.isTypeshedFile)
+            .sort((a, b) => {
+            return fs.getOriginalFilePath(a.sourceFile.getFilePath()) <
+                fs.getOriginalFilePath(b.sourceFile.getFilePath())
+                ? 1
+                : -1;
+        });
+        const zeroImportFiles = [];
+        sortedFiles.forEach((sfInfo) => {
+            this._console.info('');
+            let filePath = fs.getOriginalFilePath(sfInfo.sourceFile.getFilePath());
+            const relPath = (0, pathUtils_1.getRelativePath)(filePath, projectRootDir);
+            if (relPath) {
+                filePath = relPath;
+            }
+            this._console.info(`${filePath}`);
+            this._console.info(` Imports     ${sfInfo.imports.length} ` + `file${sfInfo.imports.length === 1 ? '' : 's'}`);
+            if (verbose) {
+                sfInfo.imports.forEach((importInfo) => {
+                    this._console.info(`    ${fs.getOriginalFilePath(importInfo.sourceFile.getFilePath())}`);
+                });
+            }
+            this._console.info(` Imported by ${sfInfo.importedBy.length} ` + `file${sfInfo.importedBy.length === 1 ? '' : 's'}`);
+            if (verbose) {
+                sfInfo.importedBy.forEach((importInfo) => {
+                    this._console.info(`    ${fs.getOriginalFilePath(importInfo.sourceFile.getFilePath())}`);
+                });
+            }
+            if (sfInfo.importedBy.length === 0) {
+                zeroImportFiles.push(sfInfo.sourceFile);
+            }
+        });
+        if (zeroImportFiles.length > 0) {
+            this._console.info('');
+            this._console.info(`${zeroImportFiles.length} file${zeroImportFiles.length === 1 ? '' : 's'}` + ` not explicitly imported`);
+            zeroImportFiles.forEach((importFile) => {
+                this._console.info(`    ${fs.getOriginalFilePath(importFile.getFilePath())}`);
+            });
+        }
+    }
+    writeTypeStub(targetImportPath, targetIsSingleFile, stubPath, token) {
+        for (const sourceFileInfo of this._sourceFileList) {
+            (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+            const filePath = sourceFileInfo.sourceFile.getFilePath();
+            // Generate type stubs only for the files within the target path,
+            // not any files that the target module happened to import.
+            const relativePath = (0, pathUtils_1.getRelativePath)(filePath, targetImportPath);
+            if (relativePath !== undefined) {
+                let typeStubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(stubPath, relativePath));
+                // If the target is a single file implementation, as opposed to
+                // a package in a directory, transform the name of the type stub
+                // to __init__.pyi because we're placing it in a directory.
+                if (targetIsSingleFile) {
+                    typeStubPath = (0, pathUtils_1.combinePaths)((0, pathUtils_1.getDirectoryPath)(typeStubPath), '__init__.pyi');
+                }
+                else {
+                    typeStubPath = (0, pathUtils_1.stripFileExtension)(typeStubPath) + '.pyi';
+                }
+                const typeStubDir = (0, pathUtils_1.getDirectoryPath)(typeStubPath);
+                try {
+                    (0, pathUtils_1.makeDirectories)(this._fs, typeStubDir, stubPath);
+                }
+                catch (e) {
+                    const errMsg = `Could not create directory for '${typeStubDir}'`;
+                    throw new Error(errMsg);
+                }
+                this._bindFile(sourceFileInfo);
+                this._runEvaluatorWithCancellationToken(token, () => {
+                    const writer = new typeStubWriter_1.TypeStubWriter(typeStubPath, sourceFileInfo.sourceFile, this._evaluator);
+                    writer.write();
+                });
+                // This operation can consume significant memory, so check
+                // for situations where we need to discard the type cache.
+                this._handleMemoryHighUsage();
+            }
+        }
+    }
+    getTypeOfSymbol(symbol) {
+        this._handleMemoryHighUsage();
+        const evaluator = this._evaluator || this._createNewEvaluator();
+        return evaluator.getEffectiveTypeOfSymbol(symbol);
+    }
+    printType(type, expandTypeAlias) {
+        this._handleMemoryHighUsage();
+        const evaluator = this._evaluator || this._createNewEvaluator();
+        return evaluator.printType(type, expandTypeAlias);
+    }
+    static _getPrintTypeFlags(configOptions) {
+        let flags = 0 /* None */;
+        if (configOptions.diagnosticRuleSet.printUnknownAsAny) {
+            flags |= 1 /* PrintUnknownWithAny */;
+        }
+        if (configOptions.diagnosticRuleSet.omitConditionalConstraint) {
+            flags |= 64 /* OmitConditionalConstraint */;
+        }
+        if (configOptions.diagnosticRuleSet.omitTypeArgsIfAny) {
+            flags |= 2 /* OmitTypeArgumentsIfAny */;
+        }
+        if (configOptions.diagnosticRuleSet.omitUnannotatedParamType) {
+            flags |= 4 /* OmitUnannotatedParamType */;
+        }
+        if (configOptions.diagnosticRuleSet.pep604Printing) {
+            flags |= 8 /* PEP604 */;
+        }
+        return flags;
+    }
+    get _fs() {
+        return this._importResolver.fileSystem;
+    }
+    _getImportNameForFile(filePath) {
+        const moduleNameAndType = this._importResolver.getModuleNameForImport(filePath, this._configOptions.getDefaultExecEnvironment());
+        return moduleNameAndType.moduleName;
+    }
+    // A "shadowed" file is a python source file that has been added to the program because
+    // it "shadows" a type stub file for purposes of finding doc strings and definitions.
+    // We need to track the relationship so if the original type stub is removed from the
+    // program, we can remove the corresponding shadowed file and any files it imports.
+    _addShadowedFile(stubFile, shadowImplPath) {
+        let shadowFileInfo = this._getSourceFileInfoFromPath(shadowImplPath);
+        if (!shadowFileInfo) {
+            const importName = this._getImportNameForFile(shadowImplPath);
+            const sourceFile = new sourceFile_1.SourceFile(this._fs, shadowImplPath, importName, 
+            /* isThirdPartyImport */ false, 
+            /* isInPyTypedPackage */ false, this._console, this._logTracker);
+            shadowFileInfo = {
+                sourceFile,
+                isTracked: false,
+                isOpenByClient: false,
+                isTypeshedFile: false,
+                isThirdPartyImport: false,
+                isThirdPartyPyTypedPresent: false,
+                diagnosticsVersion: undefined,
+                imports: [],
+                importedBy: [],
+                shadows: [],
+                shadowedBy: [],
+            };
+            this._addToSourceFileListAndMap(shadowFileInfo);
+        }
+        if (!shadowFileInfo.shadows.includes(stubFile)) {
+            shadowFileInfo.shadows.push(stubFile);
+        }
+        if (!stubFile.shadowedBy.includes(shadowFileInfo)) {
+            stubFile.shadowedBy.push(shadowFileInfo);
+        }
+        return shadowFileInfo.sourceFile;
+    }
+    _createNewEvaluator() {
+        if (this._evaluator) {
+            // We shouldn't need to call this, but there appears to be a bug
+            // in the v8 garbage collector where it's unable to resolve orphaned
+            // objects without us giving it some assistance.
+            this._evaluator.disposeEvaluator();
+        }
+        this._evaluator = (0, typeEvaluatorWithTracker_1.createTypeEvaluatorWithTracker)(this._lookUpImport, {
+            printTypeFlags: Program._getPrintTypeFlags(this._configOptions),
+            logCalls: this._configOptions.logTypeEvaluationTime,
+            minimumLoggingThreshold: this._configOptions.typeEvaluationTimeThreshold,
+            analyzeUnannotatedFunctions: this._configOptions.analyzeUnannotatedFunctions,
+            evaluateUnknownImportsAsAny: !!this._configOptions.evaluateUnknownImportsAsAny,
+            verifyTypeCacheEvaluatorFlags: !!this._configOptions.internalTestMode,
+        }, this._logTracker, this._configOptions.logTypeEvaluationTime
+            ? (0, tracePrinter_1.createTracePrinter)(this._importResolver.getImportRoots(this._configOptions.findExecEnvironment(this._configOptions.projectRoot)))
+            : undefined);
+        return this._evaluator;
+    }
+    _parseFile(fileToParse, content) {
+        if (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired()) {
+            return;
+        }
+        if (fileToParse.sourceFile.parse(this._configOptions, this._importResolver, content)) {
+            this._parsedFileCount++;
+            this._updateSourceFileImports(fileToParse, this._configOptions);
+        }
+        if (fileToParse.sourceFile.isFileDeleted()) {
+            fileToParse.isTracked = false;
+            // Mark any files that depend on this file as dirty
+            // also. This will retrigger analysis of these other files.
+            const markDirtyMap = new Map();
+            this._markFileDirtyRecursive(fileToParse, markDirtyMap);
+            // Invalidate the import resolver's cache as well.
+            this._importResolver.invalidateCache();
+        }
+    }
+    // Binds the specified file and all of its dependencies, recursively. If
+    // it runs out of time, it returns true. If it completes, it returns false.
+    _bindFile(fileToAnalyze, content) {
+        var _a, _b;
+        if (!this._isFileNeeded(fileToAnalyze) || !fileToAnalyze.sourceFile.isBindingRequired()) {
+            return;
+        }
+        this._parseFile(fileToAnalyze, content);
+        const getScopeIfAvailable = (fileInfo) => {
+            if (!fileInfo || fileInfo === fileToAnalyze) {
+                return undefined;
+            }
+            this._bindFile(fileInfo);
+            if (fileInfo.sourceFile.isFileDeleted()) {
+                return undefined;
+            }
+            const parseResults = fileInfo.sourceFile.getParseResults();
+            if (!parseResults) {
+                return undefined;
+            }
+            const scope = AnalyzerNodeInfo.getScope(parseResults.parseTree);
+            (0, debug_1.assert)(scope !== undefined);
+            return scope;
+        };
+        let builtinsScope;
+        if (fileToAnalyze.builtinsImport && fileToAnalyze.builtinsImport !== fileToAnalyze) {
+            // If it is not builtin module itself, we need to parse and bind
+            // the ipython display import if required. Otherwise, get builtin module.
+            builtinsScope =
+                (_b = (_a = getScopeIfAvailable(fileToAnalyze.chainedSourceFile)) !== null && _a !== void 0 ? _a : getScopeIfAvailable(fileToAnalyze.ipythonDisplayImport)) !== null && _b !== void 0 ? _b : getScopeIfAvailable(fileToAnalyze.builtinsImport);
+        }
+        fileToAnalyze.sourceFile.bind(this._configOptions, this._lookUpImport, builtinsScope);
+    }
+    // Build a map of all modules within this program and the module-
+    // level scope that contains the symbol table for the module.
+    _buildModuleSymbolsMap(sourceFileToExclude, userFileOnly, includeIndexUserSymbols, token) {
+        // If we have library map, always use the map for library symbols.
+        return (0, autoImporter_1.buildModuleSymbolsMap)(this._sourceFileList.filter((s) => s !== sourceFileToExclude && (userFileOnly ? this._isUserCode(s) : true)), includeIndexUserSymbols, token);
+    }
+    _shouldCheckFile(fileInfo) {
+        // Always do a full checking for a file that's open in the editor.
+        if (fileInfo.isOpenByClient) {
+            return true;
+        }
+        // If the file isn't currently open, only perform full checking for
+        // files that are tracked, and only if the checkOnlyOpenFiles is disabled.
+        if (!this._configOptions.checkOnlyOpenFiles && fileInfo.isTracked) {
+            return true;
+        }
+        return false;
+    }
+    _checkTypes(fileToCheck) {
+        return this._logTracker.log(`analyzing: ${fileToCheck.sourceFile.getFilePath()}`, (logState) => {
+            // If the file isn't needed because it was eliminated from the
+            // transitive closure or deleted, skip the file rather than wasting
+            // time on it.
+            if (!this._isFileNeeded(fileToCheck)) {
+                logState.suppress();
+                return false;
+            }
+            if (!fileToCheck.sourceFile.isCheckingRequired()) {
+                logState.suppress();
+                return false;
+            }
+            if (!this._shouldCheckFile(fileToCheck)) {
+                logState.suppress();
+                return false;
+            }
+            this._bindFile(fileToCheck);
+            if (this._preCheckCallback) {
+                const parseResults = fileToCheck.sourceFile.getParseResults();
+                if (parseResults) {
+                    this._preCheckCallback(parseResults, this._evaluator);
+                }
+            }
+            if (!this._disableChecker) {
+                fileToCheck.sourceFile.check(this._importResolver, this._evaluator);
+            }
+            // For very large programs, we may need to discard the evaluator and
+            // its cached types to avoid running out of heap space.
+            this._handleMemoryHighUsage();
+            // Detect import cycles that involve the file.
+            if (this._configOptions.diagnosticRuleSet.reportImportCycles !== 'none') {
+                // Don't detect import cycles when doing type stub generation. Some
+                // third-party modules are pretty convoluted.
+                if (!this._allowedThirdPartyImports) {
+                    // We need to force all of the files to be parsed and build
+                    // a closure map for the files.
+                    const closureMap = new Map();
+                    this._getImportsRecursive(fileToCheck, closureMap, 0);
+                    closureMap.forEach((file) => {
+                        timing_1.timingStats.cycleDetectionTime.timeOperation(() => {
+                            const filesVisitedMap = new Map();
+                            if (!this._detectAndReportImportCycles(file, filesVisitedMap)) {
+                                // If no cycles were reported, set a flag in all of the visited files
+                                // so we don't need to visit them again on subsequent cycle checks.
+                                filesVisitedMap.forEach((sourceFileInfo) => {
+                                    sourceFileInfo.sourceFile.setNoCircularDependencyConfirmed();
+                                });
+                            }
+                        });
+                    });
+                }
+            }
+            return true;
+        });
+    }
+    // Builds a map of files that includes the specified file and all of the files
+    // it imports (recursively) and ensures that all such files. If any of these files
+    // have already been checked (they and their recursive imports have completed the
+    // check phase), they are not included in the results.
+    _getImportsRecursive(file, closureMap, recursionCount) {
+        // If the file is already in the closure map, we found a cyclical
+        // dependency. Don't recur further.
+        const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, file.sourceFile.getFilePath());
+        if (closureMap.has(filePath)) {
+            return;
+        }
+        // If the import chain is too long, emit an error. Otherwise we
+        // risk blowing the stack.
+        if (recursionCount > _maxImportDepth) {
+            file.sourceFile.setHitMaxImportDepth(_maxImportDepth);
+            return;
+        }
+        // Add the file to the closure map.
+        closureMap.set(filePath, file);
+        // Recursively add the file's imports.
+        for (const importedFileInfo of file.imports) {
+            this._getImportsRecursive(importedFileInfo, closureMap, recursionCount + 1);
+        }
+    }
+    _detectAndReportImportCycles(sourceFileInfo, filesVisited, dependencyChain = [], dependencyMap = new Map()) {
+        // Don't bother checking for typestub files or third-party files.
+        if (sourceFileInfo.sourceFile.isStubFile() || sourceFileInfo.isThirdPartyImport) {
+            return false;
+        }
+        // If we've already confirmed that this source file isn't part of a
+        // cycle, we can skip it entirely.
+        if (sourceFileInfo.sourceFile.isNoCircularDependencyConfirmed()) {
+            return false;
+        }
+        filesVisited.set(sourceFileInfo.sourceFile.getFilePath(), sourceFileInfo);
+        let detectedCycle = false;
+        const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, sourceFileInfo.sourceFile.getFilePath());
+        if (dependencyMap.has(filePath)) {
+            // Look for chains at least two in length. A file that contains
+            // an "import . from X" will technically create a cycle with
+            // itself, but those are not interesting to report.
+            if (dependencyChain.length > 1 && sourceFileInfo === dependencyChain[0]) {
+                this._logImportCycle(dependencyChain);
+                detectedCycle = true;
+            }
+        }
+        else {
+            // If we've already checked this dependency along
+            // some other path, we can skip it.
+            if (dependencyMap.has(filePath)) {
+                return false;
+            }
+            // We use both a map (for fast lookups) and a list
+            // (for ordering information). Set the dependency map
+            // entry to true to indicate that we're actively exploring
+            // that dependency.
+            dependencyMap.set(filePath, true);
+            dependencyChain.push(sourceFileInfo);
+            for (const imp of sourceFileInfo.imports) {
+                if (this._detectAndReportImportCycles(imp, filesVisited, dependencyChain, dependencyMap)) {
+                    detectedCycle = true;
+                }
+            }
+            // Set the dependencyMap entry to false to indicate that we have
+            // already explored this file and don't need to explore it again.
+            dependencyMap.set(filePath, false);
+            dependencyChain.pop();
+        }
+        return detectedCycle;
+    }
+    _logImportCycle(dependencyChain) {
+        const circDep = new circularDependency_1.CircularDependency();
+        dependencyChain.forEach((sourceFileInfo) => {
+            circDep.appendPath(sourceFileInfo.sourceFile.getFilePath());
+        });
+        circDep.normalizeOrder();
+        const firstFilePath = circDep.getPaths()[0];
+        const firstSourceFile = this._getSourceFileInfoFromPath(firstFilePath);
+        (0, debug_1.assert)(firstSourceFile !== undefined);
+        firstSourceFile.sourceFile.addCircularDependency(circDep);
+    }
+    _markFileDirtyRecursive(sourceFileInfo, markMap, forceRebinding = false) {
+        const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, sourceFileInfo.sourceFile.getFilePath());
+        // Don't mark it again if it's already been visited.
+        if (!markMap.has(filePath)) {
+            sourceFileInfo.sourceFile.markReanalysisRequired(forceRebinding);
+            markMap.set(filePath, true);
+            sourceFileInfo.importedBy.forEach((dep) => {
+                // Changes on chained source file can change symbols in the symbol table and
+                // dependencies on the dependent file. Force rebinding.
+                const forceRebinding = dep.chainedSourceFile === sourceFileInfo;
+                this._markFileDirtyRecursive(dep, markMap, forceRebinding);
+            });
+        }
+    }
+    getTextOnRange(filePath, range, token) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        const sourceFile = sourceFileInfo.sourceFile;
+        const fileContents = sourceFile.getOpenFileContents();
+        if (fileContents === undefined) {
+            // this only works with opened file
+            return undefined;
+        }
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            this._parseFile(sourceFileInfo);
+            const parseTree = sourceFile.getParseResults();
+            const textRange = (0, positionUtils_1.convertRangeToTextRange)(range, parseTree.tokenizerOutput.lines);
+            if (!textRange) {
+                return undefined;
+            }
+            return fileContents.substr(textRange.start, textRange.length);
+        });
+    }
+    getAutoImports(filePath, range, similarityLimit, nameMap, libraryMap, lazyEdit, allowVariableInAll, token) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return [];
+        }
+        const sourceFile = sourceFileInfo.sourceFile;
+        const fileContents = sourceFile.getOpenFileContents();
+        if (fileContents === undefined) {
+            // this only works with opened file
+            return [];
+        }
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            this._bindFile(sourceFileInfo);
+            const parseTree = sourceFile.getParseResults();
+            const textRange = (0, positionUtils_1.convertRangeToTextRange)(range, parseTree.tokenizerOutput.lines);
+            if (!textRange) {
+                return [];
+            }
+            const currentNode = (0, parseTreeUtils_1.findNodeByOffset)(parseTree.parseTree, textRange.start);
+            if (!currentNode) {
+                return [];
+            }
+            const writtenWord = fileContents.substr(textRange.start, textRange.length);
+            const map = this._buildModuleSymbolsMap(sourceFileInfo, !!libraryMap, 
+            /* includeIndexUserSymbols */ true, token);
+            const autoImporter = new autoImporter_1.AutoImporter(this._configOptions.findExecEnvironment(filePath), this._importResolver, parseTree, range.start, new completionProvider_1.CompletionMap(), map, {
+                lazyEdit,
+                allowVariableInAll,
+                libraryMap,
+                patternMatcher: (p, t) => (0, stringUtils_1.computeCompletionSimilarity)(p, t) > similarityLimit,
+            });
+            // Filter out any name that is already defined in the current scope.
+            const results = [];
+            const currentScope = (0, scopeUtils_1.getScopeForNode)(currentNode);
+            if (currentScope) {
+                const info = nameMap === null || nameMap === void 0 ? void 0 : nameMap.get(writtenWord);
+                if (info) {
+                    // No scope filter is needed since we only do exact match.
+                    (0, collectionUtils_1.appendArray)(results, autoImporter.getAutoImportCandidatesForAbbr(writtenWord, info, token));
+                }
+                results.push(...autoImporter
+                    .getAutoImportCandidates(writtenWord, similarityLimit, /* abbrFromUsers */ undefined, token)
+                    .filter((r) => !currentScope.lookUpSymbolRecursive(r.name)));
+            }
+            return results;
+        });
+    }
+    getDiagnostics(options) {
+        const fileDiagnostics = this._removeUnneededFiles();
+        this._sourceFileList.forEach((sourceFileInfo) => {
+            if (this._shouldCheckFile(sourceFileInfo)) {
+                const diagnostics = sourceFileInfo.sourceFile.getDiagnostics(options, sourceFileInfo.diagnosticsVersion);
+                if (diagnostics !== undefined) {
+                    fileDiagnostics.push({
+                        filePath: sourceFileInfo.sourceFile.getFilePath(),
+                        version: sourceFileInfo.sourceFile.getClientVersion(),
+                        diagnostics,
+                    });
+                    // Update the cached diagnosticsVersion so we can determine
+                    // whether there are any updates next time we call getDiagnostics.
+                    sourceFileInfo.diagnosticsVersion = sourceFileInfo.sourceFile.getDiagnosticVersion();
+                }
+            }
+            else if (!sourceFileInfo.isOpenByClient &&
+                options.checkOnlyOpenFiles &&
+                sourceFileInfo.diagnosticsVersion !== undefined) {
+                // This condition occurs when the user switches from workspace to
+                // "open files only" mode. Clear all diagnostics for this file.
+                fileDiagnostics.push({
+                    filePath: sourceFileInfo.sourceFile.getFilePath(),
+                    version: sourceFileInfo.sourceFile.getClientVersion(),
+                    diagnostics: [],
+                });
+                sourceFileInfo.diagnosticsVersion = undefined;
+            }
+        });
+        return fileDiagnostics;
+    }
+    getDiagnosticsForRange(filePath, range) {
+        const sourceFile = this.getSourceFile(filePath);
+        if (!sourceFile) {
+            return [];
+        }
+        const unfilteredDiagnostics = sourceFile.getDiagnostics(this._configOptions);
+        if (!unfilteredDiagnostics) {
+            return [];
+        }
+        return unfilteredDiagnostics.filter((diag) => {
+            return (0, textRange_1.doRangesIntersect)(diag.range, range);
+        });
+    }
+    getDefinitionsForPosition(filePath, position, filter, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            return sourceFileInfo.sourceFile.getDefinitionsForPosition(this._createSourceMapper(execEnv), position, filter, this._evaluator, token);
+        });
+    }
+    getTypeDefinitionsForPosition(filePath, position, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            return sourceFileInfo.sourceFile.getTypeDefinitionsForPosition(this._createSourceMapper(execEnv, /* mapCompiled */ false, /* preferStubs */ true), position, this._evaluator, filePath, token);
+        });
+    }
+    reportReferencesForPosition(filePath, position, includeDeclaration, reporter, token) {
+        this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return;
+            }
+            const invokedFromUserFile = this._isUserCode(sourceFileInfo);
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv), position, this._evaluator, reporter, token);
+            if (!referencesResult) {
+                return;
+            }
+            // Do we need to do a global search as well?
+            if (referencesResult.requiresGlobalSearch) {
+                for (const curSourceFileInfo of this._sourceFileList) {
+                    (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+                    // "Find all references" will only include references from user code
+                    // unless the file is explicitly opened in the editor or it is invoked from non user files.
+                    if (curSourceFileInfo.isOpenByClient ||
+                        !invokedFromUserFile ||
+                        this._isUserCode(curSourceFileInfo)) {
+                        // See if the reference symbol's string is located somewhere within the file.
+                        // If not, we can skip additional processing for the file.
+                        const fileContents = curSourceFileInfo.sourceFile.getFileContent();
+                        if (!fileContents || fileContents.search(referencesResult.symbolName) >= 0) {
+                            this._bindFile(curSourceFileInfo);
+                            curSourceFileInfo.sourceFile.addReferences(referencesResult, includeDeclaration, this._evaluator, token);
+                        }
+                        // This operation can consume significant memory, so check
+                        // for situations where we need to discard the type cache.
+                        this._handleMemoryHighUsage();
+                    }
+                }
+                // Make sure to include declarations regardless where they are defined
+                // if includeDeclaration is set.
+                if (includeDeclaration) {
+                    for (const decl of referencesResult.declarations) {
+                        (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+                        if (referencesResult.locations.some((l) => l.path === decl.path)) {
+                            // Already included.
+                            continue;
+                        }
+                        const declFileInfo = this._getSourceFileInfoFromPath(decl.path);
+                        if (!declFileInfo) {
+                            // The file the declaration belongs to doesn't belong to the program.
+                            continue;
+                        }
+                        const tempResult = new referencesProvider_1.ReferencesResult(referencesResult.requiresGlobalSearch, referencesResult.nodeAtOffset, referencesResult.symbolName, referencesResult.declarations);
+                        declFileInfo.sourceFile.addReferences(tempResult, includeDeclaration, this._evaluator, token);
+                        for (const loc of tempResult.locations) {
+                            // Include declarations only. And throw away any references
+                            if (loc.path === decl.path && (0, textRange_1.doesRangeContain)(decl.range, loc.range)) {
+                                referencesResult.addLocations(loc);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                sourceFileInfo.sourceFile.addReferences(referencesResult, includeDeclaration, this._evaluator, token);
+            }
+        });
+    }
+    getFileIndex(filePath, options, token) {
+        if (options.indexingForAutoImportMode) {
+            // Memory optimization. We only want to hold onto symbols
+            // usable outside when importSymbolsOnly is on.
+            const name = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
+            if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
+                return undefined;
+            }
+        }
+        this._handleMemoryHighUsage();
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            var _a;
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            const content = (_a = sourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
+            if (options.indexingForAutoImportMode &&
+                !options.forceIndexing &&
+                !sourceFileInfo.sourceFile.isStubFile() &&
+                !sourceFileInfo.sourceFile.isThirdPartyPyTypedPresent()) {
+                // Perf optimization. if py file doesn't contain __all__
+                // No need to parse and bind.
+                if (content.indexOf('__all__') < 0) {
+                    return undefined;
+                }
+            }
+            this._bindFile(sourceFileInfo, content);
+            return sourceFileInfo.sourceFile.index(options, token);
+        });
+    }
+    addSymbolsForDocument(filePath, symbolList, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (sourceFileInfo) {
+                if (!sourceFileInfo.sourceFile.getCachedIndexResults()) {
+                    // If we already have cached index for this file, no need to bind this file.
+                    this._bindFile(sourceFileInfo);
+                }
+                sourceFileInfo.sourceFile.addHierarchicalSymbolsForDocument(symbolList, token);
+            }
+        });
+    }
+    reportSymbolsForWorkspace(query, reporter, token) {
+        this._runEvaluatorWithCancellationToken(token, () => {
+            // Don't do a search if the query is empty. We'll return
+            // too many results in this case.
+            if (!query) {
+                return;
+            }
+            // "Workspace symbols" searches symbols only from user code.
+            for (const sourceFileInfo of this._sourceFileList) {
+                if (!this._isUserCode(sourceFileInfo)) {
+                    continue;
+                }
+                if (!sourceFileInfo.sourceFile.getCachedIndexResults()) {
+                    // If we already have cached index for this file, no need to bind this file.
+                    this._bindFile(sourceFileInfo);
+                }
+                const symbolList = sourceFileInfo.sourceFile.getSymbolsForDocument(query, token);
+                if (symbolList.length > 0) {
+                    reporter(symbolList);
+                }
+                // This operation can consume significant memory, so check
+                // for situations where we need to discard the type cache.
+                this._handleMemoryHighUsage();
+            }
+        });
+    }
+    getHoverForPosition(filePath, position, format, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            return sourceFileInfo.sourceFile.getHoverForPosition(this._createSourceMapper(execEnv, /* mapCompiled */ true), position, format, this._evaluator, token);
+        });
+    }
+    getDocumentHighlight(filePath, position, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            return sourceFileInfo.sourceFile.getDocumentHighlight(this._createSourceMapper(execEnv), position, this._evaluator, token);
+        });
+    }
+    getSignatureHelpForPosition(filePath, position, format, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            return sourceFileInfo.sourceFile.getSignatureHelpForPosition(position, this._createSourceMapper(execEnv, /* mapCompiled */ true), this._evaluator, format, token);
+        });
+    }
+    async getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, libraryMap, token) {
+        var _a, _b;
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        const completionResult = this._logTracker.log(`completion at ${filePath}:${position.line}:${position.character}`, (ls) => {
+            var _a, _b;
+            const result = this._runEvaluatorWithCancellationToken(token, () => {
+                this._bindFile(sourceFileInfo);
+                const execEnv = this._configOptions.findExecEnvironment(filePath);
+                return sourceFileInfo.sourceFile.getCompletionsForPosition(position, workspacePath, this._configOptions, this._importResolver, this._lookUpImport, this._evaluator, options, this._createSourceMapper(execEnv, /* mapCompiled */ true), nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, !!libraryMap, 
+                /* includeIndexUserSymbols */ false, token), token);
+            });
+            ls.add(`found ${(_b = (_a = result === null || result === void 0 ? void 0 : result.completionMap) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 'null'} items`);
+            return result;
+        });
+        const completionResultsList = {
+            completionList: vscode_languageserver_types_1.CompletionList.create((_a = completionResult === null || completionResult === void 0 ? void 0 : completionResult.completionMap) === null || _a === void 0 ? void 0 : _a.toArray()),
+            memberAccessInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.memberAccessInfo,
+            autoImportInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.autoImportInfo,
+            extensionInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.extensionInfo,
+        };
+        if (!(completionResult === null || completionResult === void 0 ? void 0 : completionResult.completionMap) || !((_b = this._extension) === null || _b === void 0 ? void 0 : _b.completionListExtension)) {
+            return completionResultsList;
+        }
+        const parseResults = sourceFileInfo.sourceFile.getParseResults();
+        if ((parseResults === null || parseResults === void 0 ? void 0 : parseResults.parseTree) && (parseResults === null || parseResults === void 0 ? void 0 : parseResults.text)) {
+            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
+            if (offset !== undefined) {
+                await this._extension.completionListExtension.updateCompletionResults(completionResultsList, parseResults, offset, token);
+            }
+        }
+        return completionResultsList;
+    }
+    resolveCompletionItem(filePath, completionItem, options, nameMap, libraryMap, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return;
+            }
+            this._bindFile(sourceFileInfo);
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            sourceFileInfo.sourceFile.resolveCompletionItem(this._configOptions, this._importResolver, this._lookUpImport, this._evaluator, options, this._createSourceMapper(execEnv, /* mapCompiled */ true), nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, !!libraryMap, 
+            /* includeIndexUserSymbols */ false, token), completionItem, token);
+        });
+    }
+    renameModule(path, newPath, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            if ((0, pathUtils_1.isFile)(this._fs, path)) {
+                const fileInfo = this._getSourceFileInfoFromPath(path);
+                if (!fileInfo) {
+                    return undefined;
+                }
+            }
+            const renameModuleProvider = renameModuleProvider_1.RenameModuleProvider.createForModule(this._importResolver, this._configOptions, this._evaluator, path, newPath, token);
+            if (!renameModuleProvider) {
+                return undefined;
+            }
+            this._processModuleReferences(renameModuleProvider, renameModuleProvider.lastModuleName, path);
+            return { edits: renameModuleProvider.getEdits(), fileOperations: [] };
+        });
+    }
+    moveSymbolAtPosition(filePath, newFilePath, position, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const fileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!fileInfo) {
+                return undefined;
+            }
+            this._bindFile(fileInfo);
+            const parseResults = fileInfo.sourceFile.getParseResults();
+            if (!parseResults) {
+                return undefined;
+            }
+            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
+            if (offset === undefined) {
+                return undefined;
+            }
+            const node = (0, parseTreeUtils_1.findNodeByOffset)(parseResults.parseTree, offset);
+            if (node === undefined) {
+                return undefined;
+            }
+            // If this isn't a name node, there are no references to be found.
+            if (node.nodeType !== 38 /* Name */) {
+                return undefined;
+            }
+            const execEnv = this._configOptions.findExecEnvironment(filePath);
+            const declarations = documentSymbolCollector_1.DocumentSymbolCollector.getDeclarationsForNode(node, this._evaluator, 
+            /* resolveLocalNames */ false, token, this._createSourceMapper(execEnv));
+            const renameModuleProvider = renameModuleProvider_1.RenameModuleProvider.createForSymbol(this._importResolver, this._configOptions, this._evaluator, filePath, newFilePath, declarations, token);
+            if (!renameModuleProvider) {
+                return undefined;
+            }
+            this._processModuleReferences(renameModuleProvider, node.value, filePath);
+            return { edits: renameModuleProvider.getEdits(), fileOperations: [] };
+        });
+    }
+    canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const referencesResult = this._getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token);
+            if (!referencesResult) {
+                return undefined;
+            }
+            if (referencesResult.containsOnlyImportDecls &&
+                !this._supportRenameModule(referencesResult.declarations, isDefaultWorkspace)) {
+                return undefined;
+            }
+            const renameMode = this._getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace);
+            if (renameMode === 'none') {
+                return undefined;
+            }
+            // Return the range of the symbol.
+            const parseResult = sourceFileInfo.sourceFile.getParseResults();
+            return (0, positionUtils_1.convertTextRangeToRange)(referencesResult.nodeAtOffset, parseResult.tokenizerOutput.lines);
+        });
+    }
+    renameSymbolAtPosition(filePath, position, newName, isDefaultWorkspace, allowModuleRename, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            var _a;
+            const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+            if (!sourceFileInfo) {
+                return undefined;
+            }
+            this._bindFile(sourceFileInfo);
+            const referencesResult = this._getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token);
+            if (!referencesResult) {
+                return undefined;
+            }
+            if (referencesResult.containsOnlyImportDecls) {
+                // All decls must be on a user file.
+                if (!this._supportRenameModule(referencesResult.declarations, isDefaultWorkspace)) {
+                    return undefined;
+                }
+                const moduleInfo = renameModuleProvider_1.RenameModuleProvider.getRenameModulePathInfo(renameModuleProvider_1.RenameModuleProvider.getRenameModulePath(referencesResult.declarations), newName);
+                if (!moduleInfo) {
+                    // Can't figure out module to rename.
+                    return undefined;
+                }
+                const editActions = this.renameModule(moduleInfo.filePath, moduleInfo.newFilePath, token);
+                // Add file system rename.
+                editActions === null || editActions === void 0 ? void 0 : editActions.fileOperations.push({
+                    kind: 'rename',
+                    oldFilePath: moduleInfo.filePath,
+                    newFilePath: moduleInfo.newFilePath,
+                });
+                if ((0, sourceMapper_1.isStubFile)(moduleInfo.filePath)) {
+                    const matchingFiles = this._importResolver.getSourceFilesFromStub(moduleInfo.filePath, this._configOptions.findExecEnvironment(filePath), 
+                    /* mapCompiled */ false);
+                    for (const matchingFile of matchingFiles) {
+                        const matchingFileInfo = renameModuleProvider_1.RenameModuleProvider.getRenameModulePathInfo(matchingFile, newName);
+                        if (matchingFileInfo) {
+                            editActions === null || editActions === void 0 ? void 0 : editActions.fileOperations.push({
+                                kind: 'rename',
+                                oldFilePath: matchingFileInfo.filePath,
+                                newFilePath: matchingFileInfo.newFilePath,
+                            });
+                        }
+                    }
+                }
+                return editActions;
+            }
+            const renameMode = this._getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace);
+            switch (renameMode) {
+                case 'singleFileMode':
+                    sourceFileInfo.sourceFile.addReferences(referencesResult, true, this._evaluator, token);
+                    break;
+                case 'multiFileMode': {
+                    for (const curSourceFileInfo of this._sourceFileList) {
+                        // Make sure we only add user code to the references to prevent us
+                        // from accidentally changing third party library or type stub.
+                        if (this._isUserCode(curSourceFileInfo)) {
+                            // Make sure searching symbol name exists in the file.
+                            const content = (_a = curSourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
+                            if (content.indexOf(referencesResult.symbolName) < 0) {
+                                continue;
+                            }
+                            this._bindFile(curSourceFileInfo, content);
+                            curSourceFileInfo.sourceFile.addReferences(referencesResult, true, this._evaluator, token);
+                        }
+                        // This operation can consume significant memory, so check
+                        // for situations where we need to discard the type cache.
+                        this._handleMemoryHighUsage();
+                    }
+                    break;
+                }
+                case 'none':
+                    // Rename is not allowed.
+                    // ex) rename symbols from libraries.
+                    return undefined;
+                default:
+                    (0, debug_1.assertNever)(renameMode);
+            }
+            const edits = [];
+            referencesResult.locations.forEach((loc) => {
+                edits.push({
+                    filePath: loc.path,
+                    range: loc.range,
+                    replacementText: newName,
+                });
+            });
+            return { edits, fileOperations: [] };
+        });
+    }
+    getCallForPosition(filePath, position, token) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        this._bindFile(sourceFileInfo);
+        const execEnv = this._configOptions.findExecEnvironment(filePath);
+        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv), position, this._evaluator, undefined, token);
+        if (!referencesResult || referencesResult.declarations.length === 0) {
+            return undefined;
+        }
+        const targetDecl = callHierarchyProvider_1.CallHierarchyProvider.getTargetDeclaration(referencesResult.declarations, referencesResult.nodeAtOffset);
+        return callHierarchyProvider_1.CallHierarchyProvider.getCallForDeclaration(referencesResult.symbolName, targetDecl, this._evaluator, token);
+    }
+    getIncomingCallsForPosition(filePath, position, token) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        this._bindFile(sourceFileInfo);
+        const execEnv = this._configOptions.findExecEnvironment(filePath);
+        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv), position, this._evaluator, undefined, token);
+        if (!referencesResult || referencesResult.declarations.length === 0) {
+            return undefined;
+        }
+        const targetDecl = callHierarchyProvider_1.CallHierarchyProvider.getTargetDeclaration(referencesResult.declarations, referencesResult.nodeAtOffset);
+        let items = [];
+        for (const curSourceFileInfo of this._sourceFileList) {
+            if (this._isUserCode(curSourceFileInfo) || curSourceFileInfo.isOpenByClient) {
+                this._bindFile(curSourceFileInfo);
+                const itemsToAdd = callHierarchyProvider_1.CallHierarchyProvider.getIncomingCallsForDeclaration(curSourceFileInfo.sourceFile.getFilePath(), referencesResult.symbolName, targetDecl, curSourceFileInfo.sourceFile.getParseResults(), this._evaluator, token);
+                if (itemsToAdd) {
+                    items = items.concat(...itemsToAdd);
+                }
+                // This operation can consume significant memory, so check
+                // for situations where we need to discard the type cache.
+                this._handleMemoryHighUsage();
+            }
+        }
+        return items;
+    }
+    getOutgoingCallsForPosition(filePath, position, token) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        this._bindFile(sourceFileInfo);
+        const execEnv = this._configOptions.findExecEnvironment(filePath);
+        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv), position, this._evaluator, undefined, token);
+        if (!referencesResult || referencesResult.declarations.length === 0) {
+            return undefined;
+        }
+        const targetDecl = callHierarchyProvider_1.CallHierarchyProvider.getTargetDeclaration(referencesResult.declarations, referencesResult.nodeAtOffset);
+        return callHierarchyProvider_1.CallHierarchyProvider.getOutgoingCallsForDeclaration(targetDecl, sourceFileInfo.sourceFile.getParseResults(), this._evaluator, token);
+    }
+    performQuickAction(filePath, command, args, token) {
+        const sourceFileInfo = this._getSourceFileInfoFromPath(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
+        }
+        this._bindFile(sourceFileInfo);
+        return sourceFileInfo.sourceFile.performQuickAction(command, args, token);
+    }
+    test_createSourceMapper(execEnv) {
+        return this._createSourceMapper(execEnv, /* mapCompiled */ false);
+    }
+    _getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace) {
+        // We have 2 different cases
+        // Single file mode.
+        // 1. rename on default workspace (ex, standalone file mode).
+        // 2. rename local symbols.
+        // 3. rename symbols defined in the non user open file.
+        //
+        // and Multi file mode.
+        // 1. rename public symbols defined in user files on regular workspace (ex, open folder mode).
+        const userFile = this._isUserCode(sourceFileInfo);
+        if (isDefaultWorkspace ||
+            (userFile && !referencesResult.requiresGlobalSearch) ||
+            (!userFile &&
+                sourceFileInfo.isOpenByClient &&
+                referencesResult.declarations.every((d) => this._getSourceFileInfoFromPath(d.path) === sourceFileInfo))) {
+            return 'singleFileMode';
+        }
+        if (referencesResult.declarations.every((d) => this._isUserCode(this._getSourceFileInfoFromPath(d.path)))) {
+            return 'multiFileMode';
+        }
+        // Rename is not allowed.
+        // ex) rename symbols from libraries.
+        return 'none';
+    }
+    _supportRenameModule(declarations, isDefaultWorkspace) {
+        // Rename module is not supported for standalone file and all decls must be on a user file.
+        return (!isDefaultWorkspace && declarations.every((d) => this._isUserCode(this._getSourceFileInfoFromPath(d.path))));
+    }
+    _getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token) {
+        const execEnv = this._configOptions.findExecEnvironment(filePath);
+        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv), position, this._evaluator, undefined, token);
+        if (!referencesResult) {
+            return undefined;
+        }
+        if (allowModuleRename && referencesResult.containsOnlyImportDecls) {
+            return referencesResult;
+        }
+        if (referencesResult.nonImportDeclarations.length === 0) {
+            // There is no symbol we can rename.
+            return undefined;
+        }
+        // Use declarations that doesn't contain import decls.
+        return new referencesProvider_1.ReferencesResult(referencesResult.requiresGlobalSearch, referencesResult.nodeAtOffset, referencesResult.symbolName, referencesResult.nonImportDeclarations);
+    }
+    _processModuleReferences(renameModuleProvider, filteringText, currentFilePath) {
+        var _a;
+        // _sourceFileList contains every user files that match "include" pattern including
+        // py file even if corresponding pyi exists.
+        for (const currentFileInfo of this._sourceFileList) {
+            // Make sure we only touch user code to prevent us
+            // from accidentally changing third party library or type stub.
+            if (!this._isUserCode(currentFileInfo)) {
+                continue;
+            }
+            // If module name isn't mentioned in the current file, skip the file
+            // except the file that got actually renamed/moved.
+            // The file that got moved might have relative import paths we need to update.
+            const filePath = currentFileInfo.sourceFile.getFilePath();
+            const content = (_a = currentFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
+            if (filePath !== currentFilePath && content.indexOf(filteringText) < 0) {
+                continue;
+            }
+            this._bindFile(currentFileInfo, content);
+            const parseResult = currentFileInfo.sourceFile.getParseResults();
+            if (!parseResult) {
+                continue;
+            }
+            renameModuleProvider.renameReferences(filePath, parseResult);
+            // This operation can consume significant memory, so check
+            // for situations where we need to discard the type cache.
+            this._handleMemoryHighUsage();
+        }
+    }
+    _handleMemoryHighUsage() {
+        const typeCacheEntryCount = this._evaluator.getTypeCacheEntryCount();
+        const convertToMB = (bytes) => {
+            return `${Math.round(bytes / (1024 * 1024))}MB`;
+        };
+        // If the type cache size has exceeded a high-water mark, query the heap usage.
+        // Don't bother doing this until we hit this point because the heap usage may not
+        // drop immediately after we empty the cache due to garbage collection timing.
+        if (typeCacheEntryCount > 750000 || this._parsedFileCount > 1000) {
+            const heapStats = (0, v8_1.getHeapStatistics)();
+            if (this._configOptions.verboseOutput) {
+                this._console.info(`Heap stats: ` +
+                    `total_heap_size=${convertToMB(heapStats.total_heap_size)}, ` +
+                    `used_heap_size=${convertToMB(heapStats.used_heap_size)}, ` +
+                    `total_physical_size=${convertToMB(heapStats.total_physical_size)}, ` +
+                    `total_available_size=${convertToMB(heapStats.total_available_size)}, ` +
+                    `heap_size_limit=${convertToMB(heapStats.heap_size_limit)}`);
+            }
+            // The type cache uses a Map, which has an absolute limit of 2^24 entries
+            // before it will fail. If we cross the 95% mark, we'll empty the cache.
+            const absoluteMaxCacheEntryCount = (1 << 24) * 0.9;
+            // If we use more than 90% of the heap size limit, avoid a crash
+            // by emptying the type cache.
+            if (typeCacheEntryCount > absoluteMaxCacheEntryCount ||
+                heapStats.used_heap_size > heapStats.heap_size_limit * 0.9) {
+                this._console.info(`Emptying type cache to avoid heap overflow. Used ${convertToMB(heapStats.used_heap_size)} out of ${convertToMB(heapStats.heap_size_limit)} (${typeCacheEntryCount} cache entries).`);
+                this._createNewEvaluator();
+                this._discardCachedParseResults();
+                this._parsedFileCount = 0;
+            }
+        }
+    }
+    // Discards all cached parse results and file contents to free up memory.
+    // It does not discard cached index results or diagnostics for files.
+    _discardCachedParseResults() {
+        for (const sourceFileInfo of this._sourceFileList) {
+            sourceFileInfo.sourceFile.dropParseAndBindInfo();
+        }
+    }
+    _isUserCode(fileInfo) {
+        return fileInfo && fileInfo.isTracked && !fileInfo.isThirdPartyImport && !fileInfo.isTypeshedFile;
+    }
+    // Wrapper function that should be used when invoking this._evaluator
+    // with a cancellation token. It handles cancellation exceptions and
+    // any other unexpected exceptions.
+    _runEvaluatorWithCancellationToken(token, callback) {
+        try {
+            if (token) {
+                return this._evaluator.runWithCancellationToken(token, callback);
+            }
+            else {
+                return callback();
+            }
+        }
+        catch (e) {
+            // An unexpected exception occurred, potentially leaving the current evaluator
+            // in an inconsistent state. Discard it and replace it with a fresh one. It is
+            // Cancellation exceptions are known to handle this correctly.
+            if (!(e instanceof cancellationUtils_1.OperationCanceledException)) {
+                this._createNewEvaluator();
+            }
+            throw e;
+        }
+    }
+    // Returns a list of empty file diagnostic entries for the files
+    // that have been removed. This is needed to clear out the
+    // errors for files that have been deleted or closed.
+    _removeUnneededFiles() {
+        const fileDiagnostics = [];
+        // If a file is no longer tracked, opened or shadowed, it can
+        // be removed from the program.
+        for (let i = 0; i < this._sourceFileList.length;) {
+            const fileInfo = this._sourceFileList[i];
+            if (!this._isFileNeeded(fileInfo)) {
+                fileDiagnostics.push({
+                    filePath: fileInfo.sourceFile.getFilePath(),
+                    version: fileInfo.sourceFile.getClientVersion(),
+                    diagnostics: [],
+                });
+                fileInfo.sourceFile.prepareForClose();
+                this._removeSourceFileFromListAndMap(fileInfo.sourceFile.getFilePath(), i);
+                // Unlink any imports and remove them from the list if
+                // they are no longer referenced.
+                fileInfo.imports.forEach((importedFile) => {
+                    const indexToRemove = importedFile.importedBy.findIndex((fi) => fi === fileInfo);
+                    if (indexToRemove < 0) {
+                        return;
+                    }
+                    importedFile.importedBy.splice(indexToRemove, 1);
+                    // See if we need to remove the imported file because it
+                    // is no longer needed. If its index is >= i, it will be
+                    // removed when we get to it.
+                    if (!this._isFileNeeded(importedFile)) {
+                        const indexToRemove = this._sourceFileList.findIndex((fi) => fi === importedFile);
+                        if (indexToRemove >= 0 && indexToRemove < i) {
+                            fileDiagnostics.push({
+                                filePath: importedFile.sourceFile.getFilePath(),
+                                version: importedFile.sourceFile.getClientVersion(),
+                                diagnostics: [],
+                            });
+                            importedFile.sourceFile.prepareForClose();
+                            this._removeSourceFileFromListAndMap(importedFile.sourceFile.getFilePath(), indexToRemove);
+                            i--;
+                        }
+                    }
+                });
+                // Remove any shadowed files corresponding to this file.
+                fileInfo.shadowedBy.forEach((shadowedFile) => {
+                    shadowedFile.shadows = shadowedFile.shadows.filter((f) => f !== fileInfo);
+                });
+                fileInfo.shadowedBy = [];
+            }
+            else {
+                // If we're showing the user errors only for open files, clear
+                // out the errors for the now-closed file.
+                if (!this._shouldCheckFile(fileInfo) && fileInfo.diagnosticsVersion !== undefined) {
+                    fileDiagnostics.push({
+                        filePath: fileInfo.sourceFile.getFilePath(),
+                        version: fileInfo.sourceFile.getClientVersion(),
+                        diagnostics: [],
+                    });
+                    fileInfo.diagnosticsVersion = undefined;
+                }
+                i++;
+            }
+        }
+        return fileDiagnostics;
+    }
+    _isFileNeeded(fileInfo) {
+        if (fileInfo.sourceFile.isFileDeleted()) {
+            return false;
+        }
+        if (fileInfo.isTracked || fileInfo.isOpenByClient) {
+            return true;
+        }
+        if (fileInfo.shadows.length > 0) {
+            return true;
+        }
+        if (fileInfo.importedBy.length === 0) {
+            return false;
+        }
+        // It's possible for a cycle of files to be imported
+        // by a tracked file but then abandoned. The import cycle
+        // will keep the entire group "alive" if we don't detect
+        // the condition and garbage collect them.
+        return this._isImportNeededRecursive(fileInfo, new Map());
+    }
+    _isImportNeededRecursive(fileInfo, recursionMap) {
+        if (fileInfo.isTracked || fileInfo.isOpenByClient || fileInfo.shadows.length > 0) {
+            return true;
+        }
+        const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, fileInfo.sourceFile.getFilePath());
+        // Avoid infinite recursion.
+        if (recursionMap.has(filePath)) {
+            return false;
+        }
+        recursionMap.set(filePath, true);
+        for (const importerInfo of fileInfo.importedBy) {
+            if (this._isImportNeededRecursive(importerInfo, recursionMap)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _createSourceMapper(execEnv, mapCompiled, preferStubs) {
+        const sourceMapper = new sourceMapper_1.SourceMapper(this._importResolver, execEnv, this._evaluator, (stubFilePath, implFilePath) => {
+            const stubFileInfo = this._getSourceFileInfoFromPath(stubFilePath);
+            if (!stubFileInfo) {
+                return undefined;
+            }
+            this._addShadowedFile(stubFileInfo, implFilePath);
+            return this.getBoundSourceFile(implFilePath);
+        }, (f) => this.getBoundSourceFile(f), mapCompiled !== null && mapCompiled !== void 0 ? mapCompiled : false, preferStubs !== null && preferStubs !== void 0 ? preferStubs : false);
+        return sourceMapper;
+    }
+    _isImportAllowed(importer, importResult, isImportStubFile) {
+        // Don't import native libs. We don't want to track these files,
+        // and we definitely don't want to attempt to parse them.
+        if (importResult.isNativeLib) {
+            return false;
+        }
+        let thirdPartyImportAllowed = this._configOptions.useLibraryCodeForTypes ||
+            (importResult.importType === 1 /* ThirdParty */ && !!importResult.pyTypedInfo) ||
+            (importResult.importType === 2 /* Local */ && importer.isThirdPartyPyTypedPresent);
+        if (importResult.importType === 1 /* ThirdParty */ ||
+            (importer.isThirdPartyImport && importResult.importType === 2 /* Local */)) {
+            if (this._allowedThirdPartyImports) {
+                if (importResult.isRelative) {
+                    // If it's a relative import, we'll allow it because the
+                    // importer was already deemed to be allowed.
+                    thirdPartyImportAllowed = true;
+                }
+                else if (this._allowedThirdPartyImports.some((importName) => {
+                    // If this import name is the one that was explicitly
+                    // allowed or is a child of that import name,
+                    // it's considered allowed.
+                    if (importResult.importName === importName) {
+                        return true;
+                    }
+                    if (importResult.importName.startsWith(importName + '.')) {
+                        return true;
+                    }
+                    return false;
+                })) {
+                    thirdPartyImportAllowed = true;
+                }
+            }
+            // Some libraries ship with stub files that import from non-stubs. Don't
+            // explore those.
+            // Don't explore any third-party files unless they're type stub files
+            // or we've been told explicitly that third-party imports are OK.
+            if (!isImportStubFile) {
+                return thirdPartyImportAllowed;
+            }
+        }
+        return true;
+    }
+    _updateSourceFileImports(sourceFileInfo, options) {
+        const filesAdded = [];
+        // Get the new list of imports and see if it changed from the last
+        // list of imports for this file.
+        const imports = sourceFileInfo.sourceFile.getImports();
+        // Create a local function that determines whether the import should
+        // be considered a "third-party import" and whether it is coming from
+        // a third-party package that claims to be typed. An import is
+        // considered third-party if it is external to the importer
+        // or is internal but the importer is itself a third-party package.
+        const getThirdPartyImportInfo = (importResult) => {
+            let isThirdPartyImport = false;
+            let isPyTypedPresent = false;
+            if (importResult.importType === 1 /* ThirdParty */) {
+                isThirdPartyImport = true;
+                if (importResult.pyTypedInfo) {
+                    isPyTypedPresent = true;
+                }
+            }
+            else if (sourceFileInfo.isThirdPartyImport && importResult.importType === 2 /* Local */) {
+                isThirdPartyImport = true;
+                if (sourceFileInfo.isThirdPartyPyTypedPresent) {
+                    isPyTypedPresent = true;
+                }
+            }
+            return {
+                isThirdPartyImport,
+                isPyTypedPresent,
+            };
+        };
+        // Create a map of unique imports, since imports can appear more than once.
+        const newImportPathMap = new Map();
+        // Add chained source file as import if it exists.
+        if (sourceFileInfo.chainedSourceFile) {
+            if (sourceFileInfo.chainedSourceFile.sourceFile.isFileDeleted()) {
+                sourceFileInfo.chainedSourceFile = undefined;
+            }
+            else {
+                const filePath = sourceFileInfo.chainedSourceFile.sourceFile.getFilePath();
+                newImportPathMap.set((0, pathUtils_1.normalizePathCase)(this._fs, filePath), {
+                    path: filePath,
+                    isTypeshedFile: false,
+                    isThirdPartyImport: false,
+                    isPyTypedPresent: false,
+                });
+            }
+        }
+        imports.forEach((importResult) => {
+            if (importResult.isImportFound) {
+                if (this._isImportAllowed(sourceFileInfo, importResult, importResult.isStubFile)) {
+                    if (importResult.resolvedPaths.length > 0) {
+                        const filePath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+                        if (filePath) {
+                            const thirdPartyTypeInfo = getThirdPartyImportInfo(importResult);
+                            newImportPathMap.set((0, pathUtils_1.normalizePathCase)(this._fs, filePath), {
+                                path: filePath,
+                                isTypeshedFile: !!importResult.isTypeshedFile,
+                                isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
+                                isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
+                            });
+                        }
+                    }
+                }
+                importResult.filteredImplicitImports.forEach((implicitImport) => {
+                    if (this._isImportAllowed(sourceFileInfo, importResult, implicitImport.isStubFile)) {
+                        if (!implicitImport.isNativeLib) {
+                            const thirdPartyTypeInfo = getThirdPartyImportInfo(importResult);
+                            newImportPathMap.set((0, pathUtils_1.normalizePathCase)(this._fs, implicitImport.path), {
+                                path: implicitImport.path,
+                                isTypeshedFile: !!importResult.isTypeshedFile,
+                                isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
+                                isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
+                            });
+                        }
+                    }
+                });
+            }
+            else if (options.verboseOutput) {
+                this._console.info(`Could not import '${importResult.importName}' ` +
+                    `in file '${sourceFileInfo.sourceFile.getFilePath()}'`);
+                if (importResult.importFailureInfo) {
+                    importResult.importFailureInfo.forEach((diag) => {
+                        this._console.info(`  ${diag}`);
+                    });
+                }
+            }
+        });
+        const updatedImportMap = new Map();
+        sourceFileInfo.imports.forEach((importInfo) => {
+            const oldFilePath = (0, pathUtils_1.normalizePathCase)(this._fs, importInfo.sourceFile.getFilePath());
+            // A previous import was removed.
+            if (!newImportPathMap.has(oldFilePath)) {
+                importInfo.importedBy = importInfo.importedBy.filter((fi) => (0, pathUtils_1.normalizePathCase)(this._fs, fi.sourceFile.getFilePath()) !==
+                    (0, pathUtils_1.normalizePathCase)(this._fs, sourceFileInfo.sourceFile.getFilePath()));
+            }
+            else {
+                updatedImportMap.set(oldFilePath, importInfo);
+            }
+        });
+        // See if there are any new imports to be added.
+        newImportPathMap.forEach((importInfo, normalizedImportPath) => {
+            if (!updatedImportMap.has(normalizedImportPath)) {
+                // We found a new import to add. See if it's already part
+                // of the program.
+                let importedFileInfo;
+                if (this._getSourceFileInfoFromPath(importInfo.path)) {
+                    importedFileInfo = this._getSourceFileInfoFromPath(importInfo.path);
+                }
+                else {
+                    const importName = this._getImportNameForFile(importInfo.path);
+                    const sourceFile = new sourceFile_1.SourceFile(this._fs, importInfo.path, importName, importInfo.isThirdPartyImport, importInfo.isPyTypedPresent, this._console, this._logTracker);
+                    importedFileInfo = {
+                        sourceFile,
+                        isTracked: false,
+                        isOpenByClient: false,
+                        isTypeshedFile: importInfo.isTypeshedFile,
+                        isThirdPartyImport: importInfo.isThirdPartyImport,
+                        isThirdPartyPyTypedPresent: importInfo.isPyTypedPresent,
+                        diagnosticsVersion: undefined,
+                        imports: [],
+                        importedBy: [],
+                        shadows: [],
+                        shadowedBy: [],
+                    };
+                    this._addToSourceFileListAndMap(importedFileInfo);
+                    filesAdded.push(importedFileInfo);
+                }
+                importedFileInfo.importedBy.push(sourceFileInfo);
+                updatedImportMap.set(normalizedImportPath, importedFileInfo);
+            }
+        });
+        // Update the imports list. It should now map the set of imports
+        // specified by the source file.
+        sourceFileInfo.imports = [];
+        newImportPathMap.forEach((_, path) => {
+            if (this._getSourceFileInfoFromPath(path)) {
+                sourceFileInfo.imports.push(this._getSourceFileInfoFromPath(path));
+            }
+        });
+        // Resolve the builtins import for the file. This needs to be
+        // analyzed before the file can be analyzed.
+        sourceFileInfo.builtinsImport = undefined;
+        const builtinsImport = sourceFileInfo.sourceFile.getBuiltinsImport();
+        if (builtinsImport && builtinsImport.isImportFound) {
+            const resolvedBuiltinsPath = builtinsImport.resolvedPaths[builtinsImport.resolvedPaths.length - 1];
+            sourceFileInfo.builtinsImport = this._getSourceFileInfoFromPath(resolvedBuiltinsPath);
+        }
+        // Resolve the ipython display import for the file. This needs to be
+        // analyzed before the file can be analyzed.
+        sourceFileInfo.ipythonDisplayImport = undefined;
+        const ipythonDisplayImport = sourceFileInfo.sourceFile.getIPythonDisplayImport();
+        if (ipythonDisplayImport && ipythonDisplayImport.isImportFound) {
+            const resolvedIPythonDisplayPath = ipythonDisplayImport.resolvedPaths[ipythonDisplayImport.resolvedPaths.length - 1];
+            sourceFileInfo.ipythonDisplayImport = this._getSourceFileInfoFromPath(resolvedIPythonDisplayPath);
+        }
+        return filesAdded;
+    }
+    _getSourceFileInfoFromPath(filePath) {
+        return this._sourceFileMap.get((0, pathUtils_1.normalizePathCase)(this._fs, filePath));
+    }
+    _removeSourceFileFromListAndMap(filePath, indexToRemove) {
+        this._sourceFileMap.delete((0, pathUtils_1.normalizePathCase)(this._fs, filePath));
+        this._sourceFileList.splice(indexToRemove, 1);
+    }
+    _addToSourceFileListAndMap(fileInfo) {
+        const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, fileInfo.sourceFile.getFilePath());
+        // We should never add a file with the same path twice.
+        (0, debug_1.assert)(!this._sourceFileMap.has(filePath));
+        this._sourceFileList.push(fileInfo);
+        this._sourceFileMap.set(filePath, fileInfo);
+    }
+}
+exports.Program = Program;
+//# sourceMappingURL=program.js.map