Remove the 'force compute' entrypoint for diagnostics

src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs

@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Extensions;
 using Microsoft.CodeAnalysis.ErrorLogger;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Extensions;

src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessarySuppressions;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Diagnostics.CSharp;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Extensions;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Remote.Diagnostics;

src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb

@@ -13,6 +13,7 @@ Imports Microsoft.CodeAnalysis.CSharp
 Imports Microsoft.CodeAnalysis.Diagnostics
 Imports Microsoft.CodeAnalysis.Diagnostics.CSharp
 Imports Microsoft.CodeAnalysis.Editor.UnitTests
+Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions
 Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.Serialization
 Imports Microsoft.CodeAnalysis.SolutionCrawler

src/EditorFeatures/TestUtilities/Extensions/IDiagnosticServiceExtensions.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.Extensions;
+
+internal static class IDiagnosticServiceExtensions
+{
+    public static Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(
+        this IDiagnosticAnalyzerService service, Project project, CancellationToken cancellationToken)
+    {
+        return CodeAnalysisDiagnosticAnalyzerServiceHelpers.ForceCodeAnalysisDiagnosticsAsync(
+            service, project, new(), cancellationToken);
+    }
+}

src/Features/Core/Portable/CodeFixes/Service/CodeFixService.FixAllDiagnosticProvider.cs

@@ -10,7 +10,6 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CodeFixes;
 

src/Features/Core/Portable/Diagnostics/CodeAnalysisDiagnosticAnalyzerService.cs

@@ -6,25 +6,113 @@
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
 using System.Composition;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Diagnostics;
 
+internal static class CodeAnalysisDiagnosticAnalyzerServiceHelpers
+{
+    private static Func<DiagnosticAnalyzer, bool> GetDiagnosticAnalyzerFilter(
+        Project project, DiagnosticAnalyzerInfoCache infoCache)
+    {
+        return analyzer =>
+        {
+            if (analyzer == FileContentLoadAnalyzer.Instance ||
+                analyzer == GeneratorDiagnosticsPlaceholderAnalyzer.Instance ||
+                analyzer.IsCompilerAnalyzer())
+            {
+                return true;
+            }
+
+            if (analyzer.IsBuiltInAnalyzer())
+            {
+                // always return true for builtin analyzer. we can't use
+                // descriptor check since many builtin analyzer always return 
+                // hidden descriptor regardless what descriptor it actually
+                // return on runtime. they do this so that they can control
+                // severity through option page rather than rule set editor.
+                // this is special behavior only ide analyzer can do. we hope
+                // once we support editorconfig fully, third party can use this
+                // ability as well and we can remove this kind special treatment on builtin
+                // analyzer.
+                return true;
+            }
+
+            if (analyzer is DiagnosticSuppressor)
+            {
+                // Always execute diagnostic suppressors.
+                return true;
+            }
+
+            if (project.CompilationOptions is null)
+            {
+                // Skip compilation options based checks for non-C#/VB projects.
+                return true;
+            }
+
+            // For most of analyzers, the number of diagnostic descriptors is small, so this should be cheap.
+            var descriptors = infoCache.GetDiagnosticDescriptors(analyzer);
+            var analyzerConfigOptions = project.GetAnalyzerConfigOptions();
+            return descriptors.Any(static (d, arg) =>
+            {
+                var severity = d.GetEffectiveSeverity(
+                    arg.CompilationOptions,
+                    arg.analyzerConfigOptions?.ConfigOptionsWithFallback,
+                    arg.analyzerConfigOptions?.TreeOptions);
+                return severity != ReportDiagnostic.Hidden;
+            },
+            (project.CompilationOptions, analyzerConfigOptions));
+        };
+    }
+
+    public static async Task<ImmutableArray<DiagnosticData>> ForceCodeAnalysisDiagnosticsAsync(
+        IDiagnosticAnalyzerService diagnosticAnalyzerService, Project project, DiagnosticAnalyzerInfoCache infoCache, CancellationToken cancellationToken)
+    {
+        // We are being asked to explicitly analyze this project.  As such we do *not* want to use the
+        // default rules determining which analyzers to run.  For example, even if compiler diagnostics
+        // are set to 'none' for live diagnostics, we still want to run them here.
+        //
+        // As such, we are very intentionally not calling into _diagnosticAnalyzerService.GetDefaultAnalyzerFilter
+        // here.  We want to control the rules entirely when this is called.
+        var filter = GetDiagnosticAnalyzerFilter(project, infoCache);
+
+        // Compute all the diagnostics for all the documents in the project.
+        //
+        // Note: in this case we want diagnostics for source generated documents as well.  So ensure those are 
+        // generated and included in the results.
+        var sourceGeneratorDocuments = await project.GetSourceGeneratedDocumentsAsync(cancellationToken).ConfigureAwait(false);
+
+        var documentDiagnostics = await diagnosticAnalyzerService.GetDiagnosticsForIdsAsync(
+            project, [.. project.DocumentIds, .. project.AdditionalDocumentIds, .. sourceGeneratorDocuments.Select(d => d.Id)],
+            diagnosticIds: null, filter, includeLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false);
+
+        // Then all the non-document diagnostics for that project as well.
+        var projectDiagnostics = await diagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync(
+            project, diagnosticIds: null, filter, cancellationToken).ConfigureAwait(false);
+
+        return [.. documentDiagnostics, .. projectDiagnostics];
+    }
+}
+
 [ExportWorkspaceServiceFactory(typeof(ICodeAnalysisDiagnosticAnalyzerService)), Shared]
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-internal sealed class CodeAnalysisDiagnosticAnalyzerServiceFactory() : IWorkspaceServiceFactory
+internal sealed class CodeAnalysisDiagnosticAnalyzerServiceFactory(
+    DiagnosticAnalyzerInfoCache.SharedGlobalCache infoCache) : IWorkspaceServiceFactory
 {
     public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-        => new CodeAnalysisDiagnosticAnalyzerService(workspaceServices.Workspace);
+        => new CodeAnalysisDiagnosticAnalyzerService(infoCache.AnalyzerInfoCache, workspaceServices.Workspace);
 
     private sealed class CodeAnalysisDiagnosticAnalyzerService : ICodeAnalysisDiagnosticAnalyzerService
     {
         private readonly IDiagnosticAnalyzerService _diagnosticAnalyzerService;
+        private readonly DiagnosticAnalyzerInfoCache _infoCache;
         private readonly Workspace _workspace;
 
         /// <summary>
@@ -44,9 +132,11 @@ private sealed class CodeAnalysisDiagnosticAnalyzerService : ICodeAnalysisDiagno
         private readonly ConcurrentSet<ProjectId> _clearedProjectIds = [];
 
         public CodeAnalysisDiagnosticAnalyzerService(
+            DiagnosticAnalyzerInfoCache infoCache,
             Workspace workspace)
         {
             _workspace = workspace;
+            _infoCache = infoCache;
             _diagnosticAnalyzerService = _workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
 
             _ = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged);
@@ -88,8 +178,8 @@ public async ValueTask RunAnalysisAsync(Project project, CancellationToken cance
 
             Contract.ThrowIfFalse(project.Solution.Workspace == _workspace);
 
-            // Execute force analysis for the project.
-            var diagnostics = await _diagnosticAnalyzerService.ForceAnalyzeProjectAsync(project, cancellationToken).ConfigureAwait(false);
+            var diagnostics = await CodeAnalysisDiagnosticAnalyzerServiceHelpers.ForceCodeAnalysisDiagnosticsAsync(
+                _diagnosticAnalyzerService, project, _infoCache, cancellationToken).ConfigureAwait(false);
 
             // Add the given project to the analyzed projects list **after** analysis has completed.
             // We need this ordering to ensure that 'HasProjectBeenAnalyzed' call above functions correctly.

src/Features/Core/Portable/Diagnostics/IDiagnosticAnalyzerService.cs

@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.Diagnostics;
@@ -22,8 +23,22 @@ internal interface IDiagnosticAnalyzerService : IWorkspaceService
     /// </remarks>
     void RequestDiagnosticRefresh();
 
-    /// <inheritdoc cref="IRemoteDiagnosticAnalyzerService.ForceAnalyzeProjectAsync"/>
-    Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken);
+    /// <summary>
+    /// The default analyzer filter that will be used in functions like <see cref="GetDiagnosticsForIdsAsync"/> if
+    /// no filter is provided.  The default filter has the following rules:
+    /// <list type="number">
+    /// <item>The standard compiler analyzer will not be run if the compiler diagnostic scope is <see cref="CompilerDiagnosticsScope.None"/>.</item>
+    /// <item>A regular analyzer will not be run if <see cref="ProjectState.RunAnalyzers"/> is false.</item>
+    /// <item>A regular analyzer will not be run if if the background analysis scope is <see cref="BackgroundAnalysisScope.None"/>.</item>
+    /// <item>If a set of diagnostic ids are provided, the analyzer will not be run unless it declares at least one
+    /// descriptor in that set.</item>
+    /// <item>Otherwise, the analyzer will be run</item>
+    /// </list>
+    /// </summary>
+    /// <param name="additionalFilter">An additional filter that can accept or reject analyzers that the default
+    /// rules have accepted.</param>
+    Func<DiagnosticAnalyzer, bool> GetDefaultAnalyzerFilter(
+        Project project, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? additionalFilter = null);
 
     /// <inheritdoc cref="IRemoteDiagnosticAnalyzerService.GetDeprioritizationCandidatesAsync"/>
     Task<ImmutableArray<DiagnosticAnalyzer>> GetDeprioritizationCandidatesAsync(
@@ -40,7 +55,10 @@ Task<ImmutableArray<DiagnosticAnalyzer>> GetDeprioritizationCandidatesAsync(
     /// <param name="documentIds">Optional documents to scope the returned diagnostics.  If <see langword="default"/>,
     /// then diagnostics will be returned for <see cref="Project.DocumentIds"/> and <see cref="Project.AdditionalDocumentIds"/>.</param>
     /// <param name="diagnosticIds">Optional set of diagnostic IDs to scope the returned diagnostics.</param>
-    /// <param name="shouldIncludeAnalyzer">Option callback to filter out analyzers to execute for computing diagnostics.</param>
+    /// <param name="shouldIncludeAnalyzer">Optional callback to filter out analyzers to execute for computing diagnostics.
+    /// If not present, <see cref="GetDefaultAnalyzerFilter"/> will be used.  If present, no default behavior
+    /// is used, and the callback is defered to entirely.  To augment the existing default rules call
+    /// <see cref="GetDefaultAnalyzerFilter"/> explicitly, and pass the result of that into this method.</param>
     /// <param name="includeLocalDocumentDiagnostics">
     /// Indicates if local document diagnostics must be returned.
     /// Local diagnostics are the ones that are reported by analyzers on the same file for which the callback was received
@@ -62,7 +80,10 @@ Task<ImmutableArray<DiagnosticData>> GetDiagnosticsForIdsAsync(
     /// </summary>
     /// <param name="project">Project to fetch the diagnostics for.</param>
     /// <param name="diagnosticIds">Optional set of diagnostic IDs to scope the returned diagnostics.</param>
-    /// <param name="shouldIncludeAnalyzer">Option callback to filter out analyzers to execute for computing diagnostics.</param>
+    /// <param name="shouldIncludeAnalyzer">Optional callback to filter out analyzers to execute for computing diagnostics.
+    /// If not present, <see cref="GetDefaultAnalyzerFilter"/> will be used.  If present, no default behavior
+    /// is used, and the callback is defered to entirely.  To augment the existing default rules call
+    /// <see cref="GetDefaultAnalyzerFilter"/> explicitly, and pass the result of that into this method.</param>
     Task<ImmutableArray<DiagnosticData>> GetProjectDiagnosticsForIdsAsync(
         Project project, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer, CancellationToken cancellationToken);
 

src/Features/Core/Portable/Diagnostics/Service/DiagnosticAnalyzerService.cs

@@ -124,25 +124,27 @@ private ImmutableArray<DiagnosticAnalyzer> GetDiagnosticAnalyzers(
         ImmutableHashSet<string>? diagnosticIds,
         Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer)
     {
-        var analyzersForProject = GetProjectAnalyzers(project);
-        var analyzers = analyzersForProject.WhereAsArray(a => ShouldIncludeAnalyzer(project, a));
+        shouldIncludeAnalyzer ??= GetDefaultAnalyzerFilter(project, diagnosticIds, additionalFilter: null);
 
-        return analyzers;
+        var analyzersForProject = GetProjectAnalyzers(project);
+        return analyzersForProject.WhereAsArray(shouldIncludeAnalyzer);
+    }
 
-        bool ShouldIncludeAnalyzer(Project project, DiagnosticAnalyzer analyzer)
+    public Func<DiagnosticAnalyzer, bool> GetDefaultAnalyzerFilter(
+        Project project, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? additionalFilter)
+        => analyzer =>
         {
             if (!DocumentAnalysisExecutor.IsAnalyzerEnabledForProject(analyzer, project, this._globalOptions))
                 return false;
 
-            if (shouldIncludeAnalyzer != null && !shouldIncludeAnalyzer(analyzer))
+            if (additionalFilter != null && !additionalFilter(analyzer))
                 return false;
 
             if (diagnosticIds != null && _analyzerInfoCache.GetDiagnosticDescriptors(analyzer).All(d => !diagnosticIds.Contains(d.Id)))
                 return false;
 
             return true;
-        }
-    }
+        };
 
     public Task<ImmutableArray<DiagnosticData>> GetDiagnosticsForIdsAsync(
         Project project, ImmutableArray<DocumentId> documentIds, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer, bool includeLocalDocumentDiagnostics, CancellationToken cancellationToken)