Fix issue with iteration numbers in CodeFix with multiple similar diagnostics.

Author: KlausLoeffelmann

src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Analyzers/MissingControlPropertySerializationConfiguration/ControlPropertySerializationDiagnosticAnalyzerTest.cs

@@ -23,13 +23,16 @@ public static void Main()
             {
                 var control = new ScalableControl();
 
-                control.ScaleFactor = 1.5f;
-                control.ScaledSize = new SizeF(100, 100);
-                control.ScaledLocation = new PointF(10, 10);
+         // We deliberately format this weirdly, to make sure we only format code our code fix touches.
+         control.ScaleFactor = 1.5f;
+            control.ScaledSize = new SizeF(100, 100);
+               control.ScaledLocation = new PointF(10, 10);
             }
         }
 
-        public class ScalableControl : Control
+        // We are writing the fully-qualified name here to make sure, the Simplifier doesn't remove it,
+        // since this is nothing our code fix touches.
+        public class ScalableControl : System.Windows.Forms.Control
         {
             public float [|ScaleFactor|] { get; set; } = 1.0f;
 
@@ -77,22 +80,25 @@ public class ScalableControl : Control
         using System.ComponentModel;
         using System.Drawing;
         using System.Windows.Forms;
-        
+
         namespace CSharpControls;
 
         public static class Program
         {
             public static void Main()
             {
                 var control = new ScalableControl();
-        
-                control.ScaleFactor = 1.5f;
-                control.ScaledSize = new SizeF(100, 100);
-                control.ScaledLocation = new PointF(10, 10);
+
+         // We deliberately format this weirdly, to make sure we only format code our code fix touches.
+         control.ScaleFactor = 1.5f;
+            control.ScaledSize = new SizeF(100, 100);
+               control.ScaledLocation = new PointF(10, 10);
             }
         }
-        
-        public class ScalableControl : Control
+
+        // We are writing the fully-qualified name here to make sure, the Simplifier doesn't remove it,
+        // since this is nothing our code fix touches.
+        public class ScalableControl : System.Windows.Forms.Control
         {
             [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
             public float ScaleFactor { get; set; } = 1.0f;
@@ -109,9 +115,9 @@ public class ScalableControl : Control
     // We are testing the analyzer with all versions of the .NET SDK from 6.0 on.
     public static IEnumerable<object[]> GetReferenceAssemblies()
     {
-        yield return [ReferenceAssemblies.Net.Net60Windows];
-        yield return [ReferenceAssemblies.Net.Net70Windows];
-        yield return [ReferenceAssemblies.Net.Net80Windows];
+        // yield return [ReferenceAssemblies.Net.Net60Windows];
+        // yield return [ReferenceAssemblies.Net.Net70Windows];
+        // yield return [ReferenceAssemblies.Net.Net80Windows];
         yield return [ReferenceAssemblies.Net.Net90Windows];
     }
 
@@ -168,7 +174,8 @@ public async Task CS_AddDesignerSerializationVisibilityCodeFix(ReferenceAssembli
                 {
                     OutputKind = OutputKind.WindowsApplication,
                 },
-            ReferenceAssemblies = referenceAssemblies
+            ReferenceAssemblies = referenceAssemblies,
+            NumberOfFixAllIterations = 2
         };
 
         await context.RunAsync();

src/System.Windows.Forms.Analyzers.CodeFixes.CSharp/System/Windows/Forms/CSharp/CodeFixes/AddDesignerSerializationVisibility/AddDesignerSerializationVisibilityCodeFixProvider.cs

@@ -11,13 +11,17 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.Simplification;
+using Microsoft.CodeAnalysis.Formatting;
 
 namespace System.Windows.Forms.CSharp.CodeFixes.AddDesignerSerializationVisibility;
 
 [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(AddDesignerSerializationVisibilityCodeFixProvider)), Shared]
 internal sealed class AddDesignerSerializationVisibilityCodeFixProvider : CodeFixProvider
 {
     private const string SystemComponentModelName = "System.ComponentModel";
+    private const string DesignerSerializationVisibilityAttributeName = "DesignerSerializationVisibility";
 
     public sealed override ImmutableArray<string> FixableDiagnosticIds
         => [DiagnosticIDs.MissingPropertySerializationConfiguration];
@@ -62,9 +66,19 @@ private static async Task<Document> AddDesignerSerializationAttribute(
             return document;
         }
 
+        // Let's make sure, the attribute we want to add is not already there:
+        if (propertyDeclarationSyntax.AttributeLists
+            .SelectMany(al => al.Attributes)
+            .Any(a => a.Name.ToString() == DesignerSerializationVisibilityAttributeName))
+        {
+            Debug.Assert(false, "The attribute should not be there.");
+
+            return document;
+        }
+
         // Generate the Attribute we need to put on the property
         AttributeSyntax designerSerializationVisibilityAttribute = SyntaxFactory.Attribute(
-            SyntaxFactory.ParseName("DesignerSerializationVisibility"),
+            SyntaxFactory.ParseName(DesignerSerializationVisibilityAttributeName),
             SyntaxFactory.ParseAttributeArgumentList("(DesignerSerializationVisibility.Hidden)"));
 
         // Make sure, we keep the white spaces before and after the property
@@ -77,31 +91,41 @@ private static async Task<Document> AddDesignerSerializationAttribute(
                 SyntaxFactory.AttributeList(
                     SyntaxFactory.SingletonSeparatedList(designerSerializationVisibilityAttribute)));
 
-        // Let's restore the trivia:
+        // Let's format the property, so the attribute is on top of it:
+        newProperty = newProperty.NormalizeWhitespace();
+
+        // Let's restore the original trivia:
         newProperty = newProperty.WithLeadingTrivia(leadingTrivia);
         newProperty = newProperty.WithTrailingTrivia(trailingTrivia);
-
-        UsingDirectiveSyntax usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(SystemComponentModelName));
+        newProperty = newProperty.WithAdditionalAnnotations(Formatter.Annotation);
 
         // Let's check, if we already have the using directive or if we need to add it:
         // (Remember: We can't throw here, as we are in a code fixer. But this also cannot be null.)
         SyntaxNode root = (await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false))!;
 
+        // Produce a new root, which has the updated property with the attribute.
+        root = root.ReplaceNode(propertyDeclarationSyntax, newProperty);
+
         // Let's check if we already have the using directive:
         if (!root.DescendantNodes()
                 .OfType<UsingDirectiveSyntax>()
                 .Any(u => u?.Name?.ToString() == SystemComponentModelName))
         {
+            UsingDirectiveSyntax usingDirective = SyntaxFactory
+                .UsingDirective(SyntaxFactory.ParseName(SystemComponentModelName));
+
+            usingDirective = usingDirective
+                .WithAdditionalAnnotations(Simplifier.Annotation)
+                .WithAdditionalAnnotations(Formatter.Annotation);
+
             // We need to add the using directive:
             SyntaxNode firstNode = root.DescendantNodes().First();
             root = root.InsertNodesBefore(firstNode, [usingDirective]);
         }
 
-        // Produce a new root:
-        SyntaxNode originalRoot = (await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false))!;
-        SyntaxNode newRoot = originalRoot.ReplaceNode(propertyDeclarationSyntax, newProperty);
+        document = document.WithSyntaxRoot(root);
 
         // Generate the new document:
-        return document.WithSyntaxRoot(newRoot);
+        return document;
     }
 }