Feat(SwiftRefactor): Implement CollapseNestedIfStmt refactoring

Sources/SwiftRefactor/CMakeLists.txt

@@ -10,6 +10,7 @@ add_swift_syntax_library(SwiftRefactor
   AddSeparatorsToIntegerLiteral.swift
   CallLikeSyntax.swift
   CallToTrailingClosures.swift
+  CollapseNestedIfStmt.swift
   ConvertComputedPropertyToStored.swift
   ConvertComputedPropertyToZeroParameterFunction.swift
   ConvertStoredPropertyToComputed.swift

Sources/SwiftRefactor/CollapseNestedIfStmt.swift

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2026 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if compiler(>=6)
+public import SwiftSyntax
+#else
+import SwiftSyntax
+#endif
+
+/// Collapses a nested `if` statement into a single `if` statement with a
+/// combined condition list.
+///
+/// ## Before
+///
+/// ```swift
+/// if a {
+///   if b {
+///     print("hello")
+///   }
+/// }
+/// ```
+///
+/// ## After
+///
+/// ```swift
+/// if a, b {
+///   print("hello")
+/// }
+/// ```
+public struct CollapseNestedIfStmt: SyntaxRefactoringProvider {
+  public static func refactor(syntax outerIf: IfExprSyntax, in context: Void) -> IfExprSyntax {
+    // 1. Ensure the outer `if` has no `else` block.
+    guard outerIf.elseBody == nil else {
+      return outerIf
+    }
+
+    // 2. Ensure the outer `if` body has exactly one statement.
+    guard outerIf.body.statements.count == 1,
+      let firstStatement = outerIf.body.statements.first
+    else {
+      return outerIf
+    }
+
+    // 3. Check if that statement is an `IfExprSyntax` (inner `if`).
+    // It could be an `expression` statement containing the `IfExpr` or just the expression itself depending on parsing context,
+    // but typically in a code block it's an expression statement.
+    guard let expressionStmt = firstStatement.item.as(ExpressionStmtSyntax.self),
+      let innerIf = expressionStmt.expression.as(IfExprSyntax.self)
+    else {
+      return outerIf
+    }
+
+    // 4. Ensure the inner `if` has no `else` block.
+    guard innerIf.elseBody == nil else {
+      return outerIf
+    }
+
+    // 5. Merge conditions.
+    // We need to add a trailing comma to the last condition of the outer `if`
+    // before appending the inner `if`'s conditions.
+    var newConditions = outerIf.conditions
+
+    // If the last condition doesn't have a trailing comma, verify we need to add one.
+    // Actually, `ConditionElementListSyntax` elements usually handle commas.
+    // We just need to make sure the last element of the *outer* list has a comma now that it's not last.
+
+    if var lastOuterCondition = newConditions.last {
+      // Remove existing trailing spaces/trivia before comma to be clean, logic can be refined.
+      // But crucially, we must add a comma.
+      if lastOuterCondition.trailingComma == nil {
+        lastOuterCondition.condition = lastOuterCondition.condition.with(\.trailingTrivia, [])
+        lastOuterCondition.trailingComma = .commaToken(trailingTrivia: .space)
+        // Update the list with the modified condition
+        let lastIndex = newConditions.index(before: newConditions.endIndex)
+        newConditions = newConditions.with(\.[lastIndex], lastOuterCondition)
+      }
+    }
+
+    // Add inner conditions.
+    // We might need to adjust trivia on the first inner condition to look nice (e.g., remove leading newlines if any).
+    let innerConditions = innerIf.conditions
+    newConditions.append(contentsOf: innerConditions)
+
+    // 6. Return new `IfExprSyntax` with combined conditions and inner body.
+    return outerIf.with(\.conditions, newConditions)
+      .with(\.body, innerIf.body)
+  }
+}

Tests/SwiftRefactorTest/CollapseNestedIfStmtTest.swift

@@ -0,0 +1,133 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2026 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftParser
+import SwiftRefactor
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import XCTest
+import _SwiftSyntaxTestSupport
+
+final class CollapseNestedIfStmtTest: XCTestCase {
+  func testCollapseNestedIfStmt() throws {
+    let tests = [
+      (
+        """
+        if a {
+          if b {
+            print("hello")
+          }
+        }
+        """,
+        """
+        if a, b {
+            print("hello")
+          }
+        """
+      ),
+      (
+        """
+        if let x = y {
+          if let z = w {
+            body()
+          }
+        }
+        """,
+        """
+        if let x = y, let z = w {
+            body()
+          }
+        """
+      ),
+      (
+        """
+        if a, b {
+          if c {
+            body()
+          }
+        }
+        """,
+        """
+        if a, b, c {
+            body()
+          }
+        """
+      ),
+      (
+        """
+        if a {
+          // comment
+          if b {
+            body()
+          }
+        }
+        """,
+        """
+        if a, b {
+            body()
+          }
+        """
+      ),
+    ]
+
+    for (input, expected) in tests {
+      let inputSyntax = try XCTUnwrap(ExprSyntax.parse(from: input).as(IfExprSyntax.self))
+      let expectedSyntax = try XCTUnwrap(ExprSyntax.parse(from: expected).as(IfExprSyntax.self))
+
+      try assertRefactor(inputSyntax, context: (), provider: CollapseNestedIfStmt.self, expected: expectedSyntax)
+    }
+  }
+
+  func testCollapseNestedIfStmtFails() throws {
+    let tests = [
+      """
+      if a {
+        print("start")
+        if b {
+          print("hello")
+        }
+      }
+      """,
+      """
+      if a {
+        if b {
+          print("hello")
+        } else {
+          print("else")
+        }
+      }
+      """,
+      """
+      if a {
+        if b {
+          print("hello")
+        }
+      } else {
+        print("outer else")
+      }
+      """,
+    ]
+
+    for input in tests {
+      let inputSyntax = try XCTUnwrap(ExprSyntax.parse(from: input).as(IfExprSyntax.self))
+      // Expect same output as input (no change)
+      try assertRefactor(inputSyntax, context: (), provider: CollapseNestedIfStmt.self, expected: inputSyntax)
+    }
+  }
+}
+
+extension ExprSyntax {
+  static func parse(from source: String) -> ExprSyntax {
+    var parser = Parser(source)
+    return ExprSyntax.parse(from: &parser)
+  }
+}