Refactor MigrateToNewIfLetSyntax Into a RefactoringProvider

Pull the MigrateToNewIfLetSyntax transform into SwiftRefactor as its first refactoring action. This action transforms all optional binding conditions in if statements into the new Swift 5.7 if-let shorthand syntax.

Before:

 ```swift
 if let foo = foo {
   // ...
 }
 ```

After:

 ```swift
 if let foo {
   // ...
 }

Author: CodaFi

Examples/Package.swift

@@ -10,7 +10,6 @@ let package = Package(
     products: [
         .executable(name: "AddOneToIntegerLiterals", targets: ["AddOneToIntegerLiterals"]),
         .executable(name: "CodeGenerationUsingSwiftSyntaxBuilder", targets: ["CodeGenerationUsingSwiftSyntaxBuilder"]),
-        .executable(name: "MigrateToNewIfLetSyntax", targets: ["MigrateToNewIfLetSyntax"]),
     ],
     dependencies: [
         .package(path: "../"),
@@ -23,24 +22,15 @@ let package = Package(
                 .product(name: "SwiftSyntax", package: "swift-syntax"),
             ],
             path: ".",
-            exclude: ["README.md", "CodeGenerationUsingSwiftSyntaxBuilder.swift", "MigrateToNewIfLetSyntax.swift"]
+            exclude: ["README.md", "CodeGenerationUsingSwiftSyntaxBuilder.swift"]
         ),
         .executableTarget(
             name: "CodeGenerationUsingSwiftSyntaxBuilder",
             dependencies: [
                 .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
             ],
             path: ".",
-            exclude: ["README.md", "AddOneToIntegerLiterals.swift", "MigrateToNewIfLetSyntax.swift"]
-        ),
-        .executableTarget(
-            name: "MigrateToNewIfLetSyntax",
-            dependencies: [
-                .product(name: "SwiftParser", package: "swift-syntax"),
-                .product(name: "SwiftSyntax", package: "swift-syntax"),
-            ],
-            path: ".",
-            exclude: ["README.md", "CodeGenerationUsingSwiftSyntaxBuilder.swift", "AddOneToIntegerLiterals.swift"]
+            exclude: ["README.md", "AddOneToIntegerLiterals.swift"]
         ),
     ]
 )

Examples/README.md

@@ -4,7 +4,6 @@ Each example can be executed by navigating into this folder and running `swift r
 
 - [AddOneToIntegerLiterals](AddOneToIntegerLiterals.swift): Command line tool to add 1 to every integer literal in a source file
 - [CodeGenerationUsingSwiftSyntaxBuilder](CodeGenerationUsingSwiftSyntaxBuilder.swift): Code-generate a simple source file using SwiftSyntaxBuilder
-- [MigrateToNewIfLetSyntax](MigrateToNewIfLetSyntax.swift): Command line tool to transform optional bindings in `if` statements to the new shorthand syntax
 
 ## Some Example Usages
 

Examples/MigrateToNewIfLetSyntax.swift renamed to Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift

@@ -1,34 +1,39 @@
-import Foundation
 import SwiftSyntax
 import SwiftParser
 
-/// MigrateToNewIfLetSyntax will visit each `if` statement in the syntax tree
-/// replacing all "old style" optional bindings by the new shorter syntax available
-/// since Swift 5.7.
+/// ``MigrateToNewIfLetSyntax`` will visit each if statement in the Syntax tree, and
+/// checks if the there is an if condition which is of the pre Swift 5.7 "if-let-style"
+/// and rewrites it to the new one.
 ///
-/// For example, it will turn:
-/// ```
+/// - Seealso: https://github.com/apple/swift-evolution/blob/main/proposals/0345-if-let-shorthand.md
+///
+/// ## Before
+///
+/// ```swift
 /// if let foo = foo {
-///   ...
+///   // ...
 /// }
 /// ```
-/// into:
-/// ```
+///
+/// ## After
+///
+/// ```swift
 /// if let foo {
-///   ...
+///   // ...
 /// }
-class MigrateToNewIfLetSyntax: SyntaxRewriter {
-  // Visit all `if` statements.
-  override func visit(_ node: IfStmtSyntax) -> StmtSyntax {
+public struct MigrateToNewIfLetSyntax: RefactoringProvider {
+  public static func refactor(syntax node: IfStmtSyntax, in context: ()) -> StmtSyntax? {
     // Visit all conditions in the node.
     let newConditions = node.conditions.enumerated().map { (index, condition) in
       var conditionCopy = condition
       // Check if the condition is an optional binding ...
       if var binding = condition.condition.as(OptionalBindingConditionSyntax.self),
-         // ... and has an initializer ...
-         let initializer = binding.initializer,
+         // ... that binds an identifier (and not a tuple) ...
+         let bindingIdentifier = binding.pattern.as(IdentifierPatternSyntax.self),
+         // ... and has an initializer that is also an identifier ...
+         let initializerIdentifier = binding.initializer?.value.as(IdentifierExprSyntax.self),
          // ... and both sides of the assignment are the same identifiers.
-         binding.pattern.withoutTrivia().description == initializer.value.withoutTrivia().description {
+         bindingIdentifier.identifier.text == initializerIdentifier.identifier.text {
         // Remove the initializer ...
         binding.initializer = nil
         // ... and remove whitespace before the comma (in `if` statements with multiple conditions).
@@ -42,15 +47,3 @@ class MigrateToNewIfLetSyntax: SyntaxRewriter {
     return StmtSyntax(node.withConditions(ConditionElementListSyntax(newConditions)))
   }
 }
-
-@main
-struct Main {
-  static func main() throws {
-    let file = CommandLine.arguments[1]
-    let url = URL(fileURLWithPath: file)
-    let source = try String(contentsOf: url, encoding: .utf8)
-    let sourceFile = Parser.parse(source: source)
-    let rewritten = MigrateToNewIfLetSyntax().visit(sourceFile)
-    print(rewritten)
-  }
-}

Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift

@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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 SwiftRefactor
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+import XCTest
+import _SwiftSyntaxTestSupport
+
+final class MigrateToNewIfLetSyntaxTest: XCTestCase {
+  func testRefactoring() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x {}
+      """
+
+    let expectedSyntax: StmtSyntax = """
+      if let x {}
+      """
+
+    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
+    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
+
+    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+
+    AssertStringsEqualWithDiff(expected.description, refactored.description)
+  }
+
+  func testIdempotence() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x {}
+      """
+
+    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
+
+    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+    let refactoredAgain = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+
+    AssertStringsEqualWithDiff(refactored.description, refactoredAgain.description)
+  }
+
+  func testMultiBinding() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x, var y = y, let z = z {}
+      """
+
+    let expectedSyntax: StmtSyntax = """
+      if let x, var y, let z {}
+      """
+
+    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
+    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
+
+    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+
+    AssertStringsEqualWithDiff(expected.description, refactored.description)
+  }
+
+  func testMixedBinding() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x, var y = x, let z = y.w {}
+      """
+
+    let expectedSyntax: StmtSyntax = """
+      if let x, var y = x, let z = y.w {}
+      """
+
+    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
+    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
+
+    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+
+    AssertStringsEqualWithDiff(expected.description, refactored.description)
+  }
+
+  func testConditions() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x + 1, x == x, !x {}
+      """
+
+    let expectedSyntax: StmtSyntax = """
+      if let x = x + 1, x == x, !x {}
+      """
+
+    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
+    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
+
+    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+
+    AssertStringsEqualWithDiff(expected.description, refactored.description)
+  }
+
+  func testWhitespaceNormalization() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x   , let y = y {}
+      """
+
+    let expectedSyntax: StmtSyntax = """
+      if let x, let y {}
+      """
+
+    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
+    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
+
+    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+
+    AssertStringsEqualWithDiff(expected.description, refactored.description)
+  }
+}

build-script.py

@@ -766,7 +766,6 @@ def build_command(args: argparse.Namespace) -> None:
         # Build examples
         builder.buildExample("AddOneToIntegerLiterals")
         builder.buildExample("CodeGenerationUsingSwiftSyntaxBuilder")
-        builder.buildExample("MigrateToNewIfLetSyntax")
     except subprocess.CalledProcessError as e:
         fail_for_called_process_error("Building SwiftSyntax failed", e)