Merge pull request #2562 from NTaylorMullen/nimullen/fixvirtualdoctracker

Make Virtual document tracking apply to specific scheme.

Author: Ravi Chande

src/features/changeForwarding.ts

@@ -15,7 +15,7 @@ function forwardDocumentChanges(server: OmniSharpServer): IDisposable {
     return workspace.onDidChangeTextDocument(event => {
 
         let {document} = event;
-        if (document.isUntitled || document.languageId !== 'csharp') {
+        if (document.isUntitled || document.languageId !== 'csharp' || document.uri.scheme !== 'file') {
             return;
         }
 

src/features/diagnosticsProvider.ts

@@ -11,6 +11,8 @@ import { toRange } from '../omnisharp/typeConvertion';
 import * as vscode from 'vscode';
 import CompositeDisposable from '../CompositeDisposable';
 import { IDisposable } from '../Disposable';
+import { isVirtualCSharpDocument } from './virtualDocumentTracker';
+import { TextDocument } from '../vscodeAdapter';
 
 export class Advisor {
 
@@ -140,9 +142,11 @@ class DiagnosticsProvider extends AbstractSupport {
         // Go ahead and check for diagnostics in the currently visible editors.
         for (let editor of vscode.window.visibleTextEditors) {
             let document = editor.document;
-            if (document.languageId === 'csharp') {
-                this._validateDocument(document);
+            if (this.shouldIgnoreDocument(document)) {
+                continue;
             }
+
+            this._validateDocument(document);
         }
     }
 
@@ -158,6 +162,19 @@ class DiagnosticsProvider extends AbstractSupport {
         this._disposable.dispose();
     }
 
+    private shouldIgnoreDocument(document: TextDocument) {
+        if (document.languageId !== 'csharp') {
+            return true;
+        }
+
+        if (document.uri.scheme !== 'file' &&
+            !isVirtualCSharpDocument(document)) {
+            return true;
+        }
+
+        return false;
+    }
+
     private _OnDidChangeWindowState(windowState: vscode.WindowState): void {
         if (windowState.focused === true) {
             this._onDidChangeActiveTextEditor(vscode.window.activeTextEditor);
@@ -166,16 +183,18 @@ class DiagnosticsProvider extends AbstractSupport {
 
     private _onDidChangeActiveTextEditor(textEditor: vscode.TextEditor): void {
         // active text editor can be undefined.
-        if (textEditor != undefined && textEditor.document != null) { 
+        if (textEditor != undefined && textEditor.document != null) {
             this._onDocumentAddOrChange(textEditor.document);
         }
     }
 
     private _onDocumentAddOrChange(document: vscode.TextDocument): void {
-        if (document.languageId === 'csharp') {
-            this._validateDocument(document);
-            this._validateProject();
+        if (this.shouldIgnoreDocument(document)) {
+            return;
         }
+
+        this._validateDocument(document);
+        this._validateProject();
     }
 
     private _onDocumentRemove(document: vscode.TextDocument): void {

src/features/virtualDocumentTracker.ts

@@ -3,27 +3,39 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import {workspace, TextDocument, Uri} from 'vscode';
-import {OmniSharpServer} from '../omnisharp/server';
+import { workspace, TextDocument, Uri } from 'vscode';
+import { OmniSharpServer } from '../omnisharp/server';
 import * as serverUtils from '../omnisharp/utils';
 import { FileChangeType } from '../omnisharp/protocol';
 import { IDisposable } from '../Disposable';
 import CompositeDisposable from '../CompositeDisposable';
 import { EventStream } from '../EventStream';
 import { DocumentSynchronizationFailure } from '../omnisharp/loggingEvents';
 
-function trackCurrentVirtualDocuments(server: OmniSharpServer, eventStream: EventStream) {
-    let registration = server.onProjectAdded(async () => {
-        registration.dispose();
+async function trackCurrentVirtualDocuments(server: OmniSharpServer, eventStream: EventStream) {
+    for (let i = 0; i < workspace.textDocuments.length; i++) {
+        let document = workspace.textDocuments[i];
 
-        for (let i = 0; i < workspace.textDocuments.length; i++) {
-            let document = workspace.textDocuments[i];
-    
-            if (!shouldIgnoreDocument(document, server)) {
-                await openVirtualDocument(document, server, eventStream);
-            }
+        if (!shouldIgnoreDocument(document, server)) {
+            await openVirtualDocument(document, server, eventStream);
         }
-    });
+    }
+}
+
+export function isVirtualCSharpDocument(document: TextDocument) {
+    if (document.languageId !== 'csharp') {
+        return false;
+    }
+
+    if (document.uri.scheme === 'virtualCSharp-') {
+        return false;
+    }
+
+    if (!document.uri.scheme.startsWith('virtualCSharp-')) {
+        return false;
+    }
+
+    return true;
 }
 
 function trackFutureVirtualDocuments(server: OmniSharpServer, eventStream: EventStream): IDisposable {
@@ -35,22 +47,33 @@ function trackFutureVirtualDocuments(server: OmniSharpServer, eventStream: Event
         await openVirtualDocument(document, server, eventStream);
     });
 
+    let onTextDocumentChange = workspace.onDidChangeTextDocument(async changeEvent => {
+        const document = changeEvent.document;
+
+        if (shouldIgnoreDocument(document, server)) {
+            return;
+        }
+
+        await changeVirtualDocument(document, server, eventStream);
+    });
+
     let onTextDocumentClose = workspace.onDidCloseTextDocument(async document => {
         if (shouldIgnoreDocument(document, server)) {
             return;
         }
 
         await closeVirtualDocument(document, server, eventStream);
     });
-    
+
     // We already track text document changes for virtual documents in our change forwarder.
     return new CompositeDisposable(
         onTextDocumentOpen,
-        onTextDocumentClose);
+        onTextDocumentClose,
+        onTextDocumentChange);
 }
 
 function shouldIgnoreDocument(document: TextDocument, server: OmniSharpServer): boolean {
-    if (document.uri.scheme === 'file' || document.languageId !== 'csharp') {
+    if (!isVirtualCSharpDocument(document)) {
         // We're only interested in non-physical CSharp documents.
         return true;
     }
@@ -68,10 +91,27 @@ async function openVirtualDocument(document: TextDocument, server: OmniSharpServ
     if (!path) {
         path = document.uri.path;
     }
-    
+
     let req = { FileName: path, changeType: FileChangeType.Create };
     try {
         await serverUtils.filesChanged(server, [req]);
+
+        // Trigger a change for the opening so we can get content refreshed.
+        await changeVirtualDocument(document, server, eventStream);
+    }
+    catch (error) {
+        logSynchronizationFailure(document.uri, error, server, eventStream);
+    }
+}
+
+async function changeVirtualDocument(document: TextDocument, server: OmniSharpServer, eventStream: EventStream) {
+    let path = document.uri.fsPath;
+
+    if (!path) {
+        path = document.uri.path;
+    }
+
+    try {
         await serverUtils.updateBuffer(server, { Buffer: document.getText(), FileName: document.fileName });
     }
     catch (error) {
@@ -85,7 +125,7 @@ async function closeVirtualDocument(document: TextDocument, server: OmniSharpSer
     if (!path) {
         path = document.uri.path;
     }
-    
+
     let req = { FileName: path, changeType: FileChangeType.Delete };
     try {
         await serverUtils.filesChanged(server, [req]);
@@ -103,7 +143,7 @@ function logSynchronizationFailure(uri: Uri, error: any, server: OmniSharpServer
 
 export default function trackVirtualDocuments(server: OmniSharpServer, eventStream: EventStream): IDisposable {
     trackCurrentVirtualDocuments(server, eventStream);
-    let disposable = trackFutureVirtualDocuments(server, eventStream);
-    
+    const disposable = trackFutureVirtualDocuments(server, eventStream);
+
     return disposable;
 }