Improve document handling in VS Code and cohosting (#11825)

davidwengier · web-flow · commit b05db17aaab0 · 2025-05-07T14:25:51.000+10:00
Part of #11759 Goes with dotnet/vscode-csharp#8259 This adds a notification for VS Code to tell us that a Razor file has closed, so we can clear our cache, and also adds checksum matching to Html requests in VS and VS Code so we can ensure we're not out-of-sync.
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/HtmlDocumentSynchronizer.SynchronizationRequest.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/HtmlDocumentSynchronizer.SynchronizationRequest.cs
@@ -14,30 +14,30 @@ internal sealed partial class HtmlDocumentSynchronizer
     private class SynchronizationRequest(RazorDocumentVersion requestedVersion) : IDisposable
     {
         private readonly RazorDocumentVersion _requestedVersion = requestedVersion;
-        private readonly TaskCompletionSource<bool> _tcs = new();
+        private readonly TaskCompletionSource<SynchronizationResult> _tcs = new();
         private CancellationTokenSource? _cts;
 
-        public Task<bool> Task => _tcs.Task;
+        public Task<SynchronizationResult> Task => _tcs.Task;
 
         public RazorDocumentVersion RequestedVersion => _requestedVersion;
 
-        internal static SynchronizationRequest CreateAndStart(TextDocument document, RazorDocumentVersion requestedVersion, Func<TextDocument, CancellationToken, Task<bool>> syncFunction)
+        internal static SynchronizationRequest CreateAndStart(TextDocument document, RazorDocumentVersion requestedVersion, Func<TextDocument, RazorDocumentVersion, CancellationToken, Task<SynchronizationResult>> syncFunction)
         {
             var request = new SynchronizationRequest(requestedVersion);
             request.Start(document, syncFunction);
             return request;
         }
 
-        private void Start(TextDocument document, Func<TextDocument, CancellationToken, Task<bool>> syncFunction)
+        private void Start(TextDocument document, Func<TextDocument, RazorDocumentVersion, CancellationToken, Task<SynchronizationResult>> syncFunction)
         {
             _cts = new(TimeSpan.FromMinutes(1));
             _cts.Token.Register(Dispose);
-            _ = syncFunction.Invoke(document, _cts.Token).ContinueWith((t, state) =>
+            _ = syncFunction.Invoke(document, _requestedVersion, _cts.Token).ContinueWith((t, state) =>
             {
-                var tcs = (TaskCompletionSource<bool>)state.AssumeNotNull();
+                var tcs = (TaskCompletionSource<SynchronizationResult>)state.AssumeNotNull();
                 if (t.IsCanceled)
                 {
-                    tcs.SetResult(false);
+                    tcs.SetResult(default);
                 }
                 else if (t.Exception is { } ex)
                 {
@@ -58,7 +58,7 @@ public void Dispose()
             _cts?.Cancel();
             _cts?.Dispose();
             _cts = null;
-            _tcs.TrySetResult(false);
+            _tcs.TrySetResult(default);
         }
     }
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/HtmlDocumentSynchronizer.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/HtmlDocumentSynchronizer.cs
@@ -42,7 +42,7 @@ public void DocumentRemoved(Uri razorFileUri)
         }
     }
 
-    public async Task<bool> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken)
+    public async Task<SynchronizationResult> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken)
     {
         var requestedVersion = await RazorDocumentVersion.CreateAsync(document, cancellationToken).ConfigureAwait(false);
 
@@ -56,7 +56,7 @@ public async Task<bool> TrySynchronizeAsync(TextDocument document, CancellationT
         return await GetSynchronizationRequestTaskAsync(document, requestedVersion).ConfigureAwait(false);
     }
 
-    private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)
+    private Task<SynchronizationResult> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)
     {
         lock (_gate)
         {
@@ -71,7 +71,7 @@ private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, Raz
 
 #pragma warning disable VSTHRD103 // Use await instead of .Result
 #pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks
-                    if (request.Task.IsCompleted && request.Task.Result == false)
+                    if (request.Task.IsCompleted && request.Task.Result.Equals(default))
                     {
                         _logger.LogDebug($"Already finished that version for {document.FilePath}, but was unsuccessful, so will recompute");
                         request.Dispose();
@@ -92,7 +92,7 @@ private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, Raz
                     // for a different checksum, but the same workspace version, we assume the new request is the newer document.
 
                     _logger.LogDebug($"We've already seen {request.RequestedVersion} for {document.FilePath} so that's a no from me");
-                    return SpecializedTasks.False;
+                    return SpecializedTasks.Default<SynchronizationResult>();
                 }
                 else if (!request.Task.IsCompleted)
                 {
@@ -110,7 +110,7 @@ private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, Raz
         }
     }
 
-    private async Task<bool> PublishHtmlDocumentAsync(TextDocument document, CancellationToken cancellationToken)
+    private async Task<SynchronizationResult> PublishHtmlDocumentAsync(TextDocument document, RazorDocumentVersion requestedVersion, CancellationToken cancellationToken)
     {
         string? htmlText;
         try
@@ -122,30 +122,31 @@ private async Task<bool> PublishHtmlDocumentAsync(TextDocument document, Cancell
         catch (Exception ex)
         {
             _logger.LogError(ex, $"Error getting Html text for {document.FilePath}. Html document contents will be stale");
-            return false;
+            return default;
         }
 
         if (cancellationToken.IsCancellationRequested)
         {
             // Checking cancellation before logging, as a new request coming in doesn't count as "Couldn't get Html"
-            return false;
+            return default;
         }
 
         if (htmlText is null)
         {
             _logger.LogError($"Couldn't get Html text for {document.FilePath}. Html document contents will be stale");
-            return false;
+            return default;
         }
 
         try
         {
-            await _htmlDocumentPublisher.PublishAsync(document, htmlText, cancellationToken).ConfigureAwait(false);
-            return true;
+            var result = new SynchronizationResult(true, requestedVersion.Checksum);
+            await _htmlDocumentPublisher.PublishAsync(document, result, htmlText, cancellationToken).ConfigureAwait(false);
+            return result;
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, $"Error publishing Html text for {document.FilePath}. Html document contents will be stale");
-            return false;
+            return default;
         }
     }
 
@@ -163,7 +164,7 @@ internal TestAccessor(HtmlDocumentSynchronizer instance)
             _instance = instance;
         }
 
-        public Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)
+        public Task<SynchronizationResult> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)
             => _instance.GetSynchronizationRequestTaskAsync(document, requestedVersion);
     }
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/IHtmlDocumentPublisher.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/IHtmlDocumentPublisher.cs
@@ -9,5 +9,5 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
 internal interface IHtmlDocumentPublisher
 {
-    Task PublishAsync(TextDocument document, string htmlText, CancellationToken cancellationToken);
+    Task PublishAsync(TextDocument document, SynchronizationResult synchronizationResult, string htmlText, CancellationToken cancellationToken);
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/IHtmlDocumentSynchronizer.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/IHtmlDocumentSynchronizer.cs
@@ -11,5 +11,5 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 internal interface IHtmlDocumentSynchronizer
 {
     void DocumentRemoved(Uri uri);
-    Task<bool> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken);
+    Task<SynchronizationResult> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken);
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/SynchronizationResult.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/HtmlDocumentServices/SynchronizationResult.cs
@@ -0,0 +1,14 @@
+﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.ExternalAccess.Razor;
+
+namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
+
+/// <summary>
+/// A result of a synchronization operation for a Html document
+/// </summary>
+/// <remarks>
+/// If <see cref="Synchronized" /> is <see langword="false" />, <see cref="Checksum" /> will be <see langword="default" />.
+/// </remarks>
+internal readonly record struct SynchronizationResult(bool Synchronized, ChecksumWrapper Checksum);
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Microsoft.CodeAnalysis.Razor.CohostingShared.projitems b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Microsoft.CodeAnalysis.Razor.CohostingShared.projitems
@@ -24,6 +24,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)DocumentSymbol\CohostDocumentSymbolEndpoint.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\CohostDocumentFormattingEndpoint.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)FindAllReferences\CohostFindAllReferencesEndpoint.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HtmlDocumentServices\SynchronizationResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Navigation\CohostGoToDefinitionEndpoint.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Navigation\CohostGoToImplementationEndpoint.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)LinkedEditingRange\CohostLinkedEditingRangeEndpoint.cs" />
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/HtmlDocumentPublisher.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/HtmlDocumentPublisher.cs
@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor;
 using Microsoft.CodeAnalysis.Razor.Logging;
@@ -25,11 +26,9 @@ internal sealed class HtmlDocumentPublisher(
     private readonly TrackingLSPDocumentManager _documentManager = documentManager as TrackingLSPDocumentManager ?? throw new InvalidOperationException("Expected TrackingLSPDocumentManager");
     private readonly ILogger _logger = loggerFactory.GetOrCreateLogger<HtmlDocumentPublisher>();
 
-    public async Task PublishAsync(TextDocument document, string htmlText, CancellationToken cancellationToken)
+    public async Task PublishAsync(TextDocument document, SynchronizationResult synchronizationResult, string htmlText, CancellationToken cancellationToken)
     {
-        // TODO: Eventually, for VS Code, the following piece of logic needs to make an LSP call rather than directly update the
-        // buffer, but the assembly this code currently lives in doesn't ship in VS Code, so we need to solve a few other things
-        // before we get there.
+        Assumed.True(synchronizationResult.Synchronized);
 
         var uri = document.CreateUri();
         if (!_documentManager.TryGetDocument(uri, out var documentSnapshot) ||
@@ -55,7 +54,7 @@ public async Task PublishAsync(TextDocument document, string htmlText, Cancellat
         }
 
         VisualStudioTextChange[] changes = [new(0, htmlDocument.Snapshot.Length, htmlText)];
-        _documentManager.UpdateVirtualDocument<HtmlVirtualDocument>(uri, changes, documentSnapshot.Version, state: null);
+        _documentManager.UpdateVirtualDocument<HtmlVirtualDocument>(uri, changes, documentSnapshot.Version, state: synchronizationResult.Checksum);
 
         _logger.LogDebug($"Finished Html document generation for {document.FilePath} (into {uri})");
     }
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/HtmlRequestInvoker.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/HtmlRequestInvoker.cs
@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor;
 using Microsoft.CodeAnalysis.Razor.Logging;
@@ -32,7 +33,7 @@ internal sealed class HtmlRequestInvoker(
     public async Task<TResponse?> MakeHtmlLspRequestAsync<TRequest, TResponse>(TextDocument razorDocument, string method, TRequest request, TimeSpan threshold, Guid correlationId, CancellationToken cancellationToken) where TRequest : notnull
     {
         var syncResult = await _htmlDocumentSynchronizer.TrySynchronizeAsync(razorDocument, cancellationToken).ConfigureAwait(false);
-        if (!syncResult)
+        if (!syncResult.Synchronized)
         {
             _logger.LogDebug($"Couldn't synchronize for {razorDocument.FilePath}");
             return default;
@@ -50,6 +51,13 @@ internal sealed class HtmlRequestInvoker(
             return default;
         }
 
+        var existingChecksum = (ChecksumWrapper)htmlDocument.State.AssumeNotNull();
+        if (!existingChecksum.Equals(syncResult.Checksum))
+        {
+            _logger.LogError($"Checksum for {snapshot.Uri}, {htmlDocument.State} doesn't match {syncResult.Checksum}.");
+            return default;
+        }
+
         // If the request is for a text document, we need to update the Uri to point to the Html document,
         // and most importantly set it back again before leaving the method in case a caller uses it.
         Uri? originalUri = null;
@@ -62,8 +70,7 @@ internal sealed class HtmlRequestInvoker(
 
         try
         {
-
-            _logger.LogDebug($"Making LSP request for {method} from {htmlDocument.Uri}{(request is ITextDocumentPositionParams positionParams ? $" at {positionParams.Position}" : "")}.");
+            _logger.LogDebug($"Making LSP request for {method} from {htmlDocument.Uri}{(request is ITextDocumentPositionParams positionParams ? $" at {positionParams.Position}" : "")}, checksum {syncResult.Checksum}.");
 
             // Passing Guid.Empty to this method will mean no tracking
             using var _ = _telemetryReporter.TrackLspRequest(Methods.TextDocumentCodeActionName, RazorLSPConstants.HtmlLanguageServerName, threshold, correlationId);
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/HtmlVirtualDocument.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/HtmlVirtualDocument.cs
@@ -10,5 +10,5 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient;
 internal class HtmlVirtualDocument(Uri uri, ITextBuffer textBuffer, ITelemetryReporter telemetryReporter)
     : GeneratedVirtualDocument<HtmlVirtualDocumentSnapshot>(uri, textBuffer, telemetryReporter)
 {
-    protected override HtmlVirtualDocumentSnapshot GetUpdatedSnapshot(object? state) => new(Uri, TextBuffer.CurrentSnapshot, HostDocumentVersion);
+    protected override HtmlVirtualDocumentSnapshot GetUpdatedSnapshot(object? state) => new(Uri, TextBuffer.CurrentSnapshot, HostDocumentVersion, state);
 }
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/HtmlVirtualDocumentSnapshot.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/HtmlVirtualDocumentSnapshot.cs
@@ -12,7 +12,8 @@ internal class HtmlVirtualDocumentSnapshot : VirtualDocumentSnapshot
     public HtmlVirtualDocumentSnapshot(
         Uri uri,
         ITextSnapshot snapshot,
-        long? hostDocumentSyncVersion)
+        long? hostDocumentSyncVersion,
+        object? state)
     {
         if (uri is null)
         {
@@ -27,11 +28,14 @@ public HtmlVirtualDocumentSnapshot(
         Uri = uri;
         Snapshot = snapshot;
         HostDocumentSyncVersion = hostDocumentSyncVersion;
+        State = state;
     }
 
     public override Uri Uri { get; }
 
     public override ITextSnapshot Snapshot { get; }
 
     public override long? HostDocumentSyncVersion { get; }
+
+    public object? State { get; }
 }
diff --git a/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Endpoints/RazorDocumentClosedEndpoint.cs b/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Endpoints/RazorDocumentClosedEndpoint.cs
@@ -0,0 +1,35 @@
+﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor;
+using Microsoft.AspNetCore.Razor.Threading;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+using Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
+
+namespace Microsoft.VisualStudioCode.RazorExtension.Endpoints;
+
+[Shared]
+[ExportRazorStatelessLspService(typeof(RazorDocumentClosedEndpoint))]
+[RazorEndpoint("razor/documentClosed")]
+[method: ImportingConstructor]
+internal class RazorDocumentClosedEndpoint(IHtmlDocumentSynchronizer htmlDocumentSynchronizer) : AbstractRazorCohostDocumentRequestHandler<TextDocumentIdentifier, VoidResult>
+{
+    private readonly IHtmlDocumentSynchronizer _htmlDocumentSynchronizer = htmlDocumentSynchronizer;
+
+    protected override bool MutatesSolutionState => false;
+
+    protected override bool RequiresLSPSolution => true;
+
+    protected override RazorTextDocumentIdentifier? GetRazorTextDocumentIdentifier(TextDocumentIdentifier request)
+        => request.ToRazorTextDocumentIdentifier();
+
+    protected override Task<VoidResult> HandleRequestAsync(TextDocumentIdentifier textDocument, RazorCohostRequestContext requestContext, CancellationToken cancellationToken)
+    {
+        _htmlDocumentSynchronizer.DocumentRemoved(requestContext.Uri.AssumeNotNull());
+        return SpecializedTasks.Default<VoidResult>();
+    }
+}
diff --git a/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/HtmlDocumentPublisher.cs b/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/HtmlDocumentPublisher.cs
@@ -20,9 +20,11 @@ internal sealed class HtmlDocumentPublisher(
 {
     private readonly RazorClientServerManagerProvider _razorClientServerManagerProvider = razorClientServerManagerProvider;
 
-    public async Task PublishAsync(TextDocument document, string htmlText, CancellationToken cancellationToken)
+    public async Task PublishAsync(TextDocument document, SynchronizationResult synchronizationResult, string htmlText, CancellationToken cancellationToken)
     {
-        var request = new HtmlUpdateParameters(new TextDocumentIdentifier { Uri = document.CreateUri() }, htmlText);
+        Assumed.True(synchronizationResult.Synchronized);
+
+        var request = new HtmlUpdateParameters(new TextDocumentIdentifier { Uri = document.CreateUri() }, synchronizationResult.Checksum.ToString(), htmlText);
 
         var clientConnection = _razorClientServerManagerProvider.ClientLanguageServerManager.AssumeNotNull();
         await clientConnection.SendRequestAsync("razor/updateHtml", request, cancellationToken).ConfigureAwait(false);
@@ -31,6 +33,8 @@ public async Task PublishAsync(TextDocument document, string htmlText, Cancellat
     private record HtmlUpdateParameters(
         [property: JsonPropertyName("textDocument")]
         TextDocumentIdentifier TextDocument,
+        [property: JsonPropertyName("checksum")]
+        string Checksum,
         [property: JsonPropertyName("text")]
         string Text);
 }
diff --git a/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/HtmlRequestInvoker.cs b/src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/HtmlRequestInvoker.cs
@@ -3,11 +3,13 @@
 
 using System;
 using System.ComponentModel.Composition;
+using System.Text.Json.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.LanguageServer;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor;
 using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
@@ -27,14 +29,31 @@ internal sealed class HtmlRequestInvoker(
     public async Task<TResponse?> MakeHtmlLspRequestAsync<TRequest, TResponse>(TextDocument razorDocument, string method, TRequest request, TimeSpan threshold, Guid correlationId, CancellationToken cancellationToken) where TRequest : notnull
     {
         var syncResult = await _htmlDocumentSynchronizer.TrySynchronizeAsync(razorDocument, cancellationToken).ConfigureAwait(false);
-        if (!syncResult)
+        if (!syncResult.Synchronized)
         {
             return default;
         }
 
-        _logger.LogDebug($"Making Html request for {method} on {razorDocument.FilePath}");
+        var checksumString = syncResult.Checksum.ToString();
+        _logger.LogDebug($"Making Html request for {method} on {razorDocument.FilePath}, checksum {checksumString}");
+
+        var forwardedRequest = new HtmlForwardedRequest<TRequest>(
+            new TextDocumentIdentifier
+            {
+                Uri = razorDocument.CreateUri()
+            },
+            checksumString,
+            request);
 
         var clientConnection = _razorClientServerManagerProvider.ClientLanguageServerManager.AssumeNotNull();
-        return await clientConnection.SendRequestAsync<TRequest, TResponse>(method, request, cancellationToken).ConfigureAwait(false);
+        return await clientConnection.SendRequestAsync<HtmlForwardedRequest<TRequest>, TResponse>(method, forwardedRequest, cancellationToken).ConfigureAwait(false);
     }
+
+    private record HtmlForwardedRequest<TRequest>(
+        [property: JsonPropertyName("textDocument")]
+        TextDocumentIdentifier TextDocument,
+        [property: JsonPropertyName("checksum")]
+        string Checksum,
+        [property: JsonPropertyName("request")]
+        TRequest Request);
 }
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/HtmlDocumentSynchronizerTest.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/HtmlDocumentSynchronizerTest.cs

Original file line number	Diff line number	Diff line change
`@@ -14,30 +14,30 @@ internal sealed partial class HtmlDocumentSynchronizer`
`14`	`14`	`private class SynchronizationRequest(RazorDocumentVersion requestedVersion) : IDisposable`
`15`	`15`	`{`
`16`	`16`	`private readonly RazorDocumentVersion _requestedVersion = requestedVersion;`
`17`		`- private readonly TaskCompletionSource<bool> _tcs = new();`
	`17`	`+ private readonly TaskCompletionSource<SynchronizationResult> _tcs = new();`
`18`	`18`	`private CancellationTokenSource? _cts;`
`19`	`19`
`20`		`- public Task<bool> Task => _tcs.Task;`
	`20`	`+ public Task<SynchronizationResult> Task => _tcs.Task;`
`21`	`21`
`22`	`22`	`public RazorDocumentVersion RequestedVersion => _requestedVersion;`
`23`	`23`
`24`		`- internal static SynchronizationRequest CreateAndStart(TextDocument document, RazorDocumentVersion requestedVersion, Func<TextDocument, CancellationToken, Task<bool>> syncFunction)`
	`24`	`+ internal static SynchronizationRequest CreateAndStart(TextDocument document, RazorDocumentVersion requestedVersion, Func<TextDocument, RazorDocumentVersion, CancellationToken, Task<SynchronizationResult>> syncFunction)`
`25`	`25`	`{`
`26`	`26`	`var request = new SynchronizationRequest(requestedVersion);`
`27`	`27`	`request.Start(document, syncFunction);`
`28`	`28`	`return request;`
`29`	`29`	`}`
`30`	`30`
`31`		`- private void Start(TextDocument document, Func<TextDocument, CancellationToken, Task<bool>> syncFunction)`
	`31`	`+ private void Start(TextDocument document, Func<TextDocument, RazorDocumentVersion, CancellationToken, Task<SynchronizationResult>> syncFunction)`
`32`	`32`	`{`
`33`	`33`	`_cts = new(TimeSpan.FromMinutes(1));`
`34`	`34`	`_cts.Token.Register(Dispose);`
`35`		`- _ = syncFunction.Invoke(document, _cts.Token).ContinueWith((t, state) =>`
	`35`	`+ _ = syncFunction.Invoke(document, _requestedVersion, _cts.Token).ContinueWith((t, state) =>`
`36`	`36`	`{`
`37`		`- var tcs = (TaskCompletionSource<bool>)state.AssumeNotNull();`
	`37`	`+ var tcs = (TaskCompletionSource<SynchronizationResult>)state.AssumeNotNull();`
`38`	`38`	`if (t.IsCanceled)`
`39`	`39`	`{`
`40`		`- tcs.SetResult(false);`
	`40`	`+ tcs.SetResult(default);`
`41`	`41`	`}`
`42`	`42`	`else if (t.Exception is { } ex)`
`43`	`43`	`{`
`@@ -58,7 +58,7 @@ public void Dispose()`
`58`	`58`	`_cts?.Cancel();`
`59`	`59`	`_cts?.Dispose();`
`60`	`60`	`_cts = null;`
`61`		`- _tcs.TrySetResult(false);`
	`61`	`+ _tcs.TrySetResult(default);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public void DocumentRemoved(Uri razorFileUri)`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`		`- public async Task<bool> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken)`
	`45`	`+ public async Task<SynchronizationResult> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken)`
`46`	`46`	`{`
`47`	`47`	`var requestedVersion = await RazorDocumentVersion.CreateAsync(document, cancellationToken).ConfigureAwait(false);`
`48`	`48`
`@@ -56,7 +56,7 @@ public async Task<bool> TrySynchronizeAsync(TextDocument document, CancellationT`
`56`	`56`	`return await GetSynchronizationRequestTaskAsync(document, requestedVersion).ConfigureAwait(false);`
`57`	`57`	`}`
`58`	`58`
`59`		`- private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)`
	`59`	`+ private Task<SynchronizationResult> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)`
`60`	`60`	`{`
`61`	`61`	`lock (_gate)`
`62`	`62`	`{`
`@@ -71,7 +71,7 @@ private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, Raz`
`71`	`71`
`72`	`72`	`#pragma warning disable VSTHRD103 // Use await instead of .Result`
`73`	`73`	`#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks`
`74`		`- if (request.Task.IsCompleted && request.Task.Result == false)`
	`74`	`+ if (request.Task.IsCompleted && request.Task.Result.Equals(default))`
`75`	`75`	`{`
`76`	`76`	`_logger.LogDebug($"Already finished that version for {document.FilePath}, but was unsuccessful, so will recompute");`
`77`	`77`	`request.Dispose();`
`@@ -92,7 +92,7 @@ private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, Raz`
`92`	`92`	`// for a different checksum, but the same workspace version, we assume the new request is the newer document.`
`93`	`93`
`94`	`94`	`_logger.LogDebug($"We've already seen {request.RequestedVersion} for {document.FilePath} so that's a no from me");`
`95`		`- return SpecializedTasks.False;`
	`95`	`+ return SpecializedTasks.Default<SynchronizationResult>();`
`96`	`96`	`}`
`97`	`97`	`else if (!request.Task.IsCompleted)`
`98`	`98`	`{`
`@@ -110,7 +110,7 @@ private Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, Raz`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`- private async Task<bool> PublishHtmlDocumentAsync(TextDocument document, CancellationToken cancellationToken)`
	`113`	`+ private async Task<SynchronizationResult> PublishHtmlDocumentAsync(TextDocument document, RazorDocumentVersion requestedVersion, CancellationToken cancellationToken)`
`114`	`114`	`{`
`115`	`115`	`string? htmlText;`
`116`	`116`	`try`
`@@ -122,30 +122,31 @@ private async Task<bool> PublishHtmlDocumentAsync(TextDocument document, Cancell`
`122`	`122`	`catch (Exception ex)`
`123`	`123`	`{`
`124`	`124`	`_logger.LogError(ex, $"Error getting Html text for {document.FilePath}. Html document contents will be stale");`
`125`		`- return false;`
	`125`	`+ return default;`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`if (cancellationToken.IsCancellationRequested)`
`129`	`129`	`{`
`130`	`130`	`// Checking cancellation before logging, as a new request coming in doesn't count as "Couldn't get Html"`
`131`		`- return false;`
	`131`	`+ return default;`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`if (htmlText is null)`
`135`	`135`	`{`
`136`	`136`	`_logger.LogError($"Couldn't get Html text for {document.FilePath}. Html document contents will be stale");`
`137`		`- return false;`
	`137`	`+ return default;`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`try`
`141`	`141`	`{`
`142`		`- await _htmlDocumentPublisher.PublishAsync(document, htmlText, cancellationToken).ConfigureAwait(false);`
`143`		`- return true;`
	`142`	`+ var result = new SynchronizationResult(true, requestedVersion.Checksum);`
	`143`	`+ await _htmlDocumentPublisher.PublishAsync(document, result, htmlText, cancellationToken).ConfigureAwait(false);`
	`144`	`+ return result;`
`144`	`145`	`}`
`145`	`146`	`catch (Exception ex)`
`146`	`147`	`{`
`147`	`148`	`_logger.LogError(ex, $"Error publishing Html text for {document.FilePath}. Html document contents will be stale");`
`148`		`- return false;`
	`149`	`+ return default;`
`149`	`150`	`}`
`150`	`151`	`}`
`151`	`152`
`@@ -163,7 +164,7 @@ internal TestAccessor(HtmlDocumentSynchronizer instance)`
`163`	`164`	`_instance = instance;`
`164`	`165`	`}`
`165`	`166`
`166`		`- public Task<bool> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)`
	`167`	`+ public Task<SynchronizationResult> GetSynchronizationRequestTaskAsync(TextDocument document, RazorDocumentVersion requestedVersion)`
`167`	`168`	`=> _instance.GetSynchronizationRequestTaskAsync(document, requestedVersion);`
`168`	`169`	`}`
`169`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;`
`9`	`9`
`10`	`10`	`internal interface IHtmlDocumentPublisher`
`11`	`11`	`{`
`12`		`- Task PublishAsync(TextDocument document, string htmlText, CancellationToken cancellationToken);`
	`12`	`+ Task PublishAsync(TextDocument document, SynchronizationResult synchronizationResult, string htmlText, CancellationToken cancellationToken);`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,5 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;`
`11`	`11`	`internal interface IHtmlDocumentSynchronizer`
`12`	`12`	`{`
`13`	`13`	`void DocumentRemoved(Uri uri);`
`14`		`- Task<bool> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken);`
	`14`	`+ Task<SynchronizationResult> TrySynchronizeAsync(TextDocument document, CancellationToken cancellationToken);`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,5 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient;`
`10`	`10`	`internal class HtmlVirtualDocument(Uri uri, ITextBuffer textBuffer, ITelemetryReporter telemetryReporter)`
`11`	`11`	`: GeneratedVirtualDocument<HtmlVirtualDocumentSnapshot>(uri, textBuffer, telemetryReporter)`
`12`	`12`	`{`
`13`		`- protected override HtmlVirtualDocumentSnapshot GetUpdatedSnapshot(object? state) => new(Uri, TextBuffer.CurrentSnapshot, HostDocumentVersion);`
	`13`	`+ protected override HtmlVirtualDocumentSnapshot GetUpdatedSnapshot(object? state) => new(Uri, TextBuffer.CurrentSnapshot, HostDocumentVersion, state);`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,8 @@ internal class HtmlVirtualDocumentSnapshot : VirtualDocumentSnapshot`
`12`	`12`	`public HtmlVirtualDocumentSnapshot(`
`13`	`13`	`Uri uri,`
`14`	`14`	`ITextSnapshot snapshot,`
`15`		`- long? hostDocumentSyncVersion)`
	`15`	`+ long? hostDocumentSyncVersion,`
	`16`	`+ object? state)`
`16`	`17`	`{`
`17`	`18`	`if (uri is null)`
`18`	`19`	`{`
`@@ -27,11 +28,14 @@ public HtmlVirtualDocumentSnapshot(`
`27`	`28`	`Uri = uri;`
`28`	`29`	`Snapshot = snapshot;`
`29`	`30`	`HostDocumentSyncVersion = hostDocumentSyncVersion;`
	`31`	`+ State = state;`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`public override Uri Uri { get; }`
`33`	`35`
`34`	`36`	`public override ITextSnapshot Snapshot { get; }`
`35`	`37`
`36`	`38`	`public override long? HostDocumentSyncVersion { get; }`
	`39`	`+`
	`40`	`+ public object? State { get; }`
`37`	`41`	`}`