Fix issue where analyzers are missing when computing diagnostics OOP (#79821)

jasonmalinowski · web-flow · commit bdb4dbe18b19 · 2025-08-08T17:54:20.000-07:00
If you were to have the same analyzer added as both a host analyzer and a project analyzer, we might end up removing it from the "project analyzer" set when we create the project CompilationWithAnalyzers. This confuses later code since it expects the analyzers to be present. This was regressed in c860af4, where a mechanical refactoring took us from having a single CompilationWithAnalyzers to two, one for project analyzers and one for host analyzers. The loop in the method was copied into two, but the set wasn't cleared between the two loops. I believe the intent was to clear out the set (rather than the set persist to deal with duplicates between the host and project sets), given the comment implies we do want duplicates to overwrite in the analyzerMap that we're also producing. I also split the two analyzer maps, one for project analyzers and one for host analyzers. If you don't do this, it means that a conflict where the same analyzer existing in both sets will overwrite each other, later code will then return a project analyzer which might be a different instance than the host analyzer equivalent. Fixes #79706 Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/2325694
diff --git a/src/Compilers/Test/Core/Diagnostics/CommonDiagnosticAnalyzers.cs b/src/Compilers/Test/Core/Diagnostics/CommonDiagnosticAnalyzers.cs
@@ -2487,6 +2487,9 @@ public override void Initialize(AnalysisContext context)
             }
         }
 
+        /// <summary>
+        /// An analyzer that reports a diagnostic on every single named type.
+        /// </summary>
         [DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)]
         public sealed class NamedTypeAnalyzerWithConfigurableEnabledByDefault : DiagnosticAnalyzer
         {
diff --git a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs
@@ -5,6 +5,7 @@
 #nullable disable
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
@@ -652,6 +653,166 @@ internal async Task TestOnlyRequiredAnalyzerExecutedDuringDiagnosticComputation(
         Assert.Empty(diagnosticMap.Other);
     }
 
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/79706")]
+    internal async Task TestAnalysisWithAnalyzerInBothProjectAndHost_SameAnalyzerInstance(bool documentAnalysis)
+    {
+        using var workspace = TestWorkspace.CreateCSharp("class A { }");
+
+        var analyzer = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: true, DiagnosticSeverity.Warning, throwOnAllNamedTypes: false);
+        var analyzerId = analyzer.GetAnalyzerId();
+        var analyzerReference = new AnalyzerImageReference([analyzer]);
+
+        workspace.TryApplyChanges(
+            workspace.CurrentSolution.WithAnalyzerReferences([analyzerReference])
+            .Projects.Single().AddAnalyzerReference(analyzerReference).Solution);
+
+        var project = workspace.CurrentSolution.Projects.Single();
+        var document = documentAnalysis ? project.Documents.Single() : null;
+        var diagnosticsMapResults = await DiagnosticComputer.GetDiagnosticsAsync(
+            document, project, Checksum.Null, span: null, projectAnalyzerIds: [analyzerId], [analyzerId],
+            AnalysisKind.Semantic, new DiagnosticAnalyzerInfoCache(), workspace.Services,
+            logPerformanceInfo: false, getTelemetryInfo: false,
+            cancellationToken: CancellationToken.None);
+
+        // In this case, since the analyzer identity is identical, we ran it once
+        var analyzerResults = diagnosticsMapResults.Diagnostics.Single();
+        Assert.Equal(analyzerId, analyzerResults.Item1);
+        Assert.Equal(1, analyzerResults.Item2.Semantic.Length);
+    }
+
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/79706")]
+    internal async Task TestAnalysisWithAnalyzerInBothProjectAndHost_DifferentAnalyzerInstancesFromNonEqualReferences(bool documentAnalysis)
+    {
+        using var workspace = TestWorkspace.CreateCSharp("class A { }");
+
+        var analyzerProject = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: true, DiagnosticSeverity.Warning, throwOnAllNamedTypes: false);
+        var analyzerProjectId = analyzerProject.GetAnalyzerId();
+        var analyzerProjectReference = new AnalyzerImageReference([analyzerProject]);
+
+        var analyzerHost = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: true, DiagnosticSeverity.Warning, throwOnAllNamedTypes: false);
+        var analyzerHostId = analyzerHost.GetAnalyzerId();
+        var analyzerHostReference = new AnalyzerImageReference([analyzerHost]);
+
+        // AnalyzerImageReference will create a separate AnalyzerImageReference.Id for each instance created, so these will be different.
+        Assert.NotEqual(analyzerProjectReference.Id, analyzerHostReference.Id);
+        Assert.Equal(analyzerProjectId, analyzerHostId);
+
+        workspace.TryApplyChanges(
+            workspace.CurrentSolution.WithAnalyzerReferences([analyzerHostReference])
+            .Projects.Single().AddAnalyzerReference(analyzerProjectReference).Solution);
+
+        var project = workspace.CurrentSolution.Projects.Single();
+        var document = documentAnalysis ? project.Documents.Single() : null;
+        var diagnosticsMapResults = await DiagnosticComputer.GetDiagnosticsAsync(
+            document, project, Checksum.Null, span: null, projectAnalyzerIds: [analyzerProjectId], [analyzerHostId],
+            AnalysisKind.Semantic, new DiagnosticAnalyzerInfoCache(), workspace.Services,
+            logPerformanceInfo: false, getTelemetryInfo: false,
+            cancellationToken: CancellationToken.None);
+
+        // In this case, since the analyzer reference identity is identical, we ran it once
+        var analyzerResults = diagnosticsMapResults.Diagnostics.Single();
+        Assert.Equal(analyzerHostId, analyzerResults.Item1);
+        Assert.Equal(1, analyzerResults.Item2.Semantic.Length);
+    }
+
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/79706")]
+    internal async Task TestAnalysisWithAnalyzerInBothProjectAndHost_DifferentAnalyzerInstancesFromEqualReferences(bool documentAnalysis, bool includeExtraProjectReference, bool includeExtraHostReference)
+    {
+        using var workspace = TestWorkspace.CreateCSharp("class A { }");
+
+        var analyzerProject = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: true, DiagnosticSeverity.Warning, throwOnAllNamedTypes: false);
+        var analyzerProjectId = analyzerProject.GetAnalyzerId();
+        var analyzerProjectReference = CreateAnalyzerReferenceWithSameId(analyzerProject);
+
+        var analyzerHost = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: true, DiagnosticSeverity.Warning, throwOnAllNamedTypes: false);
+        var analyzerHostId = analyzerHost.GetAnalyzerId();
+        var analyzerHostReference = CreateAnalyzerReferenceWithSameId(analyzerHost);
+
+        Assert.Equal(analyzerProjectReference.Id, analyzerHostReference.Id);
+        Assert.Equal(analyzerProjectId, analyzerHostId);
+
+        workspace.TryApplyChanges(
+            workspace.CurrentSolution.WithAnalyzerReferences(AddExtraReferenceIfNeeded(analyzerHostReference, includeExtraHostReference))
+            .Projects.Single().AddAnalyzerReferences(AddExtraReferenceIfNeeded(analyzerProjectReference, includeExtraProjectReference)).Solution);
+
+        var project = workspace.CurrentSolution.Projects.Single();
+        var document = documentAnalysis ? project.Documents.Single() : null;
+        var diagnosticsMapResults = await DiagnosticComputer.GetDiagnosticsAsync(
+            document, project, Checksum.Null, span: null, projectAnalyzerIds: [analyzerProjectId], [analyzerHostId],
+            AnalysisKind.Semantic, new DiagnosticAnalyzerInfoCache(), workspace.Services,
+            logPerformanceInfo: false, getTelemetryInfo: false,
+            cancellationToken: CancellationToken.None);
+
+        // In this case, the analyzers are ran twice. This appears to be a bug in SkippedHostAnalyzersInfo.Create, because it calls
+        // HostDiagnosticAnalyzers.CreateProjectDiagnosticAnalyzersPerReference which already filters out references, it doesn't return any
+        // references to skip.
+        Assert.Equal(2, diagnosticsMapResults.Diagnostics.Length);
+
+        static AnalyzerReference CreateAnalyzerReferenceWithSameId(DiagnosticAnalyzer analyzer)
+        {
+            var map = new Dictionary<string, ImmutableArray<DiagnosticAnalyzer>>()
+            {
+                { LanguageNames.CSharp, [analyzer] }
+            };
+
+            return new TestAnalyzerReferenceByLanguage(map);
+        }
+
+        static ImmutableArray<AnalyzerReference> AddExtraReferenceIfNeeded(AnalyzerReference mainReference, bool addExtraReference)
+        {
+            if (addExtraReference)
+            {
+                return [mainReference, new AnalyzerImageReference([new FieldAnalyzer("FA1234", syntaxTreeAction: false)])];
+            }
+            else
+            {
+                return [mainReference];
+            }
+        }
+    }
+
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/79706")]
+    internal async Task TestAnalysisWithAnalyzerInBothProjectAndHost_SameAnalyzerInstancesFromEqualReferences(bool documentAnalysis)
+    {
+        using var workspace = TestWorkspace.CreateCSharp("class A { }");
+
+        var analyzer = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: true, DiagnosticSeverity.Warning, throwOnAllNamedTypes: false);
+        var analyzerProjectReference = CreateAnalyzerReferenceWithSameId(analyzer);
+        var analyzerHostReference = CreateAnalyzerReferenceWithSameId(analyzer);
+
+        var analyzerId = analyzer.GetAnalyzerId();
+
+        Assert.Equal(analyzerProjectReference.Id, analyzerHostReference.Id);
+
+        workspace.TryApplyChanges(
+            workspace.CurrentSolution.WithAnalyzerReferences([analyzerHostReference])
+            .Projects.Single().AddAnalyzerReference(analyzerProjectReference).Solution);
+
+        var project = workspace.CurrentSolution.Projects.Single();
+        var document = documentAnalysis ? project.Documents.Single() : null;
+        var diagnosticsMapResults = await DiagnosticComputer.GetDiagnosticsAsync(
+            document, project, Checksum.Null, span: null, projectAnalyzerIds: [analyzerId], [analyzerId],
+            AnalysisKind.Semantic, new DiagnosticAnalyzerInfoCache(), workspace.Services,
+            logPerformanceInfo: false, getTelemetryInfo: false,
+            cancellationToken: CancellationToken.None);
+
+        Assert.Equal(1, diagnosticsMapResults.Diagnostics.Length);
+
+        static AnalyzerReference CreateAnalyzerReferenceWithSameId(DiagnosticAnalyzer analyzer)
+        {
+            var map = new Dictionary<string, ImmutableArray<DiagnosticAnalyzer>>()
+            {
+                { LanguageNames.CSharp, [analyzer] }
+            };
+
+            return new TestAnalyzerReferenceByLanguage(map);
+        }
+    }
+
     [Theory, WorkItem(67257, "https://github.com/dotnet/roslyn/issues/67257")]
     [CombinatorialData]
     public async Task TestFilterSpanOnContextAsync(FilterSpanTestAnalyzer.AnalysisKind kind)
diff --git a/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs b/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs
@@ -130,6 +130,13 @@ public static async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnaly
         var builder = ImmutableDictionary.CreateBuilder<DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>();
         foreach (var analyzer in projectAnalyzers.ConcatFast(hostAnalyzers))
         {
+            if (builder.ContainsKey(analyzer))
+            {
+                // If we already have a result for this analyzer, we had a duplicate. We already processed the results
+                // for this so no reason to process it a second time.
+                continue;
+            }
+
             cancellationToken.ThrowIfCancellationRequested();
 
             if (skippedAnalyzersInfo.SkippedAnalyzers.Contains(analyzer))
diff --git a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/DiagnosticComputer.cs b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/DiagnosticComputer.cs

Original file line number	Diff line number	Diff line change
`@@ -2487,6 +2487,9 @@ public override void Initialize(AnalysisContext context)`
`2487`	`2487`	`}`
`2488`	`2488`	`}`
`2489`	`2489`
	`2490`	`+ /// <summary>`
	`2491`	`+ /// An analyzer that reports a diagnostic on every single named type.`
	`2492`	`+ /// </summary>`
`2490`	`2493`	`[DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)]`
`2491`	`2494`	`public sealed class NamedTypeAnalyzerWithConfigurableEnabledByDefault : DiagnosticAnalyzer`
`2492`	`2495`	`{`