@zzzen/pyright-internal 1.1.254

package/dist/analyzer/service.js

@@ -0,0 +1,1197 @@
+"use strict";
+/*
+ * service.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * A persistent service that is able to analyze a collection of
+ * Python files.
+ */
+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.AnalyzerService = exports.pyprojectTomlName = exports.configFileNames = void 0;
+const TOML = __importStar(require("@iarna/toml"));
+const JSONC = __importStar(require("jsonc-parser"));
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const configOptions_1 = require("../common/configOptions");
+const console_1 = require("../common/console");
+const fileSystem_1 = require("../common/fileSystem");
+const host_1 = require("../common/host");
+const pathUtils_1 = require("../common/pathUtils");
+const timing_1 = require("../common/timing");
+const backgroundAnalysisProgram_1 = require("./backgroundAnalysisProgram");
+const importResolver_1 = require("./importResolver");
+const pythonPathUtils_1 = require("./pythonPathUtils");
+exports.configFileNames = ['pyrightconfig.json'];
+exports.pyprojectTomlName = 'pyproject.toml';
+// How long since the last user activity should we wait until running
+// the analyzer on any files that have not yet been analyzed?
+const _userActivityBackoffTimeInMs = 250;
+const _gitDirectory = (0, pathUtils_1.normalizeSlashes)('/.git/');
+const _includeFileRegex = /\.pyi?$/;
+// How long since the last library activity should we wait until
+// re-analyzing the libraries? (10min)
+const _libraryActivityBackoffTimeInMs = 60 * 1000 * 10;
+class AnalyzerService {
+    constructor(instanceName, fs, console, hostFactory, importResolverFactory, configOptions, extension, backgroundAnalysis, maxAnalysisTime, backgroundAnalysisProgramFactory, cancellationProvider) {
+        this._typeStubTargetIsSingleFile = false;
+        this._requireTrackedFileUpdate = true;
+        this._lastUserInteractionTime = Date.now();
+        this._disposed = false;
+        this._instanceName = instanceName;
+        this._console = console || new console_1.StandardConsole();
+        this._executionRootPath = '';
+        this._extension = extension;
+        this._importResolverFactory = importResolverFactory || AnalyzerService.createImportResolver;
+        this._maxAnalysisTimeInForeground = maxAnalysisTime;
+        this._backgroundAnalysisProgramFactory = backgroundAnalysisProgramFactory;
+        this._cancellationProvider = cancellationProvider !== null && cancellationProvider !== void 0 ? cancellationProvider : new cancellationUtils_1.DefaultCancellationProvider();
+        this._hostFactory = hostFactory !== null && hostFactory !== void 0 ? hostFactory : (() => new host_1.NoAccessHost());
+        configOptions = configOptions !== null && configOptions !== void 0 ? configOptions : new configOptions_1.ConfigOptions(process.cwd());
+        const importResolver = this._importResolverFactory(fs, configOptions, this._hostFactory());
+        this._backgroundAnalysisProgram =
+            backgroundAnalysisProgramFactory !== undefined
+                ? backgroundAnalysisProgramFactory(this._console, configOptions, importResolver, this._extension, backgroundAnalysis, this._maxAnalysisTimeInForeground)
+                : new backgroundAnalysisProgram_1.BackgroundAnalysisProgram(this._console, configOptions, importResolver, this._extension, backgroundAnalysis, this._maxAnalysisTimeInForeground);
+    }
+    clone(instanceName, backgroundAnalysis, fs) {
+        const service = new AnalyzerService(instanceName, fs !== null && fs !== void 0 ? fs : this._fs, this._console, this._hostFactory, this._importResolverFactory, this._backgroundAnalysisProgram.configOptions, this._extension, backgroundAnalysis, this._maxAnalysisTimeInForeground, this._backgroundAnalysisProgramFactory, this._cancellationProvider);
+        // Make sure we keep editor content (open file) which could be different than one in the file system.
+        for (const fileInfo of this.backgroundAnalysisProgram.program.getOpened()) {
+            const version = fileInfo.sourceFile.getClientVersion();
+            if (version !== undefined) {
+                service.setFileOpened(fileInfo.sourceFile.getFilePath(), version, fileInfo.sourceFile.getOpenFileContents());
+            }
+        }
+        return service;
+    }
+    dispose() {
+        this._disposed = true;
+        this._removeSourceFileWatchers();
+        this._removeConfigFileWatcher();
+        this._removeLibraryFileWatcher();
+        this._clearReloadConfigTimer();
+        this._clearReanalysisTimer();
+        this._clearLibraryReanalysisTimer();
+    }
+    get librarySearchPathsToWatch() {
+        return this._librarySearchPathsToWatch;
+    }
+    get backgroundAnalysisProgram() {
+        return this._backgroundAnalysisProgram;
+    }
+    static createImportResolver(fs, options, host) {
+        return new importResolver_1.ImportResolver(fs, options, host);
+    }
+    setCompletionCallback(callback) {
+        this._onCompletionCallback = callback;
+        this._backgroundAnalysisProgram.setCompletionCallback(callback);
+    }
+    setOptions(commandLineOptions) {
+        this._commandLineOptions = commandLineOptions;
+        const host = this._hostFactory();
+        const configOptions = this._getConfigOptions(host, commandLineOptions);
+        if (configOptions.pythonPath) {
+            // Make sure we have default python environment set.
+            configOptions.ensureDefaultPythonVersion(host, this._console);
+        }
+        configOptions.ensureDefaultPythonPlatform(host, this._console);
+        this._backgroundAnalysisProgram.setConfigOptions(configOptions);
+        this._executionRootPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(commandLineOptions.executionRoot, configOptions.projectRoot));
+        this._applyConfigOptions(host);
+    }
+    isTracked(filePath) {
+        for (const includeSpec of this._configOptions.include) {
+            if (this._matchIncludeFileSpec(includeSpec.regExp, this._configOptions.exclude, filePath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    setFileOpened(path, version, contents, ipythonMode = false, chainedFilePath) {
+        this._backgroundAnalysisProgram.setFileOpened(path, version, contents, {
+            isTracked: this.isTracked(path),
+            ipythonMode,
+            chainedFilePath,
+        });
+        this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+    }
+    updateChainedFilePath(path, chainedFilePath) {
+        this._backgroundAnalysisProgram.updateChainedFilePath(path, chainedFilePath);
+        this._scheduleReanalysis(/*requireTrackedFileUpdate*/ false);
+    }
+    updateOpenFileContents(path, version, contents, ipythonMode = false, chainedFilePath) {
+        this._backgroundAnalysisProgram.updateOpenFileContents(path, version, contents, {
+            isTracked: this.isTracked(path),
+            ipythonMode,
+            chainedFilePath,
+        });
+        this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+    }
+    test_setIndexing(workspaceIndices, libraryIndices) {
+        this._backgroundAnalysisProgram.test_setIndexing(workspaceIndices, libraryIndices);
+    }
+    startIndexing(indexOptions) {
+        this._backgroundAnalysisProgram.startIndexing(indexOptions);
+    }
+    setFileClosed(path) {
+        this._backgroundAnalysisProgram.setFileClosed(path);
+        this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+    }
+    getParseResult(path) {
+        var _a;
+        return (_a = this._program.getBoundSourceFile(path)) === null || _a === void 0 ? void 0 : _a.getParseResults();
+    }
+    getTextOnRange(filePath, range, token) {
+        return this._program.getTextOnRange(filePath, range, token);
+    }
+    getAutoImports(filePath, range, similarityLimit, nameMap, lazyEdit, allowVariableInAll, token) {
+        return this._program.getAutoImports(filePath, range, similarityLimit, nameMap, this._backgroundAnalysisProgram.getIndexing(filePath), lazyEdit, allowVariableInAll, token);
+    }
+    getDefinitionForPosition(filePath, position, filter, token) {
+        return this._program.getDefinitionsForPosition(filePath, position, filter, token);
+    }
+    getTypeDefinitionForPosition(filePath, position, token) {
+        return this._program.getTypeDefinitionsForPosition(filePath, position, token);
+    }
+    reportReferencesForPosition(filePath, position, includeDeclaration, reporter, token) {
+        this._program.reportReferencesForPosition(filePath, position, includeDeclaration, reporter, token);
+    }
+    addSymbolsForDocument(filePath, symbolList, token) {
+        this._program.addSymbolsForDocument(filePath, symbolList, token);
+    }
+    reportSymbolsForWorkspace(query, reporter, token) {
+        this._program.reportSymbolsForWorkspace(query, reporter, token);
+    }
+    getHoverForPosition(filePath, position, format, token) {
+        return this._program.getHoverForPosition(filePath, position, format, token);
+    }
+    getDocumentHighlight(filePath, position, token) {
+        return this._program.getDocumentHighlight(filePath, position, token);
+    }
+    getSignatureHelpForPosition(filePath, position, format, token) {
+        return this._program.getSignatureHelpForPosition(filePath, position, format, token);
+    }
+    getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, token) {
+        return this._program.getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, this._backgroundAnalysisProgram.getIndexing(filePath), token);
+    }
+    getEvaluator() {
+        return this._program.evaluator;
+    }
+    resolveCompletionItem(filePath, completionItem, options, nameMap, token) {
+        this._program.resolveCompletionItem(filePath, completionItem, options, nameMap, this._backgroundAnalysisProgram.getIndexing(filePath), token);
+    }
+    performQuickAction(filePath, command, args, token) {
+        return this._program.performQuickAction(filePath, command, args, token);
+    }
+    renameModule(filePath, newFilePath, token) {
+        return this._program.renameModule(filePath, newFilePath, token);
+    }
+    canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token) {
+        return this._program.canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token);
+    }
+    renameSymbolAtPosition(filePath, position, newName, isDefaultWorkspace, allowModuleRename, token) {
+        return this._program.renameSymbolAtPosition(filePath, position, newName, isDefaultWorkspace, allowModuleRename, token);
+    }
+    getCallForPosition(filePath, position, token) {
+        return this._program.getCallForPosition(filePath, position, token);
+    }
+    getIncomingCallsForPosition(filePath, position, token) {
+        return this._program.getIncomingCallsForPosition(filePath, position, token);
+    }
+    getOutgoingCallsForPosition(filePath, position, token) {
+        return this._program.getOutgoingCallsForPosition(filePath, position, token);
+    }
+    printStats() {
+        this._console.info('');
+        this._console.info('Analysis stats');
+        const boundFileCount = this._program.getFileCount();
+        this._console.info('Total files parsed and bound: ' + boundFileCount.toString());
+        const checkedFileCount = this._program.getUserFileCount();
+        this._console.info('Total files checked: ' + checkedFileCount.toString());
+    }
+    printDetailedAnalysisTimes() {
+        this._program.printDetailedAnalysisTimes();
+    }
+    printDependencies(verbose) {
+        this._program.printDependencies(this._executionRootPath, verbose);
+    }
+    getDiagnosticsForRange(filePath, range, token) {
+        return this._backgroundAnalysisProgram.getDiagnosticsForRange(filePath, range, token);
+    }
+    getConfigOptions() {
+        return this._configOptions;
+    }
+    getImportResolver() {
+        return this._backgroundAnalysisProgram.importResolver;
+    }
+    recordUserInteractionTime() {
+        this._lastUserInteractionTime = Date.now();
+        // If we have a pending timer for reanalysis, cancel it
+        // and reschedule for some time in the future.
+        if (this._analyzeTimer) {
+            this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+        }
+    }
+    // test only APIs
+    get test_program() {
+        return this._program;
+    }
+    test_getConfigOptions(commandLineOptions) {
+        return this._getConfigOptions(this._backgroundAnalysisProgram.host, commandLineOptions);
+    }
+    test_getFileNamesFromFileSpecs() {
+        return this._getFileNamesFromFileSpecs();
+    }
+    // Calculates the effective options based on the command-line options,
+    // an optional config file, and default values.
+    _getConfigOptions(host, commandLineOptions) {
+        var _a, _b, _c;
+        let projectRoot = commandLineOptions.executionRoot;
+        let configFilePath;
+        let pyprojectFilePath;
+        if (commandLineOptions.configFilePath) {
+            // If the config file path was specified, determine whether it's
+            // a directory (in which case the default config file name is assumed)
+            // or a file.
+            configFilePath = (0, pathUtils_1.combinePaths)(commandLineOptions.executionRoot, (0, pathUtils_1.normalizePath)(commandLineOptions.configFilePath));
+            if (!this._fs.existsSync(configFilePath)) {
+                this._console.info(`Configuration file not found at ${configFilePath}.`);
+                configFilePath = commandLineOptions.executionRoot;
+            }
+            else {
+                if (configFilePath.toLowerCase().endsWith('.json')) {
+                    projectRoot = (0, pathUtils_1.getDirectoryPath)(configFilePath);
+                }
+                else {
+                    projectRoot = configFilePath;
+                    configFilePath = this._findConfigFile(configFilePath);
+                    if (!configFilePath) {
+                        this._console.info(`Configuration file not found at ${projectRoot}.`);
+                    }
+                }
+            }
+        }
+        else if (projectRoot) {
+            // In a project-based IDE like VS Code, we should assume that the
+            // project root directory contains the config file.
+            configFilePath = this._findConfigFile(projectRoot);
+            // If pyright is being executed from the command line, the working
+            // directory may be deep within a project, and we need to walk up the
+            // directory hierarchy to find the project root.
+            if (!configFilePath && !commandLineOptions.fromVsCodeExtension) {
+                configFilePath = this._findConfigFileHereOrUp(projectRoot);
+            }
+            if (configFilePath) {
+                projectRoot = (0, pathUtils_1.getDirectoryPath)(configFilePath);
+            }
+            else {
+                this._console.info(`No configuration file found.`);
+                configFilePath = undefined;
+            }
+        }
+        if (!configFilePath) {
+            // See if we can find a pyproject.toml file in this directory.
+            pyprojectFilePath = this._findPyprojectTomlFile(projectRoot);
+            if (!pyprojectFilePath && !commandLineOptions.fromVsCodeExtension) {
+                pyprojectFilePath = this._findPyprojectTomlFileHereOrUp(projectRoot);
+            }
+            if (pyprojectFilePath) {
+                projectRoot = (0, pathUtils_1.getDirectoryPath)(pyprojectFilePath);
+                this._console.info(`pyproject.toml file found at ${projectRoot}.`);
+            }
+            else {
+                this._console.info(`No pyproject.toml file found.`);
+            }
+        }
+        const configOptions = new configOptions_1.ConfigOptions(projectRoot, this._typeCheckingMode);
+        const defaultExcludes = ['**/node_modules', '**/__pycache__', '**/.*'];
+        if (commandLineOptions.pythonPath) {
+            this._console.info(`Setting pythonPath for service "${this._instanceName}": ` + `"${commandLineOptions.pythonPath}"`);
+            configOptions.pythonPath = commandLineOptions.pythonPath;
+        }
+        // The pythonPlatform and pythonVersion from the command-line can be overridden
+        // by the config file, so initialize them upfront.
+        configOptions.defaultPythonPlatform = commandLineOptions.pythonPlatform;
+        configOptions.defaultPythonVersion = commandLineOptions.pythonVersion;
+        configOptions.ensureDefaultExtraPaths(this._fs, commandLineOptions.autoSearchPaths || false, commandLineOptions.extraPaths);
+        if (commandLineOptions.fileSpecs.length > 0) {
+            commandLineOptions.fileSpecs.forEach((fileSpec) => {
+                configOptions.include.push((0, pathUtils_1.getFileSpec)(this._fs, projectRoot, fileSpec));
+            });
+        }
+        else if (!configFilePath) {
+            // If no config file was found and there are no explicit include
+            // paths specified, assume the caller wants to include all source
+            // files under the execution root path.
+            if (commandLineOptions.executionRoot) {
+                configOptions.include.push((0, pathUtils_1.getFileSpec)(this._fs, commandLineOptions.executionRoot, '.'));
+                // Add a few common excludes to avoid long scan times.
+                defaultExcludes.forEach((exclude) => {
+                    configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this._fs, commandLineOptions.executionRoot, exclude));
+                });
+            }
+        }
+        this._configFilePath = configFilePath || pyprojectFilePath;
+        // If we found a config file, parse it to compute the effective options.
+        let configJsonObj;
+        if (configFilePath) {
+            this._console.info(`Loading configuration file at ${configFilePath}`);
+            configJsonObj = this._parseJsonConfigFile(configFilePath);
+        }
+        else if (pyprojectFilePath) {
+            this._console.info(`Loading pyproject.toml file at ${pyprojectFilePath}`);
+            configJsonObj = this._parsePyprojectTomlFile(pyprojectFilePath);
+        }
+        if (configJsonObj) {
+            configOptions.initializeFromJson(configJsonObj, this._typeCheckingMode, this._console, this._fs, host, commandLineOptions.diagnosticSeverityOverrides, commandLineOptions.fileSpecs.length > 0);
+            const configFileDir = (0, pathUtils_1.getDirectoryPath)(this._configFilePath);
+            // If no include paths were provided, assume that all files within
+            // the project should be included.
+            if (configOptions.include.length === 0) {
+                this._console.info(`No include entries specified; assuming ${configFileDir}`);
+                configOptions.include.push((0, pathUtils_1.getFileSpec)(this._fs, configFileDir, '.'));
+            }
+            // If there was no explicit set of excludes, add a few common ones to avoid long scan times.
+            if (configOptions.exclude.length === 0) {
+                defaultExcludes.forEach((exclude) => {
+                    this._console.info(`Auto-excluding ${exclude}`);
+                    configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this._fs, configFileDir, exclude));
+                });
+                if (configOptions.autoExcludeVenv === undefined) {
+                    configOptions.autoExcludeVenv = true;
+                }
+            }
+        }
+        else {
+            configOptions.autoExcludeVenv = true;
+            configOptions.applyDiagnosticOverrides(commandLineOptions.diagnosticSeverityOverrides);
+        }
+        configOptions.analyzeUnannotatedFunctions = (_a = commandLineOptions.analyzeUnannotatedFunctions) !== null && _a !== void 0 ? _a : true;
+        const reportDuplicateSetting = (settingName, configValue) => {
+            const settingSource = commandLineOptions.fromVsCodeExtension
+                ? 'the client settings'
+                : 'a command-line option';
+            this._console.warn(`The ${settingName} has been specified in both the config file and ` +
+                `${settingSource}. The value in the config file (${configValue}) ` +
+                `will take precedence`);
+        };
+        // Apply the command-line options if the corresponding
+        // item wasn't already set in the config file. Report any
+        // duplicates.
+        if (commandLineOptions.venvPath) {
+            if (!configOptions.venvPath) {
+                configOptions.venvPath = commandLineOptions.venvPath;
+            }
+            else {
+                reportDuplicateSetting('venvPath', configOptions.venvPath);
+            }
+        }
+        if (commandLineOptions.typeshedPath) {
+            if (!configOptions.typeshedPath) {
+                configOptions.typeshedPath = commandLineOptions.typeshedPath;
+            }
+            else {
+                reportDuplicateSetting('typeshedPath', configOptions.typeshedPath);
+            }
+        }
+        configOptions.verboseOutput = (_b = commandLineOptions.verboseOutput) !== null && _b !== void 0 ? _b : configOptions.verboseOutput;
+        configOptions.checkOnlyOpenFiles = !!commandLineOptions.checkOnlyOpenFiles;
+        configOptions.autoImportCompletions = !!commandLineOptions.autoImportCompletions;
+        configOptions.indexing = !!commandLineOptions.indexing;
+        configOptions.logTypeEvaluationTime = !!commandLineOptions.logTypeEvaluationTime;
+        configOptions.typeEvaluationTimeThreshold = commandLineOptions.typeEvaluationTimeThreshold;
+        // If useLibraryCodeForTypes was not specified in the config, allow the settings
+        // or command line to override it.
+        if (configOptions.useLibraryCodeForTypes === undefined) {
+            configOptions.useLibraryCodeForTypes = !!commandLineOptions.useLibraryCodeForTypes;
+        }
+        else if (commandLineOptions.useLibraryCodeForTypes !== undefined) {
+            reportDuplicateSetting('useLibraryCodeForTypes', configOptions.useLibraryCodeForTypes);
+        }
+        // If there was no stub path specified, use a default path.
+        if (commandLineOptions.stubPath) {
+            if (!configOptions.stubPath) {
+                configOptions.stubPath = commandLineOptions.stubPath;
+            }
+            else {
+                reportDuplicateSetting('stubPath', configOptions.stubPath);
+            }
+        }
+        else {
+            if (!configOptions.stubPath) {
+                configOptions.stubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(configOptions.projectRoot, 'typings'));
+            }
+        }
+        // Do some sanity checks on the specified settings and report missing
+        // or inconsistent information.
+        if (configOptions.venvPath) {
+            if (!this._fs.existsSync(configOptions.venvPath) || !(0, pathUtils_1.isDirectory)(this._fs, configOptions.venvPath)) {
+                this._console.error(`venvPath ${configOptions.venvPath} is not a valid directory.`);
+            }
+            // venvPath without venv means it won't do anything while resolveImport.
+            // so first, try to set venv from existing configOption if it is null. if both are null,
+            // then, resolveImport won't consider venv
+            configOptions.venv = (_c = configOptions.venv) !== null && _c !== void 0 ? _c : this._configOptions.venv;
+            if (configOptions.venv) {
+                const fullVenvPath = (0, pathUtils_1.combinePaths)(configOptions.venvPath, configOptions.venv);
+                if (!this._fs.existsSync(fullVenvPath) || !(0, pathUtils_1.isDirectory)(this._fs, fullVenvPath)) {
+                    this._console.error(`venv ${configOptions.venv} subdirectory not found in venv path ${configOptions.venvPath}.`);
+                }
+                else {
+                    const importFailureInfo = [];
+                    if ((0, pythonPathUtils_1.findPythonSearchPaths)(this._fs, configOptions, host, importFailureInfo) === undefined) {
+                        this._console.error(`site-packages directory cannot be located for venvPath ` +
+                            `${configOptions.venvPath} and venv ${configOptions.venv}.`);
+                        if (configOptions.verboseOutput) {
+                            importFailureInfo.forEach((diag) => {
+                                this._console.error(`  ${diag}`);
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Is there a reference to a venv? If so, there needs to be a valid venvPath.
+        if (configOptions.venv) {
+            if (!configOptions.venvPath) {
+                this._console.warn(`venvPath not specified, so venv settings will be ignored.`);
+            }
+        }
+        if (configOptions.typeshedPath) {
+            if (!this._fs.existsSync(configOptions.typeshedPath) ||
+                !(0, pathUtils_1.isDirectory)(this._fs, configOptions.typeshedPath)) {
+                this._console.error(`typeshedPath ${configOptions.typeshedPath} is not a valid directory.`);
+            }
+        }
+        if (configOptions.stubPath) {
+            if (!this._fs.existsSync(configOptions.stubPath) || !(0, pathUtils_1.isDirectory)(this._fs, configOptions.stubPath)) {
+                this._console.warn(`stubPath ${configOptions.stubPath} is not a valid directory.`);
+            }
+        }
+        return configOptions;
+    }
+    writeTypeStub(token) {
+        var _a;
+        const typingsSubdirPath = this._getTypeStubFolder();
+        this._program.writeTypeStub((_a = this._typeStubTargetPath) !== null && _a !== void 0 ? _a : '', this._typeStubTargetIsSingleFile, typingsSubdirPath, token);
+    }
+    writeTypeStubInBackground(token) {
+        var _a;
+        const typingsSubdirPath = this._getTypeStubFolder();
+        return this._backgroundAnalysisProgram.writeTypeStub((_a = this._typeStubTargetPath) !== null && _a !== void 0 ? _a : '', this._typeStubTargetIsSingleFile, typingsSubdirPath, token);
+    }
+    // This is called after a new type stub has been created. It allows
+    // us to invalidate caches and force reanalysis of files that potentially
+    // are affected by the appearance of a new type stub.
+    invalidateAndForceReanalysis(rebuildUserFileIndexing = true, rebuildLibraryIndexing = true, updateTrackedFileList = false) {
+        if (updateTrackedFileList) {
+            this._updateTrackedFileList(/* markFilesDirtyUnconditionally */ false);
+        }
+        // Mark all files with one or more errors dirty.
+        this._backgroundAnalysisProgram.invalidateAndForceReanalysis(rebuildUserFileIndexing, rebuildLibraryIndexing);
+    }
+    // Forces the service to stop all analysis, discard all its caches,
+    // and research for files.
+    restart() {
+        this._applyConfigOptions(this._hostFactory());
+        this._backgroundAnalysisProgram.restart();
+    }
+    get _fs() {
+        return this._backgroundAnalysisProgram.importResolver.fileSystem;
+    }
+    get _program() {
+        return this._backgroundAnalysisProgram.program;
+    }
+    get _configOptions() {
+        return this._backgroundAnalysisProgram.configOptions;
+    }
+    get _watchForSourceChanges() {
+        var _a;
+        return !!((_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.watchForSourceChanges);
+    }
+    get _watchForLibraryChanges() {
+        var _a;
+        return !!((_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.watchForLibraryChanges);
+    }
+    get _watchForConfigChanges() {
+        var _a;
+        return !!((_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.watchForConfigChanges);
+    }
+    get _typeCheckingMode() {
+        var _a;
+        return (_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.typeCheckingMode;
+    }
+    get _verboseOutput() {
+        return !!this._configOptions.verboseOutput;
+    }
+    get _typeStubTargetImportName() {
+        var _a;
+        return (_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.typeStubTargetImportName;
+    }
+    _getTypeStubFolder() {
+        const stubPath = this._configOptions.stubPath;
+        if (!this._typeStubTargetPath || !this._typeStubTargetImportName) {
+            const errMsg = `Import '${this._typeStubTargetImportName}'` + ` could not be resolved`;
+            this._console.error(errMsg);
+            throw new Error(errMsg);
+        }
+        if (!stubPath) {
+            // We should never get here because we always generate a
+            // default typings path if none was specified.
+            const errMsg = 'No typings path was specified';
+            this._console.info(errMsg);
+            throw new Error(errMsg);
+        }
+        const typeStubInputTargetParts = this._typeStubTargetImportName.split('.');
+        if (typeStubInputTargetParts[0].length === 0) {
+            // We should never get here because the import resolution
+            // would have failed.
+            const errMsg = `Import '${this._typeStubTargetImportName}'` + ` could not be resolved`;
+            this._console.error(errMsg);
+            throw new Error(errMsg);
+        }
+        try {
+            // Generate a new typings directory if necessary.
+            if (!this._fs.existsSync(stubPath)) {
+                this._fs.mkdirSync(stubPath);
+            }
+        }
+        catch (e) {
+            const errMsg = `Could not create typings directory '${stubPath}'`;
+            this._console.error(errMsg);
+            throw new Error(errMsg);
+        }
+        // Generate a typings subdirectory hierarchy.
+        const typingsSubdirPath = (0, pathUtils_1.combinePaths)(stubPath, typeStubInputTargetParts[0]);
+        const typingsSubdirHierarchy = (0, pathUtils_1.combinePaths)(stubPath, ...typeStubInputTargetParts);
+        try {
+            // Generate a new typings subdirectory if necessary.
+            if (!this._fs.existsSync(typingsSubdirHierarchy)) {
+                (0, pathUtils_1.makeDirectories)(this._fs, typingsSubdirHierarchy, stubPath);
+            }
+        }
+        catch (e) {
+            const errMsg = `Could not create typings subdirectory '${typingsSubdirHierarchy}'`;
+            this._console.error(errMsg);
+            throw new Error(errMsg);
+        }
+        return typingsSubdirPath;
+    }
+    _findConfigFileHereOrUp(searchPath) {
+        return (0, pathUtils_1.forEachAncestorDirectory)(searchPath, (ancestor) => this._findConfigFile(ancestor));
+    }
+    _findConfigFile(searchPath) {
+        for (const name of exports.configFileNames) {
+            const fileName = (0, pathUtils_1.combinePaths)(searchPath, name);
+            if (this._fs.existsSync(fileName)) {
+                return fileName;
+            }
+        }
+        return undefined;
+    }
+    _findPyprojectTomlFileHereOrUp(searchPath) {
+        return (0, pathUtils_1.forEachAncestorDirectory)(searchPath, (ancestor) => this._findPyprojectTomlFile(ancestor));
+    }
+    _findPyprojectTomlFile(searchPath) {
+        const fileName = (0, pathUtils_1.combinePaths)(searchPath, exports.pyprojectTomlName);
+        if (this._fs.existsSync(fileName)) {
+            return fileName;
+        }
+        return undefined;
+    }
+    _parseJsonConfigFile(configPath) {
+        return this._attemptParseFile(configPath, (fileContents) => {
+            return JSONC.parse(fileContents);
+        });
+    }
+    _parsePyprojectTomlFile(pyprojectPath) {
+        return this._attemptParseFile(pyprojectPath, (fileContents, attemptCount) => {
+            try {
+                const configObj = TOML.parse(fileContents);
+                if (configObj && configObj.tool && configObj.tool.pyright) {
+                    return configObj.tool.pyright;
+                }
+            }
+            catch (e) {
+                this._console.error(`Pyproject file parse attempt ${attemptCount} error: ${JSON.stringify(e)}`);
+                throw e;
+            }
+            this._console.error(`Pyproject file "${pyprojectPath}" is missing "[tool.pyright]" section.`);
+            return undefined;
+        });
+    }
+    _attemptParseFile(filePath, parseCallback) {
+        let fileContents = '';
+        let parseAttemptCount = 0;
+        while (true) {
+            // Attempt to read the file contents.
+            try {
+                fileContents = this._fs.readFileSync(filePath, 'utf8');
+            }
+            catch {
+                this._console.error(`Config file "${filePath}" could not be read.`);
+                this._reportConfigParseError();
+                return undefined;
+            }
+            // Attempt to parse the file.
+            let parseFailed = false;
+            try {
+                return parseCallback(fileContents, parseAttemptCount + 1);
+            }
+            catch (e) {
+                parseFailed = true;
+            }
+            if (!parseFailed) {
+                break;
+            }
+            // If we attempt to read the file immediately after it was saved, it
+            // may have been partially written when we read it, resulting in parse
+            // errors. We'll give it a little more time and try again.
+            if (parseAttemptCount++ >= 5) {
+                this._console.error(`Config file "${filePath}" could not be parsed. Verify that format is correct.`);
+                this._reportConfigParseError();
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    _getFileNamesFromFileSpecs() {
+        // Use a map to generate a list of unique files.
+        const fileMap = new Map();
+        timing_1.timingStats.findFilesTime.timeOperation(() => {
+            const matchedFiles = this._matchFiles(this._configOptions.include, this._configOptions.exclude);
+            for (const file of matchedFiles) {
+                fileMap.set(file, file);
+            }
+        });
+        return [...fileMap.values()];
+    }
+    // If markFilesDirtyUnconditionally is true, we need to reparse
+    // and reanalyze all files in the program. If false, we will
+    // reparse and reanalyze only those files whose on-disk contents
+    // have changed. Unconditional dirtying is needed in the case where
+    // configuration options have changed.
+    _updateTrackedFileList(markFilesDirtyUnconditionally) {
+        // Are we in type stub generation mode? If so, we need to search
+        // for a different set of files.
+        if (this._typeStubTargetImportName) {
+            const execEnv = this._configOptions.findExecEnvironment(this._executionRootPath);
+            const moduleDescriptor = (0, importResolver_1.createImportedModuleDescriptor)(this._typeStubTargetImportName);
+            const importResult = this._backgroundAnalysisProgram.importResolver.resolveImport('', execEnv, moduleDescriptor);
+            if (importResult.isImportFound) {
+                const filesToImport = [];
+                // Determine the directory that contains the root package.
+                const finalResolvedPath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+                const isFinalPathFile = (0, pathUtils_1.isFile)(this._fs, finalResolvedPath);
+                const isFinalPathInitFile = isFinalPathFile && (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(finalResolvedPath)) === '__init__';
+                let rootPackagePath = finalResolvedPath;
+                if (isFinalPathFile) {
+                    // If the module is a __init__.pyi? file, use its parent directory instead.
+                    rootPackagePath = (0, pathUtils_1.getDirectoryPath)(rootPackagePath);
+                }
+                for (let i = importResult.resolvedPaths.length - 2; i >= 0; i--) {
+                    if (importResult.resolvedPaths[i]) {
+                        rootPackagePath = importResult.resolvedPaths[i];
+                    }
+                    else {
+                        // If there was no file corresponding to this portion
+                        // of the name path, assume that it's contained
+                        // within its parent directory.
+                        rootPackagePath = (0, pathUtils_1.getDirectoryPath)(rootPackagePath);
+                    }
+                }
+                if ((0, pathUtils_1.isDirectory)(this._fs, rootPackagePath)) {
+                    this._typeStubTargetPath = rootPackagePath;
+                }
+                else if ((0, pathUtils_1.isFile)(this._fs, rootPackagePath)) {
+                    // This can occur if there is a "dir/__init__.py" at the same level as a
+                    // module "dir/module.py" that is specifically targeted for stub generation.
+                    this._typeStubTargetPath = (0, pathUtils_1.getDirectoryPath)(rootPackagePath);
+                }
+                if (!finalResolvedPath) {
+                    this._typeStubTargetIsSingleFile = false;
+                }
+                else {
+                    filesToImport.push(finalResolvedPath);
+                    this._typeStubTargetIsSingleFile = importResult.resolvedPaths.length === 1 && !isFinalPathInitFile;
+                }
+                // Add the implicit import paths.
+                importResult.filteredImplicitImports.forEach((implicitImport) => {
+                    filesToImport.push(implicitImport.path);
+                });
+                this._backgroundAnalysisProgram.setAllowedThirdPartyImports([this._typeStubTargetImportName]);
+                this._backgroundAnalysisProgram.setTrackedFiles(filesToImport);
+            }
+            else {
+                this._console.error(`Import '${this._typeStubTargetImportName}' not found`);
+            }
+        }
+        else {
+            let fileList = [];
+            this._console.info(`Searching for source files`);
+            fileList = this._getFileNamesFromFileSpecs();
+            this._backgroundAnalysisProgram.setTrackedFiles(fileList);
+            this._backgroundAnalysisProgram.markAllFilesDirty(markFilesDirtyUnconditionally);
+            if (fileList.length === 0) {
+                this._console.info(`No source files found.`);
+            }
+            else {
+                this._console.info(`Found ${fileList.length} ` + `source ${fileList.length === 1 ? 'file' : 'files'}`);
+            }
+        }
+        this._requireTrackedFileUpdate = false;
+    }
+    _matchFiles(include, exclude) {
+        const envMarkers = [['bin', 'activate'], ['Scripts', 'activate'], ['pyvenv.cfg']];
+        const results = [];
+        const startTime = Date.now();
+        const longOperationLimitInSec = 10;
+        let loggedLongOperationError = false;
+        const visitDirectoryUnchecked = (absolutePath, includeRegExp) => {
+            if (!loggedLongOperationError) {
+                const secondsSinceStart = (Date.now() - startTime) * 0.001;
+                // If this is taking a long time, log an error to help the user
+                // diagnose and mitigate the problem.
+                if (secondsSinceStart >= longOperationLimitInSec) {
+                    this._console.error(`Enumeration of workspace source files is taking longer than ${longOperationLimitInSec} seconds.\n` +
+                        'This may be because:\n' +
+                        '* You have opened your home directory or entire hard drive as a workspace\n' +
+                        '* Your workspace contains a very large number of directories and files\n' +
+                        '* Your workspace contains a symlink to a directory with many files\n' +
+                        '* Your workspace is remote, and file enumeration is slow\n' +
+                        'To reduce this time, open a workspace directory with fewer files ' +
+                        'or add a pyrightconfig.json configuration file with an "exclude" section to exclude ' +
+                        'subdirectories from your workspace. For more details, refer to ' +
+                        'https://github.com/microsoft/pyright/blob/main/docs/configuration.md.');
+                    loggedLongOperationError = true;
+                }
+            }
+            if (this._configOptions.autoExcludeVenv) {
+                if (envMarkers.some((f) => this._fs.existsSync((0, pathUtils_1.combinePaths)(absolutePath, ...f)))) {
+                    this._console.info(`Auto-excluding ${absolutePath}`);
+                    return;
+                }
+            }
+            const { files, directories } = (0, pathUtils_1.getFileSystemEntries)(this._fs, absolutePath);
+            for (const file of files) {
+                const filePath = (0, pathUtils_1.combinePaths)(absolutePath, file);
+                if (this._matchIncludeFileSpec(includeRegExp, exclude, filePath)) {
+                    results.push(filePath);
+                }
+            }
+            for (const directory of directories) {
+                const dirPath = (0, pathUtils_1.combinePaths)(absolutePath, directory);
+                if (includeRegExp.test(dirPath)) {
+                    if (!this._isInExcludePath(dirPath, exclude)) {
+                        visitDirectory(dirPath, includeRegExp);
+                    }
+                }
+            }
+        };
+        const seenDirs = new Set();
+        const visitDirectory = (absolutePath, includeRegExp) => {
+            const realDirPath = (0, pathUtils_1.tryRealpath)(this._fs, absolutePath);
+            if (!realDirPath) {
+                this._console.warn(`Skipping broken link "${absolutePath}"`);
+                return;
+            }
+            if (seenDirs.has(realDirPath)) {
+                this._console.warn(`Skipping recursive symlink "${absolutePath}" -> "${realDirPath}"`);
+                return;
+            }
+            seenDirs.add(realDirPath);
+            try {
+                visitDirectoryUnchecked(absolutePath, includeRegExp);
+            }
+            finally {
+                seenDirs.delete(realDirPath);
+            }
+        };
+        include.forEach((includeSpec) => {
+            if (!this._isInExcludePath(includeSpec.wildcardRoot, exclude)) {
+                let foundFileSpec = false;
+                let isFileIncluded = true;
+                const stat = (0, pathUtils_1.tryStat)(this._fs, includeSpec.wildcardRoot);
+                if (stat === null || stat === void 0 ? void 0 : stat.isFile()) {
+                    if (this._shouldIncludeFile(includeSpec.wildcardRoot)) {
+                        results.push(includeSpec.wildcardRoot);
+                    }
+                    else {
+                        isFileIncluded = false;
+                    }
+                    foundFileSpec = true;
+                }
+                else if (stat === null || stat === void 0 ? void 0 : stat.isDirectory()) {
+                    visitDirectory(includeSpec.wildcardRoot, includeSpec.regExp);
+                    foundFileSpec = true;
+                }
+                if (!foundFileSpec) {
+                    this._console.error(`File or directory "${includeSpec.wildcardRoot}" does not exist.`);
+                }
+                else if (!isFileIncluded) {
+                    this._console.error(`File "${includeSpec.wildcardRoot}" is not a Python source file.`);
+                }
+            }
+        });
+        return results;
+    }
+    _removeSourceFileWatchers() {
+        if (this._sourceFileWatcher) {
+            this._sourceFileWatcher.close();
+            this._sourceFileWatcher = undefined;
+        }
+    }
+    _updateSourceFileWatchers() {
+        this._removeSourceFileWatchers();
+        if (!this._watchForSourceChanges) {
+            return;
+        }
+        if (this._configOptions.include.length > 0) {
+            const fileList = this._configOptions.include.map((spec) => {
+                return (0, pathUtils_1.combinePaths)(this._executionRootPath, spec.wildcardRoot);
+            });
+            try {
+                if (this._verboseOutput) {
+                    this._console.info(`Adding fs watcher for directories:\n ${fileList.join('\n')}`);
+                }
+                const isIgnored = (0, fileSystem_1.ignoredWatchEventFunction)(fileList);
+                this._sourceFileWatcher = this._fs.createFileSystemWatcher(fileList, (event, path) => {
+                    if (!path) {
+                        return;
+                    }
+                    if (this._verboseOutput) {
+                        this._console.info(`SourceFile: Received fs event '${event}' for path '${path}'`);
+                    }
+                    if (isIgnored(path)) {
+                        return;
+                    }
+                    // Wholesale ignore events that appear to be from tmp file / .git modification.
+                    if (path.endsWith('.tmp') || path.endsWith('.git') || path.includes(_gitDirectory)) {
+                        return;
+                    }
+                    const eventInfo = getEventInfo(this._fs, this._console, this._program, event, path);
+                    if (!eventInfo) {
+                        // no-op event, return.
+                        return;
+                    }
+                    // For file change, we only care python file change.
+                    if (eventInfo.isFile &&
+                        (!(0, pathUtils_1.hasPythonExtension)(path) || isTemporaryFile(path) || !this.isTracked(path))) {
+                        return;
+                    }
+                    if (eventInfo.isFile && (eventInfo.event === 'change' || eventInfo.event === 'unlink')) {
+                        this._backgroundAnalysisProgram.markFilesDirty([path], /* evenIfContentsAreSame */ false);
+                        this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+                    }
+                    else {
+                        // Added files or folder changes impact imports,
+                        // clear the import resolver cache and reanalyze everything.
+                        //
+                        // Here we don't need to rebuild any indexing since this kind of change can't affect
+                        // indices. For library, since the changes are on workspace files, it won't affect library
+                        // indices. For user file, since user file indices don't contains import alias symbols,
+                        // it won't affect those indices. we only need to rebuild user file indices when symbols
+                        // defined in the file are changed. ex) user modified the file.
+                        // Newly added file will be scanned since it doesn't have existing indices.
+                        this.invalidateAndForceReanalysis(
+                        /* rebuildUserFileIndexing */ false, 
+                        /* rebuildLibraryIndexing */ false);
+                        this._scheduleReanalysis(/* requireTrackedFileUpdate */ true);
+                    }
+                });
+            }
+            catch {
+                this._console.error(`Exception caught when installing fs watcher for:\n ${fileList.join('\n')}`);
+            }
+        }
+        function isTemporaryFile(path) {
+            // Determine if this is an add or delete event related to a temporary
+            // file. Some tools (like auto-formatters) create temporary files
+            // alongside the original file and name them "x.py.<temp-id>.py" where
+            // <temp-id> is a 32-character random string of hex digits. We don't
+            // want these events to trigger a full reanalysis.
+            const fileName = (0, pathUtils_1.getFileName)(path);
+            const fileNameSplit = fileName.split('.');
+            if (fileNameSplit.length === 4) {
+                if (fileNameSplit[3] === fileNameSplit[1] && fileNameSplit[2].length === 32) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function getEventInfo(fs, console, program, event, path) {
+            // Due to the way we implemented file watcher, we will only get 2 events; 'add' and 'change'.
+            // Here, we will convert those 2 to 3 events. 'add', 'change' and 'unlink';
+            const stats = (0, pathUtils_1.tryStat)(fs, path);
+            if (event === 'add') {
+                if (!stats) {
+                    // If we are told that the path is added, but if we can't access it, then consider it as already deleted.
+                    // there is nothing we need to do.
+                    return undefined;
+                }
+                return { event, isFile: stats.isFile() };
+            }
+            if (event === 'change') {
+                // If we got 'change', but can't access the path, then we consider it as delete.
+                if (!stats) {
+                    // See whether it is a file that got deleted.
+                    const isFile = !!program.getSourceFile(path);
+                    // If not, check whether it is a part of the workspace at all.
+                    if (!isFile && !program.containsSourceFileIn(path)) {
+                        // There is no source file under the given path. There is nothing we need to do.
+                        return undefined;
+                    }
+                    return { event: 'unlink', isFile };
+                }
+                return { event, isFile: stats.isFile() };
+            }
+            // We have unknown event.
+            console.warn(`Received unknown file change event: '${event}' for '${path}'`);
+            return undefined;
+        }
+    }
+    _removeLibraryFileWatcher() {
+        if (this._libraryFileWatcher) {
+            this._libraryFileWatcher.close();
+            this._libraryFileWatcher = undefined;
+        }
+    }
+    _updateLibraryFileWatcher() {
+        this._removeLibraryFileWatcher();
+        if (!this._watchForLibraryChanges) {
+            return;
+        }
+        // Watch the library paths for package install/uninstall.
+        const importFailureInfo = [];
+        this._librarySearchPathsToWatch = (0, pythonPathUtils_1.findPythonSearchPaths)(this._fs, this._backgroundAnalysisProgram.configOptions, this._backgroundAnalysisProgram.host, importFailureInfo, true, this._executionRootPath);
+        const watchList = this._librarySearchPathsToWatch;
+        if (watchList && watchList.length > 0) {
+            try {
+                if (this._verboseOutput) {
+                    this._console.info(`Adding fs watcher for library directories:\n ${watchList.join('\n')}`);
+                }
+                const isIgnored = (0, fileSystem_1.ignoredWatchEventFunction)(watchList);
+                this._libraryFileWatcher = this._fs.createFileSystemWatcher(watchList, (event, path) => {
+                    if (!path) {
+                        return;
+                    }
+                    if (this._verboseOutput) {
+                        this._console.info(`LibraryFile: Received fs event '${event}' for path '${path}'`);
+                    }
+                    if (isIgnored(path)) {
+                        return;
+                    }
+                    this._scheduleLibraryAnalysis();
+                });
+            }
+            catch {
+                this._console.error(`Exception caught when installing fs watcher for:\n ${watchList.join('\n')}`);
+            }
+        }
+    }
+    _clearLibraryReanalysisTimer() {
+        var _a;
+        if (this._libraryReanalysisTimer) {
+            clearTimeout(this._libraryReanalysisTimer);
+            this._libraryReanalysisTimer = undefined;
+            (_a = this._backgroundAnalysisProgram) === null || _a === void 0 ? void 0 : _a.cancelIndexing();
+        }
+    }
+    _scheduleLibraryAnalysis() {
+        if (this._disposed) {
+            // Already disposed.
+            return;
+        }
+        this._clearLibraryReanalysisTimer();
+        // Wait for a little while, since library changes
+        // tend to happen in big batches when packages
+        // are installed or uninstalled.
+        this._libraryReanalysisTimer = setTimeout(() => {
+            this._clearLibraryReanalysisTimer();
+            // Invalidate import resolver, mark all files dirty unconditionally,
+            // and reanalyze.
+            this.invalidateAndForceReanalysis(/* rebuildUserFileIndexing */ false);
+            this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+        }, _libraryActivityBackoffTimeInMs);
+    }
+    _removeConfigFileWatcher() {
+        if (this._configFileWatcher) {
+            this._configFileWatcher.close();
+            this._configFileWatcher = undefined;
+        }
+    }
+    _updateConfigFileWatcher() {
+        this._removeConfigFileWatcher();
+        if (!this._watchForConfigChanges) {
+            return;
+        }
+        if (this._configFilePath) {
+            this._configFileWatcher = this._fs.createFileSystemWatcher([this._configFilePath], (event) => {
+                if (this._verboseOutput) {
+                    this._console.info(`Received fs event '${event}' for config file`);
+                }
+                this._scheduleReloadConfigFile();
+            });
+        }
+        else if (this._executionRootPath) {
+            this._configFileWatcher = this._fs.createFileSystemWatcher([this._executionRootPath], (event, path) => {
+                if (!path) {
+                    return;
+                }
+                if (event === 'add' || event === 'change') {
+                    const fileName = (0, pathUtils_1.getFileName)(path);
+                    if (fileName && exports.configFileNames.some((name) => name === fileName)) {
+                        if (this._verboseOutput) {
+                            this._console.info(`Received fs event '${event}' for config file`);
+                        }
+                        if (this._commandLineOptions) {
+                            this.setOptions(this._commandLineOptions);
+                        }
+                    }
+                }
+            });
+        }
+    }
+    _clearReloadConfigTimer() {
+        if (this._reloadConfigTimer) {
+            clearTimeout(this._reloadConfigTimer);
+            this._reloadConfigTimer = undefined;
+        }
+    }
+    _scheduleReloadConfigFile() {
+        this._clearReloadConfigTimer();
+        // Wait for a little while after we receive the
+        // change update event because it may take a while
+        // for the file to be written out. Plus, there may
+        // be multiple changes.
+        this._reloadConfigTimer = setTimeout(() => {
+            this._clearReloadConfigTimer();
+            this._reloadConfigFile();
+        }, 100);
+    }
+    _reloadConfigFile() {
+        this._updateConfigFileWatcher();
+        if (this._configFilePath) {
+            this._console.info(`Reloading configuration file at ${this._configFilePath}`);
+            const host = this._backgroundAnalysisProgram.host;
+            // We can't just reload config file when it is changed; we need to consider
+            // command line options as well to construct new config Options.
+            const configOptions = this._getConfigOptions(host, this._commandLineOptions);
+            this._backgroundAnalysisProgram.setConfigOptions(configOptions);
+            this._applyConfigOptions(host);
+        }
+    }
+    _applyConfigOptions(host) {
+        var _a;
+        // Allocate a new import resolver because the old one has information
+        // cached based on the previous config options.
+        const importResolver = this._importResolverFactory(this._fs, this._backgroundAnalysisProgram.configOptions, host);
+        this._backgroundAnalysisProgram.setImportResolver(importResolver);
+        if (((_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.fromVsCodeExtension) || this._configOptions.verboseOutput) {
+            const logLevel = this._configOptions.verboseOutput ? console_1.LogLevel.Info : console_1.LogLevel.Log;
+            for (const execEnv of this._configOptions.getExecutionEnvironments()) {
+                (0, console_1.log)(this._console, logLevel, `Search paths for ${execEnv.root || '<default>'}`);
+                const roots = importResolver.getImportRoots(execEnv, /* forLogging */ true);
+                roots.forEach((path) => {
+                    (0, console_1.log)(this._console, logLevel, `  ${path}`);
+                });
+            }
+        }
+        this._updateLibraryFileWatcher();
+        this._updateConfigFileWatcher();
+        this._updateSourceFileWatchers();
+        this._updateTrackedFileList(/* markFilesDirtyUnconditionally */ true);
+        this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+    }
+    _clearReanalysisTimer() {
+        if (this._analyzeTimer) {
+            clearTimeout(this._analyzeTimer);
+            this._analyzeTimer = undefined;
+        }
+    }
+    _scheduleReanalysis(requireTrackedFileUpdate) {
+        var _a, _b;
+        if (this._disposed || !((_a = this._commandLineOptions) === null || _a === void 0 ? void 0 : _a.enableAmbientAnalysis)) {
+            // already disposed
+            return;
+        }
+        if (requireTrackedFileUpdate) {
+            this._requireTrackedFileUpdate = true;
+        }
+        (_b = this._backgroundAnalysisCancellationSource) === null || _b === void 0 ? void 0 : _b.cancel();
+        // Remove any existing analysis timer.
+        this._clearReanalysisTimer();
+        // How long has it been since the user interacted with the service?
+        // If the user is actively typing, back off to let him or her finish.
+        const timeSinceLastUserInteractionInMs = Date.now() - this._lastUserInteractionTime;
+        const minBackoffTimeInMs = _userActivityBackoffTimeInMs;
+        // We choose a small non-zero value here. If this value
+        // is too small (like zero), the VS Code extension becomes
+        // unresponsive during heavy analysis. If this number is too
+        // large, analysis takes longer.
+        const minTimeBetweenAnalysisPassesInMs = 20;
+        const timeUntilNextAnalysisInMs = Math.max(minBackoffTimeInMs - timeSinceLastUserInteractionInMs, minTimeBetweenAnalysisPassesInMs);
+        // Schedule a new timer.
+        this._analyzeTimer = setTimeout(() => {
+            this._analyzeTimer = undefined;
+            if (this._requireTrackedFileUpdate) {
+                this._updateTrackedFileList(/* markFilesDirtyUnconditionally */ false);
+            }
+            // This creates a cancellation source only if it actually gets used.
+            this._backgroundAnalysisCancellationSource = this._cancellationProvider.createCancellationTokenSource();
+            const moreToAnalyze = this._backgroundAnalysisProgram.startAnalysis(this._backgroundAnalysisCancellationSource.token);
+            if (moreToAnalyze) {
+                this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
+            }
+        }, timeUntilNextAnalysisInMs);
+    }
+    _reportConfigParseError() {
+        if (this._onCompletionCallback) {
+            this._onCompletionCallback({
+                diagnostics: [],
+                filesInProgram: 0,
+                filesRequiringAnalysis: 0,
+                checkingOnlyOpenFiles: true,
+                fatalErrorOccurred: false,
+                configParseErrorOccurred: true,
+                elapsedTime: 0,
+            });
+        }
+    }
+    _shouldIncludeFile(filePath) {
+        return _includeFileRegex.test(filePath);
+    }
+    _isInExcludePath(path, excludePaths) {
+        return !!excludePaths.find((excl) => excl.regExp.test(path));
+    }
+    _matchIncludeFileSpec(includeRegExp, exclude, filePath) {
+        if (includeRegExp.test(filePath)) {
+            if (!this._isInExcludePath(filePath, exclude) && this._shouldIncludeFile(filePath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.AnalyzerService = AnalyzerService;
+//# sourceMappingURL=service.js.map