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

package/dist/analyzer/program.js

@@ -31,6 +31,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Program = exports.MaxWorkspaceIndexFileCount = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const cancellationUtils_1 = require("../common/cancellationUtils");
 const collectionUtils_1 = require("../common/collectionUtils");
 const configOptions_1 = require("../common/configOptions");
@@ -42,24 +43,13 @@ 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 textEditTracker_1 = require("../common/textEditTracker");
 const textRange_1 = require("../common/textRange");
-const textRangeCollection_1 = require("../common/textRangeCollection");
 const timing_1 = require("../common/timing");
-const workspaceEditUtils_1 = require("../common/workspaceEditUtils");
 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 importAdder_1 = require("../languageService/importAdder");
-const indentationUtils_1 = require("../languageService/indentationUtils");
-const insertionPointUtils_1 = require("../languageService/insertionPointUtils");
-const referencesProvider_1 = require("../languageService/referencesProvider");
-const renameModuleProvider_1 = require("../languageService/renameModuleProvider");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const cacheManager_1 = require("./cacheManager");
 const circularDependency_1 = require("./circularDependency");
-const declaration_1 = require("./declaration");
 const parseTreeUtils_1 = require("./parseTreeUtils");
 const scopeUtils_1 = require("./scopeUtils");
 const sourceFile_1 = require("./sourceFile");
@@ -83,7 +73,8 @@ class Program {
         this._sourceFileList = [];
         this._sourceFileMap = new Map();
         this._parsedFileCount = 0;
-        this._lookUpImport = (filePathOrModule) => {
+        this._isEditMode = false;
+        this._lookUpImport = (filePathOrModule, options) => {
             var _a;
             let sourceFileInfo;
             if (typeof filePathOrModule === 'string') {
@@ -102,7 +93,7 @@ class Program {
                         // See if the source file already exists in the program.
                         sourceFileInfo = this.getSourceFileInfo(resolvedPath);
                         if (!sourceFileInfo) {
-                            resolvedPath = (0, pathUtils_1.normalizePathCase)(this._fs, resolvedPath);
+                            resolvedPath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, resolvedPath);
                             // Start tracking the source file.
                             this.addTrackedFile(resolvedPath);
                             sourceFileInfo = this.getSourceFileInfo(resolvedPath);
@@ -117,7 +108,7 @@ class Program {
                 // 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);
+                    this._bindFile(sourceFileInfo, /* content */ undefined, options === null || options === void 0 ? void 0 : options.skipFileNeededCheck);
                 });
             }
             const symbolTable = sourceFileInfo.sourceFile.getModuleSymbolTable();
@@ -148,9 +139,6 @@ class Program {
         this._id = Program._nextId;
         Program._nextId += 1;
     }
-    dispose() {
-        this._cacheManager.unregisterCacheOwner(this);
-    }
     get id() {
         return this._id;
     }
@@ -169,6 +157,47 @@ class Program {
     get importResolver() {
         return this._importResolver;
     }
+    get fileSystem() {
+        return this._importResolver.fileSystem;
+    }
+    dispose() {
+        this._cacheManager.unregisterCacheOwner(this);
+    }
+    enterEditMode() {
+        // Keep track of edit mode so we can apply it to new source files.
+        this._isEditMode = true;
+        // Tell all source files we're in edit mode.
+        this._sourceFileList.forEach((sourceFile) => {
+            sourceFile.sourceFile.enterEditMode();
+        });
+    }
+    exitEditMode() {
+        // Tell all source files we're no longer in edit mode. Gather
+        // up all of their edits.
+        const edits = [];
+        this._sourceFileList.forEach((sourceFile) => {
+            const newContents = sourceFile.sourceFile.exitEditMode();
+            if (newContents) {
+                // This means this source file was modified. We need to recompute its imports after
+                // we put it back to how it was.
+                this._updateSourceFileImports(sourceFile, this.configOptions);
+                // Create a text document so we can compute the edits.
+                const textDocument = vscode_languageserver_textdocument_1.TextDocument.create(sourceFile.sourceFile.getFilePath(), 'python', 1, sourceFile.sourceFile.getFileContent() || '');
+                // Add an edit action to the list.
+                edits.push({
+                    filePath: sourceFile.sourceFile.getFilePath(),
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: textDocument.lineCount, character: 0 },
+                    },
+                    replacementText: newContents,
+                });
+            }
+        });
+        // Stop applying edit mode to new source files.
+        this._isEditMode = false;
+        return edits;
+    }
     setConfigOptions(configOptions) {
         this._configOptions = configOptions;
         this._importResolver.setConfigOptions(configOptions);
@@ -188,12 +217,12 @@ class Program {
             // 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);
+                newFileMap.set((0, pathUtils_1.normalizePathCase)(this.fileSystem, 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());
+                const filePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, oldFile.sourceFile.getFilePath());
                 if (!newFileMap.has(filePath)) {
                     oldFile.isTracked = false;
                 }
@@ -240,7 +269,7 @@ class Program {
             sourceFileInfo.isTracked = true;
             return sourceFileInfo.sourceFile;
         }
-        const sourceFile = new sourceFile_1.SourceFile(this._fs, filePath, importName, isThirdPartyImport, isInPyTypedPackage, this._console, this._logTracker);
+        const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, isThirdPartyImport, isInPyTypedPackage, this._isEditMode, this._console, this._logTracker);
         sourceFileInfo = {
             sourceFile,
             isTracked: true,
@@ -262,9 +291,9 @@ class Program {
         let sourceFileInfo = this.getSourceFileInfo(filePath);
         if (!sourceFileInfo) {
             const importName = this._getImportNameForFile(filePath);
-            const sourceFile = new sourceFile_1.SourceFile(this._fs, filePath, importName, 
+            const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, 
             /* isThirdPartyImport */ false, 
-            /* isInPyTypedPackage */ false, this._console, this._logTracker, options === null || options === void 0 ? void 0 : options.realFilePath, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : sourceFile_1.IPythonMode.None);
+            /* isInPyTypedPackage */ false, this._isEditMode, this._console, this._logTracker, options === null || options === void 0 ? void 0 : options.realFilePath, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : sourceFile_1.IPythonMode.None);
             const chainedFilePath = options === null || options === void 0 ? void 0 : options.chainedFilePath;
             sourceFileInfo = {
                 sourceFile,
@@ -310,7 +339,7 @@ class Program {
         if (sourceFileInfo) {
             sourceFileInfo.isOpenByClient = false;
             sourceFileInfo.isTracked = isTracked !== null && isTracked !== void 0 ? isTracked : sourceFileInfo.isTracked;
-            sourceFileInfo.sourceFile.setClientVersion(null, []);
+            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
@@ -405,7 +434,7 @@ class Program {
         return this._configOptions.functionSignatureDisplay;
     }
     containsSourceFileIn(folder) {
-        const normalized = (0, pathUtils_1.normalizePathCase)(this._fs, folder);
+        const normalized = (0, pathUtils_1.normalizePathCase)(this.fileSystem, folder);
         return this._sourceFileList.some((i) => i.sourceFile.getFilePath().startsWith(normalized));
     }
     owns(filePath) {
@@ -428,8 +457,11 @@ class Program {
         var _a;
         return (_a = this.getBoundSourceFileInfo(filePath)) === null || _a === void 0 ? void 0 : _a.sourceFile;
     }
+    getSourceFileInfoList() {
+        return this._sourceFileList;
+    }
     getSourceFileInfo(filePath) {
-        return this._sourceFileMap.get((0, pathUtils_1.normalizePathCase)(this._fs, filePath));
+        return this._sourceFileMap.get((0, pathUtils_1.normalizePathCase)(this.fileSystem, filePath));
     }
     getBoundSourceFileInfo(filePath, content, force) {
         const sourceFileInfo = this.getSourceFileInfo(filePath);
@@ -504,13 +536,20 @@ class Program {
             // _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.
+            let count = 0;
             const initiallyParsedSet = new Set();
             for (const sourceFileInfo of this._sourceFileList) {
                 if (!sourceFileInfo.sourceFile.isParseRequired()) {
                     initiallyParsedSet.add(sourceFileInfo);
                 }
+                if ((0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo) && !sourceFileInfo.sourceFile.isIndexingRequired()) {
+                    count++;
+                }
+            }
+            if (count >= exports.MaxWorkspaceIndexFileCount) {
+                // Already processed max files.
+                return 0;
             }
-            let count = 0;
             for (const sourceFileInfo of this._sourceFileList) {
                 if (!(0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo) || !sourceFileInfo.sourceFile.isIndexingRequired()) {
                     continue;
@@ -556,6 +595,9 @@ class Program {
         var _a;
         return (_a = this.getBoundSourceFile(filePath)) === null || _a === void 0 ? void 0 : _a.getParseResults();
     }
+    handleMemoryHighUsage() {
+        this._handleMemoryHighUsage();
+    }
     // Prints a detailed list of files that have been checked and the times associated
     // with each of them, sorted greatest to least.
     printDetailedAnalysisTimes() {
@@ -636,7 +678,7 @@ class Program {
                 }
                 const typeStubDir = (0, pathUtils_1.getDirectoryPath)(typeStubPath);
                 try {
-                    (0, pathUtils_1.makeDirectories)(this._fs, typeStubDir, stubPath);
+                    (0, pathUtils_1.makeDirectories)(this.fileSystem, typeStubDir, stubPath);
                 }
                 catch (e) {
                     const errMsg = `Could not create directory for '${typeStubDir}'`;
@@ -663,1763 +705,1122 @@ class Program {
         const evaluator = this._evaluator || this._createNewEvaluator();
         return evaluator.printType(type, options);
     }
-    static _getPrintTypeFlags(configOptions) {
-        let flags = 0 /* None */;
-        if (configOptions.diagnosticRuleSet.printUnknownAsAny) {
-            flags |= 1 /* PrintUnknownWithAny */;
-        }
-        if (configOptions.diagnosticRuleSet.omitConditionalConstraint) {
-            flags |= 64 /* OmitConditionalConstraint */;
-        }
-        if (configOptions.diagnosticRuleSet.omitTypeArgsIfUnknown) {
-            flags |= 2 /* OmitTypeArgumentsIfUnknown */;
-        }
-        if (configOptions.diagnosticRuleSet.omitUnannotatedParamType) {
-            flags |= 4 /* OmitUnannotatedParamType */;
+    getTextOnRange(filePath, range, token) {
+        const sourceFileInfo = this.getSourceFileInfo(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
         }
-        if (configOptions.diagnosticRuleSet.pep604Printing) {
-            flags |= 8 /* PEP604 */;
+        const sourceFile = sourceFileInfo.sourceFile;
+        const fileContents = sourceFile.getOpenFileContents();
+        if (fileContents === undefined) {
+            // this only works with opened file
+            return undefined;
         }
-        return flags;
-    }
-    get _fs() {
-        return this._importResolver.fileSystem;
-    }
-    _getImportNameForFile(filePath) {
-        // We allow illegal module names (e.g. names that include "-" in them)
-        // because we want a unique name for each module even if it cannot be
-        // imported through an "import" statement. It's important to have a
-        // unique name in case two modules declare types with the same local
-        // name. The type checker uses the fully-qualified (unique) module name
-        // to differentiate between such types.
-        const moduleNameAndType = this._importResolver.getModuleNameForImport(filePath, this._configOptions.getDefaultExecEnvironment(), 
-        /* allowIllegalModuleName */ true);
-        return moduleNameAndType.moduleName;
+        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);
+        });
     }
-    // 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.getSourceFileInfo(shadowImplPath);
-        if (!shadowFileInfo) {
-            shadowFileInfo = this.addInterimFile(shadowImplPath);
-        }
-        if (!shadowFileInfo.shadows.includes(stubFile)) {
-            shadowFileInfo.shadows.push(stubFile);
+    getAutoImports(filePath, range, similarityLimit, nameMap, options, token) {
+        const sourceFileInfo = this.getSourceFileInfo(filePath);
+        if (!sourceFileInfo) {
+            return [];
         }
-        if (!stubFile.shadowedBy.includes(shadowFileInfo)) {
-            stubFile.shadowedBy.push(shadowFileInfo);
+        const sourceFile = sourceFileInfo.sourceFile;
+        const fileContents = sourceFile.getOpenFileContents();
+        if (fileContents === undefined) {
+            // this only works with opened file
+            return [];
         }
-        return shadowFileInfo.sourceFile;
-    }
-    _createInterimFileInfo(filePath) {
-        const importName = this._getImportNameForFile(filePath);
-        const sourceFile = new sourceFile_1.SourceFile(this._fs, filePath, importName, 
-        /* isThirdPartyImport */ false, 
-        /* isInPyTypedPackage */ false, this._console, this._logTracker);
-        const sourceFileInfo = {
-            sourceFile,
-            isTracked: false,
-            isOpenByClient: false,
-            isTypeshedFile: false,
-            isThirdPartyImport: false,
-            isThirdPartyPyTypedPresent: false,
-            diagnosticsVersion: undefined,
-            imports: [],
-            importedBy: [],
-            shadows: [],
-            shadowedBy: [],
-        };
-        return sourceFileInfo;
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            var _a;
+            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, options.libraryMap, 
+            /* includeSymbolsFromIndices */ true, token);
+            options.patternMatcher =
+                (_a = options.patternMatcher) !== null && _a !== void 0 ? _a : ((p, t) => (0, stringUtils_1.computeCompletionSimilarity)(p, t) > similarityLimit);
+            const autoImporter = new autoImporter_1.AutoImporter(this._configOptions.findExecEnvironment(filePath), this._importResolver, parseTree, range.start, new completionProvider_1.CompletionMap(), map, options);
+            // 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;
+        });
     }
-    _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,
-            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;
+    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;
     }
-    _parseFile(fileToParse, content, force) {
-        if (!force && (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired())) {
-            return;
-        }
-        // SourceFile.parse should only be called here in the program, as calling it
-        // elsewhere could break the entire dependency graph maintained by the program.
-        // Other parts of the program should use _parseFile to create ParseResults from
-        // the sourceFile. For standalone parseResults, use parseFile or the Parser directly.
-        if (fileToParse.sourceFile.parse(this._configOptions, this._importResolver, content)) {
-            this._parsedFileCount++;
-            this._updateSourceFileImports(fileToParse, this._configOptions);
+    getDiagnosticsForRange(filePath, range) {
+        const sourceFile = this.getSourceFile(filePath);
+        if (!sourceFile) {
+            return [];
         }
-        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 markDirtySet = new Set();
-            this._markFileDirtyRecursive(fileToParse, markDirtySet);
-            // Invalidate the import resolver's cache as well.
-            this._importResolver.invalidateCache();
+        const unfilteredDiagnostics = sourceFile.getDiagnostics(this._configOptions);
+        if (!unfilteredDiagnostics) {
+            return [];
         }
+        return unfilteredDiagnostics.filter((diag) => {
+            return (0, textRange_1.doRangesIntersect)(diag.range, range);
+        });
     }
-    _getImplicitImports(file) {
-        var _a, _b;
-        // If file is not parsed, then chainedSourceFile, ipythonDisplayImport,
-        // builtinsImport might not exist or incorrect.
-        // They will be added when _parseFile is called and _updateSourceFileImports ran.
-        if (file.builtinsImport === file) {
-            return undefined;
-        }
-        const tryReturn = (input) => {
-            if (!input || input.sourceFile.isFileDeleted()) {
+    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;
             }
-            return input;
-        };
-        return (_b = (_a = tryReturn(file.chainedSourceFile)) !== null && _a !== void 0 ? _a : tryReturn(file.ipythonDisplayImport)) !== null && _b !== void 0 ? _b : file.builtinsImport;
-    }
-    _bindImplicitImports(fileToAnalyze) {
-        // Get all of the potential imports for this file.
-        const implicitImports = [];
-        const implicitSet = new Set();
-        let nextImplicitImport = this._getImplicitImports(fileToAnalyze);
-        while (nextImplicitImport) {
-            const implicitPath = nextImplicitImport.sourceFile.getFilePath();
-            if (implicitSet.has(implicitPath)) {
-                // We've found a cycle. Break out of the loop.
-                debug.fail(`Found a cycle in implicit imports files for ${implicitPath}`);
-            }
-            implicitSet.add(implicitPath);
-            implicitImports.push(nextImplicitImport);
-            this._parseFile(nextImplicitImport);
-            nextImplicitImport = this._getImplicitImports(nextImplicitImport);
         }
-        if (implicitImports.length === 0) {
-            return;
-        }
-        // Go in reverse order (so top of chain is first).
-        let implicitImport = implicitImports.pop();
-        while (implicitImport) {
-            // Bind this file, but don't recurse into its imports.
-            this._bindFile(implicitImport, undefined, undefined, /* isImplicitImport */ true);
-            implicitImport = implicitImports.pop();
-        }
-    }
-    // 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, force, isImplicitImport) {
-        var _a, _b;
-        if (!force && (!this._isFileNeeded(fileToAnalyze) || !fileToAnalyze.sourceFile.isBindingRequired())) {
-            return;
-        }
-        this._parseFile(fileToAnalyze, content, force);
-        // Create a function to get the scope info.
-        const getScopeIfAvailable = (fileInfo) => {
-            if (!fileInfo || fileInfo === fileToAnalyze) {
+        this._handleMemoryHighUsage();
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            var _a;
+            const sourceFileInfo = this.getSourceFileInfo(filePath);
+            if (!sourceFileInfo) {
                 return undefined;
             }
-            // If the file was deleted, there's no scope to return.
-            if (fileInfo.sourceFile.isFileDeleted()) {
-                return undefined;
+            const content = (_a = sourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
+            if (options.indexingForAutoImportMode &&
+                !options.includeAllSymbols &&
+                !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;
+                }
             }
-            const parseResults = fileInfo.sourceFile.getParseResults();
-            if (!parseResults) {
-                return undefined;
+            this._bindFile(sourceFileInfo, content);
+            return sourceFileInfo.sourceFile.index(options, token);
+        });
+    }
+    addSymbolsForDocument(filePath, symbolList, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this.getSourceFileInfo(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);
             }
-            // File should already be bound because of the chained file binding above.
-            const scope = AnalyzerNodeInfo.getScope(parseResults.parseTree);
-            return scope;
-        };
-        let builtinsScope;
-        if (fileToAnalyze.builtinsImport && fileToAnalyze.builtinsImport !== fileToAnalyze) {
-            // Bind all of the implicit imports first. So we don't recurse into them.
-            if (!isImplicitImport) {
-                this._bindImplicitImports(fileToAnalyze);
+        });
+    }
+    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;
             }
-            // 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);
+            // "Workspace symbols" searches symbols only from user code.
+            for (const sourceFileInfo of this._sourceFileList) {
+                if (!(0, sourceFileInfoUtils_1.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();
+            }
+        });
+    }
+    async getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, libraryMap, token) {
+        const sourceFileInfo = this.getSourceFileInfo(filePath);
+        if (!sourceFileInfo) {
+            return undefined;
         }
-        let futureImports = fileToAnalyze.sourceFile.getParseResults().futureImports;
-        if (fileToAnalyze.chainedSourceFile) {
-            futureImports = this._getEffectiveFutureImports(futureImports, fileToAnalyze.chainedSourceFile);
+        const completionResult = this._logTracker.log(`completion at ${filePath}:${position.line}:${position.character}`, (ls) => {
+            var _a;
+            const result = this._runEvaluatorWithCancellationToken(token, () => {
+                this._bindFile(sourceFileInfo);
+                return sourceFileInfo.sourceFile.getCompletionsForPosition(this, position, workspacePath, this._lookUpImport, options, nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), token);
+            });
+            ls.add(`found ${(_a = result === null || result === void 0 ? void 0 : result.completionMap.size) !== null && _a !== void 0 ? _a : 'null'} items`);
+            return result;
+        });
+        const completionResultsList = {
+            completionList: vscode_languageserver_types_1.CompletionList.create(completionResult === null || completionResult === void 0 ? void 0 : completionResult.completionMap.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,
+        };
+        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 execEnv = this._configOptions.findExecEnvironment(filePath);
+            const sourceMapper = this._createSourceMapper(execEnv, token, sourceFileInfo, 
+            /* mapCompiled */ true);
+            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
+            if (offset !== undefined && sourceMapper) {
+                await Promise.all(extensibility_1.Extensions.getProgramExtensions(parseResults.parseTree).map((e) => {
+                    var _a;
+                    return (_a = e.completionListExtension) === null || _a === void 0 ? void 0 : _a.updateCompletionResults(this.evaluator, sourceMapper, options, completionResultsList, parseResults, offset, this._configOptions.functionSignatureDisplay, token);
+                }));
+            }
         }
-        fileToAnalyze.effectiveFutureImports = futureImports.size > 0 ? futureImports : undefined;
-        fileToAnalyze.sourceFile.bind(this._configOptions, this._lookUpImport, builtinsScope, futureImports);
+        return completionResultsList;
     }
-    _getEffectiveFutureImports(futureImports, chainedSourceFile) {
-        var _a;
-        const effectiveFutureImports = new Set(futureImports);
-        (_a = chainedSourceFile.effectiveFutureImports) === null || _a === void 0 ? void 0 : _a.forEach((value) => {
-            effectiveFutureImports.add(value);
+    resolveCompletionItem(filePath, completionItem, options, nameMap, libraryMap, token) {
+        return this._runEvaluatorWithCancellationToken(token, () => {
+            const sourceFileInfo = this.getSourceFileInfo(filePath);
+            if (!sourceFileInfo) {
+                return;
+            }
+            this._bindFile(sourceFileInfo);
+            sourceFileInfo.sourceFile.resolveCompletionItem(this, this._lookUpImport, options, nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), completionItem, token);
         });
-        return effectiveFutureImports;
     }
-    // Build a map of all modules within this program and the module-
-    // level scope that contains the symbol table for the module.
-    _buildModuleSymbolsMap(sourceFileToExclude, libraryMap, includeSymbolsFromIndices, token) {
-        // If we have library map, always use the map for library symbols.
-        const predicate = (s) => {
-            if (!libraryMap) {
-                // We don't have any prebuilt indices, so we need to include
-                // all files.
-                return true;
-            }
-            if (!this._configOptions.indexing) {
-                // We have some prebuilt indices such as stdlib, but indexing is disabled.
-                // Include files we don't have prebuilt indices.
-                return libraryMap.get(s.sourceFile.getFilePath()) === undefined;
+    clone() {
+        var _a, _b;
+        const program = new Program(this._importResolver, this._configOptions, this._console, new logTracker_1.LogTracker(this._console, 'Cloned'));
+        // Cloned program will use whatever user files the program currently has.
+        const userFiles = this.getUserFiles();
+        program.setTrackedFiles(userFiles.map((i) => i.sourceFile.getFilePath()));
+        program.markAllFilesDirty(true);
+        // Make sure we keep editor content (open file) which could be different than one in the file system.
+        for (const fileInfo of this.getOpened()) {
+            const version = fileInfo.sourceFile.getClientVersion();
+            if (version === undefined) {
+                continue;
             }
-            // We have prebuilt indices for third party libraries. Include only
-            // user files.
-            return (0, sourceFileInfoUtils_1.isUserCode)(s);
-        };
-        // Only include import alias from user files if indexing is off for now.
-        // Currently, when indexing is off, we don't do import alias deduplication, so
-        // adding import alias is cheap. But when indexing is on, we do deduplication, which
-        // require resolveAliasDeclaration that can cause more files to be parsed and bound.
-        return (0, autoImporter_1.buildModuleSymbolsMap)(this._sourceFileList.filter((s) => s !== sourceFileToExclude && predicate(s)), includeSymbolsFromIndices, token);
+            program.setFileOpened(fileInfo.sourceFile.getFilePath(), version, (_a = fileInfo.sourceFile.getOpenFileContents()) !== null && _a !== void 0 ? _a : '', {
+                chainedFilePath: (_b = fileInfo.chainedSourceFile) === null || _b === void 0 ? void 0 : _b.sourceFile.getFilePath(),
+                ipythonMode: fileInfo.sourceFile.getIPythonMode(),
+                isTracked: fileInfo.isTracked,
+                realFilePath: fileInfo.sourceFile.getRealFilePath(),
+            });
+        }
+        return program;
     }
-    _shouldCheckFile(fileInfo) {
-        // Always do a full checking for a file that's open in the editor.
-        if (fileInfo.isOpenByClient) {
-            return true;
+    // Returns a value from 0 to 1 (or more) indicating how "full" the cache is
+    // relative to some predetermined high-water mark. We'll compute this value
+    // based on two easy-to-compute metrics: the number of entries in the type
+    // cache and the number of parsed files.
+    getCacheUsage() {
+        const typeCacheEntryCount = this._evaluator.getTypeCacheEntryCount();
+        const entryCountRatio = typeCacheEntryCount / 750000;
+        const fileCountRatio = this._parsedFileCount / 1000;
+        return Math.max(entryCountRatio, fileCountRatio);
+    }
+    // Discards any cached information associated with this program.
+    emptyCache() {
+        this._createNewEvaluator();
+        this._discardCachedParseResults();
+        this._parsedFileCount = 0;
+        extensibility_1.Extensions.getProgramExtensions(this.rootPath).forEach((e) => (e.clearCache ? e.clearCache() : null));
+    }
+    test_createSourceMapper(execEnv, from) {
+        return this._createSourceMapper(execEnv, vscode_languageserver_1.CancellationToken.None, /* from */ from, /* mapCompiled */ false);
+    }
+    _handleMemoryHighUsage() {
+        const cacheUsage = this._cacheManager.getCacheUsage();
+        // If the total cache has exceeded 75%, determine whether we should empty
+        // the cache.
+        if (cacheUsage > 0.75) {
+            const usedHeapRatio = this._cacheManager.getUsedHeapRatio(this._configOptions.verboseOutput ? this._console : undefined);
+            // 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;
+            const typeCacheEntryCount = this._evaluator.getTypeCacheEntryCount();
+            // If we use more than 90% of the heap size limit, avoid a crash
+            // by emptying the type cache.
+            if (typeCacheEntryCount > absoluteMaxCacheEntryCount || usedHeapRatio > 0.9) {
+                this._cacheManager.emptyCache(this._console);
+            }
         }
-        // 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;
+    }
+    // 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();
         }
-        return false;
     }
-    _checkTypes(fileToCheck, token) {
-        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;
+    // 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);
             }
-            if (!fileToCheck.sourceFile.isCheckingRequired()) {
-                logState.suppress();
-                return false;
+            else {
+                return callback();
             }
-            if (!this._shouldCheckFile(fileToCheck)) {
-                logState.suppress();
-                return false;
+        }
+        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 (!cancellationUtils_1.OperationCanceledException.is(e)) {
+                this._createNewEvaluator();
             }
-            this._bindFile(fileToCheck);
-            if (this._preCheckCallback) {
-                const parseResults = fileToCheck.sourceFile.getParseResults();
-                if (parseResults) {
-                    this._preCheckCallback(parseResults, this._evaluator);
-                }
-            }
-            if (!this._disableChecker) {
-                // For ipython, make sure we check all its dependent files first since
-                // their results can affect this file's result.
-                let dependentFiles = undefined;
-                if (fileToCheck.sourceFile.getIPythonMode() === sourceFile_1.IPythonMode.CellDocs) {
-                    dependentFiles = [];
-                    const importedByFiles = (0, sourceFileInfoUtils_1.collectImportedByFiles)(fileToCheck);
-                    for (const file of importedByFiles) {
-                        if (!(0, sourceFileInfoUtils_1.isUserCode)(file)) {
-                            continue;
-                        }
-                        // If the file is already analyzed, it will be no op.
-                        // And make sure we don't dump parse tree and etc while
-                        // recursively calling checker. Otherwise, inner check
-                        // can dump parse tree required by outer check.
-                        const handle = this._cacheManager.pauseTracking();
-                        try {
-                            this._checkTypes(file, token);
-                        }
-                        finally {
-                            handle.dispose();
-                        }
-                        const parseResults = file.sourceFile.getParseResults();
-                        if (parseResults) {
-                            dependentFiles.push(parseResults);
+            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--;
                         }
                     }
-                }
-                const execEnv = this._configOptions.findExecEnvironment(fileToCheck.sourceFile.getFilePath());
-                fileToCheck.sourceFile.check(this._importResolver, this._evaluator, this._createSourceMapper(execEnv, token, fileToCheck), dependentFiles);
+                });
+                // Remove any shadowed files corresponding to this file.
+                fileInfo.shadowedBy.forEach((shadowedFile) => {
+                    shadowedFile.shadows = shadowedFile.shadows.filter((f) => f !== fileInfo);
+                });
+                fileInfo.shadowedBy = [];
             }
-            // 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 found in any of the files we visited,
-                                // set a flag to indicates that we don't need to visit them again
-                                // on subsequent cycle checks.
-                                filesVisitedMap.forEach((sourceFileInfo) => {
-                                    sourceFileInfo.sourceFile.setNoCircularDependencyConfirmed();
-                                });
-                            }
-                        });
+            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 true;
-        });
+        }
+        return fileDiagnostics;
     }
-    // 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;
+    _isFileNeeded(fileInfo, skipFileNeededCheck) {
+        if (fileInfo.sourceFile.isFileDeleted()) {
+            return false;
         }
-        // If the import chain is too long, emit an error. Otherwise we
-        // risk blowing the stack.
-        if (recursionCount > _maxImportDepth) {
-            file.sourceFile.setHitMaxImportDepth(_maxImportDepth);
-            return;
+        if (!!skipFileNeededCheck || fileInfo.isTracked || fileInfo.isOpenByClient) {
+            return true;
         }
-        // Add the file to the closure map.
-        closureMap.set(filePath, file);
-        // If this file hasn't already been parsed, parse it now. This will
-        // discover any files it imports. Skip this if the file is part
-        // of a library. We'll assume that no cycles will be generated from
-        // library code or typeshed stubs.
-        if ((0, sourceFileInfoUtils_1.isUserCode)(file)) {
-            this._parseFile(file);
+        if (fileInfo.shadows.length > 0) {
+            return true;
         }
-        // Recursively add the file's imports.
-        for (const importedFileInfo of file.imports) {
-            this._getImportsRecursive(importedFileInfo, closureMap, recursionCount + 1);
+        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 Set());
     }
-    _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;
+    _isImportNeededRecursive(fileInfo, recursionSet) {
+        if (fileInfo.isTracked || fileInfo.isOpenByClient || fileInfo.shadows.length > 0) {
+            return true;
         }
-        // If we've already confirmed that this source file isn't part of a
-        // cycle, we can skip it entirely.
-        if (sourceFileInfo.sourceFile.isNoCircularDependencyConfirmed()) {
+        const filePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, fileInfo.sourceFile.getFilePath());
+        // Avoid infinite recursion.
+        if (recursionSet.has(filePath)) {
             return false;
         }
-        const filePath = (0, pathUtils_1.normalizePathCase)(this._fs, sourceFileInfo.sourceFile.getFilePath());
-        filesVisited.set(filePath, sourceFileInfo);
-        let detectedCycle = false;
-        if (dependencyMap.has(filePath)) {
-            // We detect a cycle (partial or full). A full cycle is one that is
-            // rooted in the file at the start of our dependency chain. A partial
-            // cycle loops back on some other file in the dependency chain. We
-            // will report only full cycles here and leave the reporting of
-            // partial cycles to other passes.
-            detectedCycle = true;
-            // 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);
+        recursionSet.add(filePath);
+        for (const importerInfo of fileInfo.importedBy) {
+            if (this._isImportNeededRecursive(importerInfo, recursionSet)) {
+                return true;
             }
         }
-        else {
-            // If we've already checked this dependency along
-            // some other path, we can skip it.
-            if (dependencyMap.has(filePath)) {
-                return false;
+        return false;
+    }
+    _createSourceMapper(execEnv, token, from, mapCompiled, preferStubs) {
+        const sourceMapper = new sourceMapper_1.SourceMapper(this._importResolver, execEnv, this._evaluator, (stubFilePath, implFilePath) => {
+            let stubFileInfo = this.getSourceFileInfo(stubFilePath);
+            if (!stubFileInfo) {
+                // Special case for import statement like "import X.Y". The SourceFile
+                // for X might not be in memory since import `X.Y` only brings in Y.
+                stubFileInfo = this.addInterimFile(stubFilePath);
             }
-            // 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;
-                }
+            this._addShadowedFile(stubFileInfo, implFilePath);
+            return this.getBoundSourceFile(implFilePath);
+        }, (f) => {
+            let fileInfo = this.getBoundSourceFileInfo(f);
+            if (!fileInfo) {
+                // Special case for import statement like "import X.Y". The SourceFile
+                // for X might not be in memory since import `X.Y` only brings in Y.
+                fileInfo = this.addInterimFile(f);
+                // Even though this file is not referenced by anything, make sure
+                // we have a parse tree for the doc string.
+                this._parseFile(fileInfo, /* content */ undefined, /* force */ 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.getSourceFileInfo(firstFilePath);
-        (0, debug_1.assert)(firstSourceFile !== undefined);
-        firstSourceFile.sourceFile.addCircularDependency(circDep);
+            return fileInfo;
+        }, mapCompiled !== null && mapCompiled !== void 0 ? mapCompiled : false, preferStubs !== null && preferStubs !== void 0 ? preferStubs : false, from, token);
+        return sourceMapper;
     }
-    _markFileDirtyRecursive(sourceFileInfo, markSet, 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 (markSet.has(filePath)) {
-            return;
+    _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;
         }
-        sourceFileInfo.sourceFile.markReanalysisRequired(forceRebinding);
-        markSet.add(filePath);
-        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, markSet, forceRebinding);
-        });
-        // Change in the current file could impact checker result of chainedSourceFile such as unused symbols.
-        let chainedSourceFile = sourceFileInfo.chainedSourceFile;
-        while (chainedSourceFile) {
-            if (chainedSourceFile.sourceFile.isCheckingRequired()) {
-                // If the file is marked for checking, its chained one should be marked
-                // as well. Stop here.
-                return;
-            }
-            chainedSourceFile.sourceFile.markReanalysisRequired(/* forceRebinding */ false);
-            chainedSourceFile = chainedSourceFile.chainedSourceFile;
-        }
-    }
-    getTextOnRange(filePath, range, token) {
-        const sourceFileInfo = this.getSourceFileInfo(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, options, token) {
-        const sourceFileInfo = this.getSourceFileInfo(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, () => {
-            var _a;
-            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, options.libraryMap, 
-            /* includeSymbolsFromIndices */ true, token);
-            options.patternMatcher =
-                (_a = options.patternMatcher) !== null && _a !== void 0 ? _a : ((p, t) => (0, stringUtils_1.computeCompletionSimilarity)(p, t) > similarityLimit);
-            const autoImporter = new autoImporter_1.AutoImporter(this._configOptions.findExecEnvironment(filePath), this._importResolver, parseTree, range.start, new completionProvider_1.CompletionMap(), map, options);
-            // 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.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            return sourceFileInfo.sourceFile.getDefinitionsForPosition(this._createSourceMapper(execEnv, token, sourceFileInfo), position, filter, this._evaluator, token);
-        });
-    }
-    getTypeDefinitionsForPosition(filePath, position, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            return sourceFileInfo.sourceFile.getTypeDefinitionsForPosition(this._createSourceMapper(execEnv, token, sourceFileInfo, 
-            /* mapCompiled */ false, 
-            /* preferStubs */ true), position, this._evaluator, filePath, token);
-        });
-    }
-    reportReferencesForPosition(filePath, position, includeDeclaration, reporter, token) {
-        this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return;
-            }
-            const invokedFromUserFile = (0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo);
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            const referencesResult = this._getDeclarationForPosition(sourceFileInfo, position, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Reference, this._createSourceMapper(execEnv, token, sourceFileInfo), token, reporter);
-            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 || (0, sourceFileInfoUtils_1.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 || referencesResult.symbolNames.some((s) => fileContents.search(s) >= 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.getSourceFileInfo(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.symbolNames, referencesResult.declarations, referencesResult.useCase);
-                        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.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            const content = (_a = sourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
-            if (options.indexingForAutoImportMode &&
-                !options.includeAllSymbols &&
-                !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.getSourceFileInfo(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 (!(0, sourceFileInfoUtils_1.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();
-            }
-        });
-    }
-    getDocumentHighlight(filePath, position, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            return sourceFileInfo.sourceFile.getDocumentHighlight(this._createSourceMapper(execEnv, token, sourceFileInfo), position, this._evaluator, token);
-        });
-    }
-    getSignatureHelpForPosition(filePath, position, format, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            return sourceFileInfo.sourceFile.getSignatureHelpForPosition(position, this._createSourceMapper(execEnv, token, sourceFileInfo, /* mapCompiled */ true), this._evaluator, format, token);
-        });
-    }
-    async getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, libraryMap, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
-        }
-        let sourceMapper;
-        const completionResult = this._logTracker.log(`completion at ${filePath}:${position.line}:${position.character}`, (ls) => {
-            var _a;
-            const result = this._runEvaluatorWithCancellationToken(token, () => {
-                this._bindFile(sourceFileInfo);
-                const execEnv = this._configOptions.findExecEnvironment(filePath);
-                sourceMapper = this._createSourceMapper(execEnv, token, sourceFileInfo, /* mapCompiled */ true);
-                return sourceFileInfo.sourceFile.getCompletionsForPosition(position, workspacePath, this._configOptions, this._importResolver, this._lookUpImport, this._evaluator, options, sourceMapper, nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), token);
-            });
-            ls.add(`found ${(_a = result === null || result === void 0 ? void 0 : result.completionMap.size) !== null && _a !== void 0 ? _a : 'null'} items`);
-            return result;
-        });
-        const completionResultsList = {
-            completionList: vscode_languageserver_types_1.CompletionList.create(completionResult === null || completionResult === void 0 ? void 0 : completionResult.completionMap.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,
-        };
-        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 && sourceMapper) {
-                await Promise.all(extensibility_1.Extensions.getProgramExtensions(parseResults.parseTree).map((e) => {
-                    var _a;
-                    return (_a = e.completionListExtension) === null || _a === void 0 ? void 0 : _a.updateCompletionResults(this.evaluator, sourceMapper, options, completionResultsList, parseResults, offset, this._configOptions.functionSignatureDisplay, token);
-                }));
-            }
-        }
-        return completionResultsList;
-    }
-    resolveCompletionItem(filePath, completionItem, options, nameMap, libraryMap, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(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, token, sourceFileInfo, /* mapCompiled */ true), nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), completionItem, token);
-        });
-    }
-    renameModule(path, newPath, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            if ((0, pathUtils_1.isFile)(this._fs, path)) {
-                const fileInfo = this.getSourceFileInfo(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, options, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a, _b;
-            const sourceFileExt = (0, pathUtils_1.getFileExtension)(filePath);
-            const destFileExt = (0, pathUtils_1.getFileExtension)(newFilePath);
-            if (sourceFileExt.toLowerCase() !== destFileExt.toLowerCase()) {
-                // Don't allow moving a symbol from py to pyi or vice versa.
-                return undefined;
-            }
-            const fileInfo = this.getSourceFileInfo(filePath);
-            if (!fileInfo) {
-                return undefined;
-            }
-            const newFileInfo = this.getBoundSourceFileInfo(newFilePath);
-            if (fileInfo === newFileInfo) {
-                // Can't move symbol to the same file.
-                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 */ ||
-                !renameModuleProvider_1.RenameModuleProvider.canMoveSymbol(this._configOptions, this._evaluator, node)) {
-                return undefined;
-            }
-            // We will try to
-            // 1. Find symbol to move.
-            // 2. Update all references to the symbol to new location.
-            // 3. Remove the existing symbol.
-            // 4. Insert the symbol to the destination module.
-            // 5. Insert imports required for the symbol moved to the destination module.
-            // 6. Remove import no longer needed from the original module.
-            //
-            // Here all changes are done to edits, no features in LS will apply changes to
-            // program directly. All modification is done through LSP by a edit request so
-            // things like undo or edit stacks UI works.
-            // 1. Find symbol to move.
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            const declarations = documentSymbolCollector_1.DocumentSymbolCollector.getDeclarationsForNode(node, this._evaluator, 
-            /* resolveLocalNames */ false, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Rename, token, this._createSourceMapper(execEnv, token, fileInfo));
-            const renameModuleProvider = renameModuleProvider_1.RenameModuleProvider.createForSymbol(this._importResolver, this._configOptions, this._evaluator, filePath, newFilePath, declarations, token);
-            if (!renameModuleProvider) {
-                return undefined;
-            }
-            // 2. Update affected references.
-            this._processModuleReferences(renameModuleProvider, node.value, filePath);
-            // 3. Remove existing symbols.
-            const sourceDecl = renameModuleProvider.declarations.find((d) => d.node && (0, pathUtils_1.getFileExtension)(d.path) === sourceFileExt);
-            if (!sourceDecl) {
-                // Can't find symbol we can move.
-                return undefined;
-            }
-            const symbolRange = renameModuleProvider_1.RenameModuleProvider.getSymbolTextRange(parseResults, sourceDecl);
-            const importAdder = new importAdder_1.ImportAdder(this._configOptions, this._importResolver, this._evaluator);
-            const collectedImports = importAdder.collectImportsForSymbolsUsed(parseResults, symbolRange, token);
-            let insertionPoint = 0;
-            let insertionIndentation = 0;
-            const newFileParseResults = newFileInfo === null || newFileInfo === void 0 ? void 0 : newFileInfo.sourceFile.getParseResults();
-            if (newFileParseResults) {
-                const insertBefore = renameModuleProvider.tryGetFirstSymbolUsage(newFileParseResults);
-                insertionPoint = (0, insertionPointUtils_1.getInsertionPointForSymbolUnderModule)(this._evaluator, newFileParseResults, node.value, {
-                    symbolDeclToIgnore: sourceDecl.path,
-                    insertBefore,
-                });
-                if (insertionPoint === undefined) {
-                    // No place to insert the symbol.
-                    return undefined;
-                }
-                insertionIndentation = (0, indentationUtils_1.getModuleStatementIndentation)(newFileParseResults);
-            }
-            const reindentResult = (0, indentationUtils_1.reindentSpan)(parseResults, symbolRange, insertionIndentation);
-            const fullRange = renameModuleProvider_1.RenameModuleProvider.getSymbolFullStatementTextRange(parseResults, sourceDecl);
-            renameModuleProvider.textEditTracker.addEdit(filePath, (0, positionUtils_1.convertTextRangeToRange)(textRange_1.TextRange.combine([reindentResult.originalSpan, fullRange]), parseResults.tokenizerOutput.lines), '');
-            // 4. Add the symbol to the destination file.
-            const fileOperations = [];
-            let codeSnippetToInsert = reindentResult.text;
-            if (newFileParseResults) {
-                const range = (0, positionUtils_1.convertTextRangeToRange)({ start: insertionPoint, length: 0 }, newFileParseResults.tokenizerOutput.lines);
-                // If we are adding at the end of line (ex, end of a file),
-                // add new lines.
-                const newLinesToAdd = _getNumberOfBlankLinesToInsert(newFileParseResults, sourceDecl, range.end);
-                codeSnippetToInsert = '\n'.repeat(newLinesToAdd) + codeSnippetToInsert;
-                renameModuleProvider.textEditTracker.addEdit(newFilePath, range, codeSnippetToInsert);
-            }
-            else {
-                fileOperations.push({ kind: 'create', filePath: newFilePath });
-                renameModuleProvider.textEditTracker.addEdit(newFilePath, (0, textRange_1.getEmptyRange)(), codeSnippetToInsert);
-            }
-            // 5. Insert imports required for the symbol moved to the destination module.
-            //
-            // Since step 5 and 6 can create nested edits, we clone the program and apply all changes to re-calculate
-            // edits we need to apply to the destination file. The same workflow as `fix all` but done in program level
-            // not service level.
-            const cloned = this.clone();
-            let edits = renameModuleProvider.getEdits();
-            const textAfterSymbolAdded = (0, workspaceEditUtils_1.applyTextEditsToString)(edits.filter((v) => v.filePath === newFilePath), (_a = newFileParseResults === null || newFileParseResults === void 0 ? void 0 : newFileParseResults.tokenizerOutput.lines) !== null && _a !== void 0 ? _a : new textRangeCollection_1.TextRangeCollection([]), (_b = newFileInfo === null || newFileInfo === void 0 ? void 0 : newFileInfo.sourceFile.getFileContent()) !== null && _b !== void 0 ? _b : '');
-            _updateFileContent(cloned, newFilePath, textAfterSymbolAdded);
-            const textAfterImportsAdded = _tryGetTextAfterImportsAdded(cloned, newFilePath, collectedImports, insertionPoint, token);
-            edits = _updateFileEditActions(edits, newFilePath, newFileParseResults, textAfterSymbolAdded, textAfterImportsAdded);
-            // 6. Remove imports no longer required from original module.
-            const textAfterSymbolRemoved = (0, workspaceEditUtils_1.applyTextEditsToString)(edits.filter((v) => v.filePath === filePath), parseResults.tokenizerOutput.lines, fileInfo.sourceFile.getFileContent());
-            _updateFileContent(cloned, filePath, textAfterSymbolRemoved);
-            const textAfterUnusedImportsRemoved = _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, collectedImports, 0, token);
-            edits = _updateFileEditActions(edits, filePath, parseResults, textAfterSymbolRemoved, textAfterUnusedImportsRemoved);
-            cloned.dispose();
-            return {
-                edits,
-                fileOperations,
-            };
-            function _updateFileEditActions(edits, filePath, parseResults, oldText, newText) {
-                if (newText === undefined || oldText === newText) {
-                    return edits;
-                }
-                // There were nested edits. Replace whole file.
-                edits = edits.filter((v) => v.filePath !== filePath);
-                edits.push({
-                    filePath,
-                    range: parseResults
-                        ? (0, positionUtils_1.convertTextRangeToRange)(parseResults.parseTree, parseResults.tokenizerOutput.lines)
-                        : (0, textRange_1.getEmptyRange)(),
-                    replacementText: newText,
-                });
-                return edits;
-            }
-            function _tryGetTextAfterImportsAdded(cloned, filePath, importData, insertionPoint, token) {
-                const sourceFile = cloned.getBoundSourceFile(filePath);
-                const parseResults = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.getParseResults();
-                if (!parseResults) {
-                    return undefined;
-                }
-                const insertAddEdits = importAdder.applyImports(importData, filePath, parseResults, insertionPoint, options.importFormat, token);
-                return (0, workspaceEditUtils_1.applyTextEditsToString)(insertAddEdits, parseResults.tokenizerOutput.lines, sourceFile.getFileContent());
-            }
-            function _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, importData, attempt, token) {
-                var _a;
-                (0, cancellationUtils_1.throwIfCancellationRequested)(token);
-                cloned.analyzeFile(filePath, token);
-                const sourceFile = cloned.getBoundSourceFile(filePath);
-                const parseResults = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.getParseResults();
-                if (!parseResults) {
-                    return undefined;
+        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;
                 }
-                const tracker = new textEditTracker_1.TextEditTracker();
-                for (const diagnostic of cloned
-                    .getDiagnosticsForRange(filePath, (0, positionUtils_1.convertTextRangeToRange)(parseResults.parseTree, parseResults.tokenizerOutput.lines))
-                    .filter((d) => {
-                    var _a;
-                    return d.category === 3 /* UnusedCode */ &&
-                        ((_a = d.getActions()) === null || _a === void 0 ? void 0 : _a.some((a) => a.action === "pyright.unusedImport" /* unusedImport */));
-                })) {
-                    const nameNode = (0, parseTreeUtils_1.findNodeByPosition)(parseResults.parseTree, diagnostic.range.start, parseResults.tokenizerOutput.lines);
-                    if ((nameNode === null || nameNode === void 0 ? void 0 : nameNode.nodeType) !== 38 /* Name */) {
-                        continue;
+                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;
                     }
-                    // decl is synthesized. there is no node associated with the decl.
-                    // ex) import a or import a.b
-                    const dottedName1 = ((_a = nameNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 37 /* ModuleName */ ? nameNode.parent.nameParts : [nameNode];
-                    for (const [decl, names] of importData.declarations) {
-                        if (decl.node) {
-                            if (textRange_1.TextRange.containsRange(decl.node, nameNode)) {
-                                tracker.removeNodes({ node: nameNode, parseResults: parseResults });
-                                break;
-                            }
-                        }
-                        const dottedName2 = (0, parseTreeUtils_1.getDottedName)((0, parseTreeUtils_1.getDottedNameWithGivenNodeAsLastName)(names[0]));
-                        if (dottedName2 && (0, collectionUtils_1.arrayEquals)(dottedName1, dottedName2, (e1, e2) => e1.value === e2.value)) {
-                            tracker.removeNodes({ node: nameNode, parseResults: parseResults });
-                            break;
-                        }
+                    if (importResult.importName.startsWith(importName + '.')) {
+                        return true;
                     }
+                    return false;
+                })) {
+                    thirdPartyImportAllowed = true;
                 }
-                const oldText = sourceFile.getFileContent();
-                const newText = (0, workspaceEditUtils_1.applyTextEditsToString)(tracker.getEdits(token).filter((v) => v.filePath === filePath), parseResults.tokenizerOutput.lines, oldText);
-                // We will attempt to remove unused imports multiple times since removing 1 unused import
-                // could make another import unused. This is due to how we calculate which import is not used.
-                // ex) import os, os.path, os.path.xxx
-                // `os.path` and `os.path.xxx` will be marked as used due to `import os`.
-                // once `os` is removed `os.path` will be marked as unused and so on.
-                // We will attempt to remove those chained unused imports up to 10 chain.
-                if (attempt > 10 || oldText === newText) {
-                    return newText;
-                }
-                _updateFileContent(cloned, filePath, newText);
-                return _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, importData, attempt + 1, token);
-            }
-        });
-        function _updateFileContent(cloned, filePath, text) {
-            var _a, _b;
-            const info = cloned.getSourceFileInfo(filePath);
-            const version = info ? ((_a = info.sourceFile.getClientVersion()) !== null && _a !== void 0 ? _a : 0) + 1 : 0;
-            const chainedFilePath = info ? (_b = info.chainedSourceFile) === null || _b === void 0 ? void 0 : _b.sourceFile.getFilePath() : undefined;
-            const ipythonMode = info ? info.sourceFile.getIPythonMode() : sourceFile_1.IPythonMode.None;
-            const isTracked = info ? info.isTracked : true;
-            const realFilePath = info ? info.sourceFile.getRealFilePath() : filePath;
-            cloned.setFileOpened(filePath, version, [{ text }], {
-                chainedFilePath,
-                ipythonMode,
-                isTracked,
-                realFilePath,
-            });
-        }
-        function _getNumberOfBlankLinesToInsert(parseResults, decl, position) {
-            if (position.line === 0 && position.character === 0) {
-                return 0;
             }
-            let previousStatement;
-            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
-            if (offset && parseResults.parseTree.statements.length > 0) {
-                previousStatement = parseResults.parseTree.statements.reduce((prev, curr) => offset < curr.start ? prev : curr);
-            }
-            // This basically try to add some blank lines after the last line with text.
-            let linesToAdd = 0;
-            if (previousStatement) {
-                if ((0, declaration_1.isVariableDeclaration)(decl)) {
-                    switch (previousStatement.nodeType) {
-                        case 47 /* StatementList */:
-                            // Small statement such as call, assignment, etc.
-                            linesToAdd = 0;
-                            break;
-                        case 10 /* Class */:
-                        case 28 /* Function */:
-                            linesToAdd = 2;
-                            break;
-                        default:
-                            // any other statement such as if, while, etc. we will add 1 blank line.
-                            linesToAdd = 1;
-                    }
-                }
-                else {
-                    linesToAdd = 2;
-                }
+            else if (importer.isThirdPartyImport && this._configOptions.useLibraryCodeForTypes) {
+                // If the importing file is a third-party import, allow importing of
+                // additional third-party imports. This supports the case where the importer
+                // is in a py.typed library but is importing from another non-py.typed
+                // library. It also supports the case where someone explicitly opens a
+                // library source file in their editor.
+                thirdPartyImportAllowed = true;
             }
-            // If the position is not at the beginning of the line, we need to add 1 more '\n'
-            // to start from blank line.
-            linesToAdd += position.character !== 0 ? 1 : 0;
-            // If there are already blank lines, we only add the difference.
-            const desiredBlankLines = linesToAdd;
-            const startingLine = position.character !== 0 ? position.line : position.line - 1;
-            for (let i = 0; i < desiredBlankLines; i++) {
-                const currentLine = startingLine - i;
-                if (currentLine < 0 || !(0, parseTreeUtils_1.isBlankLine)(parseResults, currentLine)) {
-                    break;
-                }
-                linesToAdd--;
+            else if (importResult.isNamespacePackage &&
+                importResult.filteredImplicitImports.some((implicitImport) => !!implicitImport.pyTypedInfo)) {
+                // Handle the case where the import targets a namespace package, and a
+                // submodule contained within it has a py.typed marker.
+                thirdPartyImportAllowed = true;
             }
-            return linesToAdd;
-        }
-    }
-    clone() {
-        var _a;
-        const program = new Program(this._importResolver, this._configOptions, this._console, new logTracker_1.LogTracker(this._console, 'Cloned'));
-        // Cloned program will use whatever user files the program currently has.
-        const userFiles = this.getUserFiles();
-        program.setTrackedFiles(userFiles.map((i) => i.sourceFile.getFilePath()));
-        program.markAllFilesDirty(true);
-        // Make sure we keep editor content (open file) which could be different than one in the file system.
-        for (const fileInfo of this.getOpened()) {
-            const version = fileInfo.sourceFile.getClientVersion();
-            if (version === undefined) {
-                continue;
+            // 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;
             }
-            program.setFileOpened(fileInfo.sourceFile.getFilePath(), version, [{ text: fileInfo.sourceFile.getOpenFileContents() }], {
-                chainedFilePath: (_a = fileInfo.chainedSourceFile) === null || _a === void 0 ? void 0 : _a.sourceFile.getFilePath(),
-                ipythonMode: fileInfo.sourceFile.getIPythonMode(),
-                isTracked: fileInfo.isTracked,
-                realFilePath: fileInfo.sourceFile.getRealFilePath(),
-            });
         }
-        return program;
+        return true;
     }
-    canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(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;
+    _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;
+                }
             }
-            const renameMode = this._getRenameSymbolMode(sourceFileInfo, referencesResult, isDefaultWorkspace);
-            if (renameMode === 'none') {
-                return undefined;
+            else if (sourceFileInfo.isThirdPartyImport && importResult.importType === 2 /* Local */) {
+                isThirdPartyImport = true;
+                if (sourceFileInfo.isThirdPartyPyTypedPresent) {
+                    isPyTypedPresent = true;
+                }
             }
-            // Return the range of the symbol.
-            const parseResult = sourceFileInfo.sourceFile.getParseResults();
             return {
-                range: (0, positionUtils_1.convertTextRangeToRange)(referencesResult.nodeAtOffset, parseResult.tokenizerOutput.lines),
-                declarations: referencesResult.declarations,
+                isThirdPartyImport,
+                isPyTypedPresent,
             };
-        });
-    }
-    renameSymbolAtPosition(filePath, position, newName, isDefaultWorkspace, allowModuleRename, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a;
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            this._bindFile(sourceFileInfo);
-            const referencesResult = this._getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token);
-            if (!referencesResult) {
-                return undefined;
+        };
+        // 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;
             }
-            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,
+            else {
+                const filePath = sourceFileInfo.chainedSourceFile.sourceFile.getFilePath();
+                newImportPathMap.set((0, pathUtils_1.normalizePathCase)(this.fileSystem, filePath), {
+                    path: filePath,
+                    isTypeshedFile: false,
+                    isThirdPartyImport: false,
+                    isPyTypedPresent: false,
                 });
-                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,
+            }
+        }
+        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.fileSystem, filePath), {
+                                path: filePath,
+                                isTypeshedFile: !!importResult.isStdlibTypeshedFile || !!importResult.isThirdPartyTypeshedFile,
+                                isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
+                                isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
                             });
                         }
                     }
                 }
-                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 ((0, sourceFileInfoUtils_1.isUserCode)(curSourceFileInfo)) {
-                            // Make sure searching symbol name exists in the file.
-                            const content = (_a = curSourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
-                            if (!referencesResult.symbolNames.some((s) => content.search(s) >= 0)) {
-                                continue;
+                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.fileSystem, implicitImport.path), {
+                                path: implicitImport.path,
+                                isTypeshedFile: !!importResult.isStdlibTypeshedFile || !!importResult.isThirdPartyTypeshedFile,
+                                isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
+                                isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
+                            });
+                        }
+                    }
+                });
+                // If the stub was found but the non-stub (source) file was not, dump
+                // the failure to the log for diagnostic purposes.
+                if (importResult.nonStubImportResult && !importResult.nonStubImportResult.isImportFound) {
+                    // We'll skip this for imports from within stub files and imports that target
+                    // stdlib typeshed stubs because many of these are known to not have
+                    // associated source files, and we don't want to fill the logs with noise.
+                    if (!sourceFileInfo.sourceFile.isStubFile() && !importResult.isStdlibTypeshedFile) {
+                        if (options.verboseOutput) {
+                            this._console.info(`Could not resolve source for '${importResult.importName}' ` +
+                                `in file '${sourceFileInfo.sourceFile.getFilePath()}'`);
+                            if (importResult.nonStubImportResult.importFailureInfo) {
+                                importResult.nonStubImportResult.importFailureInfo.forEach((diag) => {
+                                    this._console.info(`  ${diag}`);
+                                });
                             }
-                            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: [] };
+            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}`);
+                    });
+                }
+            }
         });
-    }
-    getCallForPosition(filePath, position, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
-        }
-        this._bindFile(sourceFileInfo);
-        const execEnv = this._configOptions.findExecEnvironment(filePath);
-        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv, token, sourceFileInfo), position, this._evaluator, undefined, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Reference, token);
-        if (!referencesResult || referencesResult.declarations.length === 0) {
-            return undefined;
-        }
-        const { targetDecl, callItemUri, symbolName } = callHierarchyProvider_1.CallHierarchyProvider.getTargetDeclaration(referencesResult, filePath);
-        return callHierarchyProvider_1.CallHierarchyProvider.getCallForDeclaration(symbolName, targetDecl, this._evaluator, token, callItemUri);
-    }
-    getIncomingCallsForPosition(filePath, position, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
-        }
-        this._bindFile(sourceFileInfo);
-        const execEnv = this._configOptions.findExecEnvironment(filePath);
-        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv, token, sourceFileInfo), position, this._evaluator, undefined, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Reference, token);
-        if (!referencesResult || referencesResult.declarations.length === 0) {
-            return undefined;
-        }
-        const { targetDecl, symbolName } = callHierarchyProvider_1.CallHierarchyProvider.getTargetDeclaration(referencesResult, filePath);
-        let items = [];
-        const sourceFiles = targetDecl.type === 8 /* Alias */ ? [sourceFileInfo] : this._sourceFileList;
-        for (const curSourceFileInfo of sourceFiles) {
-            if ((0, sourceFileInfoUtils_1.isUserCode)(curSourceFileInfo) || curSourceFileInfo.isOpenByClient) {
-                this._bindFile(curSourceFileInfo);
-                const itemsToAdd = callHierarchyProvider_1.CallHierarchyProvider.getIncomingCallsForDeclaration(curSourceFileInfo.sourceFile.getFilePath(), symbolName, targetDecl, curSourceFileInfo.sourceFile.getParseResults(), this._evaluator, token);
-                if (itemsToAdd) {
-                    items = items.concat(...itemsToAdd);
+        const updatedImportMap = new Map();
+        sourceFileInfo.imports.forEach((importInfo) => {
+            const oldFilePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, importInfo.sourceFile.getFilePath());
+            // A previous import was removed.
+            if (!newImportPathMap.has(oldFilePath)) {
+                importInfo.importedBy = importInfo.importedBy.filter((fi) => (0, pathUtils_1.normalizePathCase)(this.fileSystem, fi.sourceFile.getFilePath()) !==
+                    (0, pathUtils_1.normalizePathCase)(this.fileSystem, 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 = this.getSourceFileInfo(importInfo.path);
+                if (!importedFileInfo) {
+                    const importName = this._getImportNameForFile(importInfo.path);
+                    const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, importInfo.path, importName, importInfo.isThirdPartyImport, importInfo.isPyTypedPresent, this._isEditMode, 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);
                 }
-                // This operation can consume significant memory, so check
-                // for situations where we need to discard the type cache.
-                this._handleMemoryHighUsage();
+                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.getSourceFileInfo(path)) {
+                sourceFileInfo.imports.push(this.getSourceFileInfo(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.getSourceFileInfo(resolvedBuiltinsPath);
         }
-        return items;
-    }
-    getOutgoingCallsForPosition(filePath, position, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
-        }
-        this._bindFile(sourceFileInfo);
-        const execEnv = this._configOptions.findExecEnvironment(filePath);
-        const referencesResult = sourceFileInfo.sourceFile.getDeclarationForPosition(this._createSourceMapper(execEnv, token, sourceFileInfo), position, this._evaluator, undefined, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Reference, token);
-        if (!referencesResult || referencesResult.declarations.length === 0) {
-            return undefined;
-        }
-        const { targetDecl } = callHierarchyProvider_1.CallHierarchyProvider.getTargetDeclaration(referencesResult, filePath);
-        return callHierarchyProvider_1.CallHierarchyProvider.getOutgoingCallsForDeclaration(targetDecl, sourceFileInfo.sourceFile.getParseResults(), this._evaluator, token);
-    }
-    performQuickAction(filePath, command, args, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
+        // 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.getSourceFileInfo(resolvedIPythonDisplayPath);
         }
-        this._bindFile(sourceFileInfo);
-        return sourceFileInfo.sourceFile.performQuickAction(command, args, token);
-    }
-    // Returns a value from 0 to 1 (or more) indicating how "full" the cache is
-    // relative to some predetermined high-water mark. We'll compute this value
-    // based on two easy-to-compute metrics: the number of entries in the type
-    // cache and the number of parsed files.
-    getCacheUsage() {
-        const typeCacheEntryCount = this._evaluator.getTypeCacheEntryCount();
-        const entryCountRatio = typeCacheEntryCount / 750000;
-        const fileCountRatio = this._parsedFileCount / 1000;
-        return Math.max(entryCountRatio, fileCountRatio);
+        return filesAdded;
     }
-    // Discards any cached information associated with this program.
-    emptyCache() {
-        this._createNewEvaluator();
-        this._discardCachedParseResults();
-        this._parsedFileCount = 0;
-        extensibility_1.Extensions.getProgramExtensions(this.rootPath).forEach((e) => (e.clearCache ? e.clearCache() : null));
+    _removeSourceFileFromListAndMap(filePath, indexToRemove) {
+        this._sourceFileMap.delete((0, pathUtils_1.normalizePathCase)(this.fileSystem, filePath));
+        this._sourceFileList.splice(indexToRemove, 1);
     }
-    test_createSourceMapper(execEnv, from) {
-        return this._createSourceMapper(execEnv, vscode_languageserver_1.CancellationToken.None, /* from */ from, /* mapCompiled */ false);
+    _addToSourceFileListAndMap(fileInfo) {
+        const filePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, 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);
     }
-    _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 = (0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo);
-        if (isDefaultWorkspace ||
-            (userFile && !referencesResult.requiresGlobalSearch) ||
-            (!userFile &&
-                sourceFileInfo.isOpenByClient &&
-                referencesResult.declarations.every((d) => this.getSourceFileInfo(d.path) === sourceFileInfo))) {
-            return 'singleFileMode';
-        }
-        if (referencesResult.declarations.every((d) => (0, sourceFileInfoUtils_1.isUserCode)(this.getSourceFileInfo(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) => (0, sourceFileInfoUtils_1.isUserCode)(this.getSourceFileInfo(d.path)));
-    }
-    _getReferenceResult(sourceFileInfo, filePath, position, allowModuleRename, token) {
-        const execEnv = this._configOptions.findExecEnvironment(filePath);
-        const referencesResult = this._getDeclarationForPosition(sourceFileInfo, position, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Rename, this._createSourceMapper(execEnv, token), token);
-        if (!referencesResult) {
-            return undefined;
+    static _getPrintTypeFlags(configOptions) {
+        let flags = 0 /* None */;
+        if (configOptions.diagnosticRuleSet.printUnknownAsAny) {
+            flags |= 1 /* PrintUnknownWithAny */;
         }
-        if (allowModuleRename && referencesResult.containsOnlyImportDecls) {
-            return referencesResult;
+        if (configOptions.diagnosticRuleSet.omitConditionalConstraint) {
+            flags |= 64 /* OmitConditionalConstraint */;
         }
-        if (referencesResult.nonImportDeclarations.length === 0) {
-            // There is no symbol we can rename.
-            return undefined;
+        if (configOptions.diagnosticRuleSet.omitTypeArgsIfUnknown) {
+            flags |= 2 /* OmitTypeArgumentsIfUnknown */;
+        }
+        if (configOptions.diagnosticRuleSet.omitUnannotatedParamType) {
+            flags |= 4 /* OmitUnannotatedParamType */;
         }
-        // Use declarations that doesn't contain import decls.
-        return new referencesProvider_1.ReferencesResult(referencesResult.requiresGlobalSearch, referencesResult.nodeAtOffset, referencesResult.symbolNames, referencesResult.nonImportDeclarations, referencesResult.useCase);
+        if (configOptions.diagnosticRuleSet.pep604Printing) {
+            flags |= 8 /* PEP604 */;
+        }
+        return flags;
     }
-    _getDeclarationForPosition(sourceFileInfo, position, useCase, sourceMapper, token, reporter) {
-        return sourceFileInfo.sourceFile.getDeclarationForPosition(sourceMapper, position, this._evaluator, reporter, useCase, token, Array.from((0, sourceFileInfoUtils_1.collectImportedByFiles)(sourceFileInfo)).map((fileInfo) => fileInfo.sourceFile));
+    _getImportNameForFile(filePath) {
+        // We allow illegal module names (e.g. names that include "-" in them)
+        // because we want a unique name for each module even if it cannot be
+        // imported through an "import" statement. It's important to have a
+        // unique name in case two modules declare types with the same local
+        // name. The type checker uses the fully-qualified (unique) module name
+        // to differentiate between such types.
+        const moduleNameAndType = this._importResolver.getModuleNameForImport(filePath, this._configOptions.getDefaultExecEnvironment(), 
+        /* allowIllegalModuleName */ true);
+        return moduleNameAndType.moduleName;
     }
-    _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 (!(0, sourceFileInfoUtils_1.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(parseResult);
-            // This operation can consume significant memory, so check
-            // for situations where we need to discard the type cache.
-            this._handleMemoryHighUsage();
+    // 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.getSourceFileInfo(shadowImplPath);
+        if (!shadowFileInfo) {
+            shadowFileInfo = this.addInterimFile(shadowImplPath);
         }
-    }
-    _handleMemoryHighUsage() {
-        const cacheUsage = this._cacheManager.getCacheUsage();
-        // If the total cache has exceeded 75%, determine whether we should empty
-        // the cache.
-        if (cacheUsage > 0.75) {
-            const usedHeapRatio = this._cacheManager.getUsedHeapRatio(this._configOptions.verboseOutput ? this._console : undefined);
-            // 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;
-            const typeCacheEntryCount = this._evaluator.getTypeCacheEntryCount();
-            // If we use more than 90% of the heap size limit, avoid a crash
-            // by emptying the type cache.
-            if (typeCacheEntryCount > absoluteMaxCacheEntryCount || usedHeapRatio > 0.9) {
-                this._cacheManager.emptyCache(this._console);
-            }
+        if (!shadowFileInfo.shadows.includes(stubFile)) {
+            shadowFileInfo.shadows.push(stubFile);
         }
+        if (!stubFile.shadowedBy.includes(shadowFileInfo)) {
+            stubFile.shadowedBy.push(shadowFileInfo);
+        }
+        return shadowFileInfo.sourceFile;
     }
-    // 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();
+    _createInterimFileInfo(filePath) {
+        const importName = this._getImportNameForFile(filePath);
+        const sourceFile = new sourceFile_1.SourceFile(this.fileSystem, filePath, importName, 
+        /* isThirdPartyImport */ false, 
+        /* isInPyTypedPackage */ false, this._isEditMode, this._console, this._logTracker);
+        const sourceFileInfo = {
+            sourceFile,
+            isTracked: false,
+            isOpenByClient: false,
+            isTypeshedFile: false,
+            isThirdPartyImport: false,
+            isThirdPartyPyTypedPresent: false,
+            diagnosticsVersion: undefined,
+            imports: [],
+            importedBy: [],
+            shadows: [],
+            shadowedBy: [],
+        };
+        return sourceFileInfo;
+    }
+    _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,
+            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;
     }
-    // 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();
-            }
+    _parseFile(fileToParse, content, skipFileNeededCheck) {
+        if (!this._isFileNeeded(fileToParse, skipFileNeededCheck) || !fileToParse.sourceFile.isParseRequired()) {
+            return;
         }
-        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 (!cancellationUtils_1.OperationCanceledException.is(e)) {
-                this._createNewEvaluator();
-            }
-            throw e;
+        // SourceFile.parse should only be called here in the program, as calling it
+        // elsewhere could break the entire dependency graph maintained by the program.
+        // Other parts of the program should use _parseFile to create ParseResults from
+        // the sourceFile. For standalone parseResults, use parseFile or the Parser directly.
+        if (fileToParse.sourceFile.parse(this._configOptions, this._importResolver, content)) {
+            this._parsedFileCount++;
+            this._updateSourceFileImports(fileToParse, this._configOptions);
         }
-    }
-    // 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++;
-            }
+        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 markDirtySet = new Set();
+            this._markFileDirtyRecursive(fileToParse, markDirtySet);
+            // Invalidate the import resolver's cache as well.
+            this._importResolver.invalidateCache();
         }
-        return fileDiagnostics;
     }
-    _isFileNeeded(fileInfo) {
-        if (fileInfo.sourceFile.isFileDeleted()) {
-            return false;
+    _getImplicitImports(file) {
+        var _a, _b;
+        // If file is not parsed, then chainedSourceFile, ipythonDisplayImport,
+        // builtinsImport might not exist or incorrect.
+        // They will be added when _parseFile is called and _updateSourceFileImports ran.
+        if (file.builtinsImport === file) {
+            return undefined;
         }
-        if (fileInfo.isTracked || fileInfo.isOpenByClient) {
-            return true;
+        const tryReturn = (input) => {
+            if (!input || input.sourceFile.isFileDeleted()) {
+                return undefined;
+            }
+            return input;
+        };
+        return (_b = (_a = tryReturn(file.chainedSourceFile)) !== null && _a !== void 0 ? _a : tryReturn(file.ipythonDisplayImport)) !== null && _b !== void 0 ? _b : file.builtinsImport;
+    }
+    _bindImplicitImports(fileToAnalyze, skipFileNeededCheck) {
+        // Get all of the potential imports for this file.
+        const implicitImports = [];
+        const implicitSet = new Set();
+        let nextImplicitImport = this._getImplicitImports(fileToAnalyze);
+        while (nextImplicitImport) {
+            const implicitPath = nextImplicitImport.sourceFile.getFilePath();
+            if (implicitSet.has(implicitPath)) {
+                // We've found a cycle. Break out of the loop.
+                debug.fail(`Found a cycle in implicit imports files for ${implicitPath}`);
+            }
+            implicitSet.add(implicitPath);
+            implicitImports.push(nextImplicitImport);
+            this._parseFile(nextImplicitImport, /* content */ undefined, skipFileNeededCheck);
+            nextImplicitImport = this._getImplicitImports(nextImplicitImport);
         }
-        if (fileInfo.shadows.length > 0) {
-            return true;
+        if (implicitImports.length === 0) {
+            return;
         }
-        if (fileInfo.importedBy.length === 0) {
-            return false;
+        // Go in reverse order (so top of chain is first).
+        let implicitImport = implicitImports.pop();
+        while (implicitImport) {
+            // Bind this file, but don't recurse into its imports.
+            this._bindFile(implicitImport, undefined, skipFileNeededCheck, /* isImplicitImport */ true);
+            implicitImport = implicitImports.pop();
         }
-        // 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 Set());
     }
-    _isImportNeededRecursive(fileInfo, recursionSet) {
-        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 (recursionSet.has(filePath)) {
-            return false;
+    // 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, skipFileNeededCheck, isImplicitImport) {
+        var _a, _b;
+        if (!this._isFileNeeded(fileToAnalyze, skipFileNeededCheck) || !fileToAnalyze.sourceFile.isBindingRequired()) {
+            return;
         }
-        recursionSet.add(filePath);
-        for (const importerInfo of fileInfo.importedBy) {
-            if (this._isImportNeededRecursive(importerInfo, recursionSet)) {
-                return true;
+        this._parseFile(fileToAnalyze, content, skipFileNeededCheck);
+        // Create a function to get the scope info.
+        const getScopeIfAvailable = (fileInfo) => {
+            if (!fileInfo || fileInfo === fileToAnalyze) {
+                return undefined;
+            }
+            // If the file was deleted, there's no scope to return.
+            if (fileInfo.sourceFile.isFileDeleted()) {
+                return undefined;
+            }
+            const parseResults = fileInfo.sourceFile.getParseResults();
+            if (!parseResults) {
+                return undefined;
+            }
+            // File should already be bound because of the chained file binding above.
+            const scope = AnalyzerNodeInfo.getScope(parseResults.parseTree);
+            return scope;
+        };
+        let builtinsScope;
+        if (fileToAnalyze.builtinsImport && fileToAnalyze.builtinsImport !== fileToAnalyze) {
+            // Bind all of the implicit imports first. So we don't recurse into them.
+            if (!isImplicitImport) {
+                this._bindImplicitImports(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);
         }
-        return false;
+        let futureImports = fileToAnalyze.sourceFile.getParseResults().futureImports;
+        if (fileToAnalyze.chainedSourceFile) {
+            futureImports = this._getEffectiveFutureImports(futureImports, fileToAnalyze.chainedSourceFile);
+        }
+        fileToAnalyze.effectiveFutureImports = futureImports.size > 0 ? futureImports : undefined;
+        fileToAnalyze.sourceFile.bind(this._configOptions, this._lookUpImport, builtinsScope, futureImports);
     }
-    _createSourceMapper(execEnv, token, from, mapCompiled, preferStubs) {
-        const sourceMapper = new sourceMapper_1.SourceMapper(this._importResolver, execEnv, this._evaluator, (stubFilePath, implFilePath) => {
-            let stubFileInfo = this.getSourceFileInfo(stubFilePath);
-            if (!stubFileInfo) {
-                // Special case for import statement like "import X.Y". The SourceFile
-                // for X might not be in memory since import `X.Y` only brings in Y.
-                stubFileInfo = this.addInterimFile(stubFilePath);
+    _getEffectiveFutureImports(futureImports, chainedSourceFile) {
+        var _a;
+        const effectiveFutureImports = new Set(futureImports);
+        (_a = chainedSourceFile.effectiveFutureImports) === null || _a === void 0 ? void 0 : _a.forEach((value) => {
+            effectiveFutureImports.add(value);
+        });
+        return effectiveFutureImports;
+    }
+    // Build a map of all modules within this program and the module-
+    // level scope that contains the symbol table for the module.
+    _buildModuleSymbolsMap(sourceFileToExclude, libraryMap, includeSymbolsFromIndices, token) {
+        // If we have library map, always use the map for library symbols.
+        const predicate = (s) => {
+            if (!libraryMap) {
+                // We don't have any prebuilt indices, so we need to include
+                // all files.
+                return true;
             }
-            this._addShadowedFile(stubFileInfo, implFilePath);
-            return this.getBoundSourceFile(implFilePath);
-        }, (f) => {
-            let fileInfo = this.getBoundSourceFileInfo(f);
-            if (!fileInfo) {
-                // Special case for import statement like "import X.Y". The SourceFile
-                // for X might not be in memory since import `X.Y` only brings in Y.
-                fileInfo = this.addInterimFile(f);
-                // Even though this file is not referenced by anything, make sure
-                // we have a parse tree for the doc string.
-                this._parseFile(fileInfo, /* content */ undefined, /* force */ true);
+            if (!this._configOptions.indexing) {
+                // We have some prebuilt indices such as stdlib, but indexing is disabled.
+                // Include files we don't have prebuilt indices.
+                return libraryMap.get(s.sourceFile.getFilePath()) === undefined;
             }
-            return fileInfo;
-        }, mapCompiled !== null && mapCompiled !== void 0 ? mapCompiled : false, preferStubs !== null && preferStubs !== void 0 ? preferStubs : false, from, token);
-        return sourceMapper;
+            // We have prebuilt indices for third party libraries. Include only
+            // user files.
+            return (0, sourceFileInfoUtils_1.isUserCode)(s);
+        };
+        // Only include import alias from user files if indexing is off for now.
+        // Currently, when indexing is off, we don't do import alias deduplication, so
+        // adding import alias is cheap. But when indexing is on, we do deduplication, which
+        // require resolveAliasDeclaration that can cause more files to be parsed and bound.
+        return (0, autoImporter_1.buildModuleSymbolsMap)(this._sourceFileList.filter((s) => s !== sourceFileToExclude && predicate(s)), includeSymbolsFromIndices, token);
     }
-    _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;
+    _shouldCheckFile(fileInfo) {
+        // Always do a full checking for a file that's open in the editor.
+        if (fileInfo.isOpenByClient) {
+            return true;
         }
-        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;
-                }
-            }
-            else if (importer.isThirdPartyImport && this._configOptions.useLibraryCodeForTypes) {
-                // If the importing file is a third-party import, allow importing of
-                // additional third-party imports. This supports the case where the importer
-                // is in a py.typed library but is importing from another non-py.typed
-                // library. It also supports the case where someone explicitly opens a
-                // library source file in their editor.
-                thirdPartyImportAllowed = true;
-            }
-            else if (importResult.isNamespacePackage &&
-                importResult.filteredImplicitImports.some((implicitImport) => !!implicitImport.pyTypedInfo)) {
-                // Handle the case where the import targets a namespace package, and a
-                // submodule contained within it has a py.typed marker.
-                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;
-            }
+        // 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 true;
+        return false;
     }
-    _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;
-                }
+    _checkTypes(fileToCheck, token) {
+        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;
             }
-            else if (sourceFileInfo.isThirdPartyImport && importResult.importType === 2 /* Local */) {
-                isThirdPartyImport = true;
-                if (sourceFileInfo.isThirdPartyPyTypedPresent) {
-                    isPyTypedPresent = true;
-                }
+            if (!fileToCheck.sourceFile.isCheckingRequired()) {
+                logState.suppress();
+                return false;
             }
-            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;
+            if (!this._shouldCheckFile(fileToCheck)) {
+                logState.suppress();
+                return false;
             }
-            else {
-                const filePath = sourceFileInfo.chainedSourceFile.sourceFile.getFilePath();
-                newImportPathMap.set((0, pathUtils_1.normalizePathCase)(this._fs, filePath), {
-                    path: filePath,
-                    isTypeshedFile: false,
-                    isThirdPartyImport: false,
-                    isPyTypedPresent: false,
-                });
+            this._bindFile(fileToCheck);
+            if (this._preCheckCallback) {
+                const parseResults = fileToCheck.sourceFile.getParseResults();
+                if (parseResults) {
+                    this._preCheckCallback(parseResults, this._evaluator);
+                }
             }
-        }
-        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.isStdlibTypeshedFile || !!importResult.isThirdPartyTypeshedFile,
-                                isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
-                                isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
-                            });
+            if (!this._disableChecker) {
+                // For ipython, make sure we check all its dependent files first since
+                // their results can affect this file's result.
+                let dependentFiles = undefined;
+                if (fileToCheck.sourceFile.getIPythonMode() === sourceFile_1.IPythonMode.CellDocs) {
+                    dependentFiles = [];
+                    const importedByFiles = (0, sourceFileInfoUtils_1.collectImportedByFiles)(fileToCheck);
+                    for (const file of importedByFiles) {
+                        if (!(0, sourceFileInfoUtils_1.isUserCode)(file)) {
+                            continue;
                         }
-                    }
-                }
-                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.isStdlibTypeshedFile || !!importResult.isThirdPartyTypeshedFile,
-                                isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
-                                isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
-                            });
+                        // If the file is already analyzed, it will be no op.
+                        // And make sure we don't dump parse tree and etc while
+                        // recursively calling checker. Otherwise, inner check
+                        // can dump parse tree required by outer check.
+                        const handle = this._cacheManager.pauseTracking();
+                        try {
+                            this._checkTypes(file, token);
                         }
-                    }
-                });
-                // If the stub was found but the non-stub (source) file was not, dump
-                // the failure to the log for diagnostic purposes.
-                if (importResult.nonStubImportResult && !importResult.nonStubImportResult.isImportFound) {
-                    // We'll skip this for imports from within stub files and imports that target
-                    // stdlib typeshed stubs because many of these are known to not have
-                    // associated source files, and we don't want to fill the logs with noise.
-                    if (!sourceFileInfo.sourceFile.isStubFile() && !importResult.isStdlibTypeshedFile) {
-                        if (options.verboseOutput) {
-                            this._console.info(`Could not resolve source for '${importResult.importName}' ` +
-                                `in file '${sourceFileInfo.sourceFile.getFilePath()}'`);
-                            if (importResult.nonStubImportResult.importFailureInfo) {
-                                importResult.nonStubImportResult.importFailureInfo.forEach((diag) => {
-                                    this._console.info(`  ${diag}`);
-                                });
-                            }
+                        finally {
+                            handle.dispose();
+                        }
+                        const parseResults = file.sourceFile.getParseResults();
+                        if (parseResults) {
+                            dependentFiles.push(parseResults);
                         }
                     }
                 }
+                const execEnv = this._configOptions.findExecEnvironment(fileToCheck.sourceFile.getFilePath());
+                fileToCheck.sourceFile.check(this._importResolver, this._evaluator, this._createSourceMapper(execEnv, token, fileToCheck), dependentFiles);
             }
-            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}`);
+            // 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 found in any of the files we visited,
+                                // set a flag to indicates that we don't need to visit them again
+                                // on subsequent cycle checks.
+                                filesVisitedMap.forEach((sourceFileInfo) => {
+                                    sourceFileInfo.sourceFile.setNoCircularDependencyConfirmed();
+                                });
+                            }
+                        });
                     });
                 }
             }
+            return true;
         });
-        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()));
+    }
+    // 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.fileSystem, 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);
+        // If this file hasn't already been parsed, parse it now. This will
+        // discover any files it imports. Skip this if the file is part
+        // of a library. We'll assume that no cycles will be generated from
+        // library code or typeshed stubs.
+        if ((0, sourceFileInfoUtils_1.isUserCode)(file)) {
+            this._parseFile(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;
+        }
+        const filePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, sourceFileInfo.sourceFile.getFilePath());
+        filesVisited.set(filePath, sourceFileInfo);
+        let detectedCycle = false;
+        if (dependencyMap.has(filePath)) {
+            // We detect a cycle (partial or full). A full cycle is one that is
+            // rooted in the file at the start of our dependency chain. A partial
+            // cycle loops back on some other file in the dependency chain. We
+            // will report only full cycles here and leave the reporting of
+            // partial cycles to other passes.
+            detectedCycle = true;
+            // 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);
             }
-            else {
-                updatedImportMap.set(oldFilePath, importInfo);
+        }
+        else {
+            // If we've already checked this dependency along
+            // some other path, we can skip it.
+            if (dependencyMap.has(filePath)) {
+                return false;
             }
-        });
-        // 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 = this.getSourceFileInfo(importInfo.path);
-                if (!importedFileInfo) {
-                    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);
+            // 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;
                 }
-                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.getSourceFileInfo(path)) {
-                sourceFileInfo.imports.push(this.getSourceFileInfo(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.getSourceFileInfo(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.getSourceFileInfo(resolvedIPythonDisplayPath);
+            // 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 filesAdded;
+        return detectedCycle;
     }
-    _removeSourceFileFromListAndMap(filePath, indexToRemove) {
-        this._sourceFileMap.delete((0, pathUtils_1.normalizePathCase)(this._fs, filePath));
-        this._sourceFileList.splice(indexToRemove, 1);
+    _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.getSourceFileInfo(firstFilePath);
+        (0, debug_1.assert)(firstSourceFile !== undefined);
+        firstSourceFile.sourceFile.addCircularDependency(circDep);
     }
-    _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);
+    _markFileDirtyRecursive(sourceFileInfo, markSet, forceRebinding = false) {
+        const filePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, sourceFileInfo.sourceFile.getFilePath());
+        // Don't mark it again if it's already been visited.
+        if (markSet.has(filePath)) {
+            return;
+        }
+        sourceFileInfo.sourceFile.markReanalysisRequired(forceRebinding);
+        markSet.add(filePath);
+        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, markSet, forceRebinding);
+        });
+        // Change in the current file could impact checker result of chainedSourceFile such as unused symbols.
+        let chainedSourceFile = sourceFileInfo.chainedSourceFile;
+        while (chainedSourceFile) {
+            if (chainedSourceFile.sourceFile.isCheckingRequired()) {
+                // If the file is marked for checking, its chained one should be marked
+                // as well. Stop here.
+                return;
+            }
+            chainedSourceFile.sourceFile.markReanalysisRequired(/* forceRebinding */ false);
+            chainedSourceFile = chainedSourceFile.chainedSourceFile;
+        }
     }
 }
 exports.Program = Program;