@zzzen/pyright-internal 1.1.254

package/dist/languageServerBase.js

@@ -0,0 +1,923 @@
+"use strict";
+/*
+ * languageServerBase.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Implements common language server functionality.
+ * This is split out as a base class to allow for
+ * different language server variants to be created
+ * from the same core functionality.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageServerBase = void 0;
+require("./common/extensions");
+const vscode_languageserver_1 = require("vscode-languageserver");
+const progress_1 = require("vscode-languageserver/lib/common/progress");
+const backgroundAnalysisProgram_1 = require("./analyzer/backgroundAnalysisProgram");
+const service_1 = require("./analyzer/service");
+const commandResult_1 = require("./commands/commandResult");
+const cancellationUtils_1 = require("./common/cancellationUtils");
+const collectionUtils_1 = require("./common/collectionUtils");
+const commandLineOptions_1 = require("./common/commandLineOptions");
+const configOptions_1 = require("./common/configOptions");
+const console_1 = require("./common/console");
+const deferred_1 = require("./common/deferred");
+const lspUtils_1 = require("./common/lspUtils");
+const pathUtils_1 = require("./common/pathUtils");
+const progressReporter_1 = require("./common/progressReporter");
+const uriParser_1 = require("./common/uriParser");
+const workspaceEditUtils_1 = require("./common/workspaceEditUtils");
+const analyzerServiceExecutor_1 = require("./languageService/analyzerServiceExecutor");
+const definitionProvider_1 = require("./languageService/definitionProvider");
+const documentSymbolProvider_1 = require("./languageService/documentSymbolProvider");
+const hoverProvider_1 = require("./languageService/hoverProvider");
+const localize_1 = require("./localization/localize");
+const pyrightFileSystem_1 = require("./pyrightFileSystem");
+const nullProgressReporter = (0, progress_1.attachWorkDone)(undefined, /* params */ undefined);
+class LanguageServerBase {
+    constructor(_serverOptions, _connection, console, uriParserFactory = (fs) => new uriParser_1.UriParser(fs)) {
+        var _a, _b;
+        this._serverOptions = _serverOptions;
+        this._connection = _connection;
+        this.console = console;
+        this._lastTriggerKind = vscode_languageserver_1.CompletionTriggerKind.Invoked;
+        // Global root path - the basis for all global settings.
+        this.rootPath = '';
+        this.client = {
+            hasConfigurationCapability: false,
+            hasVisualStudioExtensionsCapability: false,
+            hasWorkspaceFoldersCapability: false,
+            hasWatchFileCapability: false,
+            hasWatchFileRelativePathCapability: false,
+            hasActiveParameterCapability: false,
+            hasSignatureLabelOffsetCapability: false,
+            hasHierarchicalDocumentSymbolCapability: false,
+            hasWindowProgressCapability: false,
+            hasGoToDeclarationCapability: false,
+            hasDocumentChangeCapability: false,
+            hasDocumentAnnotationCapability: false,
+            hoverContentFormat: vscode_languageserver_1.MarkupKind.PlainText,
+            completionDocFormat: vscode_languageserver_1.MarkupKind.PlainText,
+            completionSupportsSnippet: false,
+            signatureDocFormat: vscode_languageserver_1.MarkupKind.PlainText,
+            supportsDeprecatedDiagnosticTag: false,
+            supportsUnnecessaryDiagnosticTag: false,
+            completionItemResolveSupportsAdditionalTextEdits: false,
+        };
+        // 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._workspaceMap = this._serverOptions.workspaceMap;
+        this._fileWatcherProvider = this._serverOptions.fileWatcherProvider;
+        this.fs = new pyrightFileSystem_1.PyrightFileSystem(this._serverOptions.fileSystem);
+        this._uriParser = uriParserFactory(this.fs);
+        // 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.fs.getModulePath();
+        if (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._progressReporter = new progressReporter_1.ProgressReportTracker(this.createProgressReporter());
+        // Listen on the connection.
+        this._connection.listen();
+    }
+    // Convert uri to path
+    decodeTextDocumentUri(uriString) {
+        return this._uriParser.decodeTextDocumentUri(uriString);
+    }
+    async getConfiguration(scopeUri, section) {
+        if (this.client.hasConfigurationCapability) {
+            const item = {};
+            if (scopeUri !== undefined) {
+                item.scopeUri = scopeUri;
+            }
+            if (section !== undefined) {
+                item.section = section;
+            }
+            return this._connection.workspace.getConfiguration(item);
+        }
+        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)) {
+            return enumValue;
+        }
+        return undefined;
+    }
+    getDiagnosticRuleName(value) {
+        const enumValue = value;
+        if ((0, configOptions_1.getDiagLevelDiagnosticRules)().includes(enumValue)) {
+            return enumValue;
+        }
+        return undefined;
+    }
+    createBackgroundAnalysisProgram(console, configOptions, importResolver, extension, backgroundAnalysis, maxAnalysisTime) {
+        return new backgroundAnalysisProgram_1.BackgroundAnalysisProgram(console, configOptions, importResolver, extension, backgroundAnalysis, maxAnalysisTime);
+    }
+    setExtension(extension) {
+        this._serverOptions.extension = extension;
+    }
+    // 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) {
+        this.console.log(`Starting service instance "${name}"`);
+        const service = new service_1.AnalyzerService(name, this.fs, this.console, this.createHost.bind(this), this.createImportResolver.bind(this), undefined, this._serverOptions.extension, this.createBackgroundAnalysis(), this._serverOptions.maxAnalysisTimeInForeground, this.createBackgroundAnalysisProgram.bind(this), this._serverOptions.cancellationProvider);
+        service.setCompletionCallback((results) => this.onAnalysisCompletedHandler(results));
+        return service;
+    }
+    async getWorkspaceForFile(filePath) {
+        const workspace = this._workspaceMap.getWorkspaceForFile(this, filePath);
+        await workspace.isInitialized.promise;
+        return workspace;
+    }
+    reanalyze() {
+        this._workspaceMap.forEach((workspace) => {
+            workspace.serviceInstance.invalidateAndForceReanalysis();
+        });
+    }
+    restart() {
+        this._workspaceMap.forEach((workspace) => {
+            workspace.serviceInstance.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;
+        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));
+    }
+    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;
+        if (params.locale) {
+            (0, localize_1.setLocaleOverride)(params.locale);
+        }
+        this.rootPath = params.rootPath || '';
+        const capabilities = params.capabilities;
+        this.client.hasConfigurationCapability = !!((_a = capabilities.workspace) === null || _a === void 0 ? void 0 : _a.configuration);
+        this.client.hasWatchFileCapability = !!((_c = (_b = capabilities.workspace) === null || _b === void 0 ? void 0 : _b.didChangeWatchedFiles) === null || _c === void 0 ? void 0 : _c.dynamicRegistration);
+        this.client.hasWatchFileRelativePathCapability =
+            !!((_e = (_d = capabilities.workspace) === null || _d === void 0 ? void 0 : _d.didChangeWatchedFiles) === null || _e === void 0 ? void 0 : _e.relativePatternSupport);
+        this.client.hasWorkspaceFoldersCapability = !!((_f = capabilities.workspace) === null || _f === void 0 ? void 0 : _f.workspaceFolders);
+        this.client.hasVisualStudioExtensionsCapability = !!capabilities.supportsVisualStudioExtensions;
+        this.client.hasActiveParameterCapability =
+            !!((_j = (_h = (_g = capabilities.textDocument) === null || _g === void 0 ? void 0 : _g.signatureHelp) === null || _h === void 0 ? void 0 : _h.signatureInformation) === null || _j === void 0 ? void 0 : _j.activeParameterSupport);
+        this.client.hasSignatureLabelOffsetCapability =
+            !!((_o = (_m = (_l = (_k = capabilities.textDocument) === null || _k === void 0 ? void 0 : _k.signatureHelp) === null || _l === void 0 ? void 0 : _l.signatureInformation) === null || _m === void 0 ? void 0 : _m.parameterInformation) === null || _o === void 0 ? void 0 : _o.labelOffsetSupport);
+        this.client.hasHierarchicalDocumentSymbolCapability =
+            !!((_q = (_p = capabilities.textDocument) === null || _p === void 0 ? void 0 : _p.documentSymbol) === null || _q === void 0 ? void 0 : _q.hierarchicalDocumentSymbolSupport);
+        this.client.hasDocumentChangeCapability =
+            !!((_s = (_r = capabilities.workspace) === null || _r === void 0 ? void 0 : _r.workspaceEdit) === null || _s === void 0 ? void 0 : _s.documentChanges) &&
+                !!((_t = capabilities.workspace.workspaceEdit) === null || _t === void 0 ? void 0 : _t.resourceOperations);
+        this.client.hasDocumentAnnotationCapability = !!((_v = (_u = capabilities.workspace) === null || _u === void 0 ? void 0 : _u.workspaceEdit) === null || _v === void 0 ? void 0 : _v.changeAnnotationSupport);
+        this.client.hoverContentFormat = this._getCompatibleMarkupKind((_x = (_w = capabilities.textDocument) === null || _w === void 0 ? void 0 : _w.hover) === null || _x === void 0 ? void 0 : _x.contentFormat);
+        this.client.completionDocFormat = this._getCompatibleMarkupKind((_0 = (_z = (_y = capabilities.textDocument) === null || _y === void 0 ? void 0 : _y.completion) === null || _z === void 0 ? void 0 : _z.completionItem) === null || _0 === void 0 ? void 0 : _0.documentationFormat);
+        this.client.completionSupportsSnippet = !!((_3 = (_2 = (_1 = capabilities.textDocument) === null || _1 === void 0 ? void 0 : _1.completion) === null || _2 === void 0 ? void 0 : _2.completionItem) === null || _3 === void 0 ? void 0 : _3.snippetSupport);
+        this.client.signatureDocFormat = this._getCompatibleMarkupKind((_6 = (_5 = (_4 = capabilities.textDocument) === null || _4 === void 0 ? void 0 : _4.signatureHelp) === null || _5 === void 0 ? void 0 : _5.signatureInformation) === null || _6 === void 0 ? void 0 : _6.documentationFormat);
+        const supportedDiagnosticTags = ((_9 = (_8 = (_7 = capabilities.textDocument) === null || _7 === void 0 ? void 0 : _7.publishDiagnostics) === null || _8 === void 0 ? void 0 : _8.tagSupport) === null || _9 === void 0 ? void 0 : _9.valueSet) || [];
+        this.client.supportsUnnecessaryDiagnosticTag = supportedDiagnosticTags.some((tag) => tag === vscode_languageserver_1.DiagnosticTag.Unnecessary);
+        this.client.supportsDeprecatedDiagnosticTag = supportedDiagnosticTags.some((tag) => tag === vscode_languageserver_1.DiagnosticTag.Deprecated);
+        this.client.hasWindowProgressCapability = !!((_10 = capabilities.window) === null || _10 === void 0 ? void 0 : _10.workDoneProgress);
+        this.client.hasGoToDeclarationCapability = !!((_11 = capabilities.textDocument) === null || _11 === void 0 ? void 0 : _11.declaration);
+        this.client.completionItemResolveSupportsAdditionalTextEdits =
+            !!((_15 = (_14 = (_13 = (_12 = capabilities.textDocument) === null || _12 === void 0 ? void 0 : _12.completion) === null || _13 === void 0 ? void 0 : _13.completionItem) === null || _14 === void 0 ? void 0 : _14.resolveSupport) === null || _15 === void 0 ? void 0 : _15.properties.some((p) => p === 'additionalTextEdits'));
+        // Create a service instance for each of the workspace folders.
+        if (params.workspaceFolders) {
+            params.workspaceFolders.forEach((folder) => {
+                const path = this._uriParser.decodeTextDocumentUri(folder.uri);
+                this._workspaceMap.set(path, this.createWorkspaceServiceInstance(folder, path));
+            });
+        }
+        else if (params.rootPath) {
+            this._workspaceMap.set(params.rootPath, this.createWorkspaceServiceInstance(undefined, params.rootPath));
+        }
+        const result = {
+            capabilities: {
+                textDocumentSync: vscode_languageserver_1.TextDocumentSyncKind.Incremental,
+                definitionProvider: { workDoneProgress: true },
+                declarationProvider: { workDoneProgress: true },
+                typeDefinitionProvider: { workDoneProgress: true },
+                referencesProvider: { workDoneProgress: true },
+                documentSymbolProvider: { workDoneProgress: true },
+                workspaceSymbolProvider: { workDoneProgress: true },
+                hoverProvider: { workDoneProgress: true },
+                documentHighlightProvider: { workDoneProgress: true },
+                renameProvider: { prepareProvider: true, workDoneProgress: true },
+                completionProvider: {
+                    triggerCharacters: this.client.hasVisualStudioExtensionsCapability ? ['.', '[', '@'] : ['.', '['],
+                    resolveProvider: true,
+                    workDoneProgress: true,
+                    completionItem: {
+                        labelDetailsSupport: true,
+                    },
+                },
+                signatureHelpProvider: {
+                    triggerCharacters: ['(', ',', ')'],
+                    workDoneProgress: true,
+                },
+                codeActionProvider: {
+                    codeActionKinds: supportedCodeActions,
+                    workDoneProgress: true,
+                },
+                executeCommandProvider: {
+                    commands: supportedCommands,
+                    workDoneProgress: true,
+                },
+                callHierarchyProvider: true,
+            },
+        };
+        return result;
+    }
+    onInitialized() {
+        if (this.client.hasWorkspaceFoldersCapability) {
+            this._connection.workspace.onDidChangeWorkspaceFolders((event) => {
+                event.removed.forEach((workspace) => {
+                    const rootPath = this._uriParser.decodeTextDocumentUri(workspace.uri);
+                    this._workspaceMap.delete(rootPath);
+                });
+                event.added.forEach(async (workspace) => {
+                    const rootPath = this._uriParser.decodeTextDocumentUri(workspace.uri);
+                    const newWorkspace = this.createWorkspaceServiceInstance(workspace, rootPath);
+                    this._workspaceMap.set(rootPath, newWorkspace);
+                    await this.updateSettingsForWorkspace(newWorkspace);
+                });
+                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) {
+            for (const workspace of this._workspaceMap.getNonDefaultWorkspaces()) {
+                workspace.searchPathsToWatch.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 });
+                });
+            }
+        }
+        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.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.serviceInstance.getDefinitionForPosition(filePath, position, filter, 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.serviceInstance.getDefinitionForPosition(filePath, position, filter, token));
+    }
+    async onTypeDefinition(params, token) {
+        return this.getDefinitions(params, token, definitionProvider_1.DefinitionFilter.All, (workspace, filePath, position, _, token) => workspace.serviceInstance.getTypeDefinitionForPosition(filePath, position, token));
+    }
+    async getDefinitions(params, token, filter, getDefinitionsFunc) {
+        this.recordUserInteractionTime();
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return undefined;
+        }
+        const locations = getDefinitionsFunc(workspace, filePath, position, filter, token);
+        if (!locations) {
+            return undefined;
+        }
+        return locations
+            .filter((loc) => !this.fs.isInZipOrEgg(loc.path))
+            .map((loc) => vscode_languageserver_1.Location.create((0, pathUtils_1.convertPathToUri)(this.fs, loc.path), loc.range));
+    }
+    async onReferences(params, token, workDoneReporter, resultReporter) {
+        if (this._pendingFindAllRefsCancellationSource) {
+            this._pendingFindAllRefsCancellationSource.cancel();
+            this._pendingFindAllRefsCancellationSource = undefined;
+        }
+        // VS Code doesn't support cancellation of "final all references".
+        // We provide a progress bar a cancellation button so the user can cancel
+        // any long-running actions.
+        const progress = await this._getProgressReporter(workDoneReporter, localize_1.Localizer.CodeAction.findingReferences(), token);
+        const source = progress.source;
+        this._pendingFindAllRefsCancellationSource = source;
+        try {
+            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.fs.isInZipOrEgg(loc.path))
+                    .map((loc) => vscode_languageserver_1.Location.create((0, pathUtils_1.convertPathToUri)(this.fs, loc.path), loc.range));
+            };
+            const locations = [];
+            const reporter = resultReporter
+                ? (locs) => resultReporter.report(convert(locs))
+                : (locs) => (0, collectionUtils_1.appendArray)(locations, convert(locs));
+            workspace.serviceInstance.reportReferencesForPosition(filePath, position, params.context.includeDeclaration, reporter, source.token);
+            return locations;
+        }
+        finally {
+            progress.reporter.done();
+            source.dispose();
+        }
+    }
+    async onDocumentSymbol(params, token) {
+        this.recordUserInteractionTime();
+        const filePath = this._uriParser.decodeTextDocumentUri(params.textDocument.uri);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return undefined;
+        }
+        const symbolList = [];
+        workspace.serviceInstance.addSymbolsForDocument(filePath, symbolList, token);
+        if (this.client.hasHierarchicalDocumentSymbolCapability) {
+            return symbolList;
+        }
+        return (0, documentSymbolProvider_1.convertToFlatSymbols)(params.textDocument.uri, symbolList);
+    }
+    async onWorkspaceSymbol(params, token, resultReporter) {
+        const symbolList = [];
+        const reporter = resultReporter
+            ? (symbols) => resultReporter.report(symbols)
+            : (symbols) => (0, collectionUtils_1.appendArray)(symbolList, symbols);
+        for (const workspace of this._workspaceMap.values()) {
+            await workspace.isInitialized.promise;
+            if (!workspace.disableLanguageServices && !workspace.disableWorkspaceSymbol) {
+                workspace.serviceInstance.reportSymbolsForWorkspace(params.query, reporter, token);
+            }
+        }
+        return symbolList;
+    }
+    async onHover(params, token) {
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        const hoverResults = workspace.serviceInstance.getHoverForPosition(filePath, position, this.client.hoverContentFormat, token);
+        return (0, hoverProvider_1.convertHoverResults)(this.client.hoverContentFormat, hoverResults);
+    }
+    async onDocumentHighlight(params, token) {
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        return workspace.serviceInstance.getDocumentHighlight(filePath, position, token);
+    }
+    async onSignatureHelp(params, token) {
+        var _a, _b;
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return;
+        }
+        const signatureHelpResults = workspace.serviceInstance.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 };
+    }
+    async onCompletion(params, token) {
+        var _a, _b;
+        // We set completion incomplete for the first invocation and next consecutive call,
+        // but after that we mark it as completed so the client doesn't repeatedly call back.
+        // We mark the first one as incomplete because completion could be invoked without
+        // any meaningful character provided, such as an explicit completion invocation (ctrl+space)
+        // or a period. That might cause us to not include some items (e.g., auto-imports).
+        // The next consecutive call provides some characters to help us to pick
+        // better completion items. After that, we are not going to introduce new items,
+        // so we can let the client to do the filtering and caching.
+        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 workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return;
+        }
+        const completions = await this.getWorkspaceCompletionsForPosition(workspace, filePath, position, workspace.rootPath, this.getCompletionOptions(params), token);
+        if (completions && completions.completionList) {
+            completions.completionList.isIncomplete = completionIncomplete;
+        }
+        return completions === null || completions === void 0 ? void 0 : completions.completionList;
+    }
+    // Cancellation bugs in vscode and LSP:
+    // https://github.com/microsoft/vscode-languageserver-node/issues/615
+    // https://github.com/microsoft/vscode/issues/95485
+    //
+    // If resolver throws cancellation exception, LSP and VSCode
+    // cache that result and never call us back.
+    async onCompletionResolve(params, token) {
+        const completionItemData = (0, lspUtils_1.fromLSPAny)(params.data);
+        if (completionItemData && completionItemData.filePath) {
+            const workspace = await this.getWorkspaceForFile(completionItemData.workspacePath);
+            this.resolveWorkspaceCompletionItem(workspace, completionItemData.filePath, params, token);
+        }
+        return params;
+    }
+    async onPrepareRenameRequest(params, token) {
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return null;
+        }
+        const range = workspace.serviceInstance.canRenameSymbolAtPosition(filePath, position, workspace.rootPath === '', this.allowModuleRename, token);
+        return range !== null && range !== void 0 ? range : null;
+    }
+    async onRenameRequest(params, token) {
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return;
+        }
+        const editActions = workspace.serviceInstance.renameSymbolAtPosition(filePath, position, params.newName, workspace.rootPath === '', this.allowModuleRename, token);
+        if (!editActions) {
+            return undefined;
+        }
+        return (0, workspaceEditUtils_1.convertWorkspaceDocumentEdits)(this.fs, editActions);
+    }
+    async onPrepare(params, token) {
+        const { filePath, position } = this._uriParser.decodeTextDocumentPosition(params.textDocument, params.position);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        if (workspace.disableLanguageServices) {
+            return null;
+        }
+        const callItem = workspace.serviceInstance.getCallForPosition(filePath, position, token) || null;
+        if (!callItem) {
+            return null;
+        }
+        if (this.fs.isInZipOrEgg(callItem.uri)) {
+            return null;
+        }
+        // Convert the file path in the item to proper URI.
+        callItem.uri = (0, pathUtils_1.convertPathToUri)(this.fs, callItem.uri);
+        return [callItem];
+    }
+    async onIncomingCalls(params, token) {
+        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.serviceInstance.getIncomingCallsForPosition(filePath, position, token) || null;
+        if (!callItems || callItems.length === 0) {
+            return null;
+        }
+        callItems = callItems.filter((item) => !this.fs.isInZipOrEgg(item.from.uri));
+        // Convert the file paths in the items to proper URIs.
+        callItems.forEach((item) => {
+            item.from.uri = (0, pathUtils_1.convertPathToUri)(this.fs, item.from.uri);
+        });
+        return callItems;
+    }
+    async onOutgoingCalls(params, token) {
+        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.serviceInstance.getOutgoingCallsForPosition(filePath, position, token) || null;
+        if (!callItems || callItems.length === 0) {
+            return null;
+        }
+        callItems = callItems.filter((item) => !this.fs.isInZipOrEgg(item.to.uri));
+        // Convert the file paths in the items to proper URIs.
+        callItems.forEach((item) => {
+            item.to.uri = (0, pathUtils_1.convertPathToUri)(this.fs, item.to.uri);
+        });
+        return callItems;
+    }
+    async onDidOpenTextDocument(params, ipythonMode = false) {
+        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;
+        }
+        const workspace = await this.getWorkspaceForFile(filePath);
+        workspace.serviceInstance.setFileOpened(filePath, params.textDocument.version, params.textDocument.text, ipythonMode);
+    }
+    async onDidChangeTextDocument(params, ipythonMode = false) {
+        this.recordUserInteractionTime();
+        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;
+        }
+        const workspace = await this.getWorkspaceForFile(filePath);
+        workspace.serviceInstance.updateOpenFileContents(filePath, params.textDocument.version, params.contentChanges, ipythonMode);
+    }
+    async onDidCloseTextDocument(params) {
+        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;
+        }
+        const workspace = await this.getWorkspaceForFile(filePath);
+        workspace.serviceInstance.setFileClosed(filePath);
+    }
+    onDidChangeWatchedFiles(params) {
+        params.changes.forEach((change) => {
+            const filePath = this.fs.realCasePath(this._uriParser.decodeTextDocumentUri(change.uri));
+            const eventType = change.type === 1 ? 'add' : 'change';
+            this._fileWatcherProvider.onFileChange(eventType, filePath);
+        });
+    }
+    async onExecuteCommand(params, token, reporter) {
+        // Cancel running command if there is one.
+        if (this._pendingCommandCancellationSource) {
+            this._pendingCommandCancellationSource.cancel();
+            this._pendingCommandCancellationSource = undefined;
+        }
+        const executeCommand = async (token) => {
+            const result = await this.executeCommand(params, token);
+            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 });
+            }
+            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 });
+            }
+            return result;
+        };
+        if (this.isLongRunningCommand(params.command)) {
+            // Create a progress dialog for long-running commands.
+            const progress = await this._getProgressReporter(reporter, localize_1.Localizer.CodeAction.executingCommand(), token);
+            const source = progress.source;
+            this._pendingCommandCancellationSource = source;
+            try {
+                const result = await executeCommand(source.token);
+                return result;
+            }
+            finally {
+                progress.reporter.done();
+                source.dispose();
+            }
+        }
+        else {
+            const result = await executeCommand(token);
+            return result;
+        }
+    }
+    resolveWorkspaceCompletionItem(workspace, filePath, item, token) {
+        workspace.serviceInstance.resolveCompletionItem(filePath, item, this.getCompletionOptions(), 
+        /* nameMap */ undefined, token);
+    }
+    getWorkspaceCompletionsForPosition(workspace, filePath, position, workspacePath, options, token) {
+        return workspace.serviceInstance.getCompletionsForPosition(filePath, position, workspacePath, options, undefined, token);
+    }
+    updateSettingsForAllWorkspaces() {
+        const tasks = [];
+        this._workspaceMap.forEach((workspace) => {
+            tasks.push(this.updateSettingsForWorkspace(workspace));
+        });
+        Promise.all(tasks).then(() => {
+            this._setupFileWatcher();
+        });
+    }
+    getCompletionOptions(params) {
+        return {
+            format: this.client.completionDocFormat,
+            snippet: this.client.completionSupportsSnippet,
+            lazyEdit: this.client.completionItemResolveSupportsAdditionalTextEdits,
+            autoImport: true,
+        };
+    }
+    createWorkspaceServiceInstance(workspace, rootPath) {
+        var _a, _b, _c;
+        return {
+            workspaceName: (_a = workspace === null || workspace === void 0 ? void 0 : workspace.name) !== null && _a !== void 0 ? _a : '',
+            rootPath,
+            rootUri: (_b = workspace === null || workspace === void 0 ? void 0 : workspace.uri) !== null && _b !== void 0 ? _b : '',
+            serviceInstance: this.createAnalyzerService((_c = workspace === null || workspace === void 0 ? void 0 : workspace.name) !== null && _c !== void 0 ? _c : rootPath),
+            disableLanguageServices: false,
+            disableOrganizeImports: false,
+            disableWorkspaceSymbol: false,
+            isInitialized: (0, deferred_1.createDeferred)(),
+            searchPathsToWatch: [],
+        };
+    }
+    convertDiagnostics(fileDiagnostics) {
+        return [
+            {
+                uri: (0, pathUtils_1.convertPathToUri)(this.fs, fileDiagnostics.filePath),
+                version: fileDiagnostics.version,
+                diagnostics: this._convertDiagnostics(fileDiagnostics.diagnostics),
+            },
+        ];
+    }
+    onAnalysisCompletedHandler(results) {
+        // Send the computed diagnostics to the client.
+        results.diagnostics.forEach((fileDiag) => {
+            if (this.fs.isInZipOrEgg(fileDiag.filePath)) {
+                return;
+            }
+            this._sendDiagnostics(this.convertDiagnostics(fileDiag));
+            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.
+            // This can happen if a user changes typeCheckingMode in the middle
+            // of analysis.
+            // end() is noop if there is no active progress bar.
+            this._progressReporter.end();
+            return;
+        }
+        // Update progress.
+        if (results.filesRequiringAnalysis > 0) {
+            this._progressReporter.begin();
+            const progressMessage = results.filesRequiringAnalysis === 1
+                ? localize_1.Localizer.CodeAction.filesToAnalyzeOne()
+                : localize_1.Localizer.CodeAction.filesToAnalyzeCount().format({
+                    count: results.filesRequiringAnalysis,
+                });
+            this._progressReporter.report(progressMessage);
+        }
+        else {
+            this._progressReporter.end();
+        }
+    }
+    async updateSettingsForWorkspace(workspace, serverSettings) {
+        var _a;
+        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;
+        this.updateOptionsAndRestartService(workspace, serverSettings);
+        workspace.disableLanguageServices = !!serverSettings.disableLanguageServices;
+        workspace.disableOrganizeImports = !!serverSettings.disableOrganizeImports;
+        // The workspace is now open for business.
+        workspace.isInitialized.resolve(true);
+    }
+    updateOptionsAndRestartService(workspace, serverSettings, typeStubTargetImportName) {
+        var _a;
+        analyzerServiceExecutor_1.AnalyzerServiceExecutor.runWithOptions(this.rootPath, workspace, serverSettings, typeStubTargetImportName);
+        workspace.searchPathsToWatch = (_a = workspace.serviceInstance.librarySearchPathsToWatch) !== null && _a !== void 0 ? _a : [];
+    }
+    convertLogLevel(logLevelValue) {
+        if (!logLevelValue) {
+            return console_1.LogLevel.Info;
+        }
+        switch (logLevelValue.toLowerCase()) {
+            case 'error':
+                return console_1.LogLevel.Error;
+            case 'warning':
+                return console_1.LogLevel.Warn;
+            case 'information':
+                return console_1.LogLevel.Info;
+            case 'trace':
+                return console_1.LogLevel.Log;
+            default:
+                return console_1.LogLevel.Info;
+        }
+    }
+    _sendDiagnostics(params) {
+        for (const param of params) {
+            this._connection.sendDiagnostics(param);
+        }
+    }
+    _getCompatibleMarkupKind(clientSupportedFormats) {
+        const serverSupportedFormats = [vscode_languageserver_1.MarkupKind.PlainText, vscode_languageserver_1.MarkupKind.Markdown];
+        for (const format of clientSupportedFormats !== null && clientSupportedFormats !== void 0 ? clientSupportedFormats : []) {
+            if (serverSupportedFormats.includes(format)) {
+                return format;
+            }
+        }
+        return vscode_languageserver_1.MarkupKind.PlainText;
+    }
+    async _getProgressReporter(reporter, title, token) {
+        // This is a bit ugly, but we need to determine whether the provided reporter
+        // is an actual client-side progress reporter or a dummy (null) progress reporter
+        // 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)(token) };
+        }
+        const serverInitiatedReporter = await this._connection.window.createWorkDoneProgress();
+        serverInitiatedReporter.begin(title, 
+        /* percentage */ undefined, 
+        /* message */ undefined, 
+        /* cancellable */ true);
+        return {
+            reporter: serverInitiatedReporter,
+            source: (0, cancellationUtils_1.CancelAfter)(token, serverInitiatedReporter.token),
+        };
+    }
+    _convertDiagnostics(diags) {
+        const convertedDiags = [];
+        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);
+            if (diag.category === 3 /* UnusedCode */) {
+                vsDiag.tags = [vscode_languageserver_1.DiagnosticTag.Unnecessary];
+                vsDiag.severity = vscode_languageserver_1.DiagnosticSeverity.Hint;
+                // If the client doesn't support "unnecessary" tags, don't report unused code.
+                if (!this.client.supportsUnnecessaryDiagnosticTag) {
+                    return;
+                }
+            }
+            else if (diag.category === 4 /* Deprecated */) {
+                vsDiag.tags = [vscode_languageserver_1.DiagnosticTag.Deprecated];
+                vsDiag.severity = vscode_languageserver_1.DiagnosticSeverity.Hint;
+                // If the client doesn't support "deprecated" tags, don't report.
+                if (!this.client.supportsDeprecatedDiagnosticTag) {
+                    return;
+                }
+            }
+            if (rule) {
+                const ruleDocUrl = this.getDocumentationUrlForDiagnosticRule(rule);
+                if (ruleDocUrl) {
+                    vsDiag.codeDescription = {
+                        href: ruleDocUrl,
+                    };
+                }
+            }
+            const relatedInfo = diag.getRelatedInfo();
+            if (relatedInfo.length > 0) {
+                vsDiag.relatedInformation = relatedInfo
+                    .filter((info) => !this.fs.isInZipOrEgg(info.filePath))
+                    .map((info) => vscode_languageserver_1.DiagnosticRelatedInformation.create(vscode_languageserver_1.Location.create((0, pathUtils_1.convertPathToUri)(this.fs, info.filePath), info.range), info.message));
+            }
+            convertedDiags.push(vsDiag);
+        });
+        function convertCategoryToSeverity(category) {
+            switch (category) {
+                case 0 /* Error */:
+                    return vscode_languageserver_1.DiagnosticSeverity.Error;
+                case 1 /* Warning */:
+                    return vscode_languageserver_1.DiagnosticSeverity.Warning;
+                case 2 /* Information */:
+                    return vscode_languageserver_1.DiagnosticSeverity.Information;
+                case 3 /* UnusedCode */:
+                case 4 /* Deprecated */:
+                    return vscode_languageserver_1.DiagnosticSeverity.Hint;
+            }
+        }
+        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._workspaceMap.forEach((workspace) => {
+            workspace.serviceInstance.recordUserInteractionTime();
+        });
+    }
+    getDocumentationUrlForDiagnosticRule(rule) {
+        // For now, return the same URL for all rules. We can separate these
+        // in the future.
+        return 'https://github.com/microsoft/pyright/blob/main/docs/configuration.md';
+    }
+    // Expands certain predefined variables supported within VS Code settings.
+    // Ideally, VS Code would provide an API for doing this expansion, but
+    // it doesn't. We'll handle the most common variables here as a convenience.
+    expandPathVariables(rootPath, value) {
+        const regexp = /\$\{(.*?)\}/g;
+        return value.replace(regexp, (match, name) => {
+            const trimmedName = name.trim();
+            if (trimmedName === 'workspaceFolder') {
+                return rootPath;
+            }
+            if (trimmedName === 'env:HOME' && process.env.HOME !== undefined) {
+                return process.env.HOME;
+            }
+            if (trimmedName === 'env:USERNAME' && process.env.USERNAME !== undefined) {
+                return process.env.USERNAME;
+            }
+            if (trimmedName === 'env:VIRTUAL_ENV' && process.env.VIRTUAL_ENV !== undefined) {
+                return process.env.VIRTUAL_ENV;
+            }
+            return match;
+        });
+    }
+}
+exports.LanguageServerBase = LanguageServerBase;
+//# sourceMappingURL=languageServerBase.js.map