Transform nested structs in UseEnumForNamespacing.

Sources/SwiftFormatRules/UseEnumForNamespacing.swift

@@ -29,10 +29,18 @@ import SwiftSyntax
 public final class UseEnumForNamespacing: SyntaxFormatRule {
 
   public override func visit(_ node: StructDeclSyntax) -> DeclSyntax {
+    let rewrittenMembers = node.members.members.compactMap {
+      super.visit($0).as(MemberDeclListItemSyntax.self)
+    }
+    guard rewrittenMembers.count == node.members.members.count else {
+      // No members should be deleted - exit early instead of breaking the source.
+      return DeclSyntax(node)
+    }
+    let rewrittenMemberDeclList = SyntaxFactory.makeMemberDeclList(rewrittenMembers)
     guard node.genericParameterClause == nil, node.inheritanceClause == nil,
-      let memberDecls = membersToKeepIfUsedAsNamespace(node.members.members)
+      let memberDecls = membersToKeepIfUsedAsNamespace(rewrittenMemberDeclList)
     else {
-      return DeclSyntax(node)
+      return DeclSyntax(node.withMembers(node.members.withMembers(rewrittenMemberDeclList)))
     }
 
     diagnose(.convertToEnum(kind: "struct", name: node.identifier), on: node)
@@ -76,9 +84,11 @@ public final class UseEnumForNamespacing: SyntaxFormatRule {
         // Do not append private initializer.
 
       case .ifConfigDecl(let decl):
-        let membersToKeep: [MemberDeclListSyntax] = decl.clauses
-          .compactMap { clause in
-            (clause.elements.as(MemberDeclListSyntax.self)).flatMap(membersToKeepIfUsedAsNamespace(_:))
+        // Note that the child nodes have already been rewritten, so any nested structs that should
+        // become enums have already been transformed.
+        let membersToKeep: [MemberDeclListSyntax] =
+          decl.clauses.compactMap {
+            ($0.elements.as(MemberDeclListSyntax.self)).flatMap(membersToKeepIfUsedAsNamespace(_:))
           }
 
         if membersToKeep.count < decl.clauses.count {

Tests/SwiftFormatPrettyPrintTests/XCTestManifests.swift

@@ -136,6 +136,7 @@ extension ClosureExprTests {
         ("testClosureArgumentsWithTrailingClosure", testClosureArgumentsWithTrailingClosure),
         ("testClosureCapture", testClosureCapture),
         ("testClosureCaptureWithoutArguments", testClosureCaptureWithoutArguments),
+        ("testClosureOutputGrouping", testClosureOutputGrouping),
         ("testClosuresWithIfs", testClosuresWithIfs),
         ("testClosureVariables", testClosureVariables),
         ("testTrailingClosure", testTrailingClosure),

Tests/SwiftFormatRulesTests/UseEnumForNamespacingTests.swift

@@ -164,4 +164,65 @@ public class UseEnumForNamespacingTests: DiagnosingTestCase {
                 }
                 """)
   }
+
+  public func testNestedEnumsForNameSpaces() {
+     XCTAssertFormatting(
+       UseEnumForNamespacing.self,
+       input: """
+              struct A {
+                static func fooA() {}
+                struct B {
+                  static func fooB() {}
+                }
+              }
+              struct C {
+                func fooC() {}
+                struct D {
+                  static func fooB() {}
+                }
+              }
+              struct E {
+                static func fooE() {}
+                struct F {
+                  func fooF() {}
+                }
+              }
+              struct G {
+                func fooG() {}
+                #if useH
+                struct H {
+                  static func fooH() {}
+                }
+                #endif
+              }
+              """,
+       expected: """
+                 enum A {
+                   static func fooA() {}
+                   enum B {
+                     static func fooB() {}
+                   }
+                 }
+                 struct C {
+                   func fooC() {}
+                   enum D {
+                     static func fooB() {}
+                   }
+                 }
+                 enum E {
+                   static func fooE() {}
+                   struct F {
+                     func fooF() {}
+                   }
+                 }
+                 struct G {
+                   func fooG() {}
+                   #if useH
+                   enum H {
+                     static func fooH() {}
+                   }
+                   #endif
+                 }
+                 """)
+   }
 }

Tests/SwiftFormatRulesTests/XCTestManifests.swift

@@ -288,6 +288,7 @@ extension UseEnumForNamespacingTests {
     //   `swift test --generate-linuxmain`
     // to regenerate.
     static let __allTests__UseEnumForNamespacingTests = [
+        ("testNestedEnumsForNameSpaces", testNestedEnumsForNameSpaces),
         ("testNonEnumsUsedAsNamespaces", testNonEnumsUsedAsNamespaces),
     ]
 }