@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/analyzer/sourceFile.ts

@@ -0,0 +1,1401 @@
+/*
+ * sourceFile.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Class that represents a single python source file.
+ */
+
+import {
+    CancellationToken,
+    CompletionItem,
+    DocumentHighlight,
+    DocumentSymbol,
+    MarkupKind,
+} from 'vscode-languageserver';
+import { TextDocument, TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
+import { isMainThread } from 'worker_threads';
+
+import * as SymbolNameUtils from '../analyzer/symbolNameUtils';
+import { OperationCanceledException } from '../common/cancellationUtils';
+import { ConfigOptions, ExecutionEnvironment, getBasicDiagnosticRuleSet } from '../common/configOptions';
+import { ConsoleInterface, StandardConsole } from '../common/console';
+import { assert } from '../common/debug';
+import { convertLevelToCategory, Diagnostic, DiagnosticCategory } from '../common/diagnostic';
+import { DiagnosticSink, TextRangeDiagnosticSink } from '../common/diagnosticSink';
+import { TextEditAction } from '../common/editAction';
+import { FileSystem } from '../common/fileSystem';
+import { LogTracker } from '../common/logTracker';
+import { fromLSPAny } from '../common/lspUtils';
+import { getFileName, normalizeSlashes, stripFileExtension } from '../common/pathUtils';
+import { convertOffsetsToRange } from '../common/positionUtils';
+import * as StringUtils from '../common/stringUtils';
+import { DocumentRange, getEmptyRange, Position, TextRange } from '../common/textRange';
+import { TextRangeCollection } from '../common/textRangeCollection';
+import { Duration, timingStats } from '../common/timing';
+import { ModuleSymbolMap } from '../languageService/autoImporter';
+import { AbbreviationMap, CompletionOptions, CompletionResults } from '../languageService/completionProvider';
+import { CompletionItemData, CompletionProvider } from '../languageService/completionProvider';
+import { DefinitionFilter, DefinitionProvider } from '../languageService/definitionProvider';
+import { DocumentHighlightProvider } from '../languageService/documentHighlightProvider';
+import { DocumentSymbolProvider, IndexOptions, IndexResults } from '../languageService/documentSymbolProvider';
+import { HoverProvider, HoverResults } from '../languageService/hoverProvider';
+import { performQuickAction } from '../languageService/quickActions';
+import { ReferenceCallback, ReferencesProvider, ReferencesResult } from '../languageService/referencesProvider';
+import { SignatureHelpProvider, SignatureHelpResults } from '../languageService/signatureHelpProvider';
+import { Localizer } from '../localization/localize';
+import { ModuleNode, NameNode } from '../parser/parseNodes';
+import { ModuleImport, ParseOptions, Parser, ParseResults } from '../parser/parser';
+import { IgnoreComment } from '../parser/tokenizer';
+import { Token } from '../parser/tokenizerTypes';
+import { AnalyzerFileInfo, ImportLookup } from './analyzerFileInfo';
+import * as AnalyzerNodeInfo from './analyzerNodeInfo';
+import { Binder } from './binder';
+import { Checker } from './checker';
+import { CircularDependency } from './circularDependency';
+import * as CommentUtils from './commentUtils';
+import { ImportResolver } from './importResolver';
+import { ImportResult } from './importResult';
+import { ParseTreeCleanerWalker } from './parseTreeCleaner';
+import { Scope } from './scope';
+import { SourceMapper } from './sourceMapper';
+import { SymbolTable } from './symbol';
+import { TestWalker } from './testWalker';
+import { TypeEvaluator } from './typeEvaluatorTypes';
+
+// Limit the number of import cycles tracked per source file.
+const _maxImportCyclesPerFile = 4;
+
+// Allow files up to 50MB in length, same as VS Code.
+// https://github.com/microsoft/vscode/blob/1e750a7514f365585d8dab1a7a82e0938481ea2f/src/vs/editor/common/model/textModel.ts#L194
+const _maxSourceFileSize = 50 * 1024 * 1024;
+
+interface ResolveImportResult {
+    imports: ImportResult[];
+    builtinsImportResult?: ImportResult | undefined;
+    ipythonDisplayImportResult?: ImportResult | undefined;
+}
+
+export class SourceFile {
+    // Console interface to use for debugging.
+    private _console: ConsoleInterface;
+
+    // File path on disk.
+    private readonly _filePath: string;
+
+    // Period-delimited import path for the module.
+    private readonly _moduleName: string;
+
+    // True if file is a type-hint (.pyi) file versus a python
+    // (.py) file.
+    private readonly _isStubFile: boolean;
+
+    // True if the file was imported as a third-party import.
+    private readonly _isThirdPartyImport: boolean;
+
+    // True if the file is the "typing.pyi" file, which needs
+    // special-case handling.
+    private readonly _isTypingStubFile: boolean;
+
+    // True if the file is the "typing_extensions.pyi" file, which needs
+    // special-case handling.
+    private readonly _isTypingExtensionsStubFile: boolean;
+
+    // True if the file one of the other built-in stub files
+    // that require special-case handling: "collections.pyi",
+    // "dataclasses.pyi", "abc.pyi", "asyncio/coroutines.pyi".
+    private readonly _isBuiltInStubFile: boolean;
+
+    // True if the file is part of a package that contains a
+    // "py.typed" file.
+    private readonly _isThirdPartyPyTypedPresent: boolean;
+
+    // True if the file appears to have been deleted.
+    private _isFileDeleted = false;
+
+    // Number that is incremented every time the diagnostics
+    // are updated.
+    private _diagnosticVersion = 0;
+
+    // Generation count of the file contents. When the contents
+    // change, this is incremented.
+    private _fileContentsVersion = 0;
+
+    // Length and hash of the file the last time it was read from disk.
+    private _lastFileContentLength: number | undefined = undefined;
+    private _lastFileContentHash: number | undefined = undefined;
+
+    // Client's version of the file. Undefined implies that contents
+    // need to be read from disk.
+    private _clientDocument: TextDocument | undefined;
+
+    // Version of file contents that have been analyzed.
+    private _analyzedFileContentsVersion = -1;
+
+    // Do we need to walk the parse tree and clean
+    // the binder information hanging from it?
+    private _parseTreeNeedsCleaning = false;
+
+    private _parseResults: ParseResults | undefined;
+    private _moduleSymbolTable: SymbolTable | undefined;
+    private _cachedIndexResults: IndexResults | undefined;
+
+    // Reentrancy check for binding.
+    private _isBindingInProgress = false;
+
+    // Diagnostics generated during different phases of analysis.
+    private _parseDiagnostics: Diagnostic[] = [];
+    private _bindDiagnostics: Diagnostic[] = [];
+    private _checkerDiagnostics: Diagnostic[] = [];
+    private _typeIgnoreLines = new Map<number, IgnoreComment>();
+    private _typeIgnoreAll: IgnoreComment | undefined;
+    private _pyrightIgnoreLines = new Map<number, IgnoreComment>();
+
+    // Settings that control which diagnostics should be output.
+    private _diagnosticRuleSet = getBasicDiagnosticRuleSet();
+
+    // Circular dependencies that have been reported in this file.
+    private _circularDependencies: CircularDependency[] = [];
+    private _noCircularDependencyConfirmed = false;
+
+    // Did we hit the maximum import depth?
+    private _hitMaxImportDepth: number | undefined;
+
+    // Do we need to perform a binding step?
+    private _isBindingNeeded = true;
+
+    // Do we have valid diagnostic results from a checking pass?
+    private _isCheckingNeeded = true;
+
+    // Time (in ms) that the last check() call required for this file.
+    private _checkTime: number | undefined;
+
+    // Do we need to perform an indexing step?
+    private _indexingNeeded = true;
+
+    // Indicate whether this file is for ipython or not.
+    private _ipythonMode = false;
+
+    // Information about implicit and explicit imports from this file.
+    private _imports: ImportResult[] | undefined;
+    private _builtinsImport: ImportResult | undefined;
+    private _ipythonDisplayImport: ImportResult | undefined;
+
+    private _logTracker: LogTracker;
+    readonly fileSystem: FileSystem;
+
+    constructor(
+        fs: FileSystem,
+        filePath: string,
+        moduleName: string,
+        isThirdPartyImport: boolean,
+        isThirdPartyPyTypedPresent: boolean,
+        console?: ConsoleInterface,
+        logTracker?: LogTracker,
+        ipythonMode = false
+    ) {
+        this.fileSystem = fs;
+        this._console = console || new StandardConsole();
+        this._filePath = filePath;
+        this._moduleName = moduleName;
+        this._isStubFile = filePath.endsWith('.pyi');
+        this._isThirdPartyImport = isThirdPartyImport;
+        this._isThirdPartyPyTypedPresent = isThirdPartyPyTypedPresent;
+        const fileName = getFileName(filePath);
+        this._isTypingStubFile =
+            this._isStubFile &&
+            (this._filePath.endsWith(normalizeSlashes('stdlib/typing.pyi')) || fileName === 'typing_extensions.pyi');
+        this._isTypingExtensionsStubFile = this._isStubFile && fileName === 'typing_extensions.pyi';
+
+        this._isBuiltInStubFile = false;
+        if (this._isStubFile) {
+            if (
+                this._filePath.endsWith(normalizeSlashes('stdlib/collections/__init__.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/asyncio/futures.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/asyncio/tasks.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/builtins.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/_importlib_modulespec.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/dataclasses.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/abc.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/enum.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/queue.pyi')) ||
+                this._filePath.endsWith(normalizeSlashes('stdlib/types.pyi'))
+            ) {
+                this._isBuiltInStubFile = true;
+            }
+        }
+
+        // 'FG' or 'BG' based on current thread.
+        this._logTracker = logTracker ?? new LogTracker(console, isMainThread ? 'FG' : 'BG');
+        this._ipythonMode = ipythonMode;
+    }
+
+    getFilePath(): string {
+        return this._filePath;
+    }
+
+    getDiagnosticVersion(): number {
+        return this._diagnosticVersion;
+    }
+
+    isStubFile() {
+        return this._isStubFile;
+    }
+
+    isThirdPartyPyTypedPresent() {
+        return this._isThirdPartyPyTypedPresent;
+    }
+
+    // Returns a list of cached diagnostics from the latest analysis job.
+    // If the prevVersion is specified, the method returns undefined if
+    // the diagnostics haven't changed.
+    getDiagnostics(options: ConfigOptions, prevDiagnosticVersion?: number): Diagnostic[] | undefined {
+        if (this._diagnosticVersion === prevDiagnosticVersion) {
+            return undefined;
+        }
+
+        let includeWarningsAndErrors = true;
+
+        // If a file was imported as a third-party file, don't report
+        // any errors for it. The user can't fix them anyway.
+        if (this._isThirdPartyImport) {
+            includeWarningsAndErrors = false;
+        }
+
+        let diagList = [...this._parseDiagnostics, ...this._bindDiagnostics, ...this._checkerDiagnostics];
+        const prefilteredDiagList = diagList;
+        const typeIgnoreLinesClone = new Map(this._typeIgnoreLines);
+        const pyrightIgnoreLinesClone = new Map(this._pyrightIgnoreLines);
+
+        // Filter the diagnostics based on "type: ignore" lines.
+        if (this._diagnosticRuleSet.enableTypeIgnoreComments) {
+            if (this._typeIgnoreLines.size > 0) {
+                diagList = diagList.filter((d) => {
+                    if (d.category !== DiagnosticCategory.UnusedCode && d.category !== DiagnosticCategory.Deprecated) {
+                        for (let line = d.range.start.line; line <= d.range.end.line; line++) {
+                            if (this._typeIgnoreLines.has(line)) {
+                                typeIgnoreLinesClone.delete(line);
+                                return false;
+                            }
+                        }
+                    }
+
+                    return true;
+                });
+            }
+        }
+
+        // Filter the diagnostics based on "pyright: ignore" lines.
+        if (this._pyrightIgnoreLines.size > 0) {
+            diagList = diagList.filter((d) => {
+                if (d.category !== DiagnosticCategory.UnusedCode && d.category !== DiagnosticCategory.Deprecated) {
+                    for (let line = d.range.start.line; line <= d.range.end.line; line++) {
+                        const pyrightIgnoreComment = this._pyrightIgnoreLines.get(line);
+                        if (pyrightIgnoreComment) {
+                            if (!pyrightIgnoreComment.rulesList) {
+                                pyrightIgnoreLinesClone.delete(line);
+                                return false;
+                            }
+
+                            const diagRule = d.getRule();
+                            if (!diagRule) {
+                                // If there's no diagnostic rule, it won't match
+                                // against a rules list.
+                                return true;
+                            }
+
+                            // Did we find this rule in the list?
+                            if (pyrightIgnoreComment.rulesList.find((rule) => rule.text === diagRule)) {
+                                // Update the pyrightIgnoreLinesClone to remove this rule.
+                                const oldClone = pyrightIgnoreLinesClone.get(line);
+                                if (oldClone?.rulesList) {
+                                    const filteredRulesList = oldClone.rulesList.filter(
+                                        (rule) => rule.text !== diagRule
+                                    );
+                                    if (filteredRulesList.length === 0) {
+                                        pyrightIgnoreLinesClone.delete(line);
+                                    } else {
+                                        pyrightIgnoreLinesClone.set(line, {
+                                            range: oldClone.range,
+                                            rulesList: filteredRulesList,
+                                        });
+                                    }
+                                }
+
+                                return false;
+                            }
+
+                            return true;
+                        }
+                    }
+                }
+
+                return true;
+            });
+        }
+
+        const unnecessaryTypeIgnoreDiags: Diagnostic[] = [];
+
+        if (this._diagnosticRuleSet.reportUnnecessaryTypeIgnoreComment !== 'none') {
+            const diagCategory = convertLevelToCategory(this._diagnosticRuleSet.reportUnnecessaryTypeIgnoreComment);
+
+            const prefilteredErrorList = prefilteredDiagList.filter(
+                (diag) =>
+                    diag.category === DiagnosticCategory.Error ||
+                    diag.category === DiagnosticCategory.Warning ||
+                    diag.category === DiagnosticCategory.Information
+            );
+
+            if (prefilteredErrorList.length === 0 && this._typeIgnoreAll !== undefined) {
+                unnecessaryTypeIgnoreDiags.push(
+                    new Diagnostic(
+                        diagCategory,
+                        Localizer.Diagnostic.unnecessaryTypeIgnore(),
+                        convertOffsetsToRange(
+                            this._typeIgnoreAll.range.start,
+                            this._typeIgnoreAll.range.start + this._typeIgnoreAll.range.length,
+                            this._parseResults!.tokenizerOutput.lines!
+                        )
+                    )
+                );
+            }
+
+            typeIgnoreLinesClone.forEach((ignoreComment) => {
+                if (this._parseResults?.tokenizerOutput.lines) {
+                    unnecessaryTypeIgnoreDiags.push(
+                        new Diagnostic(
+                            diagCategory,
+                            Localizer.Diagnostic.unnecessaryTypeIgnore(),
+                            convertOffsetsToRange(
+                                ignoreComment.range.start,
+                                ignoreComment.range.start + ignoreComment.range.length,
+                                this._parseResults!.tokenizerOutput.lines!
+                            )
+                        )
+                    );
+                }
+            });
+
+            pyrightIgnoreLinesClone.forEach((ignoreComment) => {
+                if (this._parseResults?.tokenizerOutput.lines) {
+                    if (!ignoreComment.rulesList) {
+                        unnecessaryTypeIgnoreDiags.push(
+                            new Diagnostic(
+                                diagCategory,
+                                Localizer.Diagnostic.unnecessaryPyrightIgnore(),
+                                convertOffsetsToRange(
+                                    ignoreComment.range.start,
+                                    ignoreComment.range.start + ignoreComment.range.length,
+                                    this._parseResults!.tokenizerOutput.lines!
+                                )
+                            )
+                        );
+                    } else {
+                        ignoreComment.rulesList.forEach((unusedRule) => {
+                            unnecessaryTypeIgnoreDiags.push(
+                                new Diagnostic(
+                                    diagCategory,
+                                    Localizer.Diagnostic.unnecessaryPyrightIgnoreRule().format({
+                                        name: unusedRule.text,
+                                    }),
+                                    convertOffsetsToRange(
+                                        unusedRule.range.start,
+                                        unusedRule.range.start + unusedRule.range.length,
+                                        this._parseResults!.tokenizerOutput.lines!
+                                    )
+                                )
+                            );
+                        });
+                    }
+                }
+            });
+        }
+
+        if (this._diagnosticRuleSet.reportImportCycles !== 'none' && this._circularDependencies.length > 0) {
+            const category = convertLevelToCategory(this._diagnosticRuleSet.reportImportCycles);
+
+            this._circularDependencies.forEach((cirDep) => {
+                diagList.push(
+                    new Diagnostic(
+                        category,
+                        Localizer.Diagnostic.importCycleDetected() +
+                            '\n' +
+                            cirDep
+                                .getPaths()
+                                .map((path) => '  ' + path)
+                                .join('\n'),
+                        getEmptyRange()
+                    )
+                );
+            });
+        }
+
+        if (this._hitMaxImportDepth !== undefined) {
+            diagList.push(
+                new Diagnostic(
+                    DiagnosticCategory.Error,
+                    Localizer.Diagnostic.importDepthExceeded().format({ depth: this._hitMaxImportDepth }),
+                    getEmptyRange()
+                )
+            );
+        }
+
+        // If the file is in the ignore list, clear the diagnostic list.
+        if (options.ignore.find((ignoreFileSpec) => ignoreFileSpec.regExp.test(this._filePath))) {
+            diagList = [];
+        }
+
+        // If there is a "type: ignore" comment at the top of the file, clear
+        // the diagnostic list of all error, warning, and information diagnostics.
+        if (this._diagnosticRuleSet.enableTypeIgnoreComments) {
+            if (this._typeIgnoreAll !== undefined) {
+                diagList = diagList.filter(
+                    (diag) =>
+                        diag.category !== DiagnosticCategory.Error &&
+                        diag.category !== DiagnosticCategory.Warning &&
+                        diag.category !== DiagnosticCategory.Information
+                );
+            }
+        }
+
+        // Now add in the "unnecessary type ignore" diagnostics.
+        diagList = diagList.concat(unnecessaryTypeIgnoreDiags);
+
+        // If we're not returning any diagnostics, filter out all of
+        // the errors and warnings, leaving only the unreachable code
+        // and deprecated diagnostics.
+        if (!includeWarningsAndErrors) {
+            diagList = diagList.filter(
+                (diag) =>
+                    diag.category === DiagnosticCategory.UnusedCode || diag.category === DiagnosticCategory.Deprecated
+            );
+        }
+
+        return diagList;
+    }
+
+    getImports(): ImportResult[] {
+        return this._imports || [];
+    }
+
+    getBuiltinsImport(): ImportResult | undefined {
+        return this._builtinsImport;
+    }
+
+    getIPythonDisplayImport(): ImportResult | undefined {
+        return this._ipythonDisplayImport;
+    }
+
+    getModuleSymbolTable(): SymbolTable | undefined {
+        return this._moduleSymbolTable;
+    }
+
+    getCheckTime() {
+        return this._checkTime;
+    }
+
+    // Indicates whether the contents of the file have changed since
+    // the last analysis was performed.
+    didContentsChangeOnDisk(): boolean {
+        // If this is an open file any content changes will be
+        // provided through the editor. We can assume contents
+        // didn't change without us knowing about them.
+        if (this._clientDocument) {
+            return false;
+        }
+
+        // If the file was never read previously, no need to check for a change.
+        if (this._lastFileContentLength === undefined) {
+            return false;
+        }
+
+        // Read in the latest file contents and see if the hash matches
+        // that of the previous contents.
+        try {
+            // Read the file's contents.
+            const fileContents = this.fileSystem.readFileSync(this._filePath, 'utf8');
+
+            if (fileContents.length !== this._lastFileContentLength) {
+                return true;
+            }
+
+            if (StringUtils.hashString(fileContents) !== this._lastFileContentHash) {
+                return true;
+            }
+        } catch (error) {
+            return true;
+        }
+
+        return false;
+    }
+
+    // Drop parse and binding info to save memory. It is used
+    // in cases where memory is low. When info is needed, the file
+    // will be re-parsed and rebound.
+    dropParseAndBindInfo(): void {
+        this._parseResults = undefined;
+        this._moduleSymbolTable = undefined;
+        this._isBindingNeeded = true;
+    }
+
+    markDirty(indexingNeeded = true): void {
+        this._fileContentsVersion++;
+        this._noCircularDependencyConfirmed = false;
+        this._isCheckingNeeded = true;
+        this._isBindingNeeded = true;
+        this._indexingNeeded = indexingNeeded;
+        this._moduleSymbolTable = undefined;
+        this._cachedIndexResults = undefined;
+    }
+
+    markReanalysisRequired(forceRebinding: boolean): void {
+        // Keep the parse info, but reset the analysis to the beginning.
+        this._isCheckingNeeded = true;
+
+        // If the file contains a wildcard import or __all__ symbols,
+        // we need to rebind because a dependent import may have changed.
+        if (this._parseResults) {
+            if (
+                this._parseResults.containsWildcardImport ||
+                AnalyzerNodeInfo.getDunderAllInfo(this._parseResults.parseTree) !== undefined ||
+                forceRebinding
+            ) {
+                // We don't need to rebuild index data since wildcard
+                // won't affect user file indices. User file indices
+                // don't contain import alias info.
+                this._parseTreeNeedsCleaning = true;
+                this._isBindingNeeded = true;
+                this._moduleSymbolTable = undefined;
+            }
+        }
+    }
+
+    getClientVersion() {
+        return this._clientDocument?.version;
+    }
+
+    getOpenFileContents() {
+        return this._clientDocument?.getText();
+    }
+
+    getFileContent(): string | undefined {
+        // Get current buffer content if the file is opened.
+        const openFileContent = this.getOpenFileContents();
+        if (openFileContent) {
+            return openFileContent;
+        }
+
+        // Otherwise, get content from file system.
+        try {
+            // Check the file's length before attempting to read its full contents.
+            const fileStat = this.fileSystem.statSync(this._filePath);
+            if (fileStat.size > _maxSourceFileSize) {
+                this._console.error(
+                    `File length of "${this._filePath}" is ${fileStat.size} ` +
+                        `which exceeds the maximum supported file size of ${_maxSourceFileSize}`
+                );
+                throw new Error('File larger than max');
+            }
+
+            return this.fileSystem.readFileSync(this._filePath, 'utf8');
+        } catch (error) {
+            return undefined;
+        }
+    }
+
+    setClientVersion(version: number | null, contents: TextDocumentContentChangeEvent[]): void {
+        if (version === null) {
+            this._clientDocument = undefined;
+        } else {
+            if (!this._clientDocument) {
+                this._clientDocument = TextDocument.create(this._filePath, 'python', version, '');
+            }
+            this._clientDocument = TextDocument.update(this._clientDocument, contents, version);
+
+            const fileContents = this._clientDocument.getText();
+            const contentsHash = StringUtils.hashString(fileContents);
+
+            // Have the contents of the file changed?
+            if (fileContents.length !== this._lastFileContentLength || contentsHash !== this._lastFileContentHash) {
+                this.markDirty();
+            }
+
+            this._lastFileContentLength = fileContents.length;
+            this._lastFileContentHash = contentsHash;
+            this._isFileDeleted = false;
+        }
+    }
+
+    prepareForClose() {
+        // Nothing to do currently.
+    }
+
+    isFileDeleted() {
+        return this._isFileDeleted;
+    }
+
+    isParseRequired() {
+        return !this._parseResults || this._analyzedFileContentsVersion !== this._fileContentsVersion;
+    }
+
+    isBindingRequired() {
+        if (this._isBindingInProgress) {
+            return false;
+        }
+
+        if (this.isParseRequired()) {
+            return true;
+        }
+
+        return this._isBindingNeeded;
+    }
+
+    isIndexingRequired() {
+        return this._indexingNeeded;
+    }
+
+    isCheckingRequired() {
+        return this._isCheckingNeeded;
+    }
+
+    getParseResults(): ParseResults | undefined {
+        if (!this.isParseRequired()) {
+            return this._parseResults;
+        }
+
+        return undefined;
+    }
+
+    getCachedIndexResults(): IndexResults | undefined {
+        return this._cachedIndexResults;
+    }
+
+    cacheIndexResults(indexResults: IndexResults) {
+        this._cachedIndexResults = indexResults;
+    }
+
+    // Adds a new circular dependency for this file but only if
+    // it hasn't already been added.
+    addCircularDependency(circDependency: CircularDependency) {
+        let updatedDependencyList = false;
+
+        // Some topologies can result in a massive number of cycles. We'll cut it off.
+        if (this._circularDependencies.length < _maxImportCyclesPerFile) {
+            if (!this._circularDependencies.some((dep) => dep.isEqual(circDependency))) {
+                this._circularDependencies.push(circDependency);
+                updatedDependencyList = true;
+            }
+        }
+
+        if (updatedDependencyList) {
+            this._diagnosticVersion++;
+        }
+    }
+
+    setNoCircularDependencyConfirmed() {
+        this._noCircularDependencyConfirmed = true;
+    }
+
+    isNoCircularDependencyConfirmed() {
+        return !this.isParseRequired() && this._noCircularDependencyConfirmed;
+    }
+
+    setHitMaxImportDepth(maxImportDepth: number) {
+        this._hitMaxImportDepth = maxImportDepth;
+    }
+
+    // Parse the file and update the state. Callers should wait for completion
+    // (or at least cancel) prior to calling again. It returns true if a parse
+    // was required and false if the parse information was up to date already.
+    parse(configOptions: ConfigOptions, importResolver: ImportResolver, content?: string): boolean {
+        return this._logTracker.log(`parsing: ${this._getPathForLogging(this._filePath)}`, (logState) => {
+            // If the file is already parsed, we can skip.
+            if (!this.isParseRequired()) {
+                logState.suppress();
+                return false;
+            }
+
+            const diagSink = new DiagnosticSink();
+            let fileContents = this.getOpenFileContents();
+            if (fileContents === undefined) {
+                try {
+                    const startTime = timingStats.readFileTime.totalTime;
+                    timingStats.readFileTime.timeOperation(() => {
+                        // Read the file's contents.
+                        fileContents = content ?? this.getFileContent();
+                        if (fileContents === undefined) {
+                            throw new Error("Can't get file content");
+                        }
+
+                        // Remember the length and hash for comparison purposes.
+                        this._lastFileContentLength = fileContents.length;
+                        this._lastFileContentHash = StringUtils.hashString(fileContents);
+                    });
+                    logState.add(`fs read ${timingStats.readFileTime.totalTime - startTime}ms`);
+                } catch (error) {
+                    diagSink.addError(`Source file could not be read`, getEmptyRange());
+                    fileContents = '';
+
+                    if (!this.fileSystem.existsSync(this._filePath)) {
+                        this._isFileDeleted = true;
+                    }
+                }
+            }
+
+            // Use the configuration options to determine the environment in which
+            // this source file will be executed.
+            const execEnvironment = configOptions.findExecEnvironment(this._filePath);
+
+            const parseOptions = new ParseOptions();
+            parseOptions.ipythonMode = this._ipythonMode;
+            if (this._filePath.endsWith('pyi')) {
+                parseOptions.isStubFile = true;
+            }
+            parseOptions.pythonVersion = execEnvironment.pythonVersion;
+            parseOptions.skipFunctionAndClassBody = configOptions.indexGenerationMode ?? false;
+
+            try {
+                // Parse the token stream, building the abstract syntax tree.
+                const parser = new Parser();
+                const parseResults = parser.parseSourceFile(fileContents!, parseOptions, diagSink);
+                assert(parseResults !== undefined && parseResults.tokenizerOutput !== undefined);
+                this._parseResults = parseResults;
+                this._typeIgnoreLines = this._parseResults.tokenizerOutput.typeIgnoreLines;
+                this._typeIgnoreAll = this._parseResults.tokenizerOutput.typeIgnoreAll;
+                this._pyrightIgnoreLines = this._parseResults.tokenizerOutput.pyrightIgnoreLines;
+
+                // Resolve imports.
+                timingStats.resolveImportsTime.timeOperation(() => {
+                    const importResult = this._resolveImports(
+                        importResolver,
+                        parseResults.importedModules,
+                        execEnvironment
+                    );
+
+                    this._imports = importResult.imports;
+                    this._builtinsImport = importResult.builtinsImportResult;
+                    this._ipythonDisplayImport = importResult.ipythonDisplayImportResult;
+
+                    this._parseDiagnostics = diagSink.fetchAndClear();
+                });
+
+                // Is this file in a "strict" path?
+                const useStrict =
+                    configOptions.strict.find((strictFileSpec) => strictFileSpec.regExp.test(this._filePath)) !==
+                    undefined;
+
+                this._diagnosticRuleSet = CommentUtils.getFileLevelDirectives(
+                    this._parseResults.tokenizerOutput.tokens,
+                    configOptions.diagnosticRuleSet,
+                    useStrict
+                );
+            } catch (e: any) {
+                const message: string =
+                    (e.stack ? e.stack.toString() : undefined) ||
+                    (typeof e.message === 'string' ? e.message : undefined) ||
+                    JSON.stringify(e);
+                this._console.error(
+                    Localizer.Diagnostic.internalParseError().format({ file: this.getFilePath(), message })
+                );
+
+                // Create dummy parse results.
+                this._parseResults = {
+                    text: '',
+                    parseTree: ModuleNode.create({ start: 0, length: 0 }),
+                    importedModules: [],
+                    futureImports: new Map<string, boolean>(),
+                    tokenizerOutput: {
+                        tokens: new TextRangeCollection<Token>([]),
+                        lines: new TextRangeCollection<TextRange>([]),
+                        typeIgnoreAll: undefined,
+                        typeIgnoreLines: new Map<number, IgnoreComment>(),
+                        pyrightIgnoreLines: new Map<number, IgnoreComment>(),
+                        predominantEndOfLineSequence: '\n',
+                        predominantTabSequence: '    ',
+                        predominantSingleQuoteCharacter: "'",
+                    },
+                    containsWildcardImport: false,
+                    typingSymbolAliases: new Map<string, string>(),
+                };
+                this._imports = undefined;
+                this._builtinsImport = undefined;
+                this._ipythonDisplayImport = undefined;
+
+                const diagSink = new DiagnosticSink();
+                diagSink.addError(
+                    Localizer.Diagnostic.internalParseError().format({ file: this.getFilePath(), message }),
+                    getEmptyRange()
+                );
+                this._parseDiagnostics = diagSink.fetchAndClear();
+
+                // Do not rethrow the exception, swallow it here. Callers are not
+                // prepared to handle an exception.
+            }
+
+            this._analyzedFileContentsVersion = this._fileContentsVersion;
+            this._indexingNeeded = true;
+            this._isBindingNeeded = true;
+            this._isCheckingNeeded = true;
+            this._parseTreeNeedsCleaning = false;
+            this._hitMaxImportDepth = undefined;
+            this._diagnosticVersion++;
+
+            return true;
+        });
+    }
+
+    index(options: IndexOptions, token: CancellationToken): IndexResults | undefined {
+        return this._logTracker.log(`indexing: ${this._getPathForLogging(this._filePath)}`, (ls) => {
+            // If we have no completed analysis job, there's nothing to do.
+            if (!this._parseResults || !this.isIndexingRequired()) {
+                ls.suppress();
+                return undefined;
+            }
+
+            this._indexingNeeded = false;
+            const symbols = DocumentSymbolProvider.indexSymbols(
+                AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree)!,
+                this._parseResults,
+                options,
+                token
+            );
+
+            ls.add(`found ${symbols.length}`);
+
+            const name = stripFileExtension(getFileName(this._filePath));
+            const privateOrProtected = SymbolNameUtils.isPrivateOrProtectedName(name);
+            return { privateOrProtected, symbols };
+        });
+    }
+
+    getDefinitionsForPosition(
+        sourceMapper: SourceMapper,
+        position: Position,
+        filter: DefinitionFilter,
+        evaluator: TypeEvaluator,
+        token: CancellationToken
+    ): DocumentRange[] | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        return DefinitionProvider.getDefinitionsForPosition(
+            sourceMapper,
+            this._parseResults,
+            position,
+            filter,
+            evaluator,
+            token
+        );
+    }
+
+    getTypeDefinitionsForPosition(
+        sourceMapper: SourceMapper,
+        position: Position,
+        evaluator: TypeEvaluator,
+        filePath: string,
+        token: CancellationToken
+    ): DocumentRange[] | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        return DefinitionProvider.getTypeDefinitionsForPosition(
+            sourceMapper,
+            this._parseResults,
+            position,
+            evaluator,
+            filePath,
+            token
+        );
+    }
+
+    getDeclarationForNode(
+        sourceMapper: SourceMapper,
+        node: NameNode,
+        evaluator: TypeEvaluator,
+        reporter: ReferenceCallback | undefined,
+        token: CancellationToken
+    ): ReferencesResult | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        return ReferencesProvider.getDeclarationForNode(sourceMapper, this._filePath, node, evaluator, reporter, token);
+    }
+
+    getDeclarationForPosition(
+        sourceMapper: SourceMapper,
+        position: Position,
+        evaluator: TypeEvaluator,
+        reporter: ReferenceCallback | undefined,
+        token: CancellationToken
+    ): ReferencesResult | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        return ReferencesProvider.getDeclarationForPosition(
+            sourceMapper,
+            this._parseResults,
+            this._filePath,
+            position,
+            evaluator,
+            reporter,
+            token
+        );
+    }
+
+    addReferences(
+        referencesResult: ReferencesResult,
+        includeDeclaration: boolean,
+        evaluator: TypeEvaluator,
+        token: CancellationToken
+    ): void {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return;
+        }
+
+        ReferencesProvider.addReferences(
+            this._parseResults,
+            this._filePath,
+            referencesResult,
+            includeDeclaration,
+            evaluator,
+            token
+        );
+    }
+
+    addHierarchicalSymbolsForDocument(symbolList: DocumentSymbol[], token: CancellationToken) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults && !this._cachedIndexResults) {
+            return;
+        }
+
+        DocumentSymbolProvider.addHierarchicalSymbolsForDocument(
+            this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : undefined,
+            this.getCachedIndexResults(),
+            this._parseResults,
+            symbolList,
+            token
+        );
+    }
+
+    getSymbolsForDocument(query: string, token: CancellationToken) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults && !this._cachedIndexResults) {
+            return [];
+        }
+
+        return DocumentSymbolProvider.getSymbolsForDocument(
+            this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : undefined,
+            this.getCachedIndexResults(),
+            this._parseResults,
+            this._filePath,
+            query,
+            token
+        );
+    }
+
+    getHoverForPosition(
+        sourceMapper: SourceMapper,
+        position: Position,
+        format: MarkupKind,
+        evaluator: TypeEvaluator,
+        token: CancellationToken
+    ): HoverResults | undefined {
+        // If this file hasn't been bound, no hover info is available.
+        if (this._isBindingNeeded || !this._parseResults) {
+            return undefined;
+        }
+
+        return HoverProvider.getHoverForPosition(sourceMapper, this._parseResults, position, format, evaluator, token);
+    }
+
+    getDocumentHighlight(
+        sourceMapper: SourceMapper,
+        position: Position,
+        evaluator: TypeEvaluator,
+        token: CancellationToken
+    ): DocumentHighlight[] | undefined {
+        // If this file hasn't been bound, no hover info is available.
+        if (this._isBindingNeeded || !this._parseResults) {
+            return undefined;
+        }
+
+        return DocumentHighlightProvider.getDocumentHighlight(this._parseResults, position, evaluator, token);
+    }
+
+    getSignatureHelpForPosition(
+        position: Position,
+        sourceMapper: SourceMapper,
+        evaluator: TypeEvaluator,
+        format: MarkupKind,
+        token: CancellationToken
+    ): SignatureHelpResults | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        return SignatureHelpProvider.getSignatureHelpForPosition(
+            this._parseResults,
+            position,
+            sourceMapper,
+            evaluator,
+            format,
+            token
+        );
+    }
+
+    getCompletionsForPosition(
+        position: Position,
+        workspacePath: string,
+        configOptions: ConfigOptions,
+        importResolver: ImportResolver,
+        importLookup: ImportLookup,
+        evaluator: TypeEvaluator,
+        options: CompletionOptions,
+        sourceMapper: SourceMapper,
+        nameMap: AbbreviationMap | undefined,
+        libraryMap: Map<string, IndexResults> | undefined,
+        moduleSymbolsCallback: () => ModuleSymbolMap,
+        token: CancellationToken
+    ): CompletionResults | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        // This command should be called only for open files, in which
+        // case we should have the file contents already loaded.
+        const fileContents = this.getOpenFileContents();
+        if (fileContents === undefined) {
+            return undefined;
+        }
+
+        const completionProvider = new CompletionProvider(
+            workspacePath,
+            this._parseResults,
+            fileContents,
+            importResolver,
+            position,
+            this._filePath,
+            configOptions,
+            importLookup,
+            evaluator,
+            options,
+            sourceMapper,
+            {
+                nameMap,
+                libraryMap,
+                getModuleSymbolsMap: moduleSymbolsCallback,
+            },
+            token
+        );
+
+        return completionProvider.getCompletionsForPosition();
+    }
+
+    resolveCompletionItem(
+        configOptions: ConfigOptions,
+        importResolver: ImportResolver,
+        importLookup: ImportLookup,
+        evaluator: TypeEvaluator,
+        options: CompletionOptions,
+        sourceMapper: SourceMapper,
+        nameMap: AbbreviationMap | undefined,
+        libraryMap: Map<string, IndexResults> | undefined,
+        moduleSymbolsCallback: () => ModuleSymbolMap,
+        completionItem: CompletionItem,
+        token: CancellationToken
+    ) {
+        const fileContents = this.getOpenFileContents();
+        if (!this._parseResults || fileContents === undefined) {
+            return;
+        }
+
+        const completionData = fromLSPAny<CompletionItemData>(completionItem.data);
+        const completionProvider = new CompletionProvider(
+            completionData.workspacePath,
+            this._parseResults,
+            fileContents,
+            importResolver,
+            completionData.position,
+            this._filePath,
+            configOptions,
+            importLookup,
+            evaluator,
+            options,
+            sourceMapper,
+            {
+                nameMap,
+                libraryMap,
+                getModuleSymbolsMap: moduleSymbolsCallback,
+            },
+            token
+        );
+
+        completionProvider.resolveCompletionItem(completionItem);
+    }
+
+    performQuickAction(command: string, args: any[], token: CancellationToken): TextEditAction[] | undefined {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+
+        // This command should be called only for open files, in which
+        // case we should have the file contents already loaded.
+        if (this.getClientVersion() === undefined) {
+            return undefined;
+        }
+
+        return performQuickAction(command, args, this._parseResults, token);
+    }
+
+    bind(configOptions: ConfigOptions, importLookup: ImportLookup, builtinsScope: Scope | undefined) {
+        assert(!this.isParseRequired(), 'Bind called before parsing');
+        assert(this.isBindingRequired(), 'Bind called unnecessarily');
+        assert(!this._isBindingInProgress, 'Bind called while binding in progress');
+        assert(this._parseResults !== undefined, 'Parse results not available');
+
+        return this._logTracker.log(`binding: ${this._getPathForLogging(this._filePath)}`, () => {
+            try {
+                // Perform name binding.
+                timingStats.bindTime.timeOperation(() => {
+                    this._cleanParseTreeIfRequired();
+
+                    const fileInfo = this._buildFileInfo(
+                        configOptions,
+                        this._parseResults!.text,
+                        importLookup,
+                        builtinsScope
+                    );
+                    AnalyzerNodeInfo.setFileInfo(this._parseResults!.parseTree, fileInfo);
+
+                    const binder = new Binder(fileInfo, configOptions.indexGenerationMode);
+                    this._isBindingInProgress = true;
+                    binder.bindModule(this._parseResults!.parseTree);
+
+                    // If we're in "test mode" (used for unit testing), run an additional
+                    // "test walker" over the parse tree to validate its internal consistency.
+                    if (configOptions.internalTestMode) {
+                        const testWalker = new TestWalker();
+                        testWalker.walk(this._parseResults!.parseTree);
+                    }
+
+                    this._bindDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
+                    const moduleScope = AnalyzerNodeInfo.getScope(this._parseResults!.parseTree);
+                    assert(moduleScope !== undefined, 'Module scope not returned by binder');
+                    this._moduleSymbolTable = moduleScope!.symbolTable;
+                });
+            } catch (e: any) {
+                const message: string =
+                    (e.stack ? e.stack.toString() : undefined) ||
+                    (typeof e.message === 'string' ? e.message : undefined) ||
+                    JSON.stringify(e);
+                this._console.error(
+                    Localizer.Diagnostic.internalBindError().format({ file: this.getFilePath(), message })
+                );
+
+                const diagSink = new DiagnosticSink();
+                diagSink.addError(
+                    Localizer.Diagnostic.internalBindError().format({ file: this.getFilePath(), message }),
+                    getEmptyRange()
+                );
+                this._bindDiagnostics = diagSink.fetchAndClear();
+
+                // Do not rethrow the exception, swallow it here. Callers are not
+                // prepared to handle an exception.
+            } finally {
+                this._isBindingInProgress = false;
+            }
+
+            // Prepare for the next stage of the analysis.
+            this._diagnosticVersion++;
+            this._isCheckingNeeded = true;
+            this._indexingNeeded = true;
+            this._isBindingNeeded = false;
+        });
+    }
+
+    check(importResolver: ImportResolver, evaluator: TypeEvaluator) {
+        assert(!this.isParseRequired(), 'Check called before parsing');
+        assert(!this.isBindingRequired(), 'Check called before binding');
+        assert(!this._isBindingInProgress, 'Check called while binding in progress');
+        assert(this.isCheckingRequired(), 'Check called unnecessarily');
+        assert(this._parseResults !== undefined, 'Parse results not available');
+
+        return this._logTracker.log(`checking: ${this._getPathForLogging(this._filePath)}`, () => {
+            try {
+                timingStats.typeCheckerTime.timeOperation(() => {
+                    const checkDuration = new Duration();
+                    const checker = new Checker(importResolver, evaluator, this._parseResults!.parseTree);
+                    checker.check();
+                    this._isCheckingNeeded = false;
+
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(this._parseResults!.parseTree)!;
+                    this._checkerDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
+                    this._checkTime = checkDuration.getDurationInMilliseconds();
+                });
+            } catch (e: any) {
+                const isCancellation = OperationCanceledException.is(e);
+                if (!isCancellation) {
+                    const message: string =
+                        (e.stack ? e.stack.toString() : undefined) ||
+                        (typeof e.message === 'string' ? e.message : undefined) ||
+                        JSON.stringify(e);
+                    this._console.error(
+                        Localizer.Diagnostic.internalTypeCheckingError().format({ file: this.getFilePath(), message })
+                    );
+                    const diagSink = new DiagnosticSink();
+                    diagSink.addError(
+                        Localizer.Diagnostic.internalTypeCheckingError().format({ file: this.getFilePath(), message }),
+                        getEmptyRange()
+                    );
+
+                    this._checkerDiagnostics = diagSink.fetchAndClear();
+
+                    // Mark the file as complete so we don't get into an infinite loop.
+                    this._isCheckingNeeded = false;
+                }
+
+                throw e;
+            } finally {
+                // Clear any circular dependencies associated with this file.
+                // These will be detected by the program module and associated
+                // with the source file right before it is finalized.
+                this._circularDependencies = [];
+                this._diagnosticVersion++;
+            }
+        });
+    }
+
+    test_enableIPythonMode(enable: boolean) {
+        this._ipythonMode = enable;
+    }
+
+    private _buildFileInfo(
+        configOptions: ConfigOptions,
+        fileContents: string,
+        importLookup: ImportLookup,
+        builtinsScope?: Scope
+    ) {
+        assert(this._parseResults !== undefined, 'Parse results not available');
+        const analysisDiagnostics = new TextRangeDiagnosticSink(this._parseResults!.tokenizerOutput.lines);
+
+        const fileInfo: AnalyzerFileInfo = {
+            importLookup,
+            futureImports: this._parseResults!.futureImports,
+            builtinsScope,
+            diagnosticSink: analysisDiagnostics,
+            executionEnvironment: configOptions.findExecEnvironment(this._filePath),
+            diagnosticRuleSet: this._diagnosticRuleSet,
+            fileContents,
+            lines: this._parseResults!.tokenizerOutput.lines,
+            typingSymbolAliases: this._parseResults!.typingSymbolAliases,
+            definedConstants: configOptions.defineConstant,
+            filePath: this._filePath,
+            moduleName: this._moduleName,
+            isStubFile: this._isStubFile,
+            isTypingStubFile: this._isTypingStubFile,
+            isTypingExtensionsStubFile: this._isTypingExtensionsStubFile,
+            isBuiltInStubFile: this._isBuiltInStubFile,
+            isInPyTypedPackage: this._isThirdPartyPyTypedPresent,
+            isIPythonMode: this._ipythonMode,
+            accessedSymbolMap: new Map<number, true>(),
+        };
+        return fileInfo;
+    }
+
+    private _cleanParseTreeIfRequired() {
+        if (this._parseResults) {
+            if (this._parseTreeNeedsCleaning) {
+                const cleanerWalker = new ParseTreeCleanerWalker(this._parseResults.parseTree);
+                cleanerWalker.clean();
+                this._parseTreeNeedsCleaning = false;
+            }
+        }
+    }
+
+    private _resolveImports(
+        importResolver: ImportResolver,
+        moduleImports: ModuleImport[],
+        execEnv: ExecutionEnvironment
+    ): ResolveImportResult {
+        const imports: ImportResult[] = [];
+
+        const resolveAndAddIfNotSelf = (nameParts: string[], skipMissingImport = false) => {
+            const importResult = importResolver.resolveImport(this._filePath, execEnv, {
+                leadingDots: 0,
+                nameParts,
+                importedSymbols: undefined,
+            });
+
+            if (skipMissingImport && !importResult.isImportFound) {
+                return undefined;
+            }
+
+            // Avoid importing module from the module file itself.
+            if (importResult.resolvedPaths.length === 0 || importResult.resolvedPaths[0] !== this._filePath) {
+                imports.push(importResult);
+                return importResult;
+            }
+
+            return undefined;
+        };
+
+        // Always include an implicit import of the builtins module.
+        let builtinsImportResult: ImportResult | undefined;
+
+        // If this is a project source file (not a stub), try to resolve
+        // the __builtins__ stub first.
+        if (!this._isThirdPartyImport && !this._isStubFile) {
+            builtinsImportResult = resolveAndAddIfNotSelf(['__builtins__'], /* skipMissingImport */ true);
+        }
+
+        if (!builtinsImportResult) {
+            builtinsImportResult = resolveAndAddIfNotSelf(['builtins']);
+        }
+
+        const ipythonDisplayImportResult = this._ipythonMode
+            ? resolveAndAddIfNotSelf(['IPython', 'display'])
+            : undefined;
+
+        for (const moduleImport of moduleImports) {
+            const importResult = importResolver.resolveImport(this._filePath, execEnv, {
+                leadingDots: moduleImport.leadingDots,
+                nameParts: moduleImport.nameParts,
+                importedSymbols: moduleImport.importedSymbols,
+            });
+
+            imports.push(importResult);
+
+            // Associate the import results with the module import
+            // name node in the parse tree so we can access it later
+            // (for hover and definition support).
+            AnalyzerNodeInfo.setImportInfo(moduleImport.nameNode, importResult);
+        }
+
+        return {
+            imports,
+            builtinsImportResult,
+            ipythonDisplayImportResult,
+        };
+    }
+
+    private _getPathForLogging(filepath: string) {
+        if (this.fileSystem.isMappedFilePath(filepath)) {
+            return this.fileSystem.getOriginalFilePath(filepath);
+        }
+
+        return filepath;
+    }
+}