Remove new line between methods in interfaces.

Author: bitbound

Bitbound.Analyzers.MemberOrder/Bitbound.Analyzers.MemberOrder.CodeFixes/MemberOrderCodeFixProvider.cs

@@ -57,7 +57,7 @@ private async Task<Solution> SortMembersAsync(Document document, TypeDeclaration
         .ThenBy(m => MemberOrderAnalyzer.GetIdentifier(m).ValueText, StringComparer.Ordinal)
         .ToList();
 
-    CopyWhiteSpace(ref members, sortedMembers);
+    CopyWhiteSpace(ref members, sortedMembers, typeDecl);
 
     var newTypeDecl = typeDecl.WithMembers(SyntaxFactory.List(sortedMembers));
 
@@ -70,10 +70,12 @@ private async Task<Solution> SortMembersAsync(Document document, TypeDeclaration
     return document.WithSyntaxRoot(newRoot).Project.Solution;
   }
 
-  private static void CopyWhiteSpace(ref SyntaxList<MemberDeclarationSyntax> members, List<MemberDeclarationSyntax> sortedMembers)
+  private static void CopyWhiteSpace(ref SyntaxList<MemberDeclarationSyntax> members, List<MemberDeclarationSyntax> sortedMembers, TypeDeclarationSyntax typeDecl)
   {
     if (members.Count == 0) return;
 
+    bool isInterface = typeDecl is InterfaceDeclarationSyntax;
+
     // First pass: normalize trailing trivia to remove excessive newlines
     for (int i = 0; i < sortedMembers.Count; i++)
     {
@@ -125,10 +127,10 @@ private static void CopyWhiteSpace(ref SyntaxList<MemberDeclarationSyntax> membe
                             prevOrder.Accessibility != currentOrder.Accessibility ||
                             prevOrder.StaticInstance != currentOrder.StaticInstance;
 
-      // Methods should always have spacing between them, even in the same group
+      // Methods should always have spacing between them in classes, but not in interfaces
       bool isMethod = currMember.Kind() == SyntaxKind.MethodDeclaration;
       bool prevIsMethod = prevMember.Kind() == SyntaxKind.MethodDeclaration;
-      bool bothMethods = isMethod && prevIsMethod;
+      bool bothMethods = isMethod && prevIsMethod && !isInterface;
 
       var prevTrailing = prevMember.GetTrailingTrivia();
       bool prevHasNewline = prevTrailing.Any(t => t.IsKind(SyntaxKind.EndOfLineTrivia));

Bitbound.Analyzers.MemberOrder/Bitbound.Analyzers.MemberOrder.Test/MemberOrderSpacingTests.cs

@@ -181,4 +181,80 @@ public interface IProcess
     var expectedDiagnostic = VerifyCS.Diagnostic("BB0001").WithLocation(0).WithArguments("Responding");
     await VerifyCS.VerifyCodeFixAsync(test, expectedDiagnostic, expectedSource);
   }
+
+  [TestMethod]
+  public async Task Fix_InterfaceMethods_NoBlankLinesBetweenMethods()
+  {
+    var test = """
+            namespace MyCode
+            {
+                public interface IMyInterface
+                {
+                    int MyProperty { get; set; }
+
+                    void MethodC();
+
+                    void {|#0:MethodA|}();
+
+                    void MethodB();
+                }
+            }
+            """;
+
+    var expectedSource = """
+            namespace MyCode
+            {
+                public interface IMyInterface
+                {
+                    int MyProperty { get; set; }
+
+                    void MethodA();
+                    void MethodB();
+                    void MethodC();
+                }
+            }
+            """;
+
+    var expectedDiagnostic = VerifyCS.Diagnostic("BB0001").WithLocation(0).WithArguments("MethodA");
+    await VerifyCS.VerifyCodeFixAsync(test, expectedDiagnostic, expectedSource);
+  }
+
+  [TestMethod]
+  public async Task Fix_ClassMethods_BlankLinesBetweenMethods()
+  {
+    var test = """
+            namespace MyCode
+            {
+                public class MyClass
+                {
+                    public int MyProperty { get; set; }
+
+                    public void MethodC() { }
+
+                    public void {|#0:MethodA|}() { }
+
+                    public void MethodB() { }
+                }
+            }
+            """;
+
+    var expectedSource = """
+            namespace MyCode
+            {
+                public class MyClass
+                {
+                    public int MyProperty { get; set; }
+
+                    public void MethodA() { }
+
+                    public void MethodB() { }
+
+                    public void MethodC() { }
+                }
+            }
+            """;
+
+    var expectedDiagnostic = VerifyCS.Diagnostic("BB0001").WithLocation(0).WithArguments("MethodA");
+    await VerifyCS.VerifyCodeFixAsync(test, expectedDiagnostic, expectedSource);
+  }
 }