Remove caching and add onChange event.

Author: JoeRobich

l10n/bundle.l10n.json

@@ -162,7 +162,7 @@
   "C# Workspace Status": "C# Workspace Status",
   "Open solution": "Open solution",
   "C# Project Context Status": "C# Project Context Status",
-  "Project Context": "Project Context",
+  "Active File Context": "Active File 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,7 +19,7 @@ export function registerLanguageStatusItems(
     if (!getCSharpDevKit()) {
         WorkspaceStatus.createStatusItem(context, languageServerEvents);
     }
-    ProjectContextStatus.createStatusItem(context, languageServer, languageServerEvents);
+    ProjectContextStatus.createStatusItem(context, languageServer);
 }
 
 class WorkspaceStatus {
@@ -43,41 +43,20 @@ class WorkspaceStatus {
 }
 
 class ProjectContextStatus {
-    static createStatusItem(
-        context: vscode.ExtensionContext,
-        languageServer: RoslynLanguageServer,
-        languageServerEvents: RoslynLanguageServerEvents
-    ) {
+    static createStatusItem(context: vscode.ExtensionContext, languageServer: RoslynLanguageServer) {
         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');
+        item.detail = vscode.l10n.t('Active File 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);
-            }
+        projectContextService.onActiveFileContextChanged((e) => {
+            item.text = e.context._vs_label;
         });
-
-        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;
-            }
-        }
+        projectContextService.refresh();
     }
 }

src/lsptoolshost/roslynLanguageServer.ts

@@ -127,7 +127,7 @@ export class RoslynLanguageServer {
         this._buildDiagnosticService = new BuildDiagnosticsService(diagnosticsReportedByBuild);
         this.registerDocumentOpenForDiagnostics();
 
-        this._projectContextService = new ProjectContextService(this);
+        this._projectContextService = new ProjectContextService(this, this._languageServerEvents);
 
         // Register Razor dynamic file info handling
         this.registerDynamicFileInfo();

src/lsptoolshost/services/projectContextService.ts

@@ -8,36 +8,71 @@ import { RoslynLanguageServer } from '../roslynLanguageServer';
 import { VSGetProjectContextsRequest, VSProjectContext, VSProjectContextList } from '../roslynProtocol';
 import { TextDocumentIdentifier } from 'vscode-languageserver-protocol';
 import { UriConverter } from '../uriConverter';
+import { LanguageServerEvents } from '../languageServerEvents';
+import { ServerState } from '../serverStateChange';
+
+export interface ProjectContextChangeEvent {
+    uri: vscode.Uri;
+    context: VSProjectContext;
+}
 
 export class ProjectContextService {
-    /** Track the project contexts for a particular document uri. */
-    private _projectContexts: { [uri: string]: Promise<VSProjectContextList> | VSProjectContextList } = {};
+    private readonly _contextChangeEmitter = new vscode.EventEmitter<ProjectContextChangeEvent>();
+    private _source = new vscode.CancellationTokenSource();
 
-    constructor(private languageServer: RoslynLanguageServer) {}
+    constructor(private _languageServer: RoslynLanguageServer, _languageServerEvents: LanguageServerEvents) {
+        _languageServerEvents.onServerStateChange((e) => {
+            // When the project initialization is complete, open files
+            // could move from the miscellaneous workspace context into
+            // an open project.
+            if (e.state === ServerState.ProjectInitializationComplete) {
+                this.refresh();
+            }
+        });
 
-    clear() {
-        this._projectContexts = {};
+        vscode.window.onDidChangeActiveTextEditor(this.refresh);
     }
 
-    async getCurrentProjectContext(uri: string | vscode.Uri): Promise<VSProjectContext | undefined> {
-        const projectContexts = await this.getProjectContexts(uri);
-        return projectContexts?._vs_projectContexts[projectContexts._vs_defaultIndex];
+    public get onActiveFileContextChanged(): vscode.Event<ProjectContextChangeEvent> {
+        return this._contextChangeEmitter.event;
     }
 
-    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));
+    public async refresh() {
+        const textEditor = vscode.window.activeTextEditor;
+        if (textEditor?.document?.languageId !== 'csharp') {
+            return;
         }
 
-        return this._projectContexts[uriString];
+        const uri = textEditor.document.uri;
+
+        // If we have an open request, cancel it.
+        this._source.cancel();
+        this._source = new vscode.CancellationTokenSource();
+
+        try {
+            const contextList = await this.getProjectContexts(uri, this._source.token);
+            if (!contextList) {
+                return;
+            }
+
+            const context = contextList._vs_projectContexts[contextList._vs_defaultIndex];
+            this._contextChangeEmitter.fire({ uri, context });
+        } catch {
+            // This request was cancelled
+        }
+    }
+
+    private async getProjectContexts(
+        uri: vscode.Uri,
+        token: vscode.CancellationToken
+    ): Promise<VSProjectContextList | undefined> {
+        const uriString = UriConverter.serialize(uri);
+        const textDocument = TextDocumentIdentifier.create(uriString);
+
+        return this._languageServer.sendRequest(
+            VSGetProjectContextsRequest.type,
+            { _vs_textDocument: textDocument },
+            token
+        );
     }
 }