Fix closure preservation in conditions

Author: PhantomInTheWire

Sources/SwiftRefactor/RemoveRedundantParentheses.swift

@@ -61,8 +61,13 @@ public struct RemoveRedundantParentheses: SyntaxRefactoringProvider {
   }
 
   private static func canRemoveParentheses(around expr: ExprSyntax, in parent: Syntax?) -> Bool {
-    // Parentheses in initializer clauses (e.g., `let x = (a + b)`) are always redundant.
+    // Parentheses in initializer clauses (e.g., `let x = (a + b)`) are redundant,
+    // unless they enclose a closure in a condition context (to avoid parsing ambiguity).
     if parent?.is(InitializerClauseSyntax.self) == true {
+      let isInCondition = parent?.ancestorOrSelf(mapping: { $0.as(ConditionElementSyntax.self) }) != nil
+      if isInCondition && (expr.is(ClosureExprSyntax.self) || hasTrailingClosure(expr)) {
+        return false
+      }
       return true
     }
 
@@ -75,7 +80,7 @@ public struct RemoveRedundantParentheses: SyntaxRefactoringProvider {
     // The parser may not always produce a TypeExprSyntax, so we conservatively check for these accesses.
     if let memberAccess = parent?.as(MemberAccessExprSyntax.self) {
       let memberName = memberAccess.declName.baseName.text
-      if memberName == "self" || memberName == "Type" {
+      if memberName == "self" || memberName == "Type" || memberName == "Protocol" {
         return false
       }
     }
@@ -87,10 +92,7 @@ public struct RemoveRedundantParentheses: SyntaxRefactoringProvider {
       parent?.ancestorOrSelf(mapping: { $0.as(ConditionElementSyntax.self) }) != nil
       || parent?.is(RepeatStmtSyntax.self) == true
     if isInCondition {
-      if expr.is(ClosureExprSyntax.self) {
-        return false
-      }
-      if hasTrailingClosure(expr) {
+      if expr.is(ClosureExprSyntax.self) || hasTrailingClosure(expr) {
         return false
       }
     }

Tests/SwiftRefactorTest/RemoveRedundantParenthesesTests.swift

@@ -76,6 +76,14 @@ final class RemoveRedundantParenthesesTest: XCTestCase {
     // `let x = (a + b)` removes parens because InitializerClauseSyntax context
     try assertParenRemoval("let x = (a + b)", expected: "let x = a + b")
     try assertParenRemoval("let x = ((1))", expected: "let x = 1")
+
+    // `if let` and `guard let` initializers also remove parentheses
+    try assertParenRemoval("if let x = (a + b) {}", expected: "if let x = a + b {}")
+    try assertParenRemoval("if var x = (a + b) {}", expected: "if var x = a + b {}")
+    try assertParenRemoval("guard let x = (a + b) else {}", expected: "guard let x = a + b else {}")
+
+    // `try f()` is not a "simple expression", but in an initializer clause the parentheses are still redundant.
+    try assertParenRemoval("let x = (try f())", expected: "let x = try f()")
   }
 
   func testPreservesParenthesesInConditions() throws {
@@ -91,6 +99,10 @@ final class RemoveRedundantParenthesesTest: XCTestCase {
     try assertParenRemoval("if (#macro { true }) == false {}", expected: "if (#macro { true }) == false {}")
     // Subscripts with trailing closures
     try assertParenRemoval("if (array[0] { true }) == false {}", expected: "if (array[0] { true }) == false {}")
+
+    // Complex trailing closures in conditions
+    try assertParenRemoval("if (call { true }) == false {}", expected: "if (call { true }) == false {}")
+    try assertParenRemoval("if let x: () -> Bool = ({ true }) {}", expected: "if let x: () -> Bool = ({ true }) {}")
   }
 
   func testPreservesParenthesesForMetatypes() throws {