Remove 'state set' concept for diagnostic analysis subsystem. (#77121)

Author: CyrusNajmabadi

src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs

@@ -19,15 +19,17 @@ internal partial class DiagnosticAnalyzerService
 {
     /// <summary>
     /// Cached data from a <see cref="Project"/> to the last <see cref="CompilationWithAnalyzersPair"/> instance created
-    /// for it.  Note: the CompilationWithAnalyzersPair instance is dependent on the set of <see cref="StateSet"/>s
-    /// passed along with the project.  As such, we might not be able to use a prior cached value if the set of state
-    /// sets changes.  In that case, a new instance will be created and will be cached for the next caller.
+    /// for it.  Note: the CompilationWithAnalyzersPair instance is dependent on the set of <see
+    /// cref="DiagnosticAnalyzer"/>s passed along with the project.  As such, we might not be able to use a prior cached
+    /// value if the set of analyzers changes.  In that case, a new instance will be created and will be cached for the
+    /// next caller.
     /// </summary>
-    private static readonly ConditionalWeakTable<Project, StrongBox<(ImmutableArray<StateSet> stateSets, CompilationWithAnalyzersPair? compilationWithAnalyzersPair)>> s_projectToCompilationWithAnalyzers = new();
+    private static readonly ConditionalWeakTable<Project, StrongBox<(ImmutableArray<DiagnosticAnalyzer> analyzers, CompilationWithAnalyzersPair? compilationWithAnalyzersPair)>> s_projectToCompilationWithAnalyzers = new();
 
     private static async Task<CompilationWithAnalyzersPair?> GetOrCreateCompilationWithAnalyzersAsync(
         Project project,
-        ImmutableArray<StateSet> stateSets,
+        ImmutableArray<DiagnosticAnalyzer> analyzers,
+        HostAnalyzerInfo hostAnalyzerInfo,
         bool crashOnAnalyzerException,
         CancellationToken cancellationToken)
     {
@@ -37,10 +39,10 @@ internal partial class DiagnosticAnalyzerService
         // Make sure the cached pair was computed with at least the same state sets we're asking about.  if not,
         // recompute and cache with the new state sets.
         if (!s_projectToCompilationWithAnalyzers.TryGetValue(project, out var tupleBox) ||
-            !stateSets.IsSubsetOf(tupleBox.Value.stateSets))
+            !analyzers.IsSubsetOf(tupleBox.Value.analyzers))
         {
             var compilationWithAnalyzersPair = await CreateCompilationWithAnalyzersAsync().ConfigureAwait(false);
-            tupleBox = new((stateSets, compilationWithAnalyzersPair));
+            tupleBox = new((analyzers, compilationWithAnalyzersPair));
 
             // Make a best effort attempt to store the latest computed value against these state sets. If this
             // fails (because another thread interleaves with this), that's ok.  We still return the pair we 
@@ -59,8 +61,8 @@ internal partial class DiagnosticAnalyzerService
         // </summary>
         async Task<CompilationWithAnalyzersPair?> CreateCompilationWithAnalyzersAsync()
         {
-            var projectAnalyzers = stateSets.SelectAsArray(s => !s.IsHostAnalyzer, s => s.Analyzer);
-            var hostAnalyzers = stateSets.SelectAsArray(s => s.IsHostAnalyzer, s => s.Analyzer);
+            var projectAnalyzers = analyzers.WhereAsArray(static (s, info) => !info.IsHostAnalyzer(s), hostAnalyzerInfo);
+            var hostAnalyzers = analyzers.WhereAsArray(static (s, info) => info.IsHostAnalyzer(s), hostAnalyzerInfo);
 
             var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
 

src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs

@@ -21,16 +21,20 @@ internal partial class DiagnosticAnalyzerService
     private partial class DiagnosticIncrementalAnalyzer
     {
         /// <summary>
-        /// Return all diagnostics that belong to given project for the given StateSets (analyzers) either from cache or by calculating them
+        /// Return all diagnostics that belong to given project for the given <see cref="DiagnosticAnalyzer"/> either
+        /// from cache or by calculating them.
         /// </summary>
         private async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> ComputeDiagnosticAnalysisResultsAsync(
-            CompilationWithAnalyzersPair? compilationWithAnalyzers, Project project, ImmutableArray<StateSet> stateSets, CancellationToken cancellationToken)
+            CompilationWithAnalyzersPair? compilationWithAnalyzers,
+            Project project,
+            ImmutableArray<DiagnosticAnalyzer> analyzers,
+            CancellationToken cancellationToken)
         {
-            using (Logger.LogBlock(FunctionId.Diagnostics_ProjectDiagnostic, GetProjectLogMessage, project, stateSets, cancellationToken))
+            using (Logger.LogBlock(FunctionId.Diagnostics_ProjectDiagnostic, GetProjectLogMessage, project, analyzers, cancellationToken))
             {
                 try
                 {
-                    var result = await ComputeDiagnosticsForStateSetsAsync(stateSets).ConfigureAwait(false);
+                    var result = await ComputeDiagnosticsForIDEAnalyzersAsync(analyzers).ConfigureAwait(false);
 
                     // If project is not loaded successfully, get rid of any semantic errors from compiler analyzer.
                     // Note: In the past when project was not loaded successfully we did not run any analyzers on the project.
@@ -111,12 +115,12 @@ async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> Co
                 }
             }
 
-            async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> ComputeDiagnosticsForStateSetsAsync(
-                ImmutableArray<StateSet> stateSets)
+            async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> ComputeDiagnosticsForIDEAnalyzersAsync(
+                ImmutableArray<DiagnosticAnalyzer> analyzers)
             {
                 try
                 {
-                    var ideAnalyzers = stateSets.Select(s => s.Analyzer).Where(a => a is ProjectDiagnosticAnalyzer or DocumentDiagnosticAnalyzer).ToImmutableArrayOrEmpty();
+                    var ideAnalyzers = analyzers.WhereAsArray(a => a is ProjectDiagnosticAnalyzer or DocumentDiagnosticAnalyzer);
 
                     return await ComputeDiagnosticsForAnalyzersAsync(ideAnalyzers).ConfigureAwait(false);
                 }

src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs renamed to src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.HostAnalyzerInfo.cs

@@ -17,24 +17,24 @@ private partial class DiagnosticIncrementalAnalyzer
     {
         private partial class StateManager
         {
-            private HostAnalyzerStateSets GetOrCreateHostStateSets(Project project, ProjectAnalyzerStateSets projectStateSets)
+            private HostAnalyzerInfo GetOrCreateHostAnalyzerInfo(Project project, ProjectAnalyzerInfo projectAnalyzerInfo)
             {
-                var key = new HostAnalyzerStateSetKey(project.Language, project.State.HasSdkCodeStyleAnalyzers, project.Solution.SolutionState.Analyzers.HostAnalyzerReferences);
+                var key = new HostAnalyzerInfoKey(project.Language, project.State.HasSdkCodeStyleAnalyzers, project.Solution.SolutionState.Analyzers.HostAnalyzerReferences);
                 // Some Host Analyzers may need to be treated as Project Analyzers so that they do not have access to the
                 // Host fallback options. These ids will be used when building up the Host and Project analyzer collections.
                 var referenceIdsToRedirect = GetReferenceIdsToRedirectAsProjectAnalyzers(project);
-                var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, (project.Solution.SolutionState.Analyzers, referenceIdsToRedirect));
-                return hostStateSets.WithExcludedAnalyzers(projectStateSets.SkippedAnalyzersInfo.SkippedAnalyzers);
+                var hostAnalyzerInfo = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, (project.Solution.SolutionState.Analyzers, referenceIdsToRedirect));
+                return hostAnalyzerInfo.WithExcludedAnalyzers(projectAnalyzerInfo.SkippedAnalyzersInfo.SkippedAnalyzers);
 
-                static HostAnalyzerStateSets CreateLanguageSpecificAnalyzerMap(HostAnalyzerStateSetKey arg, (HostDiagnosticAnalyzers HostAnalyzers, ImmutableHashSet<object> ReferenceIdsToRedirect) state)
+                static HostAnalyzerInfo CreateLanguageSpecificAnalyzerMap(HostAnalyzerInfoKey arg, (HostDiagnosticAnalyzers HostAnalyzers, ImmutableHashSet<object> ReferenceIdsToRedirect) state)
                 {
                     var language = arg.Language;
                     var analyzersPerReference = state.HostAnalyzers.GetOrCreateHostDiagnosticAnalyzersPerReference(language);
 
                     var (hostAnalyzerCollection, projectAnalyzerCollection) = GetAnalyzerCollections(analyzersPerReference, state.ReferenceIdsToRedirect);
-                    var analyzerMap = CreateStateSetMap(projectAnalyzerCollection, hostAnalyzerCollection, includeWorkspacePlaceholderAnalyzers: true);
+                    var (hostAnalyzers, allAnalyzers) = PartitionAnalyzers(projectAnalyzerCollection, hostAnalyzerCollection, includeWorkspacePlaceholderAnalyzers: true);
 
-                    return new HostAnalyzerStateSets(analyzerMap);
+                    return new HostAnalyzerInfo(hostAnalyzers, allAnalyzers);
                 }
 
                 static (IEnumerable<ImmutableArray<DiagnosticAnalyzer>> HostAnalyzerCollection, IEnumerable<ImmutableArray<DiagnosticAnalyzer>> ProjectAnalyzerCollection) GetAnalyzerCollections(
@@ -90,68 +90,65 @@ static ImmutableHashSet<object> GetFeaturesAnalyzerReferenceIds(HostDiagnosticAn
                     return builder.ToImmutable();
                 }
             }
+        }
+    }
 
-            private sealed class HostAnalyzerStateSets
-            {
-                private const int FileContentLoadAnalyzerPriority = -4;
-                private const int GeneratorDiagnosticsPlaceholderAnalyzerPriority = -3;
-                private const int BuiltInCompilerPriority = -2;
-                private const int RegularDiagnosticAnalyzerPriority = -1;
-
-                // ordered by priority
-                public readonly ImmutableArray<StateSet> OrderedStateSets;
-
-                public readonly ImmutableDictionary<DiagnosticAnalyzer, StateSet> StateSetMap;
-
-                private HostAnalyzerStateSets(ImmutableDictionary<DiagnosticAnalyzer, StateSet> stateSetMap, ImmutableArray<StateSet> orderedStateSets)
-                {
-                    StateSetMap = stateSetMap;
-                    OrderedStateSets = orderedStateSets;
-                }
+    private sealed class HostAnalyzerInfo
+    {
+        private const int FileContentLoadAnalyzerPriority = -4;
+        private const int GeneratorDiagnosticsPlaceholderAnalyzerPriority = -3;
+        private const int BuiltInCompilerPriority = -2;
+        private const int RegularDiagnosticAnalyzerPriority = -1;
+
+        private readonly ImmutableHashSet<DiagnosticAnalyzer> _hostAnalyzers;
+        private readonly ImmutableHashSet<DiagnosticAnalyzer> _allAnalyzers;
+        public readonly ImmutableArray<DiagnosticAnalyzer> OrderedAllAnalyzers;
+
+        public HostAnalyzerInfo(
+            ImmutableHashSet<DiagnosticAnalyzer> hostAnalyzers,
+            ImmutableHashSet<DiagnosticAnalyzer> allAnalyzers)
+        {
+            _hostAnalyzers = hostAnalyzers;
+            _allAnalyzers = allAnalyzers;
 
-                public HostAnalyzerStateSets(ImmutableDictionary<DiagnosticAnalyzer, StateSet> analyzerMap)
-                {
-                    StateSetMap = analyzerMap;
+            // order analyzers.
+            // order will be in this order
+            // BuiltIn Compiler Analyzer (C#/VB) < Regular DiagnosticAnalyzers < Document/ProjectDiagnosticAnalyzers
+            OrderedAllAnalyzers = [.. _allAnalyzers.OrderBy(PriorityComparison)];
+        }
 
-                    // order statesets
-                    // order will be in this order
-                    // BuiltIn Compiler Analyzer (C#/VB) < Regular DiagnosticAnalyzers < Document/ProjectDiagnosticAnalyzers
-                    OrderedStateSets = [.. StateSetMap.Values.OrderBy(PriorityComparison)];
-                }
+        public bool IsHostAnalyzer(DiagnosticAnalyzer analyzer)
+            => _hostAnalyzers.Contains(analyzer);
 
-                public HostAnalyzerStateSets WithExcludedAnalyzers(ImmutableHashSet<DiagnosticAnalyzer> excludedAnalyzers)
-                {
-                    if (excludedAnalyzers.IsEmpty)
-                    {
-                        return this;
-                    }
+        public HostAnalyzerInfo WithExcludedAnalyzers(ImmutableHashSet<DiagnosticAnalyzer> excludedAnalyzers)
+        {
+            if (excludedAnalyzers.IsEmpty)
+            {
+                return this;
+            }
 
-                    var stateSetMap = StateSetMap.Where(kvp => !excludedAnalyzers.Contains(kvp.Key)).ToImmutableDictionary();
-                    var orderedStateSets = OrderedStateSets.WhereAsArray(stateSet => !excludedAnalyzers.Contains(stateSet.Analyzer));
-                    return new HostAnalyzerStateSets(stateSetMap, orderedStateSets);
-                }
+            return new(_hostAnalyzers, _allAnalyzers.Except(excludedAnalyzers));
+        }
 
-                private int PriorityComparison(StateSet state1, StateSet state2)
-                    => GetPriority(state1) - GetPriority(state2);
+        private int PriorityComparison(DiagnosticAnalyzer state1, DiagnosticAnalyzer state2)
+            => GetPriority(state1) - GetPriority(state2);
 
-                private static int GetPriority(StateSet state)
-                {
-                    // compiler gets highest priority
-                    if (state.Analyzer.IsCompilerAnalyzer())
-                    {
-                        return BuiltInCompilerPriority;
-                    }
-
-                    return state.Analyzer switch
-                    {
-                        FileContentLoadAnalyzer _ => FileContentLoadAnalyzerPriority,
-                        GeneratorDiagnosticsPlaceholderAnalyzer _ => GeneratorDiagnosticsPlaceholderAnalyzerPriority,
-                        DocumentDiagnosticAnalyzer analyzer => Math.Max(0, analyzer.Priority),
-                        ProjectDiagnosticAnalyzer analyzer => Math.Max(0, analyzer.Priority),
-                        _ => RegularDiagnosticAnalyzerPriority,
-                    };
-                }
+        private static int GetPriority(DiagnosticAnalyzer state)
+        {
+            // compiler gets highest priority
+            if (state.IsCompilerAnalyzer())
+            {
+                return BuiltInCompilerPriority;
             }
+
+            return state switch
+            {
+                FileContentLoadAnalyzer _ => FileContentLoadAnalyzerPriority,
+                GeneratorDiagnosticsPlaceholderAnalyzer _ => GeneratorDiagnosticsPlaceholderAnalyzerPriority,
+                DocumentDiagnosticAnalyzer analyzer => Math.Max(0, analyzer.Priority),
+                ProjectDiagnosticAnalyzer analyzer => Math.Max(0, analyzer.Priority),
+                _ => RegularDiagnosticAnalyzerPriority,
+            };
         }
     }
 }