@zzzen/pyright-internal 1.2.0-dev.20230416 → 1.2.0-dev.20230430

package/dist/languageServerBase.js

@@ -14,6 +14,7 @@ exports.LanguageServerBase = void 0;
 require("./common/extensions");
 const vscode_languageserver_1 = require("vscode-languageserver");
 const progress_1 = require("vscode-languageserver/lib/common/progress");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const backgroundAnalysisProgram_1 = require("./analyzer/backgroundAnalysisProgram");
 const cacheManager_1 = require("./analyzer/cacheManager");
 const service_1 = require("./analyzer/service");
@@ -33,9 +34,14 @@ const stringUtils_1 = require("./common/stringUtils");
 const uriParser_1 = require("./common/uriParser");
 const workspaceEditUtils_1 = require("./common/workspaceEditUtils");
 const analyzerServiceExecutor_1 = require("./languageService/analyzerServiceExecutor");
+const callHierarchyProvider_1 = require("./languageService/callHierarchyProvider");
 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 navigationUtils_1 = require("./languageService/navigationUtils");
+const referencesProvider_1 = require("./languageService/referencesProvider");
+const signatureHelpProvider_1 = require("./languageService/signatureHelpProvider");
 const localize_1 = require("./localization/localize");
 const pyrightFileSystem_1 = require("./pyrightFileSystem");
 const workspaceFactory_1 = require("./workspaceFactory");
@@ -99,10 +105,10 @@ var VSDiagnosticRank;
     VSDiagnosticRank.Lowest = 500;
 })(VSDiagnosticRank || (VSDiagnosticRank = {}));
 class LanguageServerBase {
-    constructor(_serverOptions, _connection, console, uriParserFactory = (fs) => new uriParser_1.UriParser(fs)) {
+    constructor(serverOptions, connection, console, uriParserFactory = (fs) => new uriParser_1.UriParser(fs)) {
         var _a, _b;
-        this._serverOptions = _serverOptions;
-        this._connection = _connection;
+        this.serverOptions = serverOptions;
+        this.connection = connection;
         this.console = console;
         this._lastTriggerKind = vscode_languageserver_1.CompletionTriggerKind.Invoked;
         this._initialized = false;
@@ -131,33 +137,124 @@ class LanguageServerBase {
             supportsTaskItemDiagnosticTag: false,
             completionItemResolveSupportsAdditionalTextEdits: false,
         };
+        this.openFileMap = new Map();
         // Stash the base directory into a global variable.
         // This must happen before fs.getModulePath().
-        global.__rootDirectory = _serverOptions.rootDirectory;
-        this.console.info(`${_serverOptions.productName} language server ${_serverOptions.version && _serverOptions.version + ' '}starting`);
-        this.console.info(`Server root directory: ${_serverOptions.rootDirectory}`);
-        this._cacheManager = new cacheManager_1.CacheManager();
-        this._serviceFS = new pyrightFileSystem_1.PyrightFileSystem(this._serverOptions.fileSystem);
-        this._uriParser = uriParserFactory(this._serviceFS);
-        this._workspaceFactory = new workspaceFactory_1.WorkspaceFactory(this.console, this._uriParser, this.createAnalyzerServiceForWorkspace.bind(this), this.isPythonPathImmutable.bind(this), this.onWorkspaceCreated.bind(this));
+        global.__rootDirectory = serverOptions.rootDirectory;
+        this.console.info(`${serverOptions.productName} language server ${serverOptions.version && serverOptions.version + ' '}starting`);
+        this.console.info(`Server root directory: ${serverOptions.rootDirectory}`);
+        this.cacheManager = new cacheManager_1.CacheManager();
+        this.fs = new pyrightFileSystem_1.PyrightFileSystem(this.serverOptions.fileSystem);
+        this.uriParser = uriParserFactory(this.fs);
+        this.workspaceFactory = new workspaceFactory_1.WorkspaceFactory(this.console, this.uriParser, this.createAnalyzerServiceForWorkspace.bind(this), this.isPythonPathImmutable.bind(this), this.onWorkspaceCreated.bind(this));
         // Set the working directory to a known location within
         // the extension directory. Otherwise the execution of
         // python can have unintended and surprising results.
-        const moduleDirectory = this._serviceFS.getModulePath();
+        const moduleDirectory = this.fs.getModulePath();
         if (moduleDirectory) {
-            this._serviceFS.chdir(moduleDirectory);
+            this.fs.chdir(moduleDirectory);
         }
         // Set up callbacks.
-        this.setupConnection((_a = _serverOptions.supportedCommands) !== null && _a !== void 0 ? _a : [], (_b = _serverOptions.supportedCodeActions) !== null && _b !== void 0 ? _b : []);
+        this.setupConnection((_a = serverOptions.supportedCommands) !== null && _a !== void 0 ? _a : [], (_b = serverOptions.supportedCodeActions) !== null && _b !== void 0 ? _b : []);
         this._progressReporter = new progressReporter_1.ProgressReportTracker(this.createProgressReporter());
         // Listen on the connection.
-        this._connection.listen();
+        this.connection.listen();
         // Setup extensions
         extensibility_1.Extensions.createLanguageServiceExtensions(this);
     }
+    // Provides access to the client's window.
+    get window() {
+        return this.connection.window;
+    }
+    get supportAdvancedEdits() {
+        return this.client.hasDocumentChangeCapability && this.client.hasDocumentAnnotationCapability;
+    }
     // Convert uri to path
     decodeTextDocumentUri(uriString) {
-        return this._uriParser.decodeTextDocumentUri(uriString);
+        return this.uriParser.decodeTextDocumentUri(uriString);
+    }
+    // Creates a service instance that's used for analyzing a
+    // program within a workspace.
+    createAnalyzerService(name, services, libraryReanalysisTimeProvider) {
+        var _a;
+        this.console.info(`Starting service instance "${name}"`);
+        const serviceId = (0, service_1.getNextServiceId)(name);
+        const service = new service_1.AnalyzerService(name, (_a = services === null || services === void 0 ? void 0 : services.fs) !== null && _a !== void 0 ? _a : this.fs, {
+            console: this.console,
+            hostFactory: this.createHost.bind(this),
+            importResolverFactory: this.createImportResolver.bind(this),
+            backgroundAnalysis: services ? services.backgroundAnalysis : this.createBackgroundAnalysis(serviceId),
+            maxAnalysisTime: this.serverOptions.maxAnalysisTimeInForeground,
+            backgroundAnalysisProgramFactory: this.createBackgroundAnalysisProgram.bind(this),
+            cancellationProvider: this.serverOptions.cancellationProvider,
+            libraryReanalysisTimeProvider,
+            cacheManager: this.cacheManager,
+            serviceId,
+        });
+        service.setCompletionCallback((results) => this.onAnalysisCompletedHandler(service.fs, results));
+        return service;
+    }
+    async test_getWorkspaces() {
+        const workspaces = [...this.workspaceFactory.items()];
+        for (const workspace of workspaces) {
+            await workspace.isInitialized.promise;
+        }
+        return workspaces;
+    }
+    async getWorkspaceForFile(filePath, pythonPath) {
+        return this.workspaceFactory.getWorkspaceForFile(filePath, pythonPath);
+    }
+    async getContainingWorkspacesForFile(filePath) {
+        return this.workspaceFactory.getContainingWorkspacesForFile(filePath);
+    }
+    reanalyze() {
+        this.workspaceFactory.items().forEach((workspace) => {
+            workspace.service.invalidateAndForceReanalysis();
+        });
+    }
+    restart() {
+        this.workspaceFactory.items().forEach((workspace) => {
+            workspace.service.restart();
+        });
+    }
+    updateSettingsForAllWorkspaces() {
+        const tasks = [];
+        this.workspaceFactory.items().forEach((workspace) => {
+            // Updating settings can change workspace's file ownership. Make workspace uninitialized so that
+            // features can wait until workspace gets new settings.
+            // the file's ownership can also changed by `pyrightconfig.json` changes, but those are synchronous
+            // operation, so it won't affect this.
+            workspace.isInitialized = workspace.isInitialized.reset();
+            tasks.push(this.updateSettingsForWorkspace(workspace, workspace.isInitialized));
+        });
+        Promise.all(tasks).then(() => {
+            this._setupFileWatcher();
+        });
+    }
+    async updateSettingsForWorkspace(workspace, status, serverSettings) {
+        var _a;
+        status === null || status === void 0 ? void 0 : status.markCalled();
+        serverSettings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : (await this.getSettings(workspace));
+        // Set logging level first.
+        this.console.level = (_a = serverSettings.logLevel) !== null && _a !== void 0 ? _a : console_1.LogLevel.Info;
+        // Apply the new path to the workspace (before restarting the service).
+        serverSettings.pythonPath = this.workspaceFactory.applyPythonPath(workspace, serverSettings.pythonPath);
+        // Then use the updated settings to restart the service.
+        this.updateOptionsAndRestartService(workspace, serverSettings);
+        workspace.disableLanguageServices = !!serverSettings.disableLanguageServices;
+        workspace.disableOrganizeImports = !!serverSettings.disableOrganizeImports;
+        // Don't use workspace.isInitialized directly since it might have been
+        // reset due to pending config change event.
+        // The workspace is now open for business.
+        status === null || status === void 0 ? void 0 : status.resolve();
+    }
+    updateOptionsAndRestartService(workspace, serverSettings, typeStubTargetImportName) {
+        var _a;
+        analyzerServiceExecutor_1.AnalyzerServiceExecutor.runWithOptions(this.rootPath, workspace, serverSettings, typeStubTargetImportName);
+        workspace.searchPathsToWatch = (_a = workspace.service.librarySearchPathsToWatch) !== null && _a !== void 0 ? _a : [];
+    }
+    get allowModuleRename() {
+        return false;
     }
     isPythonPathImmutable(filePath) {
         // This function is called to determine if the file is using
@@ -174,19 +271,16 @@ class LanguageServerBase {
             if (section !== undefined) {
                 item.section = section;
             }
-            return this._connection.workspace.getConfiguration(item);
+            return this.connection.workspace.getConfiguration(item);
         }
-        if (this._defaultClientConfig) {
-            return (0, collectionUtils_1.getNestedProperty)(this._defaultClientConfig, section);
+        if (this.defaultClientConfig) {
+            return (0, collectionUtils_1.getNestedProperty)(this.defaultClientConfig, section);
         }
         return undefined;
     }
     isOpenFilesOnly(diagnosticMode) {
         return diagnosticMode !== 'workspace';
     }
-    get allowModuleRename() {
-        return false;
-    }
     getSeverityOverrides(value) {
         const enumValue = value;
         if ((0, commandLineOptions_1.getDiagnosticSeverityOverrides)().includes(enumValue)) {
@@ -205,87 +299,36 @@ class LanguageServerBase {
         return new backgroundAnalysisProgram_1.BackgroundAnalysisProgram(console, configOptions, importResolver, backgroundAnalysis, maxAnalysisTime, 
         /* disableChecker */ undefined, cacheManager);
     }
-    // Provides access to the client's window.
-    get window() {
-        return this._connection.window;
-    }
-    get supportAdvancedEdits() {
-        return this.client.hasDocumentChangeCapability && this.client.hasDocumentAnnotationCapability;
-    }
-    // Creates a service instance that's used for analyzing a
-    // program within a workspace.
-    createAnalyzerService(name, services, libraryReanalysisTimeProvider) {
-        var _a;
-        this.console.info(`Starting service instance "${name}"`);
-        const serviceId = (0, service_1.getNextServiceId)(name);
-        const service = new service_1.AnalyzerService(name, (_a = services === null || services === void 0 ? void 0 : services.fs) !== null && _a !== void 0 ? _a : this._serviceFS, {
-            console: this.console,
-            hostFactory: this.createHost.bind(this),
-            importResolverFactory: this.createImportResolver.bind(this),
-            backgroundAnalysis: services ? services.backgroundAnalysis : this.createBackgroundAnalysis(serviceId),
-            maxAnalysisTime: this._serverOptions.maxAnalysisTimeInForeground,
-            backgroundAnalysisProgramFactory: this.createBackgroundAnalysisProgram.bind(this),
-            cancellationProvider: this._serverOptions.cancellationProvider,
-            libraryReanalysisTimeProvider,
-            cacheManager: this._cacheManager,
-            serviceId,
-        });
-        service.setCompletionCallback((results) => this.onAnalysisCompletedHandler(service.fs, results));
-        return service;
-    }
-    async test_getWorkspaces() {
-        const workspaces = [...this._workspaceFactory.items()];
-        for (const workspace of workspaces) {
-            await workspace.isInitialized.promise;
-        }
-        return workspaces;
-    }
-    async getWorkspaceForFile(filePath, pythonPath) {
-        return this._workspaceFactory.getWorkspaceForFile(filePath, pythonPath);
-    }
-    async getContainingWorkspacesForFile(filePath) {
-        return this._workspaceFactory.getContainingWorkspacesForFile(filePath);
-    }
-    reanalyze() {
-        this._workspaceFactory.items().forEach((workspace) => {
-            workspace.service.invalidateAndForceReanalysis();
-        });
-    }
-    restart() {
-        this._workspaceFactory.items().forEach((workspace) => {
-            workspace.service.restart();
-        });
-    }
     setupConnection(supportedCommands, supportedCodeActions) {
         // After the server has started the client sends an initialize request. The server receives
         // in the passed params the rootPath of the workspace plus the client capabilities.
-        this._connection.onInitialize((params) => this.initialize(params, supportedCommands, supportedCodeActions));
-        this._connection.onInitialized(() => this.onInitialized());
-        this._connection.onDidChangeConfiguration((params) => this.onDidChangeConfiguration(params));
-        this._connection.onCodeAction((params, token) => this.executeCodeAction(params, token));
-        this._connection.onDefinition(async (params, token) => this.onDefinition(params, token));
-        this._connection.onDeclaration(async (params, token) => this.onDeclaration(params, token));
-        this._connection.onTypeDefinition(async (params, token) => this.onTypeDefinition(params, token));
-        this._connection.onReferences(async (params, token, workDoneReporter, resultReporter) => this.onReferences(params, token, workDoneReporter, resultReporter));
-        this._connection.onDocumentSymbol(async (params, token) => this.onDocumentSymbol(params, token));
-        this._connection.onWorkspaceSymbol(async (params, token, _, resultReporter) => this.onWorkspaceSymbol(params, token, resultReporter));
-        this._connection.onHover(async (params, token) => this.onHover(params, token));
-        this._connection.onDocumentHighlight(async (params, token) => this.onDocumentHighlight(params, token));
-        this._connection.onSignatureHelp(async (params, token) => this.onSignatureHelp(params, token));
-        this._connection.onCompletion((params, token) => this.onCompletion(params, token));
-        this._connection.onCompletionResolve(async (params, token) => this.onCompletionResolve(params, token));
-        this._connection.onPrepareRename(async (params, token) => this.onPrepareRenameRequest(params, token));
-        this._connection.onRenameRequest(async (params, token) => this.onRenameRequest(params, token));
-        const callHierarchy = this._connection.languages.callHierarchy;
+        this.connection.onInitialize((params) => this.initialize(params, supportedCommands, supportedCodeActions));
+        this.connection.onInitialized(() => this.onInitialized());
+        this.connection.onDidChangeConfiguration((params) => this.onDidChangeConfiguration(params));
+        this.connection.onCodeAction((params, token) => this.executeCodeAction(params, token));
+        this.connection.onDefinition(async (params, token) => this.onDefinition(params, token));
+        this.connection.onDeclaration(async (params, token) => this.onDeclaration(params, token));
+        this.connection.onTypeDefinition(async (params, token) => this.onTypeDefinition(params, token));
+        this.connection.onReferences(async (params, token, workDoneReporter, resultReporter) => this.onReferences(params, token, workDoneReporter, resultReporter));
+        this.connection.onDocumentSymbol(async (params, token) => this.onDocumentSymbol(params, token));
+        this.connection.onWorkspaceSymbol(async (params, token, _, resultReporter) => this.onWorkspaceSymbol(params, token, resultReporter));
+        this.connection.onHover(async (params, token) => this.onHover(params, token));
+        this.connection.onDocumentHighlight(async (params, token) => this.onDocumentHighlight(params, token));
+        this.connection.onSignatureHelp(async (params, token) => this.onSignatureHelp(params, token));
+        this.connection.onCompletion((params, token) => this.onCompletion(params, token));
+        this.connection.onCompletionResolve(async (params, token) => this.onCompletionResolve(params, token));
+        this.connection.onPrepareRename(async (params, token) => this.onPrepareRenameRequest(params, token));
+        this.connection.onRenameRequest(async (params, token) => this.onRenameRequest(params, token));
+        const callHierarchy = this.connection.languages.callHierarchy;
         callHierarchy.onPrepare(async (params, token) => this.onPrepare(params, token));
         callHierarchy.onIncomingCalls(async (params, token) => this.onIncomingCalls(params, token));
         callHierarchy.onOutgoingCalls(async (params, token) => this.onOutgoingCalls(params, token));
-        this._connection.onDidOpenTextDocument(async (params) => this.onDidOpenTextDocument(params));
-        this._connection.onDidChangeTextDocument(async (params) => this.onDidChangeTextDocument(params));
-        this._connection.onDidCloseTextDocument(async (params) => this.onDidCloseTextDocument(params));
-        this._connection.onDidChangeWatchedFiles((params) => this.onDidChangeWatchedFiles(params));
-        this._connection.onExecuteCommand(async (params, token, reporter) => this.onExecuteCommand(params, token, reporter));
-        this._connection.onShutdown(async (token) => this.onShutdown(token));
+        this.connection.onDidOpenTextDocument(async (params) => this.onDidOpenTextDocument(params));
+        this.connection.onDidChangeTextDocument(async (params) => this.onDidChangeTextDocument(params));
+        this.connection.onDidCloseTextDocument(async (params) => this.onDidCloseTextDocument(params));
+        this.connection.onDidChangeWatchedFiles((params) => this.onDidChangeWatchedFiles(params));
+        this.connection.onExecuteCommand(async (params, token, reporter) => this.onExecuteCommand(params, token, reporter));
+        this.connection.onShutdown(async (token) => this.onShutdown(token));
     }
     initialize(params, supportedCommands, supportedCodeActions) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19;
@@ -327,7 +370,7 @@ class LanguageServerBase {
         this.client.completionItemResolveSupportsAdditionalTextEdits =
             !!((_19 = (_18 = (_17 = (_16 = capabilities.textDocument) === null || _16 === void 0 ? void 0 : _16.completion) === null || _17 === void 0 ? void 0 : _17.completionItem) === null || _18 === void 0 ? void 0 : _18.resolveSupport) === null || _19 === void 0 ? void 0 : _19.properties.some((p) => p === 'additionalTextEdits'));
         // Create a service instance for each of the workspace folders.
-        this._workspaceFactory.handleInitialize(params);
+        this.workspaceFactory.handleInitialize(params);
         const result = {
             capabilities: {
                 textDocumentSync: vscode_languageserver_1.TextDocumentSyncKind.Incremental,
@@ -382,64 +425,37 @@ class LanguageServerBase {
             this.updateSettingsForAllWorkspaces();
             return;
         }
-        this._connection.workspace.onDidChangeWorkspaceFolders((event) => {
-            this._workspaceFactory.handleWorkspaceFoldersChanged(event);
+        this.connection.workspace.onDidChangeWorkspaceFolders((event) => {
+            this.workspaceFactory.handleWorkspaceFoldersChanged(event);
             this._setupFileWatcher();
         });
         this._setupFileWatcher();
     }
-    _setupFileWatcher() {
-        if (!this.client.hasWatchFileCapability) {
-            return;
-        }
-        const watchKind = vscode_languageserver_1.WatchKind.Create | vscode_languageserver_1.WatchKind.Change | vscode_languageserver_1.WatchKind.Delete;
-        // Set default (config files and all workspace files) first.
-        const watchers = [
-            ...service_1.configFileNames.map((fileName) => ({ globPattern: `**/${fileName}`, kind: watchKind })),
-            { globPattern: '**', kind: watchKind },
-        ];
-        // Add all python search paths to watch list
-        if (this.client.hasWatchFileRelativePathCapability) {
-            // Dedup search paths from all workspaces.
-            // Get rid of any search path under workspace root since it is already watched by
-            // "**" above.
-            const foldersToWatch = (0, pathUtils_1.deduplicateFolders)(this._workspaceFactory
-                .getNonDefaultWorkspaces()
-                .map((w) => w.searchPathsToWatch.filter((p) => !p.startsWith(w.rootPath))));
-            foldersToWatch.forEach((p) => {
-                const globPattern = (0, pathUtils_1.isFile)(this._serviceFS, p, /* treatZipDirectoryAsFile */ true)
-                    ? { baseUri: (0, pathUtils_1.convertPathToUri)(this._serviceFS, (0, pathUtils_1.getDirectoryPath)(p)), pattern: (0, pathUtils_1.getFileName)(p) }
-                    : { baseUri: (0, pathUtils_1.convertPathToUri)(this._serviceFS, p), pattern: '**' };
-                watchers.push({ globPattern, kind: watchKind });
-            });
-        }
-        // File watcher is pylance wide service. Dispose all existing file watchers and create new ones.
-        this._connection.client.register(vscode_languageserver_1.DidChangeWatchedFilesNotification.type, { watchers }).then((d) => {
-            if (this._lastFileWatcherRegistration) {
-                this._lastFileWatcherRegistration.dispose();
-            }
-            this._lastFileWatcherRegistration = d;
-        });
-    }
     onDidChangeConfiguration(params) {
         this.console.log(`Received updated settings`);
         if (params === null || params === void 0 ? void 0 : params.settings) {
-            this._defaultClientConfig = params === null || params === void 0 ? void 0 : params.settings;
+            this.defaultClientConfig = params === null || params === void 0 ? void 0 : params.settings;
         }
         this.updateSettingsForAllWorkspaces();
     }
     async onDefinition(params, token) {
-        return this.getDefinitions(params, token, this.client.hasGoToDeclarationCapability ? definitionProvider_1.DefinitionFilter.PreferSource : definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, filter, token) => workspace.service.getDefinitionForPosition(filePath, position, filter, token));
+        return this.getDefinitions(params, token, this.client.hasGoToDeclarationCapability ? definitionProvider_1.DefinitionFilter.PreferSource : definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, filter, token) => workspace.service.run((program) => {
+            return new definitionProvider_1.DefinitionProvider(program, filePath, position, filter, token).getDefinitions();
+        }, token));
     }
     async onDeclaration(params, token) {
-        return this.getDefinitions(params, token, this.client.hasGoToDeclarationCapability ? definitionProvider_1.DefinitionFilter.PreferStubs : definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, filter, token) => workspace.service.getDefinitionForPosition(filePath, position, filter, token));
+        return this.getDefinitions(params, token, this.client.hasGoToDeclarationCapability ? definitionProvider_1.DefinitionFilter.PreferStubs : definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, filter, token) => workspace.service.run((program) => {
+            return new definitionProvider_1.DefinitionProvider(program, filePath, position, filter, token).getDefinitions();
+        }, token));
     }
     async onTypeDefinition(params, token) {
-        return this.getDefinitions(params, token, definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, _, token) => workspace.service.getTypeDefinitionForPosition(filePath, position, token));
+        return this.getDefinitions(params, token, definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, _, token) => workspace.service.run((program) => {
+            return new definitionProvider_1.TypeDefinitionProvider(program, filePath, position, token).getDefinitions();
+        }, token));
     }
     async getDefinitions(params, token, filter, getDefinitionsFunc) {
         this.recordUserInteractionTime();
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return undefined;
@@ -464,22 +480,14 @@ class LanguageServerBase {
         const source = progress.source;
         this._pendingFindAllRefsCancellationSource = source;
         try {
-            const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+            const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
             const workspace = await this.getWorkspaceForFile(filePath);
             if (workspace.disableLanguageServices) {
                 return;
             }
-            const convert = (locs) => {
-                return locs
-                    .filter((loc) => this.canNavigateToFile(loc.path, workspace.service.fs))
-                    .map((loc) => vscode_languageserver_1.Location.create((0, pathUtils_1.convertPathToUri)(workspace.service.fs, loc.path), loc.range));
-            };
-            const locations = [];
-            const reporter = resultReporter
-                ? (locs) => resultReporter.report(convert(locs))
-                : (locs) => (0, collectionUtils_1.appendArray)(locations, convert(locs));
-            workspace.service.reportReferencesForPosition(filePath, position, params.context.includeDeclaration, reporter, source.token);
-            return locations;
+            return workspace.service.run((program) => {
+                return new referencesProvider_1.ReferencesProvider(program, source.token).reportReferences(filePath, position, params.context.includeDeclaration, resultReporter);
+            }, token);
         }
         finally {
             progress.reporter.done();
@@ -488,7 +496,7 @@ class LanguageServerBase {
     }
     async onDocumentSymbol(params, token) {
         this.recordUserInteractionTime();
-        const filePath = this._uriParser.decodeTextDocumentUri(params.textDocument.uri);
+        const filePath = this.uriParser.decodeTextDocumentUri(params.textDocument.uri);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return undefined;
@@ -505,7 +513,7 @@ class LanguageServerBase {
         const reporter = resultReporter
             ? (symbols) => resultReporter.report(symbols)
             : (symbols) => (0, collectionUtils_1.appendArray)(symbolList, symbols);
-        for (const workspace of this._workspaceFactory.items()) {
+        for (const workspace of this.workspaceFactory.items()) {
             await workspace.isInitialized.promise;
             if (!workspace.disableLanguageServices && !workspace.disableWorkspaceSymbol) {
                 workspace.service.reportSymbolsForWorkspace(params.query, reporter, token);
@@ -514,95 +522,28 @@ class LanguageServerBase {
         return symbolList;
     }
     async onHover(params, token) {
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
-        const hoverResults = workspace.service.getHoverForPosition(filePath, position, this.client.hoverContentFormat, token);
-        return (0, hoverProvider_1.convertHoverResults)(this.client.hoverContentFormat, hoverResults, !!this._serverOptions.supportsTelemetry);
+        return workspace.service.run((program) => {
+            return new hoverProvider_1.HoverProvider(program, filePath, position, this.client.hoverContentFormat, !!this.serverOptions.supportsTelemetry, token).getHover();
+        }, token);
     }
     async onDocumentHighlight(params, token) {
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
-        return workspace.service.getDocumentHighlight(filePath, position, token);
+        return workspace.service.run((program) => {
+            return new documentHighlightProvider_1.DocumentHighlightProvider(program, filePath, position, token).getDocumentHighlight();
+        }, token);
     }
     async onSignatureHelp(params, token) {
-        var _a, _b;
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return;
         }
-        const signatureHelpResults = workspace.service.getSignatureHelpForPosition(filePath, position, this.client.signatureDocFormat, token);
-        if (!signatureHelpResults) {
-            return undefined;
-        }
-        const signatures = signatureHelpResults.signatures.map((sig) => {
-            let paramInfo = [];
-            if (sig.parameters) {
-                paramInfo = sig.parameters.map((param) => vscode_languageserver_1.ParameterInformation.create(this.client.hasSignatureLabelOffsetCapability
-                    ? [param.startOffset, param.endOffset]
-                    : param.text, param.documentation));
-            }
-            const sigInfo = vscode_languageserver_1.SignatureInformation.create(sig.label, /* documentation */ undefined, ...paramInfo);
-            if (sig.documentation !== undefined) {
-                sigInfo.documentation = sig.documentation;
-            }
-            if (sig.activeParameter !== undefined) {
-                sigInfo.activeParameter = sig.activeParameter;
-            }
-            return sigInfo;
-        });
-        // A signature is active if it contains an active parameter,
-        // or if both the signature and its invocation have no parameters.
-        const isActive = (sig) => { var _a; return sig.activeParameter !== undefined || (!signatureHelpResults.callHasParameters && !((_a = sig.parameters) === null || _a === void 0 ? void 0 : _a.length)); };
-        let activeSignature = signatures.findIndex(isActive);
-        if (activeSignature === -1) {
-            activeSignature = undefined;
-        }
-        let activeParameter = activeSignature !== undefined ? signatures[activeSignature].activeParameter : undefined;
-        // Check if we should reuse the user's signature selection. If the retrigger was not "invoked"
-        // (i.e., the signature help call was automatically generated by the client due to some navigation
-        // or text change), check to see if the previous signature is still "active". If so, we mark it as
-        // active in our response.
-        //
-        // This isn't a perfect method. For nested calls, we can't tell when we are moving between them.
-        // Ideally, we would include a token in the signature help responses to compare later, allowing us
-        // to know when the user's navigated to a nested call (and therefore the old signature's info does
-        // not apply), but for now manually retriggering the signature help will work around the issue.
-        if (((_a = params.context) === null || _a === void 0 ? void 0 : _a.isRetrigger) && params.context.triggerKind !== vscode_languageserver_1.SignatureHelpTriggerKind.Invoked) {
-            const prevActiveSignature = (_b = params.context.activeSignatureHelp) === null || _b === void 0 ? void 0 : _b.activeSignature;
-            if (prevActiveSignature !== undefined && prevActiveSignature < signatures.length) {
-                const sig = signatures[prevActiveSignature];
-                if (isActive(sig)) {
-                    activeSignature = prevActiveSignature;
-                    activeParameter = sig.activeParameter;
-                }
-            }
-        }
-        if (this.client.hasActiveParameterCapability || activeSignature === undefined) {
-            // If there is no active parameter, then we want the client to not highlight anything.
-            // Unfortunately, the LSP spec says that "undefined" or "out of bounds" values should be
-            // treated as 0, which is the first parameter. That's not what we want, but thankfully
-            // VS Code (and potentially other clients) choose to handle out of bounds values by
-            // not highlighting them, which is what we want.
-            //
-            // The spec defines activeParameter as uinteger, so use the maximum length of any
-            // signature's parameter list to ensure that the value is always out of range.
-            //
-            // We always set this even if some signature has an active parameter, as this
-            // value is used as the fallback for signatures that don't explicitly specify an
-            // active parameter (and we use "undefined" to mean "no active parameter").
-            //
-            // We could apply this hack to each individual signature such that they all specify
-            // activeParameter, but that would make it more difficult to determine which actually
-            // are active when comparing, and we already have to set this for clients which don't
-            // support per-signature activeParameter.
-            //
-            // See:
-            //   - https://github.com/microsoft/language-server-protocol/issues/1271
-            //   - https://github.com/microsoft/pyright/pull/1783
-            activeParameter = Math.max(...signatures.map((s) => { var _a, _b; return (_b = (_a = s.parameters) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0; }));
-        }
-        return { signatures, activeSignature, activeParameter };
+        return workspace.service.run((program) => {
+            return new signatureHelpProvider_1.SignatureHelpProvider(program, filePath, position, this.client.signatureDocFormat, this.client.hasSignatureLabelOffsetCapability, this.client.hasActiveParameterCapability, params.context, token).getSignatureHelp();
+        }, token);
     }
     async onCompletion(params, token) {
         var _a, _b;
@@ -617,7 +558,7 @@ class LanguageServerBase {
         const completionIncomplete = this._lastTriggerKind !== vscode_languageserver_1.CompletionTriggerKind.TriggerForIncompleteCompletions ||
             ((_a = params.context) === null || _a === void 0 ? void 0 : _a.triggerKind) !== vscode_languageserver_1.CompletionTriggerKind.TriggerForIncompleteCompletions;
         this._lastTriggerKind = (_b = params.context) === null || _b === void 0 ? void 0 : _b.triggerKind;
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return;
@@ -632,7 +573,7 @@ class LanguageServerBase {
             completions.completionList &&
             completions.completionList.items.length > 0 &&
             completions.memberAccessInfo.lastKnownModule &&
-            this._serverOptions.supportsTelemetry) {
+            this.serverOptions.supportsTelemetry) {
             // Just stick it on the first item. It only checks the first one
             completions.completionList.items[0].data = {
                 ...completions.completionList.items[0].data,
@@ -657,7 +598,7 @@ class LanguageServerBase {
     }
     async onPrepareRenameRequest(params, token) {
         var _a;
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return null;
@@ -666,7 +607,7 @@ class LanguageServerBase {
         return (_a = result === null || result === void 0 ? void 0 : result.range) !== null && _a !== void 0 ? _a : null;
     }
     async onRenameRequest(params, token) {
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return;
@@ -678,62 +619,51 @@ class LanguageServerBase {
         return (0, workspaceEditUtils_1.convertToWorkspaceEdit)(workspace.service.fs, editActions);
     }
     async onPrepare(params, token) {
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return null;
         }
-        const callItem = workspace.service.getCallForPosition(filePath, position, token) || null;
-        if (!callItem) {
-            return null;
-        }
-        if (!this.canNavigateToFile(callItem.uri, workspace.service.fs)) {
-            return null;
-        }
-        // Convert the file path in the item to proper URI.
-        callItem.uri = (0, pathUtils_1.convertPathToUri)(workspace.service.fs, callItem.uri);
-        return [callItem];
+        return workspace.service.run((program) => {
+            return new callHierarchyProvider_1.CallHierarchyProvider(program, filePath, position, token).onPrepare();
+        }, token);
     }
     async onIncomingCalls(params, token) {
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.item, params.item.range.start);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.item, params.item.range.start);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return null;
         }
-        let callItems = workspace.service.getIncomingCallsForPosition(filePath, position, token) || null;
-        if (!callItems || callItems.length === 0) {
-            return null;
-        }
-        callItems = callItems.filter((item) => this.canNavigateToFile(item.from.uri, workspace.service.fs));
-        // Convert the file paths in the items to proper URIs.
-        callItems.forEach((item) => {
-            item.from.uri = (0, pathUtils_1.convertPathToUri)(workspace.service.fs, item.from.uri);
-        });
-        return callItems;
+        return workspace.service.run((program) => {
+            return new callHierarchyProvider_1.CallHierarchyProvider(program, filePath, position, token).getIncomingCalls();
+        }, token);
     }
     async onOutgoingCalls(params, token) {
-        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.item, params.item.range.start);
+        const { filePath, position } = this.uriParser.decodeTextDocumentPosition(params.item, params.item.range.start);
         const workspace = await this.getWorkspaceForFile(filePath);
         if (workspace.disableLanguageServices) {
             return null;
         }
-        let callItems = workspace.service.getOutgoingCallsForPosition(filePath, position, token) || null;
-        if (!callItems || callItems.length === 0) {
-            return null;
-        }
-        callItems = callItems.filter((item) => this.canNavigateToFile(item.to.uri, workspace.service.fs));
-        // Convert the file paths in the items to proper URIs.
-        callItems.forEach((item) => {
-            item.to.uri = (0, pathUtils_1.convertPathToUri)(workspace.service.fs, item.to.uri);
-        });
-        return callItems;
+        return workspace.service.run((program) => {
+            return new callHierarchyProvider_1.CallHierarchyProvider(program, filePath, position, token).getOutgoingCalls();
+        }, token);
     }
     async onDidOpenTextDocument(params, ipythonMode = sourceFile_1.IPythonMode.None) {
-        const filePath = this._uriParser.decodeTextDocumentUri(params.textDocument.uri);
-        if (!this._serviceFS.addUriMap(params.textDocument.uri, filePath)) {
+        const filePath = this.uriParser.decodeTextDocumentUri(params.textDocument.uri);
+        if (!this.fs.addUriMap(params.textDocument.uri, filePath)) {
             // We do not support opening 1 file with 2 different uri.
             return;
         }
+        let doc = this.openFileMap.get(filePath);
+        if (doc) {
+            // We shouldn't get an open text document request for an already-opened doc.
+            this.console.error(`Received redundant open text document command for ${filePath}`);
+            doc = vscode_languageserver_textdocument_1.TextDocument.update(doc, [{ text: params.textDocument.text }], params.textDocument.version);
+        }
+        else {
+            doc = vscode_languageserver_textdocument_1.TextDocument.create(filePath, 'python', params.textDocument.version, params.textDocument.text);
+        }
+        this.openFileMap.set(filePath, doc);
         // Send this open to all the workspaces that might contain this file.
         const workspaces = await this.getContainingWorkspacesForFile(filePath);
         workspaces.forEach((w) => {
@@ -742,20 +672,29 @@ class LanguageServerBase {
     }
     async onDidChangeTextDocument(params, ipythonMode = sourceFile_1.IPythonMode.None) {
         this.recordUserInteractionTime();
-        const filePath = this._uriParser.decodeTextDocumentUri(params.textDocument.uri);
-        if (!this._serviceFS.hasUriMapEntry(params.textDocument.uri, filePath)) {
+        const filePath = this.uriParser.decodeTextDocumentUri(params.textDocument.uri);
+        if (!this.fs.hasUriMapEntry(params.textDocument.uri, filePath)) {
             // We do not support opening 1 file with 2 different uri.
             return;
         }
+        let doc = this.openFileMap.get(filePath);
+        if (!doc) {
+            // We shouldn't get a change text request for a closed doc.
+            this.console.error(`Received change text document command for closed file ${filePath}`);
+            return;
+        }
+        doc = vscode_languageserver_textdocument_1.TextDocument.update(doc, params.contentChanges, params.textDocument.version);
+        this.openFileMap.set(filePath, doc);
+        const newContents = doc.getText();
         // Send this change to all the workspaces that might contain this file.
         const workspaces = await this.getContainingWorkspacesForFile(filePath);
         workspaces.forEach((w) => {
-            w.service.updateOpenFileContents(filePath, params.textDocument.version, params.contentChanges, ipythonMode);
+            w.service.updateOpenFileContents(filePath, params.textDocument.version, newContents, ipythonMode);
         });
     }
     async onDidCloseTextDocument(params) {
-        const filePath = this._uriParser.decodeTextDocumentUri(params.textDocument.uri);
-        if (!this._serviceFS.removeUriMap(params.textDocument.uri, filePath)) {
+        const filePath = this.uriParser.decodeTextDocumentUri(params.textDocument.uri);
+        if (!this.fs.removeUriMap(params.textDocument.uri, filePath)) {
             // We do not support opening 1 file with 2 different uri.
             return;
         }
@@ -764,12 +703,13 @@ class LanguageServerBase {
         workspaces.forEach((w) => {
             w.service.setFileClosed(filePath);
         });
+        this.openFileMap.delete(filePath);
     }
     onDidChangeWatchedFiles(params) {
         params.changes.forEach((change) => {
-            const filePath = this._serviceFS.realCasePath(this._uriParser.decodeTextDocumentUri(change.uri));
+            const filePath = this.fs.realCasePath(this.uriParser.decodeTextDocumentUri(change.uri));
             const eventType = change.type === 1 ? 'add' : 'change';
-            this._serverOptions.fileWatcherHandler.onFileChange(eventType, filePath);
+            this.serverOptions.fileWatcherHandler.onFileChange(eventType, filePath);
         });
     }
     async onExecuteCommand(params, token, reporter) {
@@ -783,12 +723,12 @@ class LanguageServerBase {
             if (vscode_languageserver_1.WorkspaceEdit.is(result)) {
                 // Tell client to apply edits.
                 // Do not await; the client isn't expecting a result.
-                this._connection.workspace.applyEdit({ label: `Command '${params.command}'`, edit: result });
+                this.connection.workspace.applyEdit({ label: `Command '${params.command}'`, edit: result });
             }
             if (commandResult_1.CommandResult.is(result)) {
                 // Tell client to apply edits.
                 // Await so that we return after the edit is complete.
-                await this._connection.workspace.applyEdit({ label: result.label, edit: result.edits });
+                await this.connection.workspace.applyEdit({ label: result.label, edit: result.edits });
             }
             return result;
         };
@@ -813,7 +753,9 @@ class LanguageServerBase {
     }
     onShutdown(token) {
         // Shutdown remaining workspaces.
-        this._workspaceFactory.clear();
+        this.workspaceFactory.clear();
+        // Stop tracking all open files.
+        this.openFileMap.clear();
         return Promise.resolve();
     }
     resolveWorkspaceCompletionItem(workspace, filePath, item, token) {
@@ -823,20 +765,6 @@ class LanguageServerBase {
     getWorkspaceCompletionsForPosition(workspace, filePath, position, options, token) {
         return workspace.service.getCompletionsForPosition(filePath, position, workspace.rootPath, options, undefined, token);
     }
-    updateSettingsForAllWorkspaces() {
-        const tasks = [];
-        this._workspaceFactory.items().forEach((workspace) => {
-            // Updating settings can change workspace's file ownership. Make workspace uninitialized so that
-            // features can wait until workspace gets new settings.
-            // the file's ownership can also changed by `pyrightconfig.json` changes, but those are synchronous
-            // operation, so it won't affect this.
-            workspace.isInitialized = workspace.isInitialized.reset();
-            tasks.push(this.updateSettingsForWorkspace(workspace, workspace.isInitialized));
-        });
-        Promise.all(tasks).then(() => {
-            this._setupFileWatcher();
-        });
-    }
     getCompletionOptions(workspace, params) {
         var _a;
         return {
@@ -866,7 +794,7 @@ class LanguageServerBase {
                 return;
             }
             this._sendDiagnostics(this.convertDiagnostics(fs, fileDiag));
-            this._serviceFS.pendingRequest(fileDiag.filePath, fileDiag.diagnostics.length > 0);
+            this.fs.pendingRequest(fileDiag.filePath, fileDiag.diagnostics.length > 0);
         });
         if (!this._progressReporter.isEnabled(results)) {
             // Make sure to disable progress bar if it is currently active.
@@ -890,28 +818,6 @@ class LanguageServerBase {
             this._progressReporter.end();
         }
     }
-    async updateSettingsForWorkspace(workspace, status, serverSettings) {
-        var _a;
-        status === null || status === void 0 ? void 0 : status.markCalled();
-        serverSettings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : (await this.getSettings(workspace));
-        // Set logging level first.
-        this.console.level = (_a = serverSettings.logLevel) !== null && _a !== void 0 ? _a : console_1.LogLevel.Info;
-        // Apply the new path to the workspace (before restarting the service).
-        serverSettings.pythonPath = this._workspaceFactory.applyPythonPath(workspace, serverSettings.pythonPath);
-        // Then use the updated settings to restart the service.
-        this.updateOptionsAndRestartService(workspace, serverSettings);
-        workspace.disableLanguageServices = !!serverSettings.disableLanguageServices;
-        workspace.disableOrganizeImports = !!serverSettings.disableOrganizeImports;
-        // Don't use workspace.isInitialized directly since it might have been
-        // reset due to pending config change event.
-        // The workspace is now open for business.
-        status === null || status === void 0 ? void 0 : status.resolve();
-    }
-    updateOptionsAndRestartService(workspace, serverSettings, typeStubTargetImportName) {
-        var _a;
-        analyzerServiceExecutor_1.AnalyzerServiceExecutor.runWithOptions(this.rootPath, workspace, serverSettings, typeStubTargetImportName);
-        workspace.searchPathsToWatch = (_a = workspace.service.librarySearchPathsToWatch) !== null && _a !== void 0 ? _a : [];
-    }
     onWorkspaceCreated(workspace) {
         // Update settings on this workspace (but only if initialize has happened)
         if (this._initialized) {
@@ -925,15 +831,63 @@ class LanguageServerBase {
         // 10 seconds back off for multi workspace.
         const multiWorkspaceBackOffTime = 10 * 1000;
         const libraryReanalysisTimeProvider = kinds.length === 1 && kinds[0] === workspaceFactory_1.WellKnownWorkspaceKinds.Regular
-            ? () => this._workspaceFactory.hasMultipleWorkspaces(kinds[0])
+            ? () => this.workspaceFactory.hasMultipleWorkspaces(kinds[0])
                 ? multiWorkspaceBackOffTime
                 : defaultBackOffTime
             : () => defaultBackOffTime;
         return this.createAnalyzerService(name, services, libraryReanalysisTimeProvider);
     }
+    recordUserInteractionTime() {
+        // Tell all of the services that the user is actively
+        // interacting with one or more editors, so they should
+        // back off from performing any work.
+        this.workspaceFactory.items().forEach((workspace) => {
+            workspace.service.recordUserInteractionTime();
+        });
+    }
+    getDocumentationUrlForDiagnosticRule(rule) {
+        // Configuration.md is configured to have a link for every rule name.
+        return `https://github.com/microsoft/pyright/blob/main/docs/configuration.md#${rule}`;
+    }
+    canNavigateToFile(path, fs) {
+        return (0, navigationUtils_1.canNavigateToFile)(fs, path);
+    }
+    _setupFileWatcher() {
+        if (!this.client.hasWatchFileCapability) {
+            return;
+        }
+        const watchKind = vscode_languageserver_1.WatchKind.Create | vscode_languageserver_1.WatchKind.Change | vscode_languageserver_1.WatchKind.Delete;
+        // Set default (config files and all workspace files) first.
+        const watchers = [
+            ...service_1.configFileNames.map((fileName) => ({ globPattern: `**/${fileName}`, kind: watchKind })),
+            { globPattern: '**', kind: watchKind },
+        ];
+        // Add all python search paths to watch list
+        if (this.client.hasWatchFileRelativePathCapability) {
+            // Dedup search paths from all workspaces.
+            // Get rid of any search path under workspace root since it is already watched by
+            // "**" above.
+            const foldersToWatch = (0, pathUtils_1.deduplicateFolders)(this.workspaceFactory
+                .getNonDefaultWorkspaces()
+                .map((w) => w.searchPathsToWatch.filter((p) => !p.startsWith(w.rootPath))));
+            foldersToWatch.forEach((p) => {
+                const globPattern = (0, pathUtils_1.isFile)(this.fs, p, /* treatZipDirectoryAsFile */ true)
+                    ? { baseUri: (0, pathUtils_1.convertPathToUri)(this.fs, (0, pathUtils_1.getDirectoryPath)(p)), pattern: (0, pathUtils_1.getFileName)(p) }
+                    : { baseUri: (0, pathUtils_1.convertPathToUri)(this.fs, p), pattern: '**' };
+                watchers.push({ globPattern, kind: watchKind });
+            });
+        }
+        // File watcher is pylance wide service. Dispose all existing file watchers and create new ones.
+        this.connection.client.register(vscode_languageserver_1.DidChangeWatchedFilesNotification.type, { watchers }).then((d) => {
+            if (this._lastFileWatcherRegistration) {
+                this._lastFileWatcherRegistration.dispose();
+            }
+            this._lastFileWatcherRegistration = d;
+        });
+    }
     _sendDiagnostics(params) {
         for (const param of params) {
-            this._connection.sendDiagnostics(param);
+            this.connection.sendDiagnostics(param);
         }
     }
     _getCompatibleMarkupKind(clientSupportedFormats) {
@@ -951,16 +905,16 @@ class LanguageServerBase {
         // created by the LSP library. If it's the latter, we'll create a server-initiated
         // progress reporter.
         if (reporter.constructor !== nullProgressReporter.constructor) {
-            return { reporter: reporter, source: (0, cancellationUtils_1.CancelAfter)(this._serverOptions.cancellationProvider, token) };
+            return { reporter: reporter, source: (0, cancellationUtils_1.CancelAfter)(this.serverOptions.cancellationProvider, token) };
         }
-        const serverInitiatedReporter = await this._connection.window.createWorkDoneProgress();
+        const serverInitiatedReporter = await this.connection.window.createWorkDoneProgress();
         serverInitiatedReporter.begin(title, 
         /* percentage */ undefined, 
         /* message */ undefined, 
         /* cancellable */ true);
         return {
             reporter: serverInitiatedReporter,
-            source: (0, cancellationUtils_1.CancelAfter)(this._serverOptions.cancellationProvider, token, serverInitiatedReporter.token),
+            source: (0, cancellationUtils_1.CancelAfter)(this.serverOptions.cancellationProvider, token, serverInitiatedReporter.token),
         };
     }
     _convertDiagnostics(fs, diags) {
@@ -968,7 +922,7 @@ class LanguageServerBase {
         diags.forEach((diag) => {
             const severity = convertCategoryToSeverity(diag.category);
             const rule = diag.getRule();
-            const vsDiag = vscode_languageserver_1.Diagnostic.create(diag.range, diag.message, severity, rule, this._serverOptions.productName);
+            const vsDiag = vscode_languageserver_1.Diagnostic.create(diag.range, diag.message, severity, rule, this.serverOptions.productName);
             if (diag.category === 3 /* UnusedCode */ ||
                 diag.category === 4 /* UnreachableCode */) {
                 vsDiag.tags = [vscode_languageserver_1.DiagnosticTag.Unnecessary];
@@ -1042,21 +996,6 @@ class LanguageServerBase {
         }
         return convertedDiags;
     }
-    recordUserInteractionTime() {
-        // Tell all of the services that the user is actively
-        // interacting with one or more editors, so they should
-        // back off from performing any work.
-        this._workspaceFactory.items().forEach((workspace) => {
-            workspace.service.recordUserInteractionTime();
-        });
-    }
-    getDocumentationUrlForDiagnosticRule(rule) {
-        // Configuration.md is configured to have a link for every rule name.
-        return `https://github.com/microsoft/pyright/blob/main/docs/configuration.md#${rule}`;
-    }
-    canNavigateToFile(path, fs) {
-        return !fs.isInZipOrEgg(path);
-    }
 }
 exports.LanguageServerBase = LanguageServerBase;
 //# sourceMappingURL=languageServerBase.js.map