Unified: Refine Swift block locations

Translate implicit accessor blocks through a dedicated rule and keep closure delimiters on function expressions rather than their body blocks. Also inline the synthetic enum constructor body.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: tausbn

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

@@ -62,17 +62,6 @@ impl SwiftContext {
     }
 }
 
-fn block_with_anchor(
-    ctx: &mut yeast::build::BuildCtx<'_, SwiftContext>,
-    statements: Vec<yeast::Id>,
-    anchor: Option<yeast::Id>,
-) -> yeast::Id {
-    match anchor {
-        Some(anchor) => tree_at!(ctx, anchor, (block stmt: {statements})),
-        None => tree!(ctx, (block stmt: {statements})),
-    }
-}
-
 /// Build a freshly-created `chained_declaration` modifier node if
 /// `ctx.is_chained`, else `None`. Used by inner declaration rules to
 /// emit the chained tag for non-first children of a flattening outer
@@ -301,6 +290,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!((tupleExpr elements: _* @elements) => (tuple_expr element: {elements})),
         // A code block contains its statements directly.
         rule!((codeBlock statements: _* @stmts) => (block stmt: {stmts})),
+        rule!((accessorBlock accessors: (codeBlockItem)* @stmts) => (block stmt: {stmts})),
         // ---- Properties with accessors ----
         // A computed property with an implicit getter (`var a: T { <stmts> }`)
         // becomes a single `accessor_declaration` of kind `get`. This form is
@@ -313,14 +303,14 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                 bindings: (patternBinding
                     pattern: (identifierPattern identifier: @@name)
                     typeAnnotation: (typeAnnotation type: @ty)
-                    accessorBlock: (accessorBlock accessors: (codeBlockItem)+ @body) @@accessor_block))
+                    accessorBlock: (accessorBlock accessors: (codeBlockItem)+) @body))
             =>
             (accessor_declaration
                 modifier: (modifier #{spec})
                 name_node: (identifier #{name})
                 type: {ty}
-                accessor_kind: {ctx.literal_at_start_of("accessor_kind", "get", accessor_block)}
-                body: {block_with_anchor(&mut ctx, body, Some(accessor_block))})
+                accessor_kind: {ctx.literal_at_start_of("accessor_kind", "get", body)}
+                body: {body})
         ),
         // A property with an explicit accessor block. swift-syntax makes both
         // shapes plain `accessorDecl`s, so they are told apart by the presence
@@ -485,11 +475,10 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                 parameterClause: (enumCaseParameterClause parameters: _* @params) @@clause)
             =>
             class_like_declaration {
-                let body = tree!((block));
                 let constructor = tree_spanning!(
                     ctx,
                     [name, clause],
-                    (constructor_declaration parameter: {params} body: {body})
+                    (constructor_declaration parameter: {params} body: (block))
                 );
                 tree!((class_like_declaration
                     modifier: {ctx.outer_modifiers.clone()}
@@ -803,14 +792,14 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                     capture: (closureCaptureClause items: _* @captures)?
                     parameterClause: _* @params
                     returnClause: (returnClause type: @ret)?)?
-                statements: _* @body) @@closure
+                statements: _* @body)
             =>
             (function_expr
                 modifier: {attrs}
                 capture_declaration: {captures}
                 parameter: {params}
                 return_type: {ret}
-                body: {block_with_anchor(&mut ctx, body, Some(closure))})
+                body: (block stmt: {body}))
         ),
         // A closure capture (`[weak self]`, `[x]`, `[y = expr]`). The optional
         // ownership specifier (`weak`/`unowned`) becomes a modifier; the

unified/extractor/tests/corpus/swift/closures/closure-with-capture-list.output

@@ -68,13 +68,13 @@ top_level source="⟨body⟩"
           modifier: modifier "let" source="let"
           pattern: identifier "f" source="f"
           value:
-            function_expr source="⟨body⟩⟨capture_declaration⟩"
+            function_expr source="{ [⟨capture_declaration⟩] in ⟨body⟩ }"
               capture_declaration:
                 variable_declaration source="⟨modifier⟩ ⟨pattern⟩"
                   modifier: modifier "weak" source="weak"
                   pattern: identifier "self" source="self"
               body:
-                block source="{ [weak self] in ⟨stmt⟩ }"
+                block source="⟨stmt⟩"
                   stmt:
                     call_expr source="⟨callee⟩()"
                       callee:

unified/extractor/tests/corpus/swift/closures/closure-with-explicit-parameters.output

@@ -70,14 +70,14 @@ top_level source="⟨body⟩"
           modifier: modifier "let" source="let"
           pattern: identifier "f" source="f"
           value:
-            function_expr source="⟨body⟩⟨parameter⟩⟨return_type⟩"
+            function_expr source="{ (⟨parameter⟩) -> ⟨return_type⟩ in ⟨body⟩ }"
               parameter:
                 parameter source="⟨pattern⟩: ⟨type⟩"
                   type: identifier "Int" source="Int"
                   pattern: identifier "x" source="x"
               return_type: identifier "Int" source="Int"
               body:
-                block source="{ (x: Int) -> Int in ⟨stmt⟩ }"
+                block source="⟨stmt⟩"
                   stmt:
                     binary_expr source="⟨left⟩ ⟨operator⟩ ⟨right⟩"
                       left: identifier "x" source="x"

unified/extractor/tests/corpus/swift/closures/closure-with-shorthand-parameters.output

@@ -47,9 +47,9 @@ top_level source="⟨body⟩"
           modifier: modifier "let" source="let"
           pattern: identifier "f" source="f"
           value:
-            function_expr source="⟨body⟩"
+            function_expr source="{ ⟨body⟩ }"
               body:
-                block source="{ ⟨stmt⟩ }"
+                block source="⟨stmt⟩"
                   stmt:
                     binary_expr source="⟨left⟩ ⟨operator⟩ ⟨right⟩"
                       left: identifier "$0" source="$0"

unified/extractor/tests/corpus/swift/closures/multi-statement-closure.output

@@ -101,14 +101,14 @@ top_level source="⟨body⟩"
           modifier: modifier "let" source="let"
           pattern: identifier "f" source="f"
           value:
-            function_expr source="⟨body⟩⟨parameter⟩⟨return_type⟩"
+            function_expr source="{ (⟨parameter⟩) -> ⟨return_type⟩ in\n  ⟨body⟩\n}"
               parameter:
                 parameter source="⟨pattern⟩: ⟨type⟩"
                   type: identifier "Int" source="Int"
                   pattern: identifier "x" source="x"
               return_type: identifier "Int" source="Int"
               body:
-                block source="{ (x: Int) -> Int in\n  ⟨stmt⟩\n  ⟨stmt⟩\n}"
+                block source="⟨stmt⟩\n  ⟨stmt⟩"
                   stmt:
                     variable_declaration source="⟨modifier⟩ ⟨pattern⟩ = ⟨value⟩"
                       modifier: modifier "let" source="let"

unified/extractor/tests/corpus/swift/closures/trailing-closure.output

@@ -51,9 +51,9 @@ top_level source="⟨body⟩"
           argument:
             argument source="⟨value⟩"
               value:
-                function_expr source="⟨body⟩"
+                function_expr source="{ ⟨body⟩ }"
                   body:
-                    block source="{ ⟨stmt⟩ }"
+                    block source="⟨stmt⟩"
                       stmt:
                         binary_expr source="⟨left⟩ ⟨operator⟩ ⟨right⟩"
                           left: identifier "$0" source="$0"

unified/extractor/tests/corpus/swift/expressions/array-type-constructor.output

@@ -158,14 +158,14 @@ top_level source="⟨body⟩"
                   value: int_literal "1" source="1"
                 argument source="⟨value⟩"
                   value:
-                    function_expr source="⟨body⟩⟨parameter⟩⟨parameter⟩"
+                    function_expr source="{ ⟨parameter⟩, ⟨parameter⟩ in\n\t⟨body⟩\n}"
                       parameter:
                         parameter source="⟨pattern⟩"
                           pattern: identifier "_" source="_"
                         parameter source="⟨pattern⟩"
                           pattern: identifier "count" source="count"
                       body:
-                        block source="{ _, count in\n\t⟨stmt⟩\n}"
+                        block source="⟨stmt⟩"
                           stmt:
                             binary_expr source="⟨left⟩ ⟨operator⟩ ⟨right⟩"
                               left: identifier "count" source="count"

unified/extractor/tests/corpus/swift/types/function-type-with-convention-attribute.output

@@ -67,5 +67,5 @@ top_level source="⟨body⟩"
           pattern: identifier "callback" source="callback"
           type: unsupported_node "@convention(c) () -> Void" source="@convention(c) () -> Void"
           value:
-            function_expr source="⟨body⟩"
-              body: block "{}" source="{}"
+            function_expr source="{}"
+              body: block source=""

unified/extractor/tests/corpus/swift/types/function-type-with-sendable-attribute.output

@@ -60,5 +60,5 @@ top_level source="⟨body⟩"
           pattern: identifier "handler" source="handler"
           type: unsupported_node "@Sendable () -> Void" source="@Sendable () -> Void"
           value:
-            function_expr source="⟨body⟩"
-              body: block "{}" source="{}"
+            function_expr source="{}"
+              body: block source=""

unified/extractor/tests/location_tests.rs

@@ -118,6 +118,14 @@ fn declaration_and_operator_tokens_keep_precise_ranges() {
     assert_has_span(&ast, source, "infix_operator", Some("is"), "is");
 }
 
+#[test]
+fn closure_bodies_exclude_closure_delimiters() {
+    let source = "let f = { (x: Int) -> Int in x * 2 }";
+    let ast = desugar(source);
+
+    assert_has_span(&ast, source, "block", None, "x * 2");
+}
+
 #[test]
 fn synthetic_optional_binding_nodes_anchor_to_binding_keyword() {
     let source = "if let value = optional {}";