@@ -10,6 +10,10 @@ fn translation_rules() -> Vec<yeast::Rule> {
1010 body: { ..children}
1111 )
1212 ) ,
13+ // ---- Binary expressions ----
14+ // Swift's parser produces a different node kind for each operator
15+ // family, but the field shape (`lhs` / `op` / `rhs`) is uniform, so
16+ // each maps onto `binary_expr`.
1317 rule!(
1418 ( additive_expression
1519 lhs: ( _) @left
@@ -33,10 +37,134 @@ fn translation_rules() -> Vec<yeast::Rule> {
3337 right: { right} )
3438 ) ,
3539 rule!(
36- ( simple_identifier)
40+ ( comparison_expression
41+ lhs: ( _) @left
42+ op: _ @operator
43+ rhs: ( _) @right)
44+ =>
45+ ( binary_expr
46+ left: { left}
47+ operator: ( operator #{ operator} )
48+ right: { right} )
49+ ) ,
50+ rule!(
51+ ( equality_expression
52+ lhs: ( _) @left
53+ op: _ @operator
54+ rhs: ( _) @right)
55+ =>
56+ ( binary_expr
57+ left: { left}
58+ operator: ( operator #{ operator} )
59+ right: { right} )
60+ ) ,
61+ rule!(
62+ ( conjunction_expression
63+ lhs: ( _) @left
64+ op: _ @operator
65+ rhs: ( _) @right)
66+ =>
67+ ( binary_expr
68+ left: { left}
69+ operator: ( operator #{ operator} )
70+ right: { right} )
71+ ) ,
72+ rule!(
73+ ( disjunction_expression
74+ lhs: ( _) @left
75+ op: _ @operator
76+ rhs: ( _) @right)
77+ =>
78+ ( binary_expr
79+ left: { left}
80+ operator: ( operator #{ operator} )
81+ right: { right} )
82+ ) ,
83+ rule!(
84+ ( nil_coalescing_expression
85+ lhs: ( _) @left
86+ op: _ @operator
87+ rhs: ( _) @right)
88+ =>
89+ ( binary_expr
90+ left: { left}
91+ operator: ( operator #{ operator} )
92+ right: { right} )
93+ ) ,
94+ rule!(
95+ ( range_expression
96+ start: ( _) @left
97+ op: _ @operator
98+ end: ( _) @right)
99+ =>
100+ ( binary_expr
101+ left: { left}
102+ operator: ( operator #{ operator} )
103+ right: { right} )
104+ ) ,
105+ // ---- Unary expressions ----
106+ rule!(
107+ ( prefix_expression
108+ operation: _ @operator
109+ target: ( _) @operand)
110+ =>
111+ ( unary_expr
112+ operand: { operand}
113+ operator: ( operator #{ operator} ) )
114+ ) ,
115+ // ---- Identifiers / name expressions ----
116+ rule!(
117+ ( simple_identifier) @name
118+ =>
119+ ( name_expr
120+ identifier: ( identifier #{ name} ) )
121+ ) ,
122+ // ---- Literals ----
123+ rule!(
124+ ( integer_literal) @lit
125+ =>
126+ ( int_literal #{ lit} )
127+ ) ,
128+ // String literals: render the *raw* source text, including the
129+ // surrounding quotes. Interpolations (e.g. `"hi \(x)"`) are not
130+ // yet broken out into structured pieces \u2014 they show up as part
131+ // of the literal's source text.
132+ rule!(
133+ ( line_string_literal) @lit
134+ =>
135+ ( string_literal #{ lit} )
136+ ) ,
137+ // ---- Patterns ----
138+ // The Swift parser uses a `pattern` node with a `bound_identifier`
139+ // field for simple bindings such as `let x = ...`.
140+ rule!(
141+ ( pattern bound_identifier: ( simple_identifier) @id)
142+ =>
143+ ( var_pattern
144+ identifier: ( identifier #{ id} ) )
145+ ) ,
146+ // ---- Variable declarations ----
147+ // `let x = e` / `var x = e` (with initializer).
148+ rule!(
149+ ( property_declaration
150+ name: ( _) @pat
151+ value: ( _) @value)
152+ =>
153+ ( variable_declaration_stmt
154+ variable_declarator: ( variable_declarator
155+ pattern: { pat}
156+ value: { value} ) )
157+ ) ,
158+ // `var x: T` (no initializer).
159+ rule!(
160+ ( property_declaration
161+ name: ( _) @pat)
37162 =>
38- name_expr
163+ ( variable_declaration_stmt
164+ variable_declarator: ( variable_declarator
165+ pattern: { pat} ) )
39166 ) ,
167+ // ---- Fallbacks ----
40168 rule!(
41169 ( _)
42170 =>
0 commit comments