@zzzen/pyright-internal 1.1.254

package/dist/analyzer/sourceFile.js

@@ -0,0 +1,908 @@
+"use strict";
+/*
+ * sourceFile.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Class that represents a single python source file.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceFile = void 0;
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const worker_threads_1 = require("worker_threads");
+const SymbolNameUtils = __importStar(require("../analyzer/symbolNameUtils"));
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const configOptions_1 = require("../common/configOptions");
+const console_1 = require("../common/console");
+const debug_1 = require("../common/debug");
+const diagnostic_1 = require("../common/diagnostic");
+const diagnosticSink_1 = require("../common/diagnosticSink");
+const logTracker_1 = require("../common/logTracker");
+const lspUtils_1 = require("../common/lspUtils");
+const pathUtils_1 = require("../common/pathUtils");
+const positionUtils_1 = require("../common/positionUtils");
+const StringUtils = __importStar(require("../common/stringUtils"));
+const textRange_1 = require("../common/textRange");
+const textRangeCollection_1 = require("../common/textRangeCollection");
+const timing_1 = require("../common/timing");
+const completionProvider_1 = require("../languageService/completionProvider");
+const definitionProvider_1 = require("../languageService/definitionProvider");
+const documentHighlightProvider_1 = require("../languageService/documentHighlightProvider");
+const documentSymbolProvider_1 = require("../languageService/documentSymbolProvider");
+const hoverProvider_1 = require("../languageService/hoverProvider");
+const quickActions_1 = require("../languageService/quickActions");
+const referencesProvider_1 = require("../languageService/referencesProvider");
+const signatureHelpProvider_1 = require("../languageService/signatureHelpProvider");
+const localize_1 = require("../localization/localize");
+const parseNodes_1 = require("../parser/parseNodes");
+const parser_1 = require("../parser/parser");
+const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const binder_1 = require("./binder");
+const checker_1 = require("./checker");
+const CommentUtils = __importStar(require("./commentUtils"));
+const parseTreeCleaner_1 = require("./parseTreeCleaner");
+const testWalker_1 = require("./testWalker");
+// 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;
+class SourceFile {
+    constructor(fs, filePath, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, console, logTracker, ipythonMode = false) {
+        // True if the file appears to have been deleted.
+        this._isFileDeleted = false;
+        // Number that is incremented every time the diagnostics
+        // are updated.
+        this._diagnosticVersion = 0;
+        // Generation count of the file contents. When the contents
+        // change, this is incremented.
+        this._fileContentsVersion = 0;
+        // Length and hash of the file the last time it was read from disk.
+        this._lastFileContentLength = undefined;
+        this._lastFileContentHash = undefined;
+        // Version of file contents that have been analyzed.
+        this._analyzedFileContentsVersion = -1;
+        // Do we need to walk the parse tree and clean
+        // the binder information hanging from it?
+        this._parseTreeNeedsCleaning = false;
+        // Reentrancy check for binding.
+        this._isBindingInProgress = false;
+        // Diagnostics generated during different phases of analysis.
+        this._parseDiagnostics = [];
+        this._bindDiagnostics = [];
+        this._checkerDiagnostics = [];
+        this._typeIgnoreLines = new Map();
+        this._pyrightIgnoreLines = new Map();
+        // Settings that control which diagnostics should be output.
+        this._diagnosticRuleSet = (0, configOptions_1.getBasicDiagnosticRuleSet)();
+        // Circular dependencies that have been reported in this file.
+        this._circularDependencies = [];
+        this._noCircularDependencyConfirmed = false;
+        // Do we need to perform a binding step?
+        this._isBindingNeeded = true;
+        // Do we have valid diagnostic results from a checking pass?
+        this._isCheckingNeeded = true;
+        // Do we need to perform an indexing step?
+        this._indexingNeeded = true;
+        // Indicate whether this file is for ipython or not.
+        this._ipythonMode = false;
+        this.fileSystem = fs;
+        this._console = console || new console_1.StandardConsole();
+        this._filePath = filePath;
+        this._moduleName = moduleName;
+        this._isStubFile = filePath.endsWith('.pyi');
+        this._isThirdPartyImport = isThirdPartyImport;
+        this._isThirdPartyPyTypedPresent = isThirdPartyPyTypedPresent;
+        const fileName = (0, pathUtils_1.getFileName)(filePath);
+        this._isTypingStubFile =
+            this._isStubFile &&
+                (this._filePath.endsWith((0, pathUtils_1.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((0, pathUtils_1.normalizeSlashes)('stdlib/collections/__init__.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/asyncio/futures.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/asyncio/tasks.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/builtins.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/_importlib_modulespec.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/dataclasses.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/abc.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/enum.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/queue.pyi')) ||
+                this._filePath.endsWith((0, pathUtils_1.normalizeSlashes)('stdlib/types.pyi'))) {
+                this._isBuiltInStubFile = true;
+            }
+        }
+        // 'FG' or 'BG' based on current thread.
+        this._logTracker = logTracker !== null && logTracker !== void 0 ? logTracker : new logTracker_1.LogTracker(console, worker_threads_1.isMainThread ? 'FG' : 'BG');
+        this._ipythonMode = ipythonMode;
+    }
+    getFilePath() {
+        return this._filePath;
+    }
+    getDiagnosticVersion() {
+        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, prevDiagnosticVersion) {
+        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 !== 3 /* UnusedCode */ && d.category !== 4 /* 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 !== 3 /* UnusedCode */ && d.category !== 4 /* 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 === null || oldClone === void 0 ? void 0 : 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 = [];
+        if (this._diagnosticRuleSet.reportUnnecessaryTypeIgnoreComment !== 'none') {
+            const diagCategory = (0, diagnostic_1.convertLevelToCategory)(this._diagnosticRuleSet.reportUnnecessaryTypeIgnoreComment);
+            const prefilteredErrorList = prefilteredDiagList.filter((diag) => diag.category === 0 /* Error */ ||
+                diag.category === 1 /* Warning */ ||
+                diag.category === 2 /* Information */);
+            if (prefilteredErrorList.length === 0 && this._typeIgnoreAll !== undefined) {
+                unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryTypeIgnore(), (0, positionUtils_1.convertOffsetsToRange)(this._typeIgnoreAll.range.start, this._typeIgnoreAll.range.start + this._typeIgnoreAll.range.length, this._parseResults.tokenizerOutput.lines)));
+            }
+            typeIgnoreLinesClone.forEach((ignoreComment) => {
+                var _a;
+                if ((_a = this._parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput.lines) {
+                    unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryTypeIgnore(), (0, positionUtils_1.convertOffsetsToRange)(ignoreComment.range.start, ignoreComment.range.start + ignoreComment.range.length, this._parseResults.tokenizerOutput.lines)));
+                }
+            });
+            pyrightIgnoreLinesClone.forEach((ignoreComment) => {
+                var _a;
+                if ((_a = this._parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput.lines) {
+                    if (!ignoreComment.rulesList) {
+                        unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryPyrightIgnore(), (0, positionUtils_1.convertOffsetsToRange)(ignoreComment.range.start, ignoreComment.range.start + ignoreComment.range.length, this._parseResults.tokenizerOutput.lines)));
+                    }
+                    else {
+                        ignoreComment.rulesList.forEach((unusedRule) => {
+                            unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryPyrightIgnoreRule().format({
+                                name: unusedRule.text,
+                            }), (0, positionUtils_1.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 = (0, diagnostic_1.convertLevelToCategory)(this._diagnosticRuleSet.reportImportCycles);
+            this._circularDependencies.forEach((cirDep) => {
+                diagList.push(new diagnostic_1.Diagnostic(category, localize_1.Localizer.Diagnostic.importCycleDetected() +
+                    '\n' +
+                    cirDep
+                        .getPaths()
+                        .map((path) => '  ' + path)
+                        .join('\n'), (0, textRange_1.getEmptyRange)()));
+            });
+        }
+        if (this._hitMaxImportDepth !== undefined) {
+            diagList.push(new diagnostic_1.Diagnostic(0 /* Error */, localize_1.Localizer.Diagnostic.importDepthExceeded().format({ depth: this._hitMaxImportDepth }), (0, textRange_1.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 !== 0 /* Error */ &&
+                    diag.category !== 1 /* Warning */ &&
+                    diag.category !== 2 /* 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 === 3 /* UnusedCode */ || diag.category === 4 /* Deprecated */);
+        }
+        return diagList;
+    }
+    getImports() {
+        return this._imports || [];
+    }
+    getBuiltinsImport() {
+        return this._builtinsImport;
+    }
+    getIPythonDisplayImport() {
+        return this._ipythonDisplayImport;
+    }
+    getModuleSymbolTable() {
+        return this._moduleSymbolTable;
+    }
+    getCheckTime() {
+        return this._checkTime;
+    }
+    // Indicates whether the contents of the file have changed since
+    // the last analysis was performed.
+    didContentsChangeOnDisk() {
+        // 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() {
+        this._parseResults = undefined;
+        this._moduleSymbolTable = undefined;
+        this._isBindingNeeded = true;
+    }
+    markDirty(indexingNeeded = true) {
+        this._fileContentsVersion++;
+        this._noCircularDependencyConfirmed = false;
+        this._isCheckingNeeded = true;
+        this._isBindingNeeded = true;
+        this._indexingNeeded = indexingNeeded;
+        this._moduleSymbolTable = undefined;
+        this._cachedIndexResults = undefined;
+    }
+    markReanalysisRequired(forceRebinding) {
+        // 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() {
+        var _a;
+        return (_a = this._clientDocument) === null || _a === void 0 ? void 0 : _a.version;
+    }
+    getOpenFileContents() {
+        var _a;
+        return (_a = this._clientDocument) === null || _a === void 0 ? void 0 : _a.getText();
+    }
+    getFileContent() {
+        // 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, contents) {
+        if (version === null) {
+            this._clientDocument = undefined;
+        }
+        else {
+            if (!this._clientDocument) {
+                this._clientDocument = vscode_languageserver_textdocument_1.TextDocument.create(this._filePath, 'python', version, '');
+            }
+            this._clientDocument = vscode_languageserver_textdocument_1.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() {
+        if (!this.isParseRequired()) {
+            return this._parseResults;
+        }
+        return undefined;
+    }
+    getCachedIndexResults() {
+        return this._cachedIndexResults;
+    }
+    cacheIndexResults(indexResults) {
+        this._cachedIndexResults = indexResults;
+    }
+    // Adds a new circular dependency for this file but only if
+    // it hasn't already been added.
+    addCircularDependency(circDependency) {
+        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) {
+        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, importResolver, content) {
+        return this._logTracker.log(`parsing: ${this._getPathForLogging(this._filePath)}`, (logState) => {
+            var _a;
+            // If the file is already parsed, we can skip.
+            if (!this.isParseRequired()) {
+                logState.suppress();
+                return false;
+            }
+            const diagSink = new diagnosticSink_1.DiagnosticSink();
+            let fileContents = this.getOpenFileContents();
+            if (fileContents === undefined) {
+                try {
+                    const startTime = timing_1.timingStats.readFileTime.totalTime;
+                    timing_1.timingStats.readFileTime.timeOperation(() => {
+                        // Read the file's contents.
+                        fileContents = content !== null && content !== void 0 ? 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 ${timing_1.timingStats.readFileTime.totalTime - startTime}ms`);
+                }
+                catch (error) {
+                    diagSink.addError(`Source file could not be read`, (0, textRange_1.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 parser_1.ParseOptions();
+            parseOptions.ipythonMode = this._ipythonMode;
+            if (this._filePath.endsWith('pyi')) {
+                parseOptions.isStubFile = true;
+            }
+            parseOptions.pythonVersion = execEnvironment.pythonVersion;
+            parseOptions.skipFunctionAndClassBody = (_a = configOptions.indexGenerationMode) !== null && _a !== void 0 ? _a : false;
+            try {
+                // Parse the token stream, building the abstract syntax tree.
+                const parser = new parser_1.Parser();
+                const parseResults = parser.parseSourceFile(fileContents, parseOptions, diagSink);
+                (0, debug_1.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.
+                timing_1.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) {
+                const message = (e.stack ? e.stack.toString() : undefined) ||
+                    (typeof e.message === 'string' ? e.message : undefined) ||
+                    JSON.stringify(e);
+                this._console.error(localize_1.Localizer.Diagnostic.internalParseError().format({ file: this.getFilePath(), message }));
+                // Create dummy parse results.
+                this._parseResults = {
+                    text: '',
+                    parseTree: parseNodes_1.ModuleNode.create({ start: 0, length: 0 }),
+                    importedModules: [],
+                    futureImports: new Map(),
+                    tokenizerOutput: {
+                        tokens: new textRangeCollection_1.TextRangeCollection([]),
+                        lines: new textRangeCollection_1.TextRangeCollection([]),
+                        typeIgnoreAll: undefined,
+                        typeIgnoreLines: new Map(),
+                        pyrightIgnoreLines: new Map(),
+                        predominantEndOfLineSequence: '\n',
+                        predominantTabSequence: '    ',
+                        predominantSingleQuoteCharacter: "'",
+                    },
+                    containsWildcardImport: false,
+                    typingSymbolAliases: new Map(),
+                };
+                this._imports = undefined;
+                this._builtinsImport = undefined;
+                this._ipythonDisplayImport = undefined;
+                const diagSink = new diagnosticSink_1.DiagnosticSink();
+                diagSink.addError(localize_1.Localizer.Diagnostic.internalParseError().format({ file: this.getFilePath(), message }), (0, textRange_1.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, token) {
+        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_1.DocumentSymbolProvider.indexSymbols(AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree), this._parseResults, options, token);
+            ls.add(`found ${symbols.length}`);
+            const name = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(this._filePath));
+            const privateOrProtected = SymbolNameUtils.isPrivateOrProtectedName(name);
+            return { privateOrProtected, symbols };
+        });
+    }
+    getDefinitionsForPosition(sourceMapper, position, filter, evaluator, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+        return definitionProvider_1.DefinitionProvider.getDefinitionsForPosition(sourceMapper, this._parseResults, position, filter, evaluator, token);
+    }
+    getTypeDefinitionsForPosition(sourceMapper, position, evaluator, filePath, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+        return definitionProvider_1.DefinitionProvider.getTypeDefinitionsForPosition(sourceMapper, this._parseResults, position, evaluator, filePath, token);
+    }
+    getDeclarationForNode(sourceMapper, node, evaluator, reporter, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+        return referencesProvider_1.ReferencesProvider.getDeclarationForNode(sourceMapper, this._filePath, node, evaluator, reporter, token);
+    }
+    getDeclarationForPosition(sourceMapper, position, evaluator, reporter, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+        return referencesProvider_1.ReferencesProvider.getDeclarationForPosition(sourceMapper, this._parseResults, this._filePath, position, evaluator, reporter, token);
+    }
+    addReferences(referencesResult, includeDeclaration, evaluator, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return;
+        }
+        referencesProvider_1.ReferencesProvider.addReferences(this._parseResults, this._filePath, referencesResult, includeDeclaration, evaluator, token);
+    }
+    addHierarchicalSymbolsForDocument(symbolList, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults && !this._cachedIndexResults) {
+            return;
+        }
+        documentSymbolProvider_1.DocumentSymbolProvider.addHierarchicalSymbolsForDocument(this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : undefined, this.getCachedIndexResults(), this._parseResults, symbolList, token);
+    }
+    getSymbolsForDocument(query, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults && !this._cachedIndexResults) {
+            return [];
+        }
+        return documentSymbolProvider_1.DocumentSymbolProvider.getSymbolsForDocument(this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : undefined, this.getCachedIndexResults(), this._parseResults, this._filePath, query, token);
+    }
+    getHoverForPosition(sourceMapper, position, format, evaluator, token) {
+        // If this file hasn't been bound, no hover info is available.
+        if (this._isBindingNeeded || !this._parseResults) {
+            return undefined;
+        }
+        return hoverProvider_1.HoverProvider.getHoverForPosition(sourceMapper, this._parseResults, position, format, evaluator, token);
+    }
+    getDocumentHighlight(sourceMapper, position, evaluator, token) {
+        // If this file hasn't been bound, no hover info is available.
+        if (this._isBindingNeeded || !this._parseResults) {
+            return undefined;
+        }
+        return documentHighlightProvider_1.DocumentHighlightProvider.getDocumentHighlight(this._parseResults, position, evaluator, token);
+    }
+    getSignatureHelpForPosition(position, sourceMapper, evaluator, format, token) {
+        // If we have no completed analysis job, there's nothing to do.
+        if (!this._parseResults) {
+            return undefined;
+        }
+        return signatureHelpProvider_1.SignatureHelpProvider.getSignatureHelpForPosition(this._parseResults, position, sourceMapper, evaluator, format, token);
+    }
+    getCompletionsForPosition(position, workspacePath, configOptions, importResolver, importLookup, evaluator, options, sourceMapper, nameMap, libraryMap, moduleSymbolsCallback, token) {
+        // 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_1.CompletionProvider(workspacePath, this._parseResults, fileContents, importResolver, position, this._filePath, configOptions, importLookup, evaluator, options, sourceMapper, {
+            nameMap,
+            libraryMap,
+            getModuleSymbolsMap: moduleSymbolsCallback,
+        }, token);
+        return completionProvider.getCompletionsForPosition();
+    }
+    resolveCompletionItem(configOptions, importResolver, importLookup, evaluator, options, sourceMapper, nameMap, libraryMap, moduleSymbolsCallback, completionItem, token) {
+        const fileContents = this.getOpenFileContents();
+        if (!this._parseResults || fileContents === undefined) {
+            return;
+        }
+        const completionData = (0, lspUtils_1.fromLSPAny)(completionItem.data);
+        const completionProvider = new completionProvider_1.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, args, token) {
+        // 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 (0, quickActions_1.performQuickAction)(command, args, this._parseResults, token);
+    }
+    bind(configOptions, importLookup, builtinsScope) {
+        (0, debug_1.assert)(!this.isParseRequired(), 'Bind called before parsing');
+        (0, debug_1.assert)(this.isBindingRequired(), 'Bind called unnecessarily');
+        (0, debug_1.assert)(!this._isBindingInProgress, 'Bind called while binding in progress');
+        (0, debug_1.assert)(this._parseResults !== undefined, 'Parse results not available');
+        return this._logTracker.log(`binding: ${this._getPathForLogging(this._filePath)}`, () => {
+            try {
+                // Perform name binding.
+                timing_1.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_1.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_1.TestWalker();
+                        testWalker.walk(this._parseResults.parseTree);
+                    }
+                    this._bindDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
+                    const moduleScope = AnalyzerNodeInfo.getScope(this._parseResults.parseTree);
+                    (0, debug_1.assert)(moduleScope !== undefined, 'Module scope not returned by binder');
+                    this._moduleSymbolTable = moduleScope.symbolTable;
+                });
+            }
+            catch (e) {
+                const message = (e.stack ? e.stack.toString() : undefined) ||
+                    (typeof e.message === 'string' ? e.message : undefined) ||
+                    JSON.stringify(e);
+                this._console.error(localize_1.Localizer.Diagnostic.internalBindError().format({ file: this.getFilePath(), message }));
+                const diagSink = new diagnosticSink_1.DiagnosticSink();
+                diagSink.addError(localize_1.Localizer.Diagnostic.internalBindError().format({ file: this.getFilePath(), message }), (0, textRange_1.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, evaluator) {
+        (0, debug_1.assert)(!this.isParseRequired(), 'Check called before parsing');
+        (0, debug_1.assert)(!this.isBindingRequired(), 'Check called before binding');
+        (0, debug_1.assert)(!this._isBindingInProgress, 'Check called while binding in progress');
+        (0, debug_1.assert)(this.isCheckingRequired(), 'Check called unnecessarily');
+        (0, debug_1.assert)(this._parseResults !== undefined, 'Parse results not available');
+        return this._logTracker.log(`checking: ${this._getPathForLogging(this._filePath)}`, () => {
+            try {
+                timing_1.timingStats.typeCheckerTime.timeOperation(() => {
+                    const checkDuration = new timing_1.Duration();
+                    const checker = new checker_1.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) {
+                const isCancellation = cancellationUtils_1.OperationCanceledException.is(e);
+                if (!isCancellation) {
+                    const message = (e.stack ? e.stack.toString() : undefined) ||
+                        (typeof e.message === 'string' ? e.message : undefined) ||
+                        JSON.stringify(e);
+                    this._console.error(localize_1.Localizer.Diagnostic.internalTypeCheckingError().format({ file: this.getFilePath(), message }));
+                    const diagSink = new diagnosticSink_1.DiagnosticSink();
+                    diagSink.addError(localize_1.Localizer.Diagnostic.internalTypeCheckingError().format({ file: this.getFilePath(), message }), (0, textRange_1.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) {
+        this._ipythonMode = enable;
+    }
+    _buildFileInfo(configOptions, fileContents, importLookup, builtinsScope) {
+        (0, debug_1.assert)(this._parseResults !== undefined, 'Parse results not available');
+        const analysisDiagnostics = new diagnosticSink_1.TextRangeDiagnosticSink(this._parseResults.tokenizerOutput.lines);
+        const fileInfo = {
+            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(),
+        };
+        return fileInfo;
+    }
+    _cleanParseTreeIfRequired() {
+        if (this._parseResults) {
+            if (this._parseTreeNeedsCleaning) {
+                const cleanerWalker = new parseTreeCleaner_1.ParseTreeCleanerWalker(this._parseResults.parseTree);
+                cleanerWalker.clean();
+                this._parseTreeNeedsCleaning = false;
+            }
+        }
+    }
+    _resolveImports(importResolver, moduleImports, execEnv) {
+        const imports = [];
+        const resolveAndAddIfNotSelf = (nameParts, 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;
+        // 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,
+        };
+    }
+    _getPathForLogging(filepath) {
+        if (this.fileSystem.isMappedFilePath(filepath)) {
+            return this.fileSystem.getOriginalFilePath(filepath);
+        }
+        return filepath;
+    }
+}
+exports.SourceFile = SourceFile;
+//# sourceMappingURL=sourceFile.js.map