Refresh diagnostics when fading options change

src/LanguageServer/Protocol/Features/Diagnostics/DiagnosticAnalyzerService.cs

@@ -68,7 +68,12 @@ public static bool IsGlobalOptionAffectingDiagnostics(IOption2 option)
                option == SolutionCrawlerOptionsStorage.BackgroundAnalysisScopeOption ||
                option == SolutionCrawlerOptionsStorage.SolutionBackgroundAnalysisScopeOption ||
                option == SolutionCrawlerOptionsStorage.CompilerDiagnosticsScopeOption ||
-               option == s_crashOnAnalyzerException;
+               option == s_crashOnAnalyzerException ||
+               // Fading is controlled by reporting diagnostics for the faded region.  So if a fading option changes we
+               // want to recompute and rereport up to date diagnostics.
+               option == FadingOptions.FadeOutUnusedImports ||
+               option == FadingOptions.FadeOutUnusedMembers ||
+               option == FadingOptions.FadeOutUnreachableCode;
 
         public void RequestDiagnosticRefresh()
             => _diagnosticsRefresher.RequestWorkspaceRefresh();

src/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs

@@ -123,7 +123,8 @@ protected virtual Task WaitForChangesAsync(string? category, RequestContext cont
             var handlerName = $"{this.GetType().Name}(category: {category})";
             context.TraceInformation($"{handlerName} started getting diagnostics");
 
-            var versionedCache = _categoryToVersionedCache.GetOrAdd(handlerName, static handlerName => new(handlerName));
+            var versionedCache = _categoryToVersionedCache.GetOrAdd(
+                handlerName, static (handlerName, globalOptions) => new(globalOptions, handlerName), GlobalOptions);
 
             // Get the set of results the request said were previously reported.  We can use this to determine both
             // what to skip, and what files we have to tell the client have been removed.

src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticsPullCache.cs

@@ -5,7 +5,10 @@
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.LanguageServer.Protocol;
 using Roslyn.Utilities;
@@ -25,8 +28,11 @@ internal abstract partial class AbstractPullDiagnosticHandler<TDiagnosticsParams
     /// well for us in the normal case.  The latter still allows us to reuse diagnostics when changes happen that update
     /// the version stamp but not the content (for example, forking LSP text).
     /// </summary>
-    private sealed class DiagnosticsPullCache(string uniqueKey) : VersionedPullCache<(int globalStateVersion, VersionStamp? dependentVersion), (int globalStateVersion, Checksum dependentChecksum), DiagnosticsRequestState, ImmutableArray<DiagnosticData>>(uniqueKey)
+    private sealed class DiagnosticsPullCache(IGlobalOptionService globalOptions, string uniqueKey)
+        : VersionedPullCache<(int globalStateVersion, VersionStamp? dependentVersion), (int globalStateVersion, Checksum dependentChecksum), DiagnosticsRequestState, ImmutableArray<DiagnosticData>>(uniqueKey)
     {
+        private readonly IGlobalOptionService _globalOptions = globalOptions;
+
         public override async Task<(int globalStateVersion, VersionStamp? dependentVersion)> ComputeCheapVersionAsync(DiagnosticsRequestState state, CancellationToken cancellationToken)
         {
             return (state.GlobalStateVersion, await state.Project.GetDependentVersionAsync(cancellationToken).ConfigureAwait(false));
@@ -45,14 +51,28 @@ public override async Task<ImmutableArray<DiagnosticData>> ComputeDataAsync(Diag
             return diagnostics;
         }
 
-        public override Checksum ComputeChecksum(ImmutableArray<DiagnosticData> data)
+        public override Checksum ComputeChecksum(ImmutableArray<DiagnosticData> data, string language)
         {
             // Create checksums of diagnostic data and sort to ensure stable ordering for comparison.
-            var diagnosticDataChecksums = data
-                .SelectAsArray(d => Checksum.Create(d, SerializeDiagnosticData))
-                .Sort();
+            using var _ = ArrayBuilder<Checksum>.GetInstance(out var builder);
+            foreach (var datum in data)
+                builder.Add(Checksum.Create(datum, SerializeDiagnosticData));
+
+            // Ensure that if fading options change that we recompute the checksum as it will produce different data
+            // that we would report to the client.
+            var option1 = _globalOptions.GetOption(FadingOptions.FadeOutUnreachableCode, language);
+            var option2 = _globalOptions.GetOption(FadingOptions.FadeOutUnusedImports, language);
+            var option3 = _globalOptions.GetOption(FadingOptions.FadeOutUnusedMembers, language);
+
+            var value =
+                (option1 ? (1 << 2) : 0) |
+                (option2 ? (1 << 1) : 0) |
+                (option3 ? (1 << 0) : 0);
+
+            builder.Add(new Checksum(0, value));
+            builder.Sort();
 
-            return Checksum.Create(diagnosticDataChecksums);
+            return Checksum.Create(builder);
         }
 
         private static void SerializeDiagnosticData(DiagnosticData diagnosticData, ObjectWriter writer)

src/LanguageServer/Protocol/Handler/PullHandlers/VersionedPullCache.CacheItem.cs

@@ -57,6 +57,7 @@ private sealed class CacheItem(string uniqueKey)
             PreviousPullResult? previousPullResult,
             bool isFullyLoaded,
             TState state,
+            string language,
             CancellationToken cancellationToken)
         {
             // Ensure that we only update the cache item one at a time.
@@ -99,7 +100,7 @@ _lastResult is not null &&
 
                 // Compute the new result for the request.
                 var data = await cache.ComputeDataAsync(state, cancellationToken).ConfigureAwait(false);
-                var dataChecksum = cache.ComputeChecksum(data);
+                var dataChecksum = cache.ComputeChecksum(data, language);
 
                 string newResultId;
                 if (_lastResult is not null && _lastResult?.resultId == previousPullResult?.PreviousResultId && _lastResult?.dataChecksum == dataChecksum)

src/LanguageServer/Protocol/Handler/PullHandlers/VersionedPullCache.cs

@@ -59,7 +59,7 @@ internal abstract partial class VersionedPullCache<TCheapVersion, TExpensiveVers
     /// </summary>
     public abstract Task<TComputedData> ComputeDataAsync(TState state, CancellationToken cancellationToken);
 
-    public abstract Checksum ComputeChecksum(TComputedData data);
+    public abstract Checksum ComputeChecksum(TComputedData data, string language);
 
     /// <summary>
     /// If results have changed since the last request this calculates and returns a new
@@ -75,14 +75,16 @@ internal abstract partial class VersionedPullCache<TCheapVersion, TExpensiveVers
         TState state,
         CancellationToken cancellationToken)
     {
-        var workspace = project.Solution.Workspace;
-
         // We have to make sure we've been fully loaded before using cached results as the previous results may not be complete.
         var isFullyLoaded = await IsFullyLoadedAsync(project.Solution, cancellationToken).ConfigureAwait(false);
         var previousResult = IDictionaryExtensions.GetValueOrDefault(idToClientLastResult, projectOrDocumentId);
 
-        var cacheEntry = _idToLastReportedResult.GetOrAdd((project.Solution.Workspace, projectOrDocumentId), (_) => new CacheItem(uniqueKey));
-        return await cacheEntry.UpdateCacheItemAsync(this, previousResult, isFullyLoaded, state, cancellationToken).ConfigureAwait(false);
+        var cacheEntry = _idToLastReportedResult.GetOrAdd(
+            (project.Solution.Workspace, projectOrDocumentId),
+            static (_, uniqueKey) => new CacheItem(uniqueKey),
+            uniqueKey);
+        return await cacheEntry.UpdateCacheItemAsync(
+            this, previousResult, isFullyLoaded, state, project.Language, cancellationToken).ConfigureAwait(false);
     }
 
     private long GetNextResultId()

src/LanguageServer/Protocol/Handler/SourceGenerators/SourceGeneratedDocumentCache.cs

@@ -30,7 +30,7 @@ internal sealed class SourceGeneratedDocumentCache(string uniqueKey) : Versioned
         return SpecializedTasks.Null<object>();
     }
 
-    public override Checksum ComputeChecksum(SourceText? data)
+    public override Checksum ComputeChecksum(SourceText? data, string language)
     {
         return data is null ? Checksum.Null : Checksum.From(data.GetChecksum());
     }

src/LanguageServer/Protocol/Handler/SpellCheck/SpellCheckPullCache.cs

@@ -29,7 +29,7 @@ internal sealed class SpellCheckPullCache(string uniqueKey) : VersionedPullCache
         return (parseOptionsChecksum, textChecksum);
     }
 
-    public override Checksum ComputeChecksum(ImmutableArray<SpellCheckSpan> data)
+    public override Checksum ComputeChecksum(ImmutableArray<SpellCheckSpan> data, string language)
     {
         var checksums = data.SelectAsArray(s => Checksum.Create(s, SerializeSpellCheckSpan)).Sort();
         return Checksum.Create(checksums);