Transform nested structs in UseEnumForNamespacing.

The rule was not visiting any structs nested in other structs, because it wasn't calling super to visit the node's children.

I tried to combine `super.visit` with the member enumeration in `membersToKeepIfUsedAsNamespace(_:)` but that method intentionally returns nil to signal that the decl shouldn't be rewritten which would discard the changes to the nested nodes. Instead, the rule now visits the members and uses the rewritten member list even if it's not converted to an enum to keep any changes to nested structs.

Author: dylansturg

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),
     ]
 }