Remove the 'force compute' entrypoint for diagnostics

Author: CyrusNajmabadi

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
@@ -2141,8 +2142,7 @@ class MyClass
                 Assert.Equal(analyzer.Descriptor.Id, descriptors.Single().Id)
 
                 ' Get cached project diagnostics.
-                Dim diagnostics = Await diagnosticService.ForceAnalyzeProjectAsync(
-                    project, CancellationToken.None)
+                Dim diagnostics = Await diagnosticService.ForceAnalyzeProjectAsync(project, CancellationToken.None)
 
                 ' in v2, solution crawler never creates non-local hidden diagnostics.
                 ' v2 still creates those for LB and explicit queries such as FixAll.

src/EditorFeatures/TestUtilities/Extensions/IDiagnosticServiceExtensions.cs

@@ -0,0 +1,21 @@
+// 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 async Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(
+        this IDiagnosticAnalyzerService service, Project project, CancellationToken cancellationToken)
+    {
+        var documentDiagnostics = await service.GetDiagnosticsForIdsAsync(project, documentId: null, diagnosticIds: null, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false);
+        var projectDiagnostics = await service.GetProjectDiagnosticsForIdsAsync(project, diagnosticIds: null, shouldIncludeAnalyzer: null, cancellationToken).ConfigureAwait(false);
+        return [.. documentDiagnostics, .. projectDiagnostics];
+    }
+}

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

@@ -88,12 +88,17 @@ 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);
+            // Compute all the diagnostics for all the documents in the project.
+            var documentDiagnostics = await _diagnosticAnalyzerService.GetDiagnosticsForIdsAsync(
+                project, documentId: null, diagnosticIds: null, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false);
+
+            // Then all the non-document diagnostics for that project as well.
+            var projectDiagnostics = await _diagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync(
+                project, diagnosticIds: null, shouldIncludeAnalyzer: null, 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.
-            _analyzedProjectToDiagnostics[project.Id] = diagnostics;
+            _analyzedProjectToDiagnostics[project.Id] = [.. documentDiagnostics, .. projectDiagnostics];
 
             // Remove from the cleared list now that we've run a more recent "run code analysis" on this project.
             _clearedProjectIds.Remove(project.Id);

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

@@ -22,9 +22,6 @@ internal interface IDiagnosticAnalyzerService : IWorkspaceService
     /// </remarks>
     void RequestDiagnosticRefresh();
 
-    /// <inheritdoc cref="IRemoteDiagnosticAnalyzerService.ForceAnalyzeProjectAsync"/>
-    Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken);
-
     /// <inheritdoc cref="IRemoteDiagnosticAnalyzerService.GetDeprioritizationCandidatesAsync"/>
     Task<ImmutableArray<DiagnosticAnalyzer>> GetDeprioritizationCandidatesAsync(
         Project project, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken);

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

@@ -17,22 +17,7 @@ namespace Microsoft.CodeAnalysis.Diagnostics;
 
 internal sealed partial class DiagnosticAnalyzerService
 {
-    /// <summary>
-    /// Cached data from a real <see cref="ProjectState"/> instance to the cached diagnostic data produced by
-    /// <em>all</em> the analyzers for the project.  This data can then be used by <see
-    /// cref="GetDiagnosticsForIdsAsync"/> to speed up subsequent calls through the normal <see
-    /// cref="IDiagnosticAnalyzerService"/> entry points as long as the project hasn't changed at all.
-    /// </summary>
-    /// <remarks>
-    /// This table is keyed off of <see cref="ProjectState"/> but stores data from <see cref="SolutionState"/> on
-    /// it.  Specifically <see cref="SolutionState.Analyzers"/>.  Normally keying off a ProjectState would not be ok
-    /// as the ProjectState might stay the same while the SolutionState changed.  However, that can't happen as
-    /// SolutionState has the data for Analyzers computed prior to Projects being added, and then never changes.
-    /// Practically, solution analyzers are the core Roslyn analyzers themselves we distribute, or analyzers shipped
-    /// by vsix (not nuget).  These analyzers do not get loaded after changing *until* VS restarts.
-    /// </remarks>
-    private static readonly ConditionalWeakTable<ProjectState, StrongBox<(Checksum checksum, ImmutableArray<DiagnosticAnalyzer> analyzers, ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult> diagnosticAnalysisResults)>> s_projectToForceAnalysisData = new();
-
+#if false
     public async Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectInProcessAsync(Project project, CancellationToken cancellationToken)
     {
         var projectState = project.State;
@@ -134,4 +119,5 @@ static bool IsCandidateForFullSolutionAnalysis(
             return descriptors.Any(static (d, arg) => d.GetEffectiveSeverity(arg.CompilationOptions, arg.isHostAnalyzer ? arg.analyzerConfigOptions?.ConfigOptionsWithFallback : arg.analyzerConfigOptions?.ConfigOptionsWithoutFallback, arg.analyzerConfigOptions?.TreeOptions) != ReportDiagnostic.Hidden, (project.CompilationOptions, isHostAnalyzer, analyzerConfigOptions));
         }
     }
+#endif
 }

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

@@ -70,24 +70,6 @@ void AddIncludedDiagnostics(ArrayBuilder<DiagnosticData> builder, ImmutableArray
         async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> GetOrComputeDiagnosticAnalysisResultsAsync(
             ImmutableArray<DiagnosticAnalyzer> analyzers)
         {
-            // If there was a 'ForceAnalyzeProjectAsync' run for this project, we can piggy back off of the
-            // prior computed/cached results as they will be a superset of the results we want.
-            //
-            // Note: the caller will loop over *its* analyzers, grabbing from the full set of data we've cached for
-            // this project, and filtering down further.  So it's ok to return this potentially larger set.
-            //
-            // Note: While ForceAnalyzeProjectAsync should always run with a larger set of analyzers than us
-            // (since it runs all analyzers), we still run a paranoia check that the analyzers we care about are
-            // a subset of that call so that we don't accidentally reuse results that would not correspond to
-            // what we are computing ourselves.
-            if (s_projectToForceAnalysisData.TryGetValue(project.State, out var box) &&
-                analyzers.IsSubsetOf(box.Value.analyzers))
-            {
-                var checksum = await project.GetDiagnosticChecksumAsync(cancellationToken).ConfigureAwait(false);
-                if (box.Value.checksum == checksum)
-                    return box.Value.diagnosticAnalysisResults;
-            }
-
             // Otherwise, just compute for the analyzers we care about.
             var compilation = await GetOrCreateCompilationWithAnalyzersAsync(
                 project, analyzers, hostAnalyzerInfo, this.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false);

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

@@ -19,23 +19,6 @@ namespace Microsoft.CodeAnalysis.Diagnostics;
 
 internal sealed partial class DiagnosticAnalyzerService : IDiagnosticAnalyzerService
 {
-    public async Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken)
-    {
-        var client = await RemoteHostClient.TryGetClientAsync(project, cancellationToken).ConfigureAwait(false);
-        if (client is not null)
-        {
-            var result = await client.TryInvokeAsync<IRemoteDiagnosticAnalyzerService, ImmutableArray<DiagnosticData>>(
-                project,
-                (service, solution, cancellationToken) => service.ForceAnalyzeProjectAsync(solution, project.Id, cancellationToken),
-                cancellationToken).ConfigureAwait(false);
-
-            return result.HasValue ? result.Value : [];
-        }
-
-        // No OOP connection. Compute in proc.
-        return await ForceAnalyzeProjectInProcessAsync(project, cancellationToken).ConfigureAwait(false);
-    }
-
     public async Task<ImmutableArray<DiagnosticDescriptor>> GetDiagnosticDescriptorsAsync(
         Solution solution, ProjectId projectId, AnalyzerReference analyzerReference, string language, CancellationToken cancellationToken)
     {

src/Workspaces/Core/Portable/Diagnostics/IRemoteDiagnosticAnalyzerService.cs

@@ -14,11 +14,6 @@ namespace Microsoft.CodeAnalysis.Diagnostics;
 
 internal interface IRemoteDiagnosticAnalyzerService
 {
-    /// <summary>
-    /// Force analyzes the given project by running all applicable analyzers on the project.
-    /// </summary>
-    ValueTask<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Checksum solutionChecksum, ProjectId projectId, CancellationToken cancellationToken);
-
     /// <summary>
     /// Returns the analyzers that are candidates to be de-prioritized to
     /// <see cref="CodeActionRequestPriority.Low"/> priority for improvement in analyzer