Simplify the CodeFix type (#80236)

CyrusNajmabadi · web-flow · commit e3cf188c71ec · 2025-09-12T02:26:08.000+02:00
diff --git a/src/EditorFeatures/Core/Suggestions/SuggestedActions/SuggestedActionWithNestedFlavors.cs b/src/EditorFeatures/Core/Suggestions/SuggestedActions/SuggestedActionWithNestedFlavors.cs
@@ -171,8 +171,8 @@ await copilotService.IsAvailableAsync(cancellationToken).ConfigureAwait(false) i
 
         // after this point, this method should only return at GetPreviewPane. otherwise, DifferenceViewer will leak
         // since there is no one to close the viewer
-        var preferredDocumentId = this.SubjectBuffer.AsTextContainer().GetOpenDocumentInCurrentContext()?.Id;
-        var preferredProjectId = preferredDocumentId?.ProjectId;
+        var preferredDocumentId = this.OriginalDocument.Id;
+        var preferredProjectId = preferredDocumentId.ProjectId;
 
         var extensionManager = this.OriginalSolution.Services.GetRequiredService<IExtensionManager>();
         var previewContents = await extensionManager.PerformFunctionAsync(Provider, async cancellationToken =>
@@ -197,7 +197,7 @@ await copilotService.IsAvailableAsync(cancellationToken).ConfigureAwait(false) i
         // GetPreviewPane() needs to run on the UI thread.
         this.ThreadingContext.ThrowIfNotOnUIThread();
 
-        var diagnosticData = _diagnostic is null ? null : CodeFix.GetDiagnosticData(this.OriginalDocument.Project, _diagnostic);
+        var diagnosticData = DiagnosticData.Create(_diagnostic, this.OriginalDocument.Project);
         return previewPaneService.GetPreviewPane(diagnosticData, previewContents!);
     }
 
diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractUserDiagnosticTest.cs b/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractUserDiagnosticTest.cs
@@ -157,7 +157,7 @@ protected static Document GetDocumentAndSelectSpan(EditorTestWorkspace workspace
                 document,
                 diagnostic.Location.SourceSpan,
                 [diagnostic],
-                (a, d) => fixes.Add(new CodeFix(document.Project, a, d)),
+                (a, d) => fixes.Add(new CodeFix(a, d)),
                 CancellationToken.None);
 
             await fixer.RegisterCodeFixesAsync(context);
diff --git a/src/EditorFeatures/Test2/Diagnostics/AbstractCrossLanguageUserDiagnosticTests.vb b/src/EditorFeatures/Test2/Diagnostics/AbstractCrossLanguageUserDiagnosticTests.vb
@@ -165,7 +165,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics
 
             For Each diagnostic In diagnostics
                 Dim fixes = New List(Of CodeFix)
-                Dim context = New CodeFixContext(document, diagnostic, Sub(a, d) fixes.Add(New CodeFix(document.Project, a, d)), CancellationToken.None)
+                Dim context = New CodeFixContext(document, diagnostic, Sub(a, d) fixes.Add(New CodeFix(a, d)), CancellationToken.None)
                 providerAndFixer.Item2.RegisterCodeFixesAsync(context).Wait()
                 If fixes.Any() Then
                     result.Add(Tuple.Create(diagnostic, New CodeFixCollection(
diff --git a/src/Features/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs b/src/Features/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
@@ -492,7 +492,7 @@ void Method()
                 var allFixes = (await fixService.GetFixesAsync(document, span, CancellationToken.None))
                     .SelectMany(fixCollection => fixCollection.Fixes);
 
-                var cs0219Fixes = allFixes.Where(fix => fix.PrimaryDiagnostic.Id == "CS0219").ToArray();
+                var cs0219Fixes = allFixes.Where(fix => fix.Diagnostics.First().Id == "CS0219").ToArray();
 
                 // Ensure that there are no duplicate suppression fixes.
                 Assert.Equal(1, cs0219Fixes.Length);
@@ -502,7 +502,7 @@ void Method()
                 // Ensure that there *is* a fix for the other warning and that it has a *different*
                 // equivalence key so that it *doesn't* get de-duplicated
                 Assert.Equal(1, diagnostics.Where(d => d.Id == "CS0168").Count());
-                var cs0168Fixes = allFixes.Where(fix => fix.PrimaryDiagnostic.Id == "CS0168");
+                var cs0168Fixes = allFixes.Where(fix => fix.Diagnostics.First().Id == "CS0168");
                 var cs0168EquivalenceKey = cs0168Fixes.Single().Action.EquivalenceKey;
                 Assert.NotNull(cs0168EquivalenceKey);
                 Assert.NotEqual(cs0219EquivalenceKey, cs0168EquivalenceKey);
diff --git a/src/Features/Core/Portable/CodeFixes/Configuration/ConfigureCodeStyle/ConfigureCodeStyleOptionCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/Configuration/ConfigureCodeStyle/ConfigureCodeStyleOptionCodeFixProvider.cs
@@ -91,7 +91,7 @@ private static ImmutableArray<CodeFix> GetConfigurations(Project project, IEnume
                     ? new TopLevelConfigureCodeStyleOptionCodeAction(diagnostic, nestedActions.ToImmutable())
                     : nestedActions.Single();
 
-                result.Add(new CodeFix(project, resultCodeAction, diagnostic));
+                result.Add(new CodeFix(resultCodeAction, [diagnostic]));
             }
         }
 
diff --git a/src/Features/Core/Portable/CodeFixes/Configuration/ConfigureSeverity/ConfigureSeverityLevelCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/Configuration/ConfigureSeverity/ConfigureSeverityLevelCodeFixProvider.cs
@@ -68,7 +68,7 @@ private static ImmutableArray<CodeFix> GetConfigurations(Project project, IEnume
             }
 
             var codeAction = new TopLevelConfigureSeverityCodeAction(diagnostic, nestedActions.ToImmutableAndFree());
-            result.Add(new CodeFix(project, codeAction, diagnostic));
+            result.Add(new CodeFix(codeAction, [diagnostic]));
 
             // Bulk configuration is only supported for analyzer diagnostics.
             if (!SuppressionHelpers.IsCompilerDiagnostic(diagnostic))
@@ -111,7 +111,7 @@ void AddBulkConfigurationCodeFixes(ImmutableArray<Diagnostic> diagnostics, strin
             }
 
             var codeAction = new TopLevelBulkConfigureSeverityCodeAction(nestedActions.ToImmutableAndFree(), category);
-            result.Add(new CodeFix(project, codeAction, diagnostics));
+            result.Add(new CodeFix(codeAction, diagnostics));
         }
     }
 }
diff --git a/src/Features/Core/Portable/CodeFixes/Service/CodeFixService.cs b/src/Features/Core/Portable/CodeFixes/Service/CodeFixService.cs
@@ -682,7 +682,7 @@ private static async Task<ImmutableArray<CodeFix>> GetCodeFixesAsync(
                         // name metadata.
                         action.AddCustomTagAndTelemetryInfo(fixerMetadata, fixer);
 
-                        fixes.Add(new CodeFix(document.Project, action, applicableDiagnostics));
+                        fixes.Add(new CodeFix(action, applicableDiagnostics));
                     }
                 }
             },
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.cs
@@ -235,16 +235,14 @@ private async Task<ImmutableArray<CodeFix>> GetSuppressionsAsync(
                 {
                     var codeAction = new TopLevelSuppressionCodeAction(
                         diagnostic, nestedActions.ToImmutableAndClear());
-                    result.Add(new CodeFix(project, codeAction, diagnostic));
+                    result.Add(new CodeFix(codeAction, [diagnostic]));
                 }
             }
             else if (!skipUnsuppress)
             {
                 var codeAction = await RemoveSuppressionCodeAction.CreateAsync(suppressionTargetInfo, documentOpt, project, diagnostic, this, cancellationToken).ConfigureAwait(false);
                 if (codeAction != null)
-                {
-                    result.Add(new CodeFix(project, codeAction, diagnostic));
-                }
+                    result.Add(new CodeFix(codeAction, [diagnostic]));
             }
         }
 
diff --git a/src/Features/Core/Portable/Copilot/ICopilotChangeAnalysisService.cs b/src/Features/Core/Portable/Copilot/ICopilotChangeAnalysisService.cs
@@ -350,9 +350,9 @@ static async (span, callback, args, cancellationToken) =>
                         if (codeFixCollection is
                             {
                                 Provider: not IConfigurationFixProvider,
-                                Fixes: [var codeFix, ..],
+                                Fixes: [{ Diagnostics: [var primaryDiagnostic, ..] }, ..],
                             } &&
-                            IsVisibleDiagnostic(codeFix.PrimaryDiagnostic.IsSuppressed, codeFix.PrimaryDiagnostic.Severity) &&
+                            IsVisibleDiagnostic(primaryDiagnostic.IsSuppressed, primaryDiagnostic.Severity) &&
                             (codeFixCollection.Provider.GetType().Namespace ?? "").StartsWith(RoslynPrefix))
                         {
                             callback(codeFixCollection);
diff --git a/src/Features/DiagnosticsTestUtilities/Diagnostics/AbstractUserDiagnosticTest_NoEditor.cs b/src/Features/DiagnosticsTestUtilities/Diagnostics/AbstractUserDiagnosticTest_NoEditor.cs
@@ -165,7 +165,7 @@ protected static Document GetDocumentAndSelectSpan(TTestWorkspace workspace, out
                 document,
                 diagnostic.Location.SourceSpan,
                 [diagnostic],
-                (a, d) => fixes.Add(new CodeFix(document.Project, a, d)),
+                (a, d) => fixes.Add(new CodeFix(a, d)),
                 CancellationToken.None);
 
             await fixer.RegisterCodeFixesAsync(context);
diff --git a/src/LanguageServer/Protocol/Features/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/LanguageServer/Protocol/Features/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -13,16 +13,18 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CodeFixesAndRefactorings;
 using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 using static Microsoft.CodeAnalysis.CodeActions.CodeAction;
-using CodeFixGroupKey = System.Tuple<Microsoft.CodeAnalysis.Diagnostics.DiagnosticData, Microsoft.CodeAnalysis.CodeActions.CodeActionPriority, Microsoft.CodeAnalysis.CodeActions.CodeActionPriority?>;
 
 namespace Microsoft.CodeAnalysis.UnifiedSuggestions;
 
+using CodeFixGroupKey = (DiagnosticData diagnostic, CodeActionPriority firstPriority, CodeActionPriority? secondPriority);
+
 /// <summary>
 /// Provides mutual code action logic for both local and LSP scenarios
 /// via intermediate interface <see cref="UnifiedSuggestedAction"/>.
@@ -50,7 +52,7 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
 
         var filteredFixes = fixes.WhereAsArray(c => c.Fixes.Length > 0);
         var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
-        var organizedFixes = await OrganizeFixesAsync(text, filteredFixes, cancellationToken).ConfigureAwait(false);
+        var organizedFixes = await OrganizeFixesAsync(document.Project, text, filteredFixes, cancellationToken).ConfigureAwait(false);
 
         return organizedFixes;
     }
@@ -59,6 +61,7 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
     /// Arrange fixes into groups based on the issue (diagnostic being fixed) and prioritize these groups.
     /// </summary>
     private static async Task<ImmutableArray<UnifiedSuggestedActionSet>> OrganizeFixesAsync(
+        Project project,
         SourceText text,
         ImmutableArray<CodeFixCollection> fixCollections,
         CancellationToken cancellationToken)
@@ -67,7 +70,7 @@ private static async Task<ImmutableArray<UnifiedSuggestedActionSet>> OrganizeFix
         using var _ = ArrayBuilder<CodeFixGroupKey>.GetInstance(out var order);
 
         // First group fixes by diagnostic and priority.
-        await GroupFixesAsync(fixCollections, map, order, cancellationToken).ConfigureAwait(false);
+        await GroupFixesAsync(project, fixCollections, map, order, cancellationToken).ConfigureAwait(false);
 
         // Then prioritize between the groups.
         var prioritizedFixes = PrioritizeFixGroups(text, map.ToImmutable(), order.ToImmutable());
@@ -78,16 +81,18 @@ private static async Task<ImmutableArray<UnifiedSuggestedActionSet>> OrganizeFix
     /// Groups fixes by the diagnostic being addressed by each fix.
     /// </summary>
     private static async Task GroupFixesAsync(
+        Project project,
         ImmutableArray<CodeFixCollection> fixCollections,
         IDictionary<CodeFixGroupKey, IList<UnifiedSuggestedAction>> map,
         ArrayBuilder<CodeFixGroupKey> order,
         CancellationToken cancellationToken)
     {
         foreach (var fixCollection in fixCollections)
-            await ProcessFixCollectionAsync(map, order, fixCollection, cancellationToken).ConfigureAwait(false);
+            await ProcessFixCollectionAsync(project, map, order, fixCollection, cancellationToken).ConfigureAwait(false);
     }
 
     private static async Task ProcessFixCollectionAsync(
+        Project project,
         IDictionary<CodeFixGroupKey, IList<UnifiedSuggestedAction>> map,
         ArrayBuilder<CodeFixGroupKey> order,
         CodeFixCollection fixCollection,
@@ -99,11 +104,11 @@ private static async Task ProcessFixCollectionAsync(
         var nonSupressionCodeFixes = fixes.WhereAsArray(f => !IsTopLevelSuppressionAction(f.Action));
         var supressionCodeFixes = fixes.WhereAsArray(f => IsTopLevelSuppressionAction(f.Action));
 
-        await AddCodeActionsAsync(map, order, fixCollection, GetFixAllSuggestedActionSetAsync, nonSupressionCodeFixes).ConfigureAwait(false);
+        await AddCodeActionsAsync(project, map, order, fixCollection, GetFixAllSuggestedActionSetAsync, nonSupressionCodeFixes).ConfigureAwait(false);
 
         // Add suppression fixes to the end of a given SuggestedActionSet so that they
         // always show up last in a group.
-        await AddCodeActionsAsync(map, order, fixCollection, GetFixAllSuggestedActionSetAsync, supressionCodeFixes).ConfigureAwait(false);
+        await AddCodeActionsAsync(project, map, order, fixCollection, GetFixAllSuggestedActionSetAsync, supressionCodeFixes).ConfigureAwait(false);
 
         return;
 
@@ -114,6 +119,7 @@ private static async Task ProcessFixCollectionAsync(
     }
 
     private static async Task AddCodeActionsAsync(
+        Project project,
         IDictionary<CodeFixGroupKey, IList<UnifiedSuggestedAction>> map,
         ArrayBuilder<CodeFixGroupKey> order,
         CodeFixCollection fixCollection,
@@ -122,27 +128,30 @@ private static async Task AddCodeActionsAsync(
     {
         foreach (var fix in codeFixes)
         {
-            var unifiedSuggestedAction = await GetUnifiedSuggestedActionAsync(fix.Action, fix).ConfigureAwait(false);
-            AddFix(fix, unifiedSuggestedAction, map, order);
+            var unifiedSuggestedAction = await GetUnifiedSuggestedActionAsync(project, fix.Action, fix).ConfigureAwait(false);
+            AddFix(project, fix, unifiedSuggestedAction, map, order);
         }
 
         return;
 
         // Local functions
-        async Task<UnifiedSuggestedAction> GetUnifiedSuggestedActionAsync(CodeAction action, CodeFix fix)
+        async Task<UnifiedSuggestedAction> GetUnifiedSuggestedActionAsync(Project project, CodeAction action, CodeFix fix)
         {
             if (action.NestedActions.Length > 0)
             {
                 var unifiedNestedActions = new FixedSizeArrayBuilder<UnifiedSuggestedAction>(action.NestedActions.Length);
                 foreach (var nestedAction in action.NestedActions)
-                    unifiedNestedActions.Add(await GetUnifiedSuggestedActionAsync(nestedAction, fix).ConfigureAwait(false));
+                {
+                    var unifiedNestedAction = await GetUnifiedSuggestedActionAsync(project, nestedAction, fix).ConfigureAwait(false);
+                    unifiedNestedActions.Add(unifiedNestedAction);
+                }
 
                 var set = new UnifiedSuggestedActionSet(
                     categoryName: null,
                     actions: unifiedNestedActions.MoveToImmutable(),
                     title: null,
                     priority: action.Priority,
-                    applicableToSpan: fix.PrimaryDiagnostic.Location.SourceSpan);
+                    applicableToSpan: fix.Diagnostics.First().Location.SourceSpan);
 
                 return new UnifiedSuggestedActionWithNestedActions(
                     action, action.Priority, fixCollection.Provider, [set]);
@@ -159,11 +168,13 @@ await getFixAllSuggestedActionSetAsync(action).ConfigureAwait(false),
     }
 
     private static void AddFix(
-        CodeFix fix, UnifiedSuggestedAction suggestedAction,
+        Project project,
+        CodeFix fix,
+        UnifiedSuggestedAction suggestedAction,
         IDictionary<CodeFixGroupKey, IList<UnifiedSuggestedAction>> map,
         ArrayBuilder<CodeFixGroupKey> order)
     {
-        var groupKey = GetGroupKey(fix);
+        var groupKey = GetGroupKey(fix, project);
         if (!map.TryGetValue(groupKey, out var suggestedActions))
         {
             order.Add(groupKey);
@@ -174,16 +185,16 @@ private static void AddFix(
         suggestedActions.Add(suggestedAction);
         return;
 
-        static CodeFixGroupKey GetGroupKey(CodeFix fix)
+        static CodeFixGroupKey GetGroupKey(CodeFix fix, Project project)
         {
-            var diag = fix.GetPrimaryDiagnosticData();
+            var diagnosticData = DiagnosticData.Create(fix.Diagnostics.First(), project);
             if (fix.Action is AbstractConfigurationActionWithNestedActions configurationAction)
             {
                 return new CodeFixGroupKey(
-                    diag, configurationAction.Priority, configurationAction.AdditionalPriority);
+                    diagnosticData, configurationAction.Priority, configurationAction.AdditionalPriority);
             }
 
-            return new CodeFixGroupKey(diag, fix.Action.Priority, null);
+            return new CodeFixGroupKey(diagnosticData, fix.Action.Priority, null);
         }
     }
 
diff --git a/src/Workspaces/Core/Portable/CodeFixes/CodeFix.cs b/src/Workspaces/Core/Portable/CodeFixes/CodeFix.cs
@@ -2,12 +2,8 @@
 // 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.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
-using System.Linq;
 using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace Microsoft.CodeAnalysis.CodeFixes;
 
@@ -18,61 +14,19 @@ namespace Microsoft.CodeAnalysis.CodeFixes;
 /// </summary>
 internal sealed class CodeFix
 {
-    public readonly Project Project;
     public readonly CodeAction Action;
-    public readonly ImmutableArray<Diagnostic> Diagnostics;
 
     /// <summary>
-    /// This is the diagnostic that will show up in the preview pane header when a particular fix is selected in the
-    /// light bulb menu. We also group all fixes with the same <see cref="PrimaryDiagnostic"/> together (into a single
-    /// SuggestedActionSet) in the light bulb menu.
+    /// Note: a code fix can fix one or more diagnostics.  For the purposes of display in a UI, it is recommended that
+    /// the first diagnostic in this list be treated as the "primary" diagnostic.  For example, withing Visual Studio,
+    /// all fixes with the same primary diagnostic are grouped together in the light bulb menu.
     /// </summary>
-    /// <remarks>
-    /// A given fix can fix one or more diagnostics. However, our light bulb UI (preview pane, grouping of fixes in the
-    /// light bulb menu etc.) currently keeps things simple and pretends that each fix fixes a single <see
-    /// cref="PrimaryDiagnostic"/>.
-    /// 
-    /// Implementation-wise the <see cref="PrimaryDiagnostic"/> is always the first diagnostic that the <see
-    /// cref="CodeFixProvider"/> supplied when registering the fix (<see
-    /// cref="CodeFixContext.RegisterCodeFix(CodeAction, IEnumerable{Diagnostic})"/>). This could change in the future,
-    /// if we decide to change the UI to depict the true mapping between fixes and diagnostics or if we decide to use
-    /// some other heuristic to determine the <see cref="PrimaryDiagnostic"/>.
-    /// </remarks>
-    public Diagnostic PrimaryDiagnostic => Diagnostics[0];
-
-    public CodeFix(Project project, CodeAction action, Diagnostic diagnostic)
-    {
-        Project = project;
-        Action = action;
-        Diagnostics = [diagnostic];
-    }
+    public readonly ImmutableArray<Diagnostic> Diagnostics;
 
-    public CodeFix(Project project, CodeAction action, ImmutableArray<Diagnostic> diagnostics)
+    public CodeFix(CodeAction action, ImmutableArray<Diagnostic> diagnostics)
     {
-        Debug.Assert(!diagnostics.IsDefaultOrEmpty);
-        Project = project;
+        Contract.ThrowIfTrue(diagnostics.IsDefaultOrEmpty);
         Action = action;
         Diagnostics = diagnostics;
     }
-
-    public DiagnosticData GetPrimaryDiagnosticData()
-        => GetDiagnosticData(Project, PrimaryDiagnostic);
-
-    public static DiagnosticData GetDiagnosticData(Project project, Diagnostic diagnostic)
-    {
-        if (diagnostic.Location.IsInSource)
-        {
-            var document = project.GetDocument(diagnostic.Location.SourceTree);
-            if (document != null)
-                return DiagnosticData.Create(diagnostic, document);
-        }
-        else if (diagnostic.Location.Kind == LocationKind.ExternalFile)
-        {
-            var document = project.Documents.FirstOrDefault(d => d.FilePath == diagnostic.Location.GetLineSpan().Path);
-            if (document != null)
-                return DiagnosticData.Create(diagnostic, document);
-        }
-
-        return DiagnosticData.Create(diagnostic, project);
-    }
 }
diff --git a/src/Workspaces/Core/Portable/Diagnostics/DiagnosticData.cs b/src/Workspaces/Core/Portable/Diagnostics/DiagnosticData.cs

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ private static ImmutableArray<CodeFix> GetConfigurations(Project project, IEnume`
`91`	`91`	`? new TopLevelConfigureCodeStyleOptionCodeAction(diagnostic, nestedActions.ToImmutable())`
`92`	`92`	`: nestedActions.Single();`
`93`	`93`
`94`		`- result.Add(new CodeFix(project, resultCodeAction, diagnostic));`
	`94`	`+ result.Add(new CodeFix(resultCodeAction, [diagnostic]));`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ private static ImmutableArray<CodeFix> GetConfigurations(Project project, IEnume`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`var codeAction = new TopLevelConfigureSeverityCodeAction(diagnostic, nestedActions.ToImmutableAndFree());`
`71`		`- result.Add(new CodeFix(project, codeAction, diagnostic));`
	`71`	`+ result.Add(new CodeFix(codeAction, [diagnostic]));`
`72`	`72`
`73`	`73`	`// Bulk configuration is only supported for analyzer diagnostics.`
`74`	`74`	`if (!SuppressionHelpers.IsCompilerDiagnostic(diagnostic))`
`@@ -111,7 +111,7 @@ void AddBulkConfigurationCodeFixes(ImmutableArray<Diagnostic> diagnostics, strin`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`var codeAction = new TopLevelBulkConfigureSeverityCodeAction(nestedActions.ToImmutableAndFree(), category);`
`114`		`- result.Add(new CodeFix(project, codeAction, diagnostics));`
	`114`	`+ result.Add(new CodeFix(codeAction, diagnostics));`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -682,7 +682,7 @@ private static async Task<ImmutableArray<CodeFix>> GetCodeFixesAsync(`
`682`	`682`	`// name metadata.`
`683`	`683`	`action.AddCustomTagAndTelemetryInfo(fixerMetadata, fixer);`
`684`	`684`
`685`		`- fixes.Add(new CodeFix(document.Project, action, applicableDiagnostics));`
	`685`	`+ fixes.Add(new CodeFix(action, applicableDiagnostics));`
`686`	`686`	`}`
`687`	`687`	`}`
`688`	`688`	`},`
Original file line number	Diff line number	Diff line change
`@@ -235,16 +235,14 @@ private async Task<ImmutableArray<CodeFix>> GetSuppressionsAsync(`
`235`	`235`	`{`
`236`	`236`	`var codeAction = new TopLevelSuppressionCodeAction(`
`237`	`237`	`diagnostic, nestedActions.ToImmutableAndClear());`
`238`		`- result.Add(new CodeFix(project, codeAction, diagnostic));`
	`238`	`+ result.Add(new CodeFix(codeAction, [diagnostic]));`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`	`else if (!skipUnsuppress)`
`242`	`242`	`{`
`243`	`243`	`var codeAction = await RemoveSuppressionCodeAction.CreateAsync(suppressionTargetInfo, documentOpt, project, diagnostic, this, cancellationToken).ConfigureAwait(false);`
`244`	`244`	`if (codeAction != null)`
`245`		`- {`
`246`		`- result.Add(new CodeFix(project, codeAction, diagnostic));`
`247`		`- }`
	`245`	`+ result.Add(new CodeFix(codeAction, [diagnostic]));`
`248`	`246`	`}`
`249`	`247`	`}`
`250`	`248`
Original file line number	Diff line number	Diff line change
`@@ -350,9 +350,9 @@ static async (span, callback, args, cancellationToken) =>`
`350`	`350`	`if (codeFixCollection is`
`351`	`351`	`{`
`352`	`352`	`Provider: not IConfigurationFixProvider,`
`353`		`- Fixes: [var codeFix, ..],`
	`353`	`+ Fixes: [{ Diagnostics: [var primaryDiagnostic, ..] }, ..],`
`354`	`354`	`} &&`
`355`		`- IsVisibleDiagnostic(codeFix.PrimaryDiagnostic.IsSuppressed, codeFix.PrimaryDiagnostic.Severity) &&`
	`355`	`+ IsVisibleDiagnostic(primaryDiagnostic.IsSuppressed, primaryDiagnostic.Severity) &&`
`356`	`356`	`(codeFixCollection.Provider.GetType().Namespace ?? "").StartsWith(RoslynPrefix))`
`357`	`357`	`{`
`358`	`358`	`callback(codeFixCollection);`