Adding Let to case

Author: leogdion

Sources/SyntaxKit/PatternConvertible.swift

@@ -60,19 +60,23 @@ extension Int: PatternConvertible {
 
 extension Swift.Range: PatternConvertible where Bound == Int {
   public var patternSyntax: PatternSyntax {
-    let lhs = ExprSyntax(IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.lowerBound))))
+    let lhs = ExprSyntax(
+      IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.lowerBound))))
     let op = ExprSyntax(BinaryOperatorExprSyntax(operator: .binaryOperator("..<")))
-    let rhs = ExprSyntax(IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.upperBound))))
+    let rhs = ExprSyntax(
+      IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.upperBound))))
     let seq = SequenceExprSyntax(elements: ExprListSyntax([lhs, op, rhs]))
     return PatternSyntax(ExpressionPatternSyntax(expression: ExprSyntax(seq)))
   }
 }
 
 extension Swift.ClosedRange: PatternConvertible where Bound == Int {
   public var patternSyntax: PatternSyntax {
-    let lhs = ExprSyntax(IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.lowerBound))))
+    let lhs = ExprSyntax(
+      IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.lowerBound))))
     let op = ExprSyntax(BinaryOperatorExprSyntax(operator: .binaryOperator("...")))
-    let rhs = ExprSyntax(IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.upperBound))))
+    let rhs = ExprSyntax(
+      IntegerLiteralExprSyntax(literal: .integerLiteral(String(self.upperBound))))
     let seq = SequenceExprSyntax(elements: ExprListSyntax([lhs, op, rhs]))
     return PatternSyntax(ExpressionPatternSyntax(expression: ExprSyntax(seq)))
   }
@@ -91,11 +95,11 @@ extension String: PatternConvertible {
 /// A `let` binding pattern for switch cases.
 public struct LetBindingPattern: PatternConvertible {
   private let identifier: String
-  
+
   internal init(identifier: String) {
     self.identifier = identifier
   }
-  
+
   public var patternSyntax: PatternSyntax {
     PatternSyntax(
       ValueBindingPatternSyntax(

Tests/SyntaxKitTests/ConditionalsExampleTests.swift

@@ -95,7 +95,8 @@ import Testing
             ParameterExp(
               name: "",
               value:
-                "\"The string \\\"\\(possibleNumber)\\\" could not be converted to an integer\"")
+                "\"The string \"\\(possibleNumber)\" could not be converted to an integer\""
+            )
           }
         })
 
@@ -220,7 +221,8 @@ import Testing
       }
 
       // MARK: - Switch with value binding
-      Variable(.let, name: "anotherPoint", equals: TupleLiteral([.int(2), .int(0)])).withExplicitType()
+      Variable(.let, name: "anotherPoint", equals: TupleLiteral([.int(2), .int(0)]))
+        .withExplicitType()
         .comment {
           Line("Switch with value binding")
         }

Tests/SyntaxKitTests/PatternConvertibleTests.swift

@@ -27,64 +27,63 @@
 //  OTHER DEALINGS IN THE SOFTWARE.
 //
 
-import Testing
 import SwiftSyntax
+import Testing
 
 @testable import SyntaxKit
 
 internal struct PatternConvertibleTests {
-  
   // MARK: - Let Binding Pattern Tests
-  
+
   @Test internal func testLetBindingPattern() {
     let pattern = Pattern.let("x")
     let syntax = pattern.patternSyntax
-    
+
     let generated = syntax.description
     #expect(generated.contains("let x"))
   }
-  
+
   @Test internal func testLetBindingPatternInTuple() {
     let tuplePattern = Tuple.pattern([Pattern.let("x"), 0])
     let syntax = tuplePattern.patternSyntax
-    
+
     let generated = syntax.description
     #expect(generated.contains("(let x, 0)"))
   }
-  
+
   @Test internal func testLetBindingPatternInSwitchCase() {
     let switchCase = SwitchCase(Tuple.pattern([Pattern.let("x"), Pattern.let("y")])) {
       Call("print") {
         ParameterExp(name: "", value: "\"somewhere else at (\\(x), \\(y))\"")
       }
     }
-    
+
     let generated = switchCase.generateCode()
     #expect(generated.contains("case (let x, let y):"))
     #expect(generated.contains("print(\"somewhere else at (\\(x), \\(y))\")"))
   }
-  
+
   @Test internal func testLetBindingPatternWithSingleElement() {
     let pattern = Pattern.let("value")
     let syntax = pattern.patternSyntax
-    
+
     let generated = syntax.description
     #expect(generated.contains("let value"))
   }
-  
+
   @Test internal func testLetBindingPatternInComplexTuple() {
     let tuplePattern = Tuple.pattern([Pattern.let("x"), 0, Pattern.let("y")])
     let syntax = tuplePattern.patternSyntax
-    
+
     let generated = syntax.description
     #expect(generated.contains("(let x, 0, let y)"))
   }
-  
+
   @Test internal func testLetBindingPatternWithWildcard() {
     let tuplePattern = Tuple.pattern([Pattern.let("x"), nil, Pattern.let("y")])
     let syntax = tuplePattern.patternSyntax
-    
+
     let generated = syntax.description
     #expect(generated.contains("(let x, _, let y)"))
   }
-} 
+}