Visit child nodes in NoParensAroundConditions rule.

Without visiting the child nodes, the rule wasn't applied to nested nodes meaning parens wouldn't be removed.

Author: dylansturg

Sources/SwiftFormatRules/NoParensAroundConditions.swift

@@ -40,26 +40,36 @@ public final class NoParensAroundConditions: SyntaxFormatRule {
       $0.highlight(expr.sourceRange(converter: self.context.sourceLocationConverter))
     }
 
+    guard
+      let visitedTuple = visit(tuple).as(TupleExprSyntax.self),
+      let visitedExpr = visitedTuple.elementList.first?.expression
+    else {
+      return expr
+    }
     return replaceTrivia(
-      on: expr,
-      token: expr.lastToken,
-      leadingTrivia: tuple.leftParen.leadingTrivia,
-      trailingTrivia: tuple.rightParen.trailingTrivia
+      on: visitedExpr,
+      token: visitedExpr.lastToken,
+      leadingTrivia: visitedTuple.leftParen.leadingTrivia,
+      trailingTrivia: visitedTuple.rightParen.trailingTrivia
     )
   }
 
   public override func visit(_ node: IfStmtSyntax) -> StmtSyntax {
     let conditions = visit(node.conditions).as(ConditionElementListSyntax.self)!
-    let result = node.withIfKeyword(node.ifKeyword.withOneTrailingSpace())
+    var result = node.withIfKeyword(node.ifKeyword.withOneTrailingSpace())
       .withConditions(conditions)
+      .withBody(CodeBlockSyntax(visit(node.body)))
+    if let elseBody = node.elseBody {
+      result = result.withElseBody(visit(elseBody))
+    }
     return StmtSyntax(result)
   }
 
   public override func visit(_ node: ConditionElementSyntax) -> Syntax {
     guard let tup = node.condition.as(TupleExprSyntax.self),
       tup.elementList.firstAndOnly != nil
     else {
-      return Syntax(node)
+      return super.visit(node)
     }
     return Syntax(node.withCondition(Syntax(extractExpr(tup))))
   }
@@ -69,19 +79,21 @@ public final class NoParensAroundConditions: SyntaxFormatRule {
     guard let tup = node.expression.as(TupleExprSyntax.self),
       tup.elementList.firstAndOnly != nil
     else {
-      return StmtSyntax(node)
+      return super.visit(node)
     }
-    return StmtSyntax(node.withExpression(extractExpr(tup)))
+    return StmtSyntax(
+      node.withExpression(extractExpr(tup)).withCases(SwitchCaseListSyntax(visit(node.cases))))
   }
 
   public override func visit(_ node: RepeatWhileStmtSyntax) -> StmtSyntax {
     guard let tup = node.condition.as(TupleExprSyntax.self),
       tup.elementList.firstAndOnly != nil
     else {
-      return StmtSyntax(node)
+      return super.visit(node)
     }
     let newNode = node.withCondition(extractExpr(tup))
       .withWhileKeyword(node.whileKeyword.withOneTrailingSpace())
+      .withBody(CodeBlockSyntax(visit(node.body)))
     return StmtSyntax(newNode)
   }
 }

Tests/SwiftFormatRulesTests/NoParensAroundConditionsTests.swift

@@ -21,4 +21,118 @@ final class NoParensAroundConditionsTests: LintOrFormatRuleTestCase {
                 switch 4 { default: break }
                 """)
   }
+
+  func testParensAroundNestedParenthesizedStatements() {
+    XCTAssertFormatting(
+      NoParensAroundConditions.self,
+      input: """
+             switch (a) {
+               case 1:
+                 switch (b) {
+                   default: break
+                 }
+             }
+             if (x) {
+               if (y) {
+               } else if (z) {
+               } else {
+               }
+             } else if (w) {
+             }
+             while (x) {
+               while (y) {}
+             }
+             guard (x), (y), (x == 3) else {
+               guard (a), (b), (c == x) else {
+                 return
+               }
+               return
+             }
+             repeat {
+               repeat {
+               } while (y)
+             } while(x)
+             if (foo.someCall({ if (x) {} })) {}
+             """,
+      expected: """
+                switch a {
+                  case 1:
+                    switch b {
+                      default: break
+                    }
+                }
+                if x {
+                  if y {
+                  } else if z {
+                  } else {
+                  }
+                } else if w {
+                }
+                while x {
+                  while y {}
+                }
+                guard x, y, x == 3 else {
+                  guard a, b, c == x else {
+                    return
+                  }
+                  return
+                }
+                repeat {
+                  repeat {
+                  } while y
+                } while x
+                if foo.someCall({ if x {} }) {}
+                """)
+  }
+
+  func testParensAroundNestedUnparenthesizedStatements() {
+    XCTAssertFormatting(
+      NoParensAroundConditions.self,
+      input: """
+             switch b {
+               case 2:
+                 switch (d) {
+                   default: break
+                 }
+             }
+             if x {
+               if (y) {
+               } else if (z) {
+               } else {
+               }
+             } else if (w) {
+             }
+             while x {
+               while (y) {}
+             }
+             repeat {
+               repeat {
+               } while (y)
+             } while x
+             if foo.someCall({ if (x) {} }) {}
+             """,
+      expected: """
+                switch b {
+                  case 2:
+                    switch d {
+                      default: break
+                    }
+                }
+                if x {
+                  if y {
+                  } else if z {
+                  } else {
+                  }
+                } else if w {
+                }
+                while x {
+                  while y {}
+                }
+                repeat {
+                  repeat {
+                  } while y
+                } while x
+                if foo.someCall({ if x {} }) {}
+                """)
+  }
 }