Wati for Html buffer updates before making requests

Author: davidwengier

CHANGELOG.md

@@ -29,6 +29,7 @@
   * Fix(ish) formatting of RenderFragments (C# templates) (PR: [#12397](https://github.com/dotnet/razor/pull/12397))
   * Drop Html edits that would split a C# literal across multiple lines (PR: [#12396](https://github.com/dotnet/razor/pull/12396))
   * Fix completion resolve for provisional completion (PR: [#12403](https://github.com/dotnet/razor/pull/12403))
+* Wait for Html buffer updates before making requests (PR: [#8748](https://github.com/dotnet/vscode-csharp/pull/8748))
 
 # 2.96.x
 * Update Debugger to v2.95.0 (PR: [#8710](https://github.com/dotnet/vscode-csharp/pull/8710))

src/lsptoolshost/razor/htmlDocument.ts

@@ -10,6 +10,7 @@ export class HtmlDocument {
     public readonly path: string;
     private content = '';
     private checksum = '';
+    private previousVersion = -1;
 
     public constructor(public readonly uri: vscode.Uri, checksum: string) {
         this.path = getUriPath(uri);
@@ -24,8 +25,21 @@ export class HtmlDocument {
         return this.checksum;
     }
 
-    public setContent(checksum: string, content: string) {
+    public async setContent(checksum: string, content: string) {
+        var document = await vscode.workspace.openTextDocument(this.uri);
+        // Capture the version _before_ the change, so we can know for sure if it's been seen
+        this.previousVersion = document.version;
         this.checksum = checksum;
         this.content = content;
     }
+
+    public async waitForBufferUpdate() {
+        var document = await vscode.workspace.openTextDocument(this.uri);
+
+        // Wait for VS Code to process any previous content change. We don't care about finding
+        // a specific version, just that it's moved on from the previous one.
+        while (document.version === this.previousVersion) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
 }

src/lsptoolshost/razor/htmlDocumentManager.ts

@@ -79,9 +79,7 @@ export class HtmlDocumentManager {
 
         this.logger.logTrace(`New content for '${uri}', updating '${document.path}', checksum '${checksum}'.`);
 
-        await vscode.workspace.openTextDocument(document.uri);
-
-        document.setContent(checksum, text);
+        await document.setContent(checksum, text);
 
         this.contentProvider.fireDidChange(document.uri);
     }

src/lsptoolshost/razor/razorEndpoints.ts

@@ -252,6 +252,13 @@ export function registerRazorEndpoints(
                 return undefined;
             }
 
+            // We know that we've got the right document, and we've been told about the right content by the server,
+            // but all we can be sure of at this point is that we've fired the change event for it. The event firing
+            // is async, and the didChange notification that it would generate is a notification, so doesn't necessarily
+            // block. Before we actually make a call to the Html server, we should at least make sure that the document
+            // version is not still the same as before we updated the content.
+            await document.waitForBufferUpdate();
+
             return invocation(document, params.request);
         });
     }