Add Project Context status item

Author: JoeRobich

l10n/bundle.l10n.json

@@ -161,6 +161,8 @@
   "Fix All: ": "Fix All: ",
   "C# Workspace Status": "C# Workspace Status",
   "Open solution": "Open solution",
+  "C# Project Context Status": "C# Project Context Status",
+  "Project Context": "Project Context",
   "Pick a fix all scope": "Pick a fix all scope",
   "Fix All Code Action": "Fix All Code Action",
   "pipeArgs must be a string or a string array type": "pipeArgs must be a string or a string array type",

src/lsptoolshost/languageStatusBar.ts

@@ -19,6 +19,7 @@ export function registerLanguageStatusItems(
     if (!getCSharpDevKit()) {
         WorkspaceStatus.createStatusItem(context, languageServerEvents);
     }
+    ProjectContextStatus.createStatusItem(context, languageServer, languageServerEvents);
 }
 
 class WorkspaceStatus {
@@ -40,3 +41,43 @@ class WorkspaceStatus {
         });
     }
 }
+
+class ProjectContextStatus {
+    static createStatusItem(
+        context: vscode.ExtensionContext,
+        languageServer: RoslynLanguageServer,
+        languageServerEvents: RoslynLanguageServerEvents
+    ) {
+        const projectContextService = languageServer._projectContextService;
+
+        const item = vscode.languages.createLanguageStatusItem(
+            'csharp.projectContextStatus',
+            languageServerOptions.documentSelector
+        );
+        item.name = vscode.l10n.t('C# Project Context Status');
+        item.detail = vscode.l10n.t('Project Context');
+        context.subscriptions.push(item);
+
+        updateItem(vscode.window.activeTextEditor);
+        context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor(updateItem));
+
+        languageServerEvents.onServerStateChange((e) => {
+            if (e.state === ServerState.ProjectInitializationComplete) {
+                projectContextService.clear();
+                updateItem(vscode.window.activeTextEditor);
+            }
+        });
+
+        async function updateItem(e: vscode.TextEditor | undefined) {
+            if (e?.document.languageId !== 'csharp') {
+                item.text = '';
+                return;
+            }
+
+            const projectContext = await projectContextService.getCurrentProjectContext(e.document.uri);
+            if (projectContext) {
+                item.text = projectContext._vs_label;
+            }
+        }
+    }
+}

src/lsptoolshost/roslynLanguageServer.ts

@@ -65,6 +65,7 @@ import { BuildDiagnosticsService } from './buildDiagnosticsService';
 import { getComponentPaths } from './builtInComponents';
 import { OnAutoInsertFeature } from './onAutoInsertFeature';
 import { registerLanguageStatusItems } from './languageStatusBar';
+import { ProjectContextService } from './services/projectContextService';
 
 let _channel: vscode.OutputChannel;
 let _traceChannel: vscode.OutputChannel;
@@ -106,6 +107,7 @@ export class RoslynLanguageServer {
     public readonly _onAutoInsertFeature: OnAutoInsertFeature;
 
     public _buildDiagnosticService: BuildDiagnosticsService;
+    public _projectContextService: ProjectContextService;
 
     constructor(
         private _languageClient: RoslynLanguageClient,
@@ -125,6 +127,8 @@ export class RoslynLanguageServer {
         this._buildDiagnosticService = new BuildDiagnosticsService(diagnosticsReportedByBuild);
         this.registerDocumentOpenForDiagnostics();
 
+        this._projectContextService = new ProjectContextService(this);
+
         // Register Razor dynamic file info handling
         this.registerDynamicFileInfo();
 

src/lsptoolshost/roslynProtocol.ts

@@ -8,6 +8,21 @@ import * as lsp from 'vscode-languageserver-protocol';
 import { CodeAction, TextDocumentRegistrationOptions } from 'vscode-languageserver-protocol';
 import { ProjectConfigurationMessage } from '../shared/projectConfiguration';
 
+export interface VSProjectContextList {
+    _vs_projectContexts: VSProjectContext[];
+    _vs_defaultIndex: number;
+}
+
+export interface VSProjectContext {
+    _vs_label: string;
+    _vs_id: string;
+    _vs_kind: string;
+}
+
+export interface VSTextDocumentIdentifier extends lsp.TextDocumentIdentifier {
+    _vs_projectContext: VSProjectContext | undefined;
+}
+
 export interface WorkspaceDebugConfigurationParams {
     /**
      * Workspace path containing the solution/projects to get debug information for.
@@ -88,6 +103,13 @@ export interface RegisterSolutionSnapshotResponseItem {
     id: lsp.integer;
 }
 
+export interface VSGetProjectContextParams {
+    /**
+     * The document the project context is being requested for.
+     */
+    _vs_textDocument: lsp.TextDocumentIdentifier;
+}
+
 export interface RunTestsParams extends lsp.WorkDoneProgressParams, lsp.PartialResultParams {
     /**
      * The text document containing the tests to run.
@@ -210,6 +232,12 @@ export namespace RegisterSolutionSnapshotRequest {
     export const type = new lsp.RequestType0<RegisterSolutionSnapshotResponseItem, void>(method);
 }
 
+export namespace VSGetProjectContextsRequest {
+    export const method = 'textDocument/_vs_getProjectContexts';
+    export const messageDirection: lsp.MessageDirection = lsp.MessageDirection.clientToServer;
+    export const type = new lsp.RequestType<VSGetProjectContextParams, VSProjectContextList, void>(method);
+}
+
 export namespace ProjectInitializationCompleteNotification {
     export const method = 'workspace/projectInitializationComplete';
     export const messageDirection: lsp.MessageDirection = lsp.MessageDirection.serverToClient;

src/lsptoolshost/services/projectContextService.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { RoslynLanguageServer } from '../roslynLanguageServer';
+import { VSGetProjectContextsRequest, VSProjectContext, VSProjectContextList } from '../roslynProtocol';
+import { TextDocumentIdentifier } from 'vscode-languageserver-protocol';
+import { UriConverter } from '../uriConverter';
+
+export class ProjectContextService {
+    /** Track the project contexts for a particular document uri. */
+    private _projectContexts: { [uri: string]: Promise<VSProjectContextList> | VSProjectContextList } = {};
+
+    constructor(private languageServer: RoslynLanguageServer) {}
+
+    clear() {
+        this._projectContexts = {};
+    }
+
+    async getCurrentProjectContext(uri: string | vscode.Uri): Promise<VSProjectContext | undefined> {
+        const projectContexts = await this.getProjectContexts(uri);
+        return projectContexts?._vs_projectContexts[projectContexts._vs_defaultIndex];
+    }
+
+    async getProjectContexts(uri: string | vscode.Uri): Promise<VSProjectContextList | undefined> {
+        const uriString = uri instanceof vscode.Uri ? UriConverter.serialize(uri) : uri;
+
+        if (!(uriString in this._projectContexts)) {
+            const source = new vscode.CancellationTokenSource();
+            this._projectContexts[uriString] = this.languageServer
+                .sendRequest(
+                    VSGetProjectContextsRequest.type,
+                    { _vs_textDocument: TextDocumentIdentifier.create(uriString) },
+                    source.token
+                )
+                .then((contextList) => (this._projectContexts[uriString] = contextList));
+        }
+
+        return this._projectContexts[uriString];
+    }
+}