adding better tuple support

leogdion · leogdion · commit 464d6346fea7 · 2025-06-19T17:17:36.000-04:00
diff --git a/Examples/Completed/conditionals/code.swift b/Examples/Completed/conditionals/code.swift
@@ -67,4 +67,19 @@ case 100..<1000:
 default:
     naturalCount = "many"
 }
-print("There are \(naturalCount) \(countedThings).")
+print("There are \(naturalCount) \(countedThings).")
+
+// Switch with tuple matching
+let somePoint = (1, 1)
+switch somePoint {
+case (0, 0):
+    print("(0, 0) is at the origin")
+case (_, 0):
+    print("(\(somePoint.0), 0) is on the x-axis")
+case (0, _):
+    print("(0, \(somePoint.1)) is on the y-axis")
+case (-2...2, -2...2):
+    print("(\(somePoint.0), \(somePoint.1)) is inside the box")
+default:
+    print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
+}
diff --git a/Examples/Completed/conditionals/dsl.swift b/Examples/Completed/conditionals/dsl.swift
@@ -104,4 +104,25 @@ Switch("approximateCount") {
         Assignment("naturalCount", Literal.string("many"))
     }
 }
-Call("print", "There are \\(naturalCount) \\(countedThings).")
+Call("print", "There are \\(naturalCount) \\(countedThings).")
+Variable(.let, "somePoint", equals: TupleLiteral([.int(1), .int(1)])).withExplicitType()
+.comment {
+    Line("Switch with tuple matching")
+}
+Switch("somePoint") {
+    SwitchCase(Tuple.pattern([0, 0])) {
+        Call("print", "(0, 0) is at the origin")
+    }
+    SwitchCase(Tuple.pattern([nil, 0])) {
+        Call("print", "(\\(somePoint.0), 0) is on the x-axis")
+    }
+    SwitchCase(Tuple.pattern([0, nil])) {
+        Call("print", "(0, \\(somePoint.1)) is on the y-axis")
+    }
+    SwitchCase(Tuple.pattern([(-2...2), (-2...2)])) {
+        Call("print", "(\\(somePoint.0), \\(somePoint.1)) is inside the box")
+    }
+    Default {
+        Call("print", "(\\(somePoint.0), \\(somePoint.1)) is outside of the box")
+    }
+}
diff --git a/Examples/Completed/conditionals/syntax.json b/Examples/Completed/conditionals/syntax.json
diff --git a/Sources/SyntaxKit/Enum.swift b/Sources/SyntaxKit/Enum.swift
@@ -242,6 +242,8 @@ public struct EnumCase: CodeBlock {
           equal: .equalToken(leadingTrivia: .space, trailingTrivia: .space),
           value: DeclReferenceExprSyntax(baseName: .identifier(value))
         )
+      case .tuple:
+        fatalError("Tuple is not supported as a raw value for enum cases.")
       }
     }
 
diff --git a/Sources/SyntaxKit/Literal.swift b/Sources/SyntaxKit/Literal.swift
@@ -52,6 +52,8 @@ public enum Literal: CodeBlock {
   case boolean(Bool)
   /// A reference to a variable or identifier (outputs without quotes).
   case ref(String)
+  /// A tuple literal.
+  case tuple([Literal?])
 
   /// The SwiftSyntax representation of this literal.
   public var syntax: SyntaxProtocol {
@@ -75,12 +77,90 @@ public enum Literal: CodeBlock {
       return BooleanLiteralExprSyntax(literal: value ? .keyword(.true) : .keyword(.false))
     case .ref(let value):
       return DeclReferenceExprSyntax(baseName: .identifier(value))
+    case .tuple(let elements):
+      let tupleElements = TupleExprElementListSyntax(
+        elements.enumerated().map { index, element in
+          let elementExpr: ExprSyntax
+          if let element = element {
+            elementExpr =
+              element.syntax.as(ExprSyntax.self)
+              ?? ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier("")))
+          } else {
+            // Wildcard pattern - use underscore
+            elementExpr = ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier("_")))
+          }
+          return TupleExprElementSyntax(
+            label: nil,
+            colon: nil,
+            expression: elementExpr,
+            trailingComma: index < elements.count - 1 ? .commaToken(trailingTrivia: .space) : nil
+          )
+        }
+      )
+      return TupleExprSyntax(
+        leftParen: .leftParenToken(),
+        elements: tupleElements,
+        rightParen: .rightParenToken()
+      )
     }
   }
 }
 
 // MARK: - LiteralValue Implementations
 
+/// A tuple value that can be used as a literal.
+public struct TupleLiteral: LiteralValue {
+  private let elements: [Literal?]
+
+  /// Creates a tuple with the given elements.
+  /// - Parameter elements: The tuple elements, where `nil` represents a wildcard.
+  public init(_ elements: [Literal?]) {
+    self.elements = elements
+  }
+
+  /// The Swift type name for this tuple.
+  public var typeName: String {
+    let elementTypes = elements.map { element in
+      if let element = element {
+        switch element {
+        case .integer: return "Int"
+        case .float: return "Double"
+        case .string: return "String"
+        case .boolean: return "Bool"
+        case .nil: return "Any?"
+        case .ref: return "Any"
+        case .tuple: return "Any"
+        }
+      } else {
+        return "Any"
+      }
+    }
+    return "(\(elementTypes.joined(separator: ", ")))"
+  }
+
+  /// Renders this tuple as a Swift literal string.
+  public var literalString: String {
+    let elementStrings = elements.map { element in
+      if let element = element {
+        switch element {
+        case .integer(let value): return String(value)
+        case .float(let value): return String(value)
+        case .string(let value): return "\"\(value)\""
+        case .boolean(let value): return value ? "true" : "false"
+        case .nil: return "nil"
+        case .ref(let value): return value
+        case .tuple(let tupleElements):
+          let tuple = TupleLiteral(tupleElements)
+          return tuple.literalString
+        }
+      } else {
+        return "_"
+      }
+    }
+    return "(\(elementStrings.joined(separator: ", ")))"
+  }
+}
+
 extension Array: LiteralValue where Element == String {
   /// The Swift type name for an array of strings.
   public var typeName: String { "[String]" }
@@ -122,3 +202,27 @@ extension Dictionary: LiteralValue where Key == Int, Value == String {
     return "[\(elements)]"
   }
 }
+
+// MARK: - Convenience Methods
+
+extension Literal {
+  /// Creates a tuple literal from an array of optional literals (for patterns with wildcards).
+  public static func tuplePattern(_ elements: [Literal?]) -> Literal {
+    .tuple(elements)
+  }
+
+  /// Creates an integer literal.
+  public static func int(_ value: Int) -> Literal {
+    .integer(value)
+  }
+
+  /// Converts a Literal.tuple to a TupleLiteral for use in Variable declarations.
+  public var asTupleLiteral: TupleLiteral? {
+    switch self {
+    case .tuple(let elements):
+      return TupleLiteral(elements)
+    default:
+      return nil
+    }
+  }
+}
diff --git a/Sources/SyntaxKit/Tuple.swift b/Sources/SyntaxKit/Tuple.swift
@@ -41,6 +41,12 @@ public struct Tuple: CodeBlock {
     self.elements = content()
   }
 
+  /// Creates a tuple pattern for switch cases.
+  /// - Parameter elements: Array of pattern elements, where `nil` represents a wildcard pattern.
+  public static func pattern(_ elements: [PatternConvertible?]) -> TuplePattern {
+    TuplePattern(elements: elements)
+  }
+
   public var syntax: SyntaxProtocol {
     guard !elements.isEmpty else {
       fatalError("Tuple must contain at least one element.")
@@ -69,3 +75,45 @@ public struct Tuple: CodeBlock {
     return tupleExpr
   }
 }
+
+/// A tuple pattern for switch cases.
+public struct TuplePattern: PatternConvertible {
+  private let elements: [PatternConvertible?]
+
+  internal init(elements: [PatternConvertible?]) {
+    self.elements = elements
+  }
+
+  public var patternSyntax: PatternSyntax {
+    let patternElements = TuplePatternElementListSyntax(
+      elements.enumerated().map { index, element in
+        let patternElement: TuplePatternElementSyntax
+        if let element = element {
+          patternElement = TuplePatternElementSyntax(
+            label: nil,
+            colon: nil,
+            pattern: element.patternSyntax,
+            trailingComma: index < elements.count - 1 ? .commaToken(trailingTrivia: .space) : nil
+          )
+        } else {
+          // Wildcard pattern
+          patternElement = TuplePatternElementSyntax(
+            label: nil,
+            colon: nil,
+            pattern: PatternSyntax(WildcardPatternSyntax(wildcard: .wildcardToken())),
+            trailingComma: index < elements.count - 1 ? .commaToken(trailingTrivia: .space) : nil
+          )
+        }
+        return patternElement
+      }
+    )
+
+    return PatternSyntax(
+      TuplePatternSyntax(
+        leftParen: .leftParenToken(),
+        elements: patternElements,
+        rightParen: .rightParenToken()
+      )
+    )
+  }
+}
diff --git a/Tests/SyntaxKitTests/ConditionalsExampleTests.swift b/Tests/SyntaxKitTests/ConditionalsExampleTests.swift
@@ -183,6 +183,41 @@ import Testing
       Call("print") {
         ParameterExp(name: "", value: "\"There are \\(naturalCount) \\(countedThings).\"")
       }
+
+      // MARK: - Tuple literal and tuple pattern switch
+      Variable(.let, name: "somePoint", equals: TupleLiteral([.int(1), .int(1)]))
+        .comment {
+          Line("Switch with tuple matching")
+        }
+      Switch("somePoint") {
+        SwitchCase(Tuple.pattern([0, 0])) {
+          Call("print") {
+            ParameterExp(name: "", value: "\"(0, 0) is at the origin\"")
+          }
+        }
+        SwitchCase(Tuple.pattern([nil, 0])) {
+          Call("print") {
+            ParameterExp(name: "", value: "\"(\\(somePoint.0), 0) is on the x-axis\"")
+          }
+        }
+        SwitchCase(Tuple.pattern([0, nil])) {
+          Call("print") {
+            ParameterExp(name: "", value: "\"(0, \\(somePoint.1)) is on the y-axis\"")
+          }
+        }
+        SwitchCase(Tuple.pattern([(-2...2), (-2...2)])) {
+          Call("print") {
+            ParameterExp(
+              name: "", value: "\"(\\(somePoint.0), \\(somePoint.1)) is inside the box\"")
+          }
+        }
+        Default {
+          Call("print") {
+            ParameterExp(
+              name: "", value: "\"(\\(somePoint.0), \\(somePoint.1)) is outside of the box\"")
+          }
+        }
+      }
     }
 
     // Generate Swift from DSL
diff --git a/Tests/SyntaxKitTests/LiteralValueTests.swift b/Tests/SyntaxKitTests/LiteralValueTests.swift
@@ -108,4 +108,109 @@ internal struct LiteralValueTests {
     #expect(literal2.contains("2: \"b\""))
     #expect(literal2.contains("3: \"c\""))
   }
+
+  // MARK: - TupleLiteral Tests
+
+  @Test internal func testTupleLiteralTypeName() {
+    let tuple1 = TupleLiteral([.int(1), .int(2)])
+    #expect(tuple1.typeName == "(Int, Int)")
+
+    let tuple2 = TupleLiteral([.string("hello"), .int(42), .boolean(true)])
+    #expect(tuple2.typeName == "(String, Int, Bool)")
+
+    let tuple3 = TupleLiteral([.int(1), nil, .string("test")])
+    #expect(tuple3.typeName == "(Int, Any, String)")
+
+    let tuple4 = TupleLiteral([nil, nil])
+    #expect(tuple4.typeName == "(Any, Any)")
+  }
+
+  @Test internal func testTupleLiteralString() {
+    let tuple1 = TupleLiteral([.int(1), .int(2)])
+    #expect(tuple1.literalString == "(1, 2)")
+
+    let tuple2 = TupleLiteral([.string("hello"), .int(42), .boolean(true)])
+    #expect(tuple2.literalString == "(\"hello\", 42, true)")
+
+    let tuple3 = TupleLiteral([.int(1), nil, .string("test")])
+    #expect(tuple3.literalString == "(1, _, \"test\")")
+
+    let tuple4 = TupleLiteral([nil, nil])
+    #expect(tuple4.literalString == "(_, _)")
+
+    let tuple5 = TupleLiteral([.float(3.14), .nil])
+    #expect(tuple5.literalString == "(3.14, nil)")
+  }
+
+  @Test internal func testTupleLiteralWithNestedTuples() {
+    let nestedTuple = TupleLiteral([.int(1), .tuple([.string("nested"), .int(2)])])
+    #expect(nestedTuple.typeName == "(Int, Any)")
+    #expect(nestedTuple.literalString == "(1, (\"nested\", 2))")
+  }
+
+  @Test internal func testTupleLiteralWithRef() {
+    let tuple = TupleLiteral([.ref("variable"), .int(42)])
+    #expect(tuple.typeName == "(Any, Int)")
+    #expect(tuple.literalString == "(variable, 42)")
+  }
+
+  @Test internal func testEmptyTupleLiteral() {
+    let tuple = TupleLiteral([])
+    #expect(tuple.typeName == "()")
+    #expect(tuple.literalString == "()")
+  }
+
+  // MARK: - TupleLiteral Code Generation Tests
+
+  @Test internal func testVariableWithTupleLiteral() {
+    let tuple = TupleLiteral([.int(1), .int(2)])
+    let variable = Variable(.let, name: "point", equals: tuple)
+
+    let generated = variable.syntax.description
+    #expect(generated.contains("let point  = (1, 2)"))
+    #expect(generated.contains("point"))
+  }
+
+  @Test internal func testVariableWithTupleLiteralWithExplicitType() {
+    let tuple = TupleLiteral([.int(1), .int(2)])
+    let variable = Variable(.let, name: "point", equals: tuple).withExplicitType()
+
+    let generated = variable.syntax.description
+    #expect(generated.contains("let point  : (Int, Int) = (1, 2)"))
+    #expect(generated.contains("point"))
+  }
+
+  @Test internal func testVariableWithComplexTupleLiteral() {
+    let tuple = TupleLiteral([.string("hello"), .int(42), .boolean(true)])
+    let variable = Variable(.let, name: "data", equals: tuple).withExplicitType()
+
+    let generated = variable.syntax.description
+    #expect(generated.contains("let data  : (String, Int, Bool) = (\"hello\", 42, true)"))
+    #expect(generated.contains("data"))
+  }
+
+  @Test internal func testVariableWithTupleLiteralWithWildcards() {
+    let tuple = TupleLiteral([.int(1), nil, .string("test")])
+    let variable = Variable(.let, name: "partial", equals: tuple).withExplicitType()
+
+    let generated = variable.syntax.description
+    #expect(generated.contains("let partial  : (Int, Any, String) = (1, _, \"test\")"))
+    #expect(generated.contains("partial"))
+  }
+
+  @Test internal func testLiteralAsTupleLiteralConversion() {
+    let literal = Literal.tuple([.int(1), .int(2)])
+    let tupleLiteral = literal.asTupleLiteral
+
+    #expect(tupleLiteral != nil)
+    #expect(tupleLiteral?.typeName == "(Int, Int)")
+    #expect(tupleLiteral?.literalString == "(1, 2)")
+  }
+
+  @Test internal func testNonTupleLiteralAsTupleLiteralConversion() {
+    let literal = Literal.int(42)
+    let tupleLiteral = literal.asTupleLiteral
+
+    #expect(tupleLiteral == nil)
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -242,6 +242,8 @@ public struct EnumCase: CodeBlock {`
`242`	`242`	`equal: .equalToken(leadingTrivia: .space, trailingTrivia: .space),`
`243`	`243`	`value: DeclReferenceExprSyntax(baseName: .identifier(value))`
`244`	`244`	`)`
	`245`	`+ case .tuple:`
	`246`	`+ fatalError("Tuple is not supported as a raw value for enum cases.")`
`245`	`247`	`}`
`246`	`248`	`}`
`247`	`249`