unified: Fix translation of tuple expressions

Author: asgerf

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

@@ -297,14 +297,14 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!((sequenceExpr elements: _* @els) => (unresolved_operator_sequence element: {els})),
         // Prefix unary operators (`!a`, `-x`).
         rule!((prefixOperatorExpr operator: @op expression: @operand) => (unary_expr operator: (prefix_operator #{op}) operand: {operand})),
-        // A `tupleExpr` is a tuple literal (`(a, b)`) or a parenthesised
-        // expression (`(x)`). For now it is kept as an opaque `tuple_expr` leaf
-        // (its source text); its elements are not descended into.
-        //
-        // TODO: a parenthesised single-element `tupleExpr` is really a grouping
-        // expression and should be elided (unwrapped to its inner expression)
-        // rather than modelled as a tuple.
-        rule!((tupleExpr) => (tuple_expr)),
+        // A parenthesised expression has a single tuple element; elide the
+        // grouping and preserve the expression itself. Actual tuple literals
+        // retain their translated labeled elements as `argument` children.
+        rule!((tupleExpr
+            elements: (labeledExpr label: _? @@lbl expression: @element)
+            elements: _* @@rest)
+            where rest.is_empty() && lbl.is_none() => expr { element }),
+        rule!((tupleExpr elements: _* @elements) => (tuple_expr element: {elements})),
         // A code block contains its statements directly.
         rule!((codeBlock statements: _* @stmts) => (block stmt: {stmts})),
         // ---- Properties with accessors ----

unified/extractor/tests/corpus/swift/collections/tuple-literal.output

@@ -52,4 +52,12 @@ top_level
         variable_declaration
           modifier: modifier "let"
           pattern: identifier "t"
-          value: tuple_expr "(1, \"two\", 3.0)"
+          value:
+            tuple_expr
+              element:
+                argument
+                  value: int_literal "1"
+                argument
+                  value: string_literal "\"two\""
+                argument
+                  value: float_literal "3.0"

unified/extractor/tests/corpus/swift/control-flow/switch-expression-pattern.output

@@ -333,7 +333,12 @@ top_level
                     member_access_expr
                       base: inferred_type_expr "."
                       member_name_node: identifier "inferred"
-                    tuple_expr "(value, offset)"
+                    tuple_expr
+                      element:
+                        argument
+                          value: identifier "value"
+                        argument
+                          value: identifier "offset"
                     array_literal
                       element: identifier "value"
                     map_literal "[key: value]"

unified/extractor/tests/corpus/swift/operators/parenthesised-expression.output

@@ -39,6 +39,10 @@ top_level
     block
       stmt:
         binary_expr
-          left: tuple_expr "(a + b)"
+          left:
+            binary_expr
+              left: identifier "a"
+              operator: infix_operator "+"
+              right: identifier "b"
           operator: infix_operator "*"
           right: identifier "c"

unified/ql/test/library-tests/BasicTest/test.expected

@@ -129,6 +129,7 @@ identifier
 | test.swift:74:10:74:17 | isSorted | isSorted |
 | test.swift:74:24:74:27 | Bool | Bool |
 | test.swift:75:13:75:13 | i | i |
+| test.swift:75:23:75:27 | count | count |
 | test.swift:76:16:76:19 | self | self |
 | test.swift:76:21:76:21 | i | i |
 | test.swift:76:26:76:29 | self | self |