Fix incrementalism when suppressed:

src/Compiler/Microsoft.NET.Sdk.Razor.SourceGenerators/IncrementalValueProviderExtensions.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.AspNetCore.Razor;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -52,11 +53,52 @@ internal static IncrementalValueProvider<TSource> ReportDiagnostics<TSource>(thi
             return source.Select((pair, ct) => pair.Item1!);
         }
 
-        internal static IncrementalValuesProvider<T> EmptyWhen<T>(this IncrementalValuesProvider<T> provider, IncrementalValueProvider<bool> checkProvider, bool check)
+        internal static IncrementalValuesProvider<T> EmptyOrCachedWhen<T>(this IncrementalValuesProvider<T> provider, IncrementalValueProvider<bool> checkProvider, bool check)
         {
-            return provider.Combine(checkProvider)
-                .Where(pair => pair.Right != check)
+            // This code is a little hard to understand:
+            // Basically you can think about this provider having two states: 'on' and 'off'.
+            // When the checkProvider equals the check value, the provider is 'on'
+            // When in the 'on' state, data flows through it as usual.
+            // When in the 'off' state you get either: an empty provider, if it has never been 'on' before, or the last 'on' data, but all cached.
+
+            // First we create a check provider that 'latches'. That is, once it has been flipped into the 'on' state, it never goes back to 'off'
+            var latchedCheckProvider = checkProvider.WithLambdaComparer((old, @new) => IsOn(old) || old == @new);
+
+            // Next we filter on the latched provider. When the provider is off we return an empty array, when it's on we allow data to flow through.
+            var dataProvider = provider.Combine(latchedCheckProvider)
+                .Where(pair => IsOn(pair.Right))
+                .Select((pair, _) => pair.Left);
+
+            // Now, we compare against the real value of the check provider. If the real provider is 'on' we allow the data through. When the provider is
+            // 'off' we set all the data to cached. This allows the caches to remain full, but still disable any further downstream processing.
+            var realProvider = dataProvider.Combine(checkProvider)
+
+                // We have to group and ungroup the data before comparing to ensure that we correctly handle added and removed cases which would otherwise
+                // not get compared and would be processed downstream
+                .Collect()
+
+                // When the real value is 'on', always say the data is modified. When the value is 'off' say it's cached
+                .WithLambdaComparer((old, @new) => !IsOn(@new.FirstOrDefault().Right))
+
+                // When 'on' the data will be re-evaluated item-wise here, ensuring only things that have actually changed will be marked as such.
+                // When 'off' the previous data was cached so nothing downstream runs.
+                .SelectMany((arr, _) => arr)
                 .Select((pair, _) => pair.Left);
+
+            return realProvider;
+
+            bool IsOn(bool value) => value != check;
+        }
+
+        /// <summary>
+        /// Ensures that <paramref name="input"/> reports as up to date if <paramref name="suppressionCheck"/> returns <see langword="true"/>.
+        /// </summary>
+        internal static IncrementalValueProvider<(T, bool)> SuppressIfNeeded<T>(this IncrementalValueProvider<T> input, IncrementalValueProvider<bool> suppressionCheck)
+        {
+            return input
+                .Combine(suppressionCheck)
+                // when the suppression check is true, we always say its up to date. Otherwise we perform the default comparison on the item itself.
+                .WithLambdaComparer((old, @new) => @new.Right || EqualityComparer<T>.Default.Equals(old.Left, @new.Left));
         }
 
         internal static IncrementalValueProvider<bool> CheckGlobalFlagSet(this IncrementalValueProvider<AnalyzerConfigOptionsProvider> optionsProvider, string flagName)

src/Compiler/Microsoft.NET.Sdk.Razor.SourceGenerators/RazorSourceGenerator.cs

@@ -37,12 +37,12 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
             // determine if we should suppress this run and filter out all the additional files and references if so
             var isGeneratorSuppressed = analyzerConfigOptions.CheckGlobalFlagSet("SuppressRazorSourceGenerator");
-            var additionalTexts = context.AdditionalTextsProvider.EmptyWhen(isGeneratorSuppressed, true);
-            var metadataRefs = context.MetadataReferencesProvider.EmptyWhen(isGeneratorSuppressed, true);
+            var additionalTexts = context.AdditionalTextsProvider.EmptyOrCachedWhen(isGeneratorSuppressed, true);
+            var metadataRefs = context.MetadataReferencesProvider.EmptyOrCachedWhen(isGeneratorSuppressed, true);
 
             var razorSourceGeneratorOptions = analyzerConfigOptions
                 .Combine(parseOptions)
-                .Combine(isGeneratorSuppressed)
+                .SuppressIfNeeded(isGeneratorSuppressed)
                 .Select(ComputeRazorSourceGeneratorOptions)
                 .ReportDiagnostics(context);
 
@@ -112,7 +112,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
             var tagHelpersFromCompilation = declCompilation
                 .Combine(razorSourceGeneratorOptions)
-                .Combine(isGeneratorSuppressed)
+                .SuppressIfNeeded(isGeneratorSuppressed)
                 .Select(static (pair, _) =>
                 {
 
@@ -199,7 +199,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
             // Currently unused. See https://github.com/dotnet/roslyn/issues/71024.
             var razorHostOutputsEnabled = analyzerConfigOptions.CheckGlobalFlagSet("EnableRazorHostOutputs");
-            var withOptionsDesignTime = withOptions.EmptyWhen(razorHostOutputsEnabled, false);
+            var withOptionsDesignTime = withOptions.EmptyOrCachedWhen(razorHostOutputsEnabled, false);
 
             var isAddComponentParameterAvailable = metadataRefs
                 .Where(r => r.Display is { } display && display.EndsWith("Microsoft.AspNetCore.Components.dll", StringComparison.Ordinal))
@@ -284,24 +284,34 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     }
 
                     return string.Equals(a.csharpDocument.GeneratedCode, b.csharpDocument.GeneratedCode, StringComparison.Ordinal);
-                });
+                })
+                .WithTrackingName("CSharpDocuments");
 
-            context.RegisterImplementationSourceOutput(csharpDocuments, static (context, pair) =>
-            {
-                var (filePath, csharpDocument) = pair;
+            var csharpDocumentsWithSuppressionFlag = csharpDocuments
+                // Explicitly combine with the suppression state. We *do* want this to run even if we're in the latched state
+                .Combine(isGeneratorSuppressed)
+                .WithTrackingName("DocumentsWithSuppression");
 
-                // Add a generated suffix so tools, such as coverlet, consider the file to be generated
-                var hintName = GetIdentifierFromPath(filePath) + ".g.cs";
+            context.RegisterImplementationSourceOutput(csharpDocumentsWithSuppressionFlag, static (context, pair) =>
+            {
+                var ((filePath, csharpDocument), isGeneratorSuppressed) = pair;
 
-                RazorSourceGeneratorEventSource.Log.AddSyntaxTrees(hintName);
-                for (var i = 0; i < csharpDocument.Diagnostics.Count; i++)
+                // When the generator is suppressed, we may still have a lot of cached data for perf, but we don't want to actually add any of the files to the output
+                if (!isGeneratorSuppressed)
                 {
-                    var razorDiagnostic = csharpDocument.Diagnostics[i];
-                    var csharpDiagnostic = razorDiagnostic.AsDiagnostic();
-                    context.ReportDiagnostic(csharpDiagnostic);
-                }
+                    // Add a generated suffix so tools, such as coverlet, consider the file to be generated
+                    var hintName = GetIdentifierFromPath(filePath) + ".g.cs";
+
+                    RazorSourceGeneratorEventSource.Log.AddSyntaxTrees(hintName);
+                    for (var i = 0; i < csharpDocument.Diagnostics.Count; i++)
+                    {
+                        var razorDiagnostic = csharpDocument.Diagnostics[i];
+                        var csharpDiagnostic = razorDiagnostic.AsDiagnostic();
+                        context.ReportDiagnostic(csharpDiagnostic);
+                    }
 
-                context.AddSource(hintName, csharpDocument.GeneratedCode);
+                    context.AddSource(hintName, csharpDocument.GeneratedCode);
+                }
             });
         }
     }