Ensure taggers that compute frozen partial data eventually move to a 'correct' final state.

src/EditorFeatures/CSharpTest/Interactive/BraceMatching/InteractiveBraceHighlightingTests.cs

@@ -45,7 +45,9 @@ private static async Task<IEnumerable<ITagSpan<BraceHighlightTag>>> ProduceTagsA
 
             var context = new TaggerContext<BraceHighlightTag>(
                 buffer.CurrentSnapshot.GetRelatedDocumentsWithChanges().FirstOrDefault(),
-                buffer.CurrentSnapshot, new SnapshotPoint(buffer.CurrentSnapshot, position));
+                buffer.CurrentSnapshot,
+                frozenPartialSemantics: false,
+                new SnapshotPoint(buffer.CurrentSnapshot, position));
             await producer.GetTestAccessor().ProduceTagsAsync(context);
 
             return context.TagSpans;

src/EditorFeatures/Core/Classification/Semantic/AbstractSemanticOrEmbeddedClassificationViewTaggerProvider.cs

@@ -53,6 +53,12 @@ protected AbstractSemanticOrEmbeddedClassificationViewTaggerProvider(
 
     protected sealed override TaggerDelay EventChangeDelay => TaggerDelay.Short;
 
+    /// <summary>
+    /// We support frozen partial semantics, so we can quickly get classification items without building SG docs. We
+    /// will still run a tagging pass after the frozen-pass where we run again on non-frozen docs.
+    /// </summary>
+    protected sealed override bool SupportsFrozenPartialSemantics => true;
+
     protected sealed override ITaggerEventSource CreateEventSource(ITextView textView, ITextBuffer subjectBuffer)
     {
         this.ThreadingContext.ThrowIfNotOnUIThread();
@@ -92,7 +98,19 @@ protected sealed override Task ProduceTagsAsync(
         if (isLspSemanticTokensEnabled)
             return Task.CompletedTask;
 
-        var classificationOptions = _globalOptions.GetClassificationOptions(document.Project.Language);
+        // Don't block getting classifications on building the full compilation.  This may take a significant amount
+        // of time and can cause a very latency sensitive operation (copying) to block the user while we wait on this
+        // work to happen.  
+        //
+        // It's also a better experience to get classifications to the user faster versus waiting a potentially large
+        // amount of time waiting for all the compilation information to be built.  For example, we can classify types
+        // that we've parsed in other files, or partially loaded from metadata, even if we're still parsing/loading.
+        // For cross language projects, this also produces semantic classifications more quickly as we do not have to
+        // wait on skeletons to be built.
+        var classificationOptions = _globalOptions.GetClassificationOptions(document.Project.Language) with
+        {
+            FrozenPartialSemantics = context.FrozenPartialSemantics,
+        };
         return ClassificationUtilities.ProduceTagsAsync(
             context, spanToTag, classificationService, _typeMap, classificationOptions, _type, cancellationToken);
     }

src/EditorFeatures/Core/Classification/Semantic/ClassificationUtilities.cs

@@ -49,19 +49,6 @@ public static async Task ProduceTagsAsync(
         if (document == null)
             return;
 
-        // Don't block getting classifications on building the full compilation.  This may take a significant amount
-        // of time and can cause a very latency sensitive operation (copying) to block the user while we wait on this
-        // work to happen.  
-        //
-        // It's also a better experience to get classifications to the user faster versus waiting a potentially
-        // large amount of time waiting for all the compilation information to be built.  For example, we can
-        // classify types that we've parsed in other files, or partially loaded from metadata, even if we're still
-        // parsing/loading.  For cross language projects, this also produces semantic classifications more quickly
-        // as we do not have to wait on skeletons to be built.
-
-        document = document.WithFrozenPartialSemantics(cancellationToken);
-        options = options with { ForceFrozenPartialSemanticsForCrossProcessOperations = true };
-
         var classified = await TryClassifyContainingMemberSpanAsync(
                 context, document, spanToTag.SnapshotSpan, classificationService, typeMap, options, type, cancellationToken).ConfigureAwait(false);
         if (classified)

src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs

@@ -57,6 +57,12 @@ internal sealed partial class ReferenceHighlightingViewTaggerProvider(
 
     protected override TaggerDelay EventChangeDelay => TaggerDelay.Medium;
 
+    /// <summary>
+    /// We support frozen partial semantics, so we can quickly get reference highlights without building SG docs.  We
+    /// will still run a tagging pass after the frozen-pass where we run again on non-frozen docs.
+    /// </summary>
+    protected override bool SupportsFrozenPartialSemantics => true;
+
     protected override ITaggerEventSource CreateEventSource(ITextView textView, ITextBuffer subjectBuffer)
     {
         // Note: we don't listen for OnTextChanged.  Text changes to this buffer will get
@@ -129,7 +135,10 @@ protected override Task ProduceTagsAsync(
         }
 
         // Otherwise, we need to go produce all tags.
-        var options = _globalOptions.GetHighlightingOptions(document.Project.Language);
+        var options = _globalOptions.GetHighlightingOptions(document.Project.Language) with
+        {
+            FrozenPartialSemantics = context.FrozenPartialSemantics,
+        };
         return ProduceTagsAsync(context, caretPosition, document, options, cancellationToken);
     }
 

src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource.cs

@@ -79,7 +79,7 @@ private sealed partial class TagSource
         /// up event change notifications and only dispatch one recomputation every <see cref="EventChangeDelay"/>
         /// to actually produce the latest set of tags.
         /// </summary>
-        private readonly AsyncBatchingWorkQueue<bool, VoidResult> _eventChangeQueue;
+        private readonly AsyncBatchingWorkQueue<(bool highPriority, bool frozenPartialSemantics)> _eventChangeQueue;
 
         #endregion
 
@@ -164,10 +164,10 @@ public TagSource(
             //
             // PERF: Use AsyncBatchingWorkQueue<bool, VoidResult> instead of AsyncBatchingWorkQueue<bool> because
             // the latter has an async state machine that rethrows a very common cancellation exception.
-            _eventChangeQueue = new AsyncBatchingWorkQueue<bool, VoidResult>(
+            _eventChangeQueue = new AsyncBatchingWorkQueue<(bool highPriority, bool frozenPartialSemantics)>(
                 dataSource.EventChangeDelay.ComputeTimeDelay(),
                 ProcessEventChangeAsync,
-                EqualityComparer<bool>.Default,
+                EqualityComparer<(bool highPriority, bool frozenPartialSemantics)>.Default,
                 asyncListener,
                 _disposalTokenSource.Token);
 

src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs

@@ -168,13 +168,17 @@ private void OnEventSourceChanged(object? _1, TaggerEventArgs _2)
             => EnqueueWork(highPriority: false);
 
         private void EnqueueWork(bool highPriority)
-            => _eventChangeQueue.AddWork(highPriority, _dataSource.CancelOnNewWork);
+            => EnqueueWork(highPriority, _dataSource.SupportsFrozenPartialSemantics);
 
-        private ValueTask<VoidResult> ProcessEventChangeAsync(ImmutableSegmentedList<bool> changes, CancellationToken cancellationToken)
+        private void EnqueueWork(bool highPriority, bool frozenPartialSemantics)
+            => _eventChangeQueue.AddWork((highPriority, frozenPartialSemantics), _dataSource.CancelOnNewWork);
+
+        private async ValueTask ProcessEventChangeAsync(ImmutableSegmentedList<(bool highPriority, bool frozenPartialSemantics)> changes, CancellationToken cancellationToken)
         {
             // If any of the requests was high priority, then compute at that speed.
-            var highPriority = changes.Contains(true);
-            return new ValueTask<VoidResult>(RecomputeTagsAsync(highPriority, cancellationToken));
+            var highPriority = changes.Contains(x => x.highPriority);
+            var frozenPartialSemantics = changes.Contains(t => t.frozenPartialSemantics);
+            await RecomputeTagsAsync(highPriority, frozenPartialSemantics, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -191,11 +195,14 @@ private ValueTask<VoidResult> ProcessEventChangeAsync(ImmutableSegmentedList<boo
         /// <param name="highPriority">
         /// If this tagging request should be processed as quickly as possible with no extra delays added for it.
         /// </param>
-        private async Task<VoidResult> RecomputeTagsAsync(bool highPriority, CancellationToken cancellationToken)
+        private async Task RecomputeTagsAsync(
+            bool highPriority,
+            bool frozenPartialSemantics,
+            CancellationToken cancellationToken)
         {
             await _dataSource.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken).NoThrowAwaitable();
             if (cancellationToken.IsCancellationRequested)
-                return default;
+                return;
 
             // if we're tagging documents that are not visible, then introduce a long delay so that we avoid
             // consuming machine resources on work the user isn't likely to see.  ConfigureAwait(true) so that if
@@ -211,12 +218,12 @@ await _visibilityTracker.DelayWhileNonVisibleAsync(
                     _dataSource.ThreadingContext, _dataSource.AsyncListener, _subjectBuffer, DelayTimeSpan.NonFocus, cancellationToken).NoThrowAwaitable(captureContext: true);
 
                 if (cancellationToken.IsCancellationRequested)
-                    return default;
+                    return;
             }
 
             _dataSource.ThreadingContext.ThrowIfNotOnUIThread();
             if (cancellationToken.IsCancellationRequested)
-                return default;
+                return;
 
             using (Logger.LogBlock(FunctionId.Tagger_TagSource_RecomputeTags, cancellationToken))
             {
@@ -234,15 +241,22 @@ await _visibilityTracker.DelayWhileNonVisibleAsync(
                 await TaskScheduler.Default;
 
                 if (cancellationToken.IsCancellationRequested)
-                    return default;
+                    return;
+
+                if (frozenPartialSemantics)
+                {
+                    spansToTag = spansToTag.SelectAsArray(ds => new DocumentSnapshotSpan(
+                        ds.Document?.WithFrozenPartialSemantics(cancellationToken),
+                        ds.SnapshotSpan));
+                }
 
                 // Create a context to store pass the information along and collect the results.
                 var context = new TaggerContext<TTag>(
-                    oldState, spansToTag, caretPosition, textChangeRange, oldTagTrees);
+                    oldState, frozenPartialSemantics, spansToTag, caretPosition, textChangeRange, oldTagTrees);
                 await ProduceTagsAsync(context, cancellationToken).ConfigureAwait(false);
 
                 if (cancellationToken.IsCancellationRequested)
-                    return default;
+                    return;
 
                 // Process the result to determine what changed.
                 var newTagTrees = ComputeNewTagTrees(oldTagTrees, context);
@@ -251,7 +265,7 @@ await _visibilityTracker.DelayWhileNonVisibleAsync(
                 // Then switch back to the UI thread to update our state and kick off the work to notify the editor.
                 await _dataSource.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken).NoThrowAwaitable();
                 if (cancellationToken.IsCancellationRequested)
-                    return default;
+                    return;
 
                 // Once we assign our state, we're uncancellable.  We must report the changed information
                 // to the editor.  The only case where it's ok not to is if the tagger itself is disposed.
@@ -275,9 +289,14 @@ await _visibilityTracker.DelayWhileNonVisibleAsync(
                 // Once we've computed tags, pause ourselves if we're no longer visible.  That way we don't consume any
                 // machine resources that the user won't even notice.
                 PauseIfNotVisible();
-            }
 
-            return default;
+                // If we were computing with frozen partial semantics here, enqueue work to compute *without* frozen
+                // partial snapshots so we move to accurate results shortly. Note: when the queue goes to process this
+                // message, if it sees any other events asking for frozen-partial-semantics, it will process in that
+                // mode again, kicking the can down the road to finally end with non-frozen-partial computation
+                if (frozenPartialSemantics)
+                    this.EnqueueWork(highPriority, frozenPartialSemantics: false);
+            }
         }
 
         private ImmutableArray<DocumentSnapshotSpan> GetSpansAndDocumentsToTag()
@@ -560,8 +579,8 @@ private DiffResult ComputeDifference(
                 !this.CachedTagTrees.TryGetValue(buffer, out _))
             {
                 // Compute this as a high priority work item to have the lease amount of blocking as possible.
-                _dataSource.ThreadingContext.JoinableTaskFactory.Run(() =>
-                    this.RecomputeTagsAsync(highPriority: true, _disposalTokenSource.Token));
+                _dataSource.ThreadingContext.JoinableTaskFactory.Run(async () =>
+                    await this.RecomputeTagsAsync(highPriority: true, _dataSource.SupportsFrozenPartialSemantics, _disposalTokenSource.Token).ConfigureAwait(false));
             }
 
             _firstTagsRequest = false;

src/EditorFeatures/Core/Tagging/AbstractAsynchronousTaggerProvider.cs

@@ -95,6 +95,11 @@ internal abstract partial class AbstractAsynchronousTaggerProvider<TTag> where T
     /// </summary>
     protected virtual bool CancelOnNewWork { get; }
 
+    /// <summary>
+    /// Whether or not this tagger would like to use frozen-partial snapshots to compute tags. TODO: doc more before submitting.
+    /// </summary>
+    protected virtual bool SupportsFrozenPartialSemantics { get; }
+
     protected virtual void BeforeTagsChanged(ITextSnapshot snapshot)
     {
     }

src/EditorFeatures/Core/Tagging/AsynchronousViewportTaggerProvider.SingleViewportTaggerProvider.cs

@@ -47,6 +47,9 @@ protected override TaggerTextChangeBehavior TextChangeBehavior
         protected override SpanTrackingMode SpanTrackingMode
             => _callback.SpanTrackingMode;
 
+        protected override bool SupportsFrozenPartialSemantics
+            => _callback.SupportsFrozenPartialSemantics;
+
         protected override ITaggerEventSource CreateEventSource(ITextView textView, ITextBuffer subjectBuffer)
             => _callback.CreateEventSource(textView, subjectBuffer);
 

src/EditorFeatures/Core/Tagging/AsynchronousViewportTaggerProvider.cs

@@ -103,6 +103,9 @@ SingleViewportTaggerProvider CreateSingleViewportTaggerProvider(ViewPortToTag vi
     /// <inheritdoc cref="AbstractAsynchronousTaggerProvider{TTag}.SpanTrackingMode"/>
     protected virtual SpanTrackingMode SpanTrackingMode => SpanTrackingMode.EdgeExclusive;
 
+    /// <inheritdoc cref="AbstractAsynchronousTaggerProvider{TTag}.SupportsFrozenPartialSemantics"/>
+    protected virtual bool SupportsFrozenPartialSemantics { get; }
+
     /// <summary>
     /// Indicates whether a tagger should be created for this text view and buffer.
     /// </summary>

src/EditorFeatures/Core/Tagging/TaggerContext.cs

@@ -4,18 +4,14 @@
 
 #nullable disable
 
-using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Tagging;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Tagging;
 
@@ -26,6 +22,7 @@ internal class TaggerContext<TTag> where TTag : ITag
     internal ImmutableArray<SnapshotSpan> _spansTagged;
     public readonly SegmentedList<ITagSpan<TTag>> TagSpans = [];
 
+    public bool FrozenPartialSemantics { get; }
     public ImmutableArray<DocumentSnapshotSpan> SpansToTag { get; }
     public SnapshotPoint? CaretPosition { get; }
 
@@ -48,22 +45,31 @@ internal class TaggerContext<TTag> where TTag : ITag
 
     // For testing only.
     internal TaggerContext(
-        Document document, ITextSnapshot snapshot,
+        Document document,
+        ITextSnapshot snapshot,
+        bool frozenPartialSemantics,
         SnapshotPoint? caretPosition = null,
         TextChangeRange? textChangeRange = null)
-        : this(state: null, [new DocumentSnapshotSpan(document, snapshot.GetFullSpan())],
-               caretPosition, textChangeRange, existingTags: null)
+        : this(
+              state: null,
+              frozenPartialSemantics,
+              [new DocumentSnapshotSpan(document, snapshot.GetFullSpan())],
+              caretPosition,
+              textChangeRange,
+              existingTags: null)
     {
     }
 
     internal TaggerContext(
         object state,
+        bool frozenPartialSemantics,
         ImmutableArray<DocumentSnapshotSpan> spansToTag,
         SnapshotPoint? caretPosition,
         TextChangeRange? textChangeRange,
         ImmutableDictionary<ITextBuffer, TagSpanIntervalTree<TTag>> existingTags)
     {
         this.State = state;
+        this.FrozenPartialSemantics = frozenPartialSemantics;
         this.SpansToTag = spansToTag;
         this.CaretPosition = caretPosition;
         this.TextChangeRange = textChangeRange;

src/EditorFeatures/Test/Options/GlobalOptionsTests.cs

@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 using Microsoft.CodeAnalysis.DocumentationComments;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
@@ -165,7 +166,8 @@ private static bool IsStoredInGlobalOptions(PropertyInfo property, string? langu
              property.DeclaringType == typeof(AddImportPlacementOptions) && property.Name == nameof(AddImportPlacementOptions.UsingDirectivePlacement) && language == LanguageNames.VisualBasic ||
              property.DeclaringType == typeof(DocumentFormattingOptions) && property.Name == nameof(DocumentFormattingOptions.FileHeaderTemplate) ||
              property.DeclaringType == typeof(DocumentFormattingOptions) && property.Name == nameof(DocumentFormattingOptions.InsertFinalNewLine) ||
-             property.DeclaringType == typeof(ClassificationOptions) && property.Name == nameof(ClassificationOptions.ForceFrozenPartialSemanticsForCrossProcessOperations) ||
+             property.DeclaringType == typeof(ClassificationOptions) && property.Name == nameof(ClassificationOptions.FrozenPartialSemantics) ||
+             property.DeclaringType == typeof(HighlightingOptions) && property.Name == nameof(HighlightingOptions.FrozenPartialSemantics) ||
              property.DeclaringType == typeof(BlockStructureOptions) && property.Name == nameof(BlockStructureOptions.IsMetadataAsSource));
 
     /// <summary>

src/EditorFeatures/Test/Structure/StructureTaggerTests.cs

@@ -336,7 +336,7 @@ private static async Task<List<IContainerStructureTag>> GetTagsFromWorkspaceAsyn
             var provider = workspace.ExportProvider.GetExportedValue<AbstractStructureTaggerProvider>();
 
             var document = workspace.CurrentSolution.GetDocument(hostdoc.Id);
-            var context = new TaggerContext<IContainerStructureTag>(document, view.TextSnapshot);
+            var context = new TaggerContext<IContainerStructureTag>(document, view.TextSnapshot, frozenPartialSemantics: false);
             await provider.GetTestAccessor().ProduceTagsAsync(context);
 
             return context.TagSpans.Select(x => x.Tag).OrderBy(t => t.OutliningSpan.Value.Start).ToList();