Refactor: map switch case patterns to constructor_pattern instead of tuple_pattern

Changed the desugaring rules to properly map case patterns with binding (e.g.,
'case .circle(let r):') to constructor_pattern nodes instead of tuple_pattern.

New rules added:
- tuple_pattern_item → pattern_element (preserves optional name/key)
- pattern.kind: binding_pattern → name_pattern (extracts bound identifier)
- pattern.kind: case_pattern → constructor_pattern (creates proper constructor
  with bound arguments as pattern_elements)

This provides a more semantically correct AST representation:
- Constructor name: name_expr identifier 'circle'
- Elements: pattern_element containing name_pattern identifier 'r'

Instead of the previous tuple_pattern string representation.

Updated control-flow.txt corpus outputs.

Author: asgerf

unified/extractor/src/languages/swift/swift.rs

@@ -282,6 +282,32 @@ fn translation_rules() -> Vec<yeast::Rule> {
         rule!((type name: @inner) => {inner}),
         // `directly_assignable_expression` is just a wrapper; unwrap it
         rule!((directly_assignable_expression expr: @inner) => {inner}),
+        // tuple_pattern_item → pattern_element (preserves optional name/key)
+        rule!((tuple_pattern_item name: _? @key pattern: @pat) => (pattern_element key: {..key} pattern: {pat})),
+        rule!((tuple_pattern_item pattern: @pat) => (pattern_element pattern: {pat})),
+        // Pattern with 'let' or 'var' binding: extract the inner pattern
+        // TODO: Names in a pattern need to be translated to expr_equality_pattern if not under a 'var/let' but we lack a way to pass down context to do this.
+        rule!(
+            (pattern kind: (binding_pattern binding: _? pattern: @pattern))
+            =>
+            {pattern}
+        ),
+        // case T.foo(x,y) pattern
+        rule!(
+            (pattern kind: (case_pattern type: @typ name: @name arguments: (tuple_pattern item: (tuple_pattern_item)* @items)? ))
+            =>
+            (constructor_pattern
+                constructor: (member_access_expr base: {typ} member: (identifier #{name}))
+                element: {..items})
+        ),
+        // case .foo(x,y) pattern
+        rule!(
+            (pattern kind: (case_pattern name: @name arguments: (tuple_pattern item: (tuple_pattern_item)* @items)? ))
+            =>
+            (constructor_pattern
+                constructor: (member_access_expr base: (inferred_type_expr) member: (identifier #{name}))
+                element: {..items})
+        ),
         // Pattern with bound_identifier → name_pattern
         rule!((pattern bound_identifier: @name) => (name_pattern identifier: (identifier #{name}))),
         // Tuple pattern (destructuring)

unified/extractor/tests/corpus/swift/control-flow.txt

@@ -692,7 +692,17 @@ top_level
                       callee:
                         name_expr
                           identifier: identifier "print"
-              pattern: tuple_pattern ".circle(let r)"
+              pattern:
+                constructor_pattern
+                  element:
+                    pattern_element
+                      pattern:
+                        name_pattern
+                          identifier: identifier "r"
+                  constructor:
+                    member_access_expr
+                      base: inferred_type_expr ".circle(let r)"
+                      member: identifier "circle"
             switch_case
               body:
                 block
@@ -706,7 +716,17 @@ top_level
                       callee:
                         name_expr
                           identifier: identifier "print"
-              pattern: tuple_pattern ".square(let s)"
+              pattern:
+                constructor_pattern
+                  element:
+                    pattern_element
+                      pattern:
+                        name_pattern
+                          identifier: identifier "s"
+                  constructor:
+                    member_access_expr
+                      base: inferred_type_expr ".square(let s)"
+                      member: identifier "square"
           value:
             name_expr
               identifier: identifier "shape"