Send workspace label with ServerStatusChange event

Author: JoeRobich

src/lsptoolshost/debugger.ts

@@ -10,7 +10,7 @@ import { IWorkspaceDebugInformationProvider } from '../shared/IWorkspaceDebugInf
 import { RoslynLanguageServer } from './roslynLanguageServer';
 import { RoslynWorkspaceDebugInformationProvider } from './roslynWorkspaceDebugConfigurationProvider';
 import { PlatformInformation } from '../shared/platform';
-import { ServerStateChange } from './serverStateChange';
+import { ServerState } from './serverStateChange';
 import { DotnetConfigurationResolver } from '../shared/dotnetConfigurationProvider';
 import { getCSharpDevKit } from '../utils/getCSharpDevKit';
 import { RoslynLanguageServerEvents } from './languageServerEvents';
@@ -25,8 +25,8 @@ export function registerDebugger(
     const workspaceInformationProvider: IWorkspaceDebugInformationProvider =
         new RoslynWorkspaceDebugInformationProvider(languageServer, csharpOutputChannel);
 
-    const disposable = languageServerEvents.onServerStateChange(async (state) => {
-        if (state === ServerStateChange.ProjectInitializationComplete) {
+    const disposable = languageServerEvents.onServerStateChange(async (e) => {
+        if (e.state === ServerState.ProjectInitializationComplete) {
             const csharpDevkitExtension = getCSharpDevKit();
             if (!csharpDevkitExtension) {
                 // Update or add tasks.json and launch.json

src/lsptoolshost/languageServerEvents.ts

@@ -4,15 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { ServerStateChange } from './serverStateChange';
+import { ServerStateChangeEvent } from './serverStateChange';
 import { IDisposable } from '../disposable';
 
 /**
  * Defines events that are fired by the language server.
  * These events can be consumed to wait for the server to reach a certain state.
  */
 export interface LanguageServerEvents {
-    readonly onServerStateChange: vscode.Event<ServerStateChange>;
+    readonly onServerStateChange: vscode.Event<ServerStateChangeEvent>;
 }
 
 /**
@@ -21,9 +21,9 @@ export interface LanguageServerEvents {
  * register for events without having to know about the specific current state of the language server.
  */
 export class RoslynLanguageServerEvents implements LanguageServerEvents, IDisposable {
-    public readonly onServerStateChangeEmitter = new vscode.EventEmitter<ServerStateChange>();
+    public readonly onServerStateChangeEmitter = new vscode.EventEmitter<ServerStateChangeEvent>();
 
-    public get onServerStateChange(): vscode.Event<ServerStateChange> {
+    public get onServerStateChange(): vscode.Event<ServerStateChangeEvent> {
         return this.onServerStateChangeEmitter.event;
     }
 

src/lsptoolshost/languageStatusBar.ts

@@ -7,7 +7,7 @@ import * as vscode from 'vscode';
 import { RoslynLanguageServer } from './roslynLanguageServer';
 import { RoslynLanguageServerEvents } from './languageServerEvents';
 import { languageServerOptions } from '../shared/options';
-import { ServerStateChange } from './serverStateChange';
+import { ServerState } from './serverStateChange';
 import { getCSharpDevKit } from '../utils/getCSharpDevKit';
 
 export function registerLanguageStatusItems(
@@ -17,16 +17,12 @@ export function registerLanguageStatusItems(
 ) {
     // DevKit will provide an equivalent workspace status item.
     if (!getCSharpDevKit()) {
-        WorkspaceStatus.createStatusItem(context, languageServer, languageServerEvents);
+        WorkspaceStatus.createStatusItem(context, languageServerEvents);
     }
 }
 
 class WorkspaceStatus {
-    static createStatusItem(
-        context: vscode.ExtensionContext,
-        languageServer: RoslynLanguageServer,
-        languageServerEvents: RoslynLanguageServerEvents
-    ) {
+    static createStatusItem(context: vscode.ExtensionContext, languageServerEvents: RoslynLanguageServerEvents) {
         const item = vscode.languages.createLanguageStatusItem(
             'csharp.workspaceStatus',
             languageServerOptions.documentSelector
@@ -39,13 +35,8 @@ class WorkspaceStatus {
         context.subscriptions.push(item);
 
         languageServerEvents.onServerStateChange((e) => {
-            if (e === ServerStateChange.ProjectInitializationStarted) {
-                item.text = languageServer.workspaceDisplayName();
-                item.busy = true;
-            } else if (e === ServerStateChange.ProjectInitializationComplete) {
-                item.text = languageServer.workspaceDisplayName();
-                item.busy = false;
-            }
+            item.text = e.workspaceLabel;
+            item.busy = e.state === ServerState.ProjectInitializationStarted;
         });
     }
 }

src/lsptoolshost/roslynLanguageServer.ts

@@ -37,7 +37,7 @@ import ShowInformationMessage from '../shared/observers/utils/showInformationMes
 import * as RoslynProtocol from './roslynProtocol';
 import { CSharpDevKitExports } from '../csharpDevKitExports';
 import { SolutionSnapshotId } from './services/ISolutionSnapshotProvider';
-import { ServerStateChange } from './serverStateChange';
+import { ServerState } from './serverStateChange';
 import TelemetryReporter from '@vscode/extension-telemetry';
 import CSharpIntelliCodeExports from '../csharpIntelliCodeExports';
 import { csharpDevkitExtensionId, csharpDevkitIntelliCodeExtensionId, getCSharpDevKit } from '../utils/getCSharpDevKit';
@@ -158,18 +158,20 @@ export class RoslynLanguageServer {
                     await this.openDefaultSolutionOrProjects();
                 }
                 await this.sendOrSubscribeForServiceBrokerConnection();
-                this._languageServerEvents.onServerStateChangeEmitter.fire(ServerStateChange.Started);
+                this._languageServerEvents.onServerStateChangeEmitter.fire({
+                    state: ServerState.Started,
+                    workspaceLabel: this.workspaceDisplayName(),
+                });
             }
         });
     }
 
     private registerProjectInitialization() {
-        this._languageClient.onNotification(RoslynProtocol.ProjectInitializationStartedNotification.type, () => {
-            this._languageServerEvents.onServerStateChangeEmitter.fire(ServerStateChange.ProjectInitializationStarted);
-        });
-
         this._languageClient.onNotification(RoslynProtocol.ProjectInitializationCompleteNotification.type, () => {
-            this._languageServerEvents.onServerStateChangeEmitter.fire(ServerStateChange.ProjectInitializationComplete);
+            this._languageServerEvents.onServerStateChangeEmitter.fire({
+                state: ServerState.ProjectInitializationComplete,
+                workspaceLabel: this.workspaceDisplayName(),
+            });
         });
     }
 
@@ -394,16 +396,20 @@ export class RoslynLanguageServer {
                 await this._languageClient.sendNotification(RoslynProtocol.OpenSolutionNotification.type, {
                     solution: protocolUri,
                 });
-            }
-
-            if (this._projectFiles.length > 0) {
+            } else if (this._projectFiles.length > 0) {
                 const projectProtocolUris = this._projectFiles.map((uri) =>
                     this._languageClient.clientOptions.uriConverters!.code2Protocol(uri)
                 );
                 await this._languageClient.sendNotification(RoslynProtocol.OpenProjectNotification.type, {
                     projects: projectProtocolUris,
                 });
+            } else {
+                return;
             }
+            this._languageServerEvents.onServerStateChangeEmitter.fire({
+                state: ServerState.ProjectInitializationStarted,
+                workspaceLabel: this.workspaceDisplayName(),
+            });
         }
     }
 

src/lsptoolshost/serverStateChange.ts

@@ -3,8 +3,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-export enum ServerStateChange {
+export enum ServerState {
     Started = 0,
     ProjectInitializationStarted = 1,
     ProjectInitializationComplete = 2,
 }
+
+export interface ServerStateChangeEvent {
+    state: ServerState;
+    workspaceLabel: string;
+}

src/main.ts

@@ -52,7 +52,7 @@ import { RazorOmnisharpDownloader } from './razor/razorOmnisharpDownloader';
 import { RoslynLanguageServerExport } from './lsptoolshost/roslynLanguageServerExportChannel';
 import { registerOmnisharpOptionChanges } from './omnisharp/omnisharpOptionChanges';
 import { RoslynLanguageServerEvents } from './lsptoolshost/languageServerEvents';
-import { ServerStateChange } from './lsptoolshost/serverStateChange';
+import { ServerState } from './lsptoolshost/serverStateChange';
 import { SolutionSnapshotProvider } from './lsptoolshost/services/solutionSnapshotProvider';
 import { commonOptions, languageServerOptions, omnisharpOptions, razorOptions } from './shared/options';
 import { BuildResultDiagnostics } from './lsptoolshost/services/buildResultReporterService';
@@ -149,8 +149,8 @@ export async function activate(
 
         // Setup a listener for project initialization complete before we start the server.
         projectInitializationCompletePromise = new Promise((resolve, _) => {
-            roslynLanguageServerEvents.onServerStateChange(async (state) => {
-                if (state === ServerStateChange.ProjectInitializationComplete) {
+            roslynLanguageServerEvents.onServerStateChange(async (e) => {
+                if (e.state === ServerState.ProjectInitializationComplete) {
                     resolve();
                 }
             });

test/integrationTests/integrationHelpers.ts

@@ -7,7 +7,7 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import { CSharpExtensionExports } from '../../src/csharpExtensionExports';
 import { existsSync } from 'fs';
-import { ServerStateChange } from '../../src/lsptoolshost/serverStateChange';
+import { ServerState } from '../../src/lsptoolshost/serverStateChange';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 
 export async function activateCSharpExtension(): Promise<void> {
@@ -70,8 +70,8 @@ export async function restartLanguageServer(): Promise<void> {
     const csharpExtension = vscode.extensions.getExtension<CSharpExtensionExports>('ms-dotnettools.csharp');
     // Register to wait for initialization events and restart the server.
     const waitForInitialProjectLoad = new Promise<void>((resolve, _) => {
-        csharpExtension!.exports.experimental.languageServerEvents.onServerStateChange(async (state) => {
-            if (state === ServerStateChange.ProjectInitializationComplete) {
+        csharpExtension!.exports.experimental.languageServerEvents.onServerStateChange(async (e) => {
+            if (e.state === ServerState.ProjectInitializationComplete) {
                 resolve();
             }
         });