toasty_core/stmt/
visit_mut.rs

1#![allow(unused_variables)]
2
3use super::{
4    Assignment, Assignments, Association, Condition, Cte, Delete, Expr, ExprAnd, ExprAny, ExprArg,
5    ExprBinaryOp, ExprCast, ExprColumn, ExprError, ExprExists, ExprFunc, ExprInList,
6    ExprInSubquery, ExprIsNull, ExprIsVariant, ExprLet, ExprList, ExprMap, ExprMatch, ExprNot,
7    ExprOr, ExprProject, ExprRecord, ExprReference, ExprSet, ExprSetOp, ExprStmt, Filter,
8    FuncCount, FuncLastInsertId, Insert, InsertTarget, Join, JoinOp, Limit, Node, Offset, OrderBy,
9    OrderByExpr, Path, Projection, Query, Returning, Select, Source, SourceModel, SourceTable,
10    SourceTableId, Statement, TableDerived, TableFactor, TableRef, TableWithJoins, Type, Update,
11    UpdateTarget, Value, ValueRecord, Values, With,
12};
13
14pub trait VisitMut {
15    fn visit_mut<N: Node>(&mut self, i: &mut N)
16    where
17        Self: Sized,
18    {
19        i.visit_mut(self);
20    }
21
22    fn visit_assignment_mut(&mut self, i: &mut Assignment) {
23        visit_assignment_mut(self, i);
24    }
25
26    fn visit_assignments_mut(&mut self, i: &mut Assignments) {
27        visit_assignments_mut(self, i);
28    }
29
30    fn visit_association_mut(&mut self, i: &mut Association) {
31        visit_association_mut(self, i);
32    }
33
34    fn visit_cte_mut(&mut self, i: &mut Cte) {
35        visit_cte_mut(self, i);
36    }
37
38    fn visit_expr_mut(&mut self, i: &mut Expr) {
39        visit_expr_mut(self, i);
40    }
41
42    fn visit_expr_and_mut(&mut self, i: &mut ExprAnd) {
43        visit_expr_and_mut(self, i);
44    }
45
46    fn visit_expr_any_mut(&mut self, i: &mut ExprAny) {
47        visit_expr_any_mut(self, i);
48    }
49
50    fn visit_expr_arg_mut(&mut self, i: &mut ExprArg) {
51        visit_expr_arg_mut(self, i);
52    }
53
54    fn visit_expr_binary_op_mut(&mut self, i: &mut ExprBinaryOp) {
55        visit_expr_binary_op_mut(self, i);
56    }
57
58    fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
59        visit_expr_cast_mut(self, i);
60    }
61
62    fn visit_expr_column_mut(&mut self, i: &mut ExprColumn) {
63        visit_expr_column_mut(self, i);
64    }
65
66    fn visit_expr_default_mut(&mut self) {
67        visit_expr_default_mut(self);
68    }
69
70    fn visit_expr_error_mut(&mut self, i: &mut ExprError) {
71        visit_expr_error_mut(self, i);
72    }
73
74    fn visit_expr_exists_mut(&mut self, i: &mut ExprExists) {
75        visit_expr_exists_mut(self, i);
76    }
77
78    fn visit_expr_func_mut(&mut self, i: &mut ExprFunc) {
79        visit_expr_func_mut(self, i);
80    }
81
82    fn visit_expr_func_count_mut(&mut self, i: &mut FuncCount) {
83        visit_expr_func_count_mut(self, i);
84    }
85
86    fn visit_expr_func_last_insert_id_mut(&mut self, i: &mut FuncLastInsertId) {
87        visit_expr_func_last_insert_id_mut(self, i);
88    }
89
90    fn visit_expr_in_list_mut(&mut self, i: &mut ExprInList) {
91        visit_expr_in_list_mut(self, i);
92    }
93
94    fn visit_expr_in_subquery_mut(&mut self, i: &mut ExprInSubquery) {
95        visit_expr_in_subquery_mut(self, i);
96    }
97
98    fn visit_expr_is_null_mut(&mut self, i: &mut ExprIsNull) {
99        visit_expr_is_null_mut(self, i);
100    }
101
102    fn visit_expr_is_variant_mut(&mut self, i: &mut ExprIsVariant) {
103        visit_expr_is_variant_mut(self, i);
104    }
105
106    fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
107        visit_expr_let_mut(self, i);
108    }
109
110    fn visit_expr_map_mut(&mut self, i: &mut ExprMap) {
111        visit_expr_map_mut(self, i);
112    }
113
114    fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
115        visit_expr_match_mut(self, i);
116    }
117
118    fn visit_expr_not_mut(&mut self, i: &mut ExprNot) {
119        visit_expr_not_mut(self, i);
120    }
121
122    fn visit_expr_or_mut(&mut self, i: &mut ExprOr) {
123        visit_expr_or_mut(self, i);
124    }
125
126    fn visit_expr_list_mut(&mut self, i: &mut ExprList) {
127        visit_expr_list_mut(self, i);
128    }
129
130    fn visit_expr_record_mut(&mut self, i: &mut ExprRecord) {
131        visit_expr_record_mut(self, i);
132    }
133
134    fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
135        visit_expr_reference_mut(self, i);
136    }
137
138    fn visit_expr_set_mut(&mut self, i: &mut ExprSet) {
139        visit_expr_set_mut(self, i);
140    }
141
142    fn visit_expr_set_op_mut(&mut self, i: &mut ExprSetOp) {
143        visit_expr_set_op_mut(self, i);
144    }
145
146    fn visit_expr_stmt_mut(&mut self, i: &mut ExprStmt) {
147        visit_expr_stmt_mut(self, i);
148    }
149
150    fn visit_filter_mut(&mut self, i: &mut Filter) {
151        visit_filter_mut(self, i);
152    }
153
154    fn visit_condition_mut(&mut self, i: &mut Condition) {
155        visit_condition_mut(self, i);
156    }
157
158    fn visit_expr_project_mut(&mut self, i: &mut ExprProject) {
159        visit_expr_project_mut(self, i);
160    }
161
162    fn visit_insert_target_mut(&mut self, i: &mut InsertTarget) {
163        visit_insert_target_mut(self, i);
164    }
165
166    fn visit_join_mut(&mut self, i: &mut Join) {
167        visit_join_mut(self, i);
168    }
169
170    fn visit_limit_mut(&mut self, i: &mut Limit) {
171        visit_limit_mut(self, i);
172    }
173
174    fn visit_offset_mut(&mut self, i: &mut Offset) {
175        visit_offset_mut(self, i);
176    }
177
178    fn visit_order_by_mut(&mut self, i: &mut OrderBy) {
179        visit_order_by_mut(self, i);
180    }
181
182    fn visit_order_by_expr_mut(&mut self, i: &mut OrderByExpr) {
183        visit_order_by_expr_mut(self, i);
184    }
185
186    fn visit_path_mut(&mut self, i: &mut Path) {
187        visit_path_mut(self, i);
188    }
189
190    fn visit_projection_mut(&mut self, i: &mut Projection) {
191        visit_projection_mut(self, i);
192    }
193
194    fn visit_returning_mut(&mut self, i: &mut Returning) {
195        visit_returning_mut(self, i);
196    }
197
198    fn visit_source_mut(&mut self, i: &mut Source) {
199        visit_source_mut(self, i);
200    }
201
202    fn visit_source_model_mut(&mut self, i: &mut SourceModel) {
203        visit_source_model_mut(self, i);
204    }
205
206    fn visit_source_table_mut(&mut self, i: &mut SourceTable) {
207        visit_source_table_mut(self, i);
208    }
209
210    fn visit_source_table_id_mut(&mut self, i: &mut SourceTableId) {
211        visit_source_table_id_mut(self, i);
212    }
213
214    fn visit_stmt_mut(&mut self, i: &mut Statement) {
215        visit_stmt_mut(self, i);
216    }
217
218    fn visit_stmt_delete_mut(&mut self, i: &mut Delete) {
219        visit_stmt_delete_mut(self, i);
220    }
221
222    fn visit_stmt_insert_mut(&mut self, i: &mut Insert) {
223        visit_stmt_insert_mut(self, i);
224    }
225
226    fn visit_stmt_query_mut(&mut self, i: &mut Query) {
227        visit_stmt_query_mut(self, i);
228    }
229
230    fn visit_stmt_select_mut(&mut self, i: &mut Select) {
231        visit_stmt_select_mut(self, i);
232    }
233
234    fn visit_stmt_update_mut(&mut self, i: &mut Update) {
235        visit_stmt_update_mut(self, i);
236    }
237
238    fn visit_table_derived_mut(&mut self, i: &mut TableDerived) {
239        visit_table_derived_mut(self, i);
240    }
241
242    fn visit_table_ref_mut(&mut self, i: &mut TableRef) {
243        visit_table_ref_mut(self, i);
244    }
245
246    fn visit_table_factor_mut(&mut self, i: &mut TableFactor) {
247        visit_table_factor_mut(self, i);
248    }
249
250    fn visit_table_with_joins_mut(&mut self, i: &mut TableWithJoins) {
251        visit_table_with_joins_mut(self, i);
252    }
253
254    fn visit_type_mut(&mut self, i: &mut Type) {
255        visit_type_mut(self, i);
256    }
257
258    fn visit_update_target_mut(&mut self, i: &mut UpdateTarget) {
259        visit_update_target_mut(self, i);
260    }
261
262    fn visit_value_mut(&mut self, i: &mut Value) {
263        visit_value_mut(self, i);
264    }
265
266    fn visit_value_record(&mut self, i: &mut ValueRecord) {
267        visit_value_record(self, i);
268    }
269
270    fn visit_values_mut(&mut self, i: &mut Values) {
271        visit_values_mut(self, i);
272    }
273
274    fn visit_with_mut(&mut self, i: &mut With) {
275        visit_with_mut(self, i);
276    }
277}
278
279impl<V: VisitMut> VisitMut for &mut V {
280    fn visit_assignment_mut(&mut self, i: &mut Assignment) {
281        VisitMut::visit_assignment_mut(&mut **self, i);
282    }
283
284    fn visit_assignments_mut(&mut self, i: &mut Assignments) {
285        VisitMut::visit_assignments_mut(&mut **self, i);
286    }
287
288    fn visit_association_mut(&mut self, i: &mut Association) {
289        VisitMut::visit_association_mut(&mut **self, i);
290    }
291
292    fn visit_cte_mut(&mut self, i: &mut Cte) {
293        VisitMut::visit_cte_mut(&mut **self, i);
294    }
295
296    fn visit_expr_mut(&mut self, i: &mut Expr) {
297        VisitMut::visit_expr_mut(&mut **self, i);
298    }
299
300    fn visit_expr_and_mut(&mut self, i: &mut ExprAnd) {
301        VisitMut::visit_expr_and_mut(&mut **self, i);
302    }
303
304    fn visit_expr_arg_mut(&mut self, i: &mut ExprArg) {
305        VisitMut::visit_expr_arg_mut(&mut **self, i);
306    }
307
308    fn visit_expr_binary_op_mut(&mut self, i: &mut ExprBinaryOp) {
309        VisitMut::visit_expr_binary_op_mut(&mut **self, i);
310    }
311
312    fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
313        VisitMut::visit_expr_cast_mut(&mut **self, i);
314    }
315
316    fn visit_expr_column_mut(&mut self, i: &mut ExprColumn) {
317        VisitMut::visit_expr_column_mut(&mut **self, i);
318    }
319
320    fn visit_expr_default_mut(&mut self) {
321        VisitMut::visit_expr_default_mut(&mut **self);
322    }
323
324    fn visit_expr_error_mut(&mut self, i: &mut ExprError) {
325        VisitMut::visit_expr_error_mut(&mut **self, i);
326    }
327
328    fn visit_expr_exists_mut(&mut self, i: &mut ExprExists) {
329        VisitMut::visit_expr_exists_mut(&mut **self, i);
330    }
331
332    fn visit_expr_func_mut(&mut self, i: &mut ExprFunc) {
333        VisitMut::visit_expr_func_mut(&mut **self, i);
334    }
335
336    fn visit_expr_func_count_mut(&mut self, i: &mut FuncCount) {
337        VisitMut::visit_expr_func_count_mut(&mut **self, i);
338    }
339
340    fn visit_expr_in_list_mut(&mut self, i: &mut ExprInList) {
341        VisitMut::visit_expr_in_list_mut(&mut **self, i);
342    }
343
344    fn visit_expr_in_subquery_mut(&mut self, i: &mut ExprInSubquery) {
345        VisitMut::visit_expr_in_subquery_mut(&mut **self, i);
346    }
347
348    fn visit_expr_is_null_mut(&mut self, i: &mut ExprIsNull) {
349        VisitMut::visit_expr_is_null_mut(&mut **self, i);
350    }
351
352    fn visit_expr_is_variant_mut(&mut self, i: &mut ExprIsVariant) {
353        VisitMut::visit_expr_is_variant_mut(&mut **self, i);
354    }
355
356    fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
357        VisitMut::visit_expr_let_mut(&mut **self, i);
358    }
359
360    fn visit_expr_map_mut(&mut self, i: &mut ExprMap) {
361        VisitMut::visit_expr_map_mut(&mut **self, i);
362    }
363
364    fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
365        VisitMut::visit_expr_match_mut(&mut **self, i);
366    }
367
368    fn visit_expr_not_mut(&mut self, i: &mut ExprNot) {
369        VisitMut::visit_expr_not_mut(&mut **self, i);
370    }
371
372    fn visit_expr_or_mut(&mut self, i: &mut ExprOr) {
373        VisitMut::visit_expr_or_mut(&mut **self, i);
374    }
375
376    fn visit_expr_list_mut(&mut self, i: &mut ExprList) {
377        VisitMut::visit_expr_list_mut(&mut **self, i);
378    }
379
380    fn visit_expr_record_mut(&mut self, i: &mut ExprRecord) {
381        VisitMut::visit_expr_record_mut(&mut **self, i);
382    }
383
384    fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
385        VisitMut::visit_expr_reference_mut(&mut **self, i);
386    }
387
388    fn visit_expr_set_mut(&mut self, i: &mut ExprSet) {
389        VisitMut::visit_expr_set_mut(&mut **self, i);
390    }
391
392    fn visit_expr_set_op_mut(&mut self, i: &mut ExprSetOp) {
393        VisitMut::visit_expr_set_op_mut(&mut **self, i);
394    }
395
396    fn visit_expr_stmt_mut(&mut self, i: &mut ExprStmt) {
397        VisitMut::visit_expr_stmt_mut(&mut **self, i);
398    }
399
400    fn visit_filter_mut(&mut self, i: &mut Filter) {
401        VisitMut::visit_filter_mut(&mut **self, i);
402    }
403
404    fn visit_condition_mut(&mut self, i: &mut Condition) {
405        VisitMut::visit_condition_mut(&mut **self, i);
406    }
407
408    fn visit_expr_project_mut(&mut self, i: &mut ExprProject) {
409        VisitMut::visit_expr_project_mut(&mut **self, i);
410    }
411
412    fn visit_insert_target_mut(&mut self, i: &mut InsertTarget) {
413        VisitMut::visit_insert_target_mut(&mut **self, i);
414    }
415
416    fn visit_join_mut(&mut self, i: &mut Join) {
417        VisitMut::visit_join_mut(&mut **self, i);
418    }
419
420    fn visit_limit_mut(&mut self, i: &mut Limit) {
421        VisitMut::visit_limit_mut(&mut **self, i);
422    }
423
424    fn visit_offset_mut(&mut self, i: &mut Offset) {
425        VisitMut::visit_offset_mut(&mut **self, i);
426    }
427
428    fn visit_order_by_mut(&mut self, i: &mut OrderBy) {
429        VisitMut::visit_order_by_mut(&mut **self, i);
430    }
431
432    fn visit_order_by_expr_mut(&mut self, i: &mut OrderByExpr) {
433        VisitMut::visit_order_by_expr_mut(&mut **self, i);
434    }
435
436    fn visit_path_mut(&mut self, i: &mut Path) {
437        VisitMut::visit_path_mut(&mut **self, i);
438    }
439
440    fn visit_projection_mut(&mut self, i: &mut Projection) {
441        VisitMut::visit_projection_mut(&mut **self, i);
442    }
443
444    fn visit_returning_mut(&mut self, i: &mut Returning) {
445        VisitMut::visit_returning_mut(&mut **self, i);
446    }
447
448    fn visit_source_mut(&mut self, i: &mut Source) {
449        VisitMut::visit_source_mut(&mut **self, i);
450    }
451
452    fn visit_source_model_mut(&mut self, i: &mut SourceModel) {
453        VisitMut::visit_source_model_mut(&mut **self, i);
454    }
455
456    fn visit_source_table_mut(&mut self, i: &mut SourceTable) {
457        VisitMut::visit_source_table_mut(&mut **self, i);
458    }
459
460    fn visit_source_table_id_mut(&mut self, i: &mut SourceTableId) {
461        VisitMut::visit_source_table_id_mut(&mut **self, i);
462    }
463
464    fn visit_stmt_mut(&mut self, i: &mut Statement) {
465        VisitMut::visit_stmt_mut(&mut **self, i);
466    }
467
468    fn visit_stmt_delete_mut(&mut self, i: &mut Delete) {
469        VisitMut::visit_stmt_delete_mut(&mut **self, i);
470    }
471
472    fn visit_stmt_insert_mut(&mut self, i: &mut Insert) {
473        VisitMut::visit_stmt_insert_mut(&mut **self, i);
474    }
475
476    fn visit_stmt_query_mut(&mut self, i: &mut Query) {
477        VisitMut::visit_stmt_query_mut(&mut **self, i);
478    }
479
480    fn visit_stmt_select_mut(&mut self, i: &mut Select) {
481        VisitMut::visit_stmt_select_mut(&mut **self, i);
482    }
483
484    fn visit_stmt_update_mut(&mut self, i: &mut Update) {
485        VisitMut::visit_stmt_update_mut(&mut **self, i);
486    }
487
488    fn visit_table_derived_mut(&mut self, i: &mut TableDerived) {
489        VisitMut::visit_table_derived_mut(&mut **self, i);
490    }
491
492    fn visit_table_ref_mut(&mut self, i: &mut TableRef) {
493        VisitMut::visit_table_ref_mut(&mut **self, i);
494    }
495
496    fn visit_table_factor_mut(&mut self, i: &mut TableFactor) {
497        VisitMut::visit_table_factor_mut(&mut **self, i);
498    }
499
500    fn visit_table_with_joins_mut(&mut self, i: &mut TableWithJoins) {
501        VisitMut::visit_table_with_joins_mut(&mut **self, i);
502    }
503
504    fn visit_type_mut(&mut self, i: &mut Type) {
505        VisitMut::visit_type_mut(&mut **self, i);
506    }
507
508    fn visit_update_target_mut(&mut self, i: &mut UpdateTarget) {
509        VisitMut::visit_update_target_mut(&mut **self, i);
510    }
511
512    fn visit_value_mut(&mut self, i: &mut Value) {
513        VisitMut::visit_value_mut(&mut **self, i);
514    }
515
516    fn visit_value_record(&mut self, i: &mut ValueRecord) {
517        VisitMut::visit_value_record(&mut **self, i);
518    }
519
520    fn visit_values_mut(&mut self, i: &mut Values) {
521        VisitMut::visit_values_mut(&mut **self, i);
522    }
523
524    fn visit_with_mut(&mut self, i: &mut With) {
525        VisitMut::visit_with_mut(&mut **self, i);
526    }
527}
528
529pub fn visit_assignment_mut<V>(v: &mut V, node: &mut Assignment)
530where
531    V: VisitMut + ?Sized,
532{
533    v.visit_expr_mut(&mut node.expr);
534}
535
536pub fn visit_assignments_mut<V>(v: &mut V, node: &mut Assignments)
537where
538    V: VisitMut + ?Sized,
539{
540    for (_, assignment) in node.iter_mut() {
541        v.visit_assignment_mut(assignment);
542    }
543}
544
545pub fn visit_association_mut<V>(v: &mut V, node: &mut Association)
546where
547    V: VisitMut + ?Sized,
548{
549    v.visit_stmt_query_mut(&mut node.source);
550}
551
552pub fn visit_cte_mut<V>(v: &mut V, node: &mut Cte)
553where
554    V: VisitMut + ?Sized,
555{
556    v.visit_stmt_query_mut(&mut node.query);
557}
558
559pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr)
560where
561    V: VisitMut + ?Sized,
562{
563    match node {
564        Expr::And(expr) => v.visit_expr_and_mut(expr),
565        Expr::Any(expr) => v.visit_expr_any_mut(expr),
566        Expr::Arg(expr) => v.visit_expr_arg_mut(expr),
567        Expr::BinaryOp(expr) => v.visit_expr_binary_op_mut(expr),
568        Expr::Cast(expr) => v.visit_expr_cast_mut(expr),
569        Expr::Default => v.visit_expr_default_mut(),
570        Expr::Error(expr) => v.visit_expr_error_mut(expr),
571        Expr::Exists(expr) => v.visit_expr_exists_mut(expr),
572        Expr::Func(expr) => v.visit_expr_func_mut(expr),
573        Expr::InList(expr) => v.visit_expr_in_list_mut(expr),
574        Expr::InSubquery(expr) => v.visit_expr_in_subquery_mut(expr),
575        Expr::IsNull(expr) => v.visit_expr_is_null_mut(expr),
576        Expr::IsVariant(expr) => v.visit_expr_is_variant_mut(expr),
577        Expr::Let(expr) => v.visit_expr_let_mut(expr),
578        Expr::Map(expr) => v.visit_expr_map_mut(expr),
579        Expr::Match(expr) => v.visit_expr_match_mut(expr),
580        Expr::Not(expr) => v.visit_expr_not_mut(expr),
581        Expr::Or(expr) => v.visit_expr_or_mut(expr),
582        Expr::Project(expr) => v.visit_expr_project_mut(expr),
583        Expr::Record(expr) => v.visit_expr_record_mut(expr),
584        Expr::Reference(expr) => v.visit_expr_reference_mut(expr),
585        Expr::List(expr) => v.visit_expr_list_mut(expr),
586        Expr::Stmt(expr) => v.visit_expr_stmt_mut(expr),
587        Expr::Value(expr) => v.visit_value_mut(expr),
588    }
589}
590
591pub fn visit_expr_and_mut<V>(v: &mut V, node: &mut ExprAnd)
592where
593    V: VisitMut + ?Sized,
594{
595    for expr in node {
596        v.visit_expr_mut(expr);
597    }
598}
599
600pub fn visit_expr_any_mut<V>(v: &mut V, node: &mut ExprAny)
601where
602    V: VisitMut + ?Sized,
603{
604    v.visit_expr_mut(&mut node.expr);
605}
606
607pub fn visit_expr_arg_mut<V>(v: &mut V, node: &mut ExprArg)
608where
609    V: VisitMut + ?Sized,
610{
611}
612
613pub fn visit_expr_binary_op_mut<V>(v: &mut V, node: &mut ExprBinaryOp)
614where
615    V: VisitMut + ?Sized,
616{
617    v.visit_expr_mut(&mut node.lhs);
618    v.visit_expr_mut(&mut node.rhs);
619}
620
621pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast)
622where
623    V: VisitMut + ?Sized,
624{
625    v.visit_expr_mut(&mut node.expr);
626    v.visit_type_mut(&mut node.ty);
627}
628
629pub fn visit_expr_column_mut<V>(v: &mut V, node: &mut ExprColumn)
630where
631    V: VisitMut + ?Sized,
632{
633}
634
635pub fn visit_expr_default_mut<V>(v: &mut V)
636where
637    V: VisitMut + ?Sized,
638{
639}
640
641pub fn visit_expr_error_mut<V>(v: &mut V, node: &mut ExprError)
642where
643    V: VisitMut + ?Sized,
644{
645    // ExprError has no child expressions to visit
646}
647
648pub fn visit_expr_exists_mut<V>(v: &mut V, node: &mut ExprExists)
649where
650    V: VisitMut + ?Sized,
651{
652    v.visit_stmt_query_mut(&mut node.subquery);
653}
654
655pub fn visit_expr_func_mut<V>(v: &mut V, node: &mut ExprFunc)
656where
657    V: VisitMut + ?Sized,
658{
659    match node {
660        ExprFunc::Count(func) => v.visit_expr_func_count_mut(func),
661        ExprFunc::LastInsertId(func) => v.visit_expr_func_last_insert_id_mut(func),
662    }
663}
664
665pub fn visit_expr_func_count_mut<V>(v: &mut V, node: &mut FuncCount)
666where
667    V: VisitMut + ?Sized,
668{
669    if let Some(expr) = &mut node.arg {
670        v.visit_expr_mut(expr);
671    }
672
673    if let Some(expr) = &mut node.filter {
674        v.visit_expr_mut(expr);
675    }
676}
677
678pub fn visit_expr_func_last_insert_id_mut<V>(_v: &mut V, _node: &mut FuncLastInsertId)
679where
680    V: VisitMut + ?Sized,
681{
682    // FuncLastInsertId has no fields to visit
683}
684
685pub fn visit_expr_in_list_mut<V>(v: &mut V, node: &mut ExprInList)
686where
687    V: VisitMut + ?Sized,
688{
689    v.visit_expr_mut(&mut node.expr);
690    v.visit_expr_mut(&mut node.list);
691}
692
693pub fn visit_expr_in_subquery_mut<V>(v: &mut V, node: &mut ExprInSubquery)
694where
695    V: VisitMut + ?Sized,
696{
697    v.visit_expr_mut(&mut node.expr);
698    v.visit_stmt_query_mut(&mut node.query);
699}
700
701pub fn visit_expr_is_null_mut<V>(v: &mut V, node: &mut ExprIsNull)
702where
703    V: VisitMut + ?Sized,
704{
705    v.visit_expr_mut(&mut node.expr);
706}
707
708pub fn visit_expr_is_variant_mut<V>(v: &mut V, node: &mut ExprIsVariant)
709where
710    V: VisitMut + ?Sized,
711{
712    v.visit_expr_mut(&mut node.expr);
713}
714
715pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet)
716where
717    V: VisitMut + ?Sized,
718{
719    for binding in &mut node.bindings {
720        v.visit_expr_mut(binding);
721    }
722    v.visit_expr_mut(&mut node.body);
723}
724
725pub fn visit_expr_map_mut<V>(v: &mut V, node: &mut ExprMap)
726where
727    V: VisitMut + ?Sized,
728{
729    v.visit_expr_mut(&mut node.base);
730    v.visit_expr_mut(&mut node.map);
731}
732
733pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch)
734where
735    V: VisitMut + ?Sized,
736{
737    v.visit_expr_mut(&mut node.subject);
738    for arm in &mut node.arms {
739        v.visit_expr_mut(&mut arm.expr);
740    }
741    v.visit_expr_mut(&mut node.else_expr);
742}
743
744pub fn visit_expr_not_mut<V>(v: &mut V, node: &mut ExprNot)
745where
746    V: VisitMut + ?Sized,
747{
748    v.visit_expr_mut(&mut node.expr);
749}
750
751pub fn visit_expr_or_mut<V>(v: &mut V, node: &mut ExprOr)
752where
753    V: VisitMut + ?Sized,
754{
755    for expr in node {
756        v.visit_expr_mut(expr);
757    }
758}
759
760pub fn visit_expr_list_mut<V>(v: &mut V, node: &mut ExprList)
761where
762    V: VisitMut + ?Sized,
763{
764    for e in &mut node.items {
765        v.visit_expr_mut(e);
766    }
767}
768
769pub fn visit_expr_record_mut<V>(v: &mut V, node: &mut ExprRecord)
770where
771    V: VisitMut + ?Sized,
772{
773    for expr in &mut **node {
774        v.visit_expr_mut(expr);
775    }
776}
777
778pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference)
779where
780    V: VisitMut + ?Sized,
781{
782    match node {
783        ExprReference::Model { .. } => {}
784        ExprReference::Field { .. } => {}
785        ExprReference::Column(expr_column) => v.visit_expr_column_mut(expr_column),
786    }
787}
788
789pub fn visit_expr_set_mut<V>(v: &mut V, node: &mut ExprSet)
790where
791    V: VisitMut + ?Sized,
792{
793    match node {
794        ExprSet::Select(expr) => v.visit_stmt_select_mut(expr),
795        ExprSet::SetOp(expr) => v.visit_expr_set_op_mut(expr),
796        ExprSet::Update(expr) => v.visit_stmt_update_mut(expr),
797        ExprSet::Values(expr) => v.visit_values_mut(expr),
798        ExprSet::Insert(expr) => v.visit_stmt_insert_mut(expr),
799    }
800}
801
802pub fn visit_expr_set_op_mut<V>(v: &mut V, node: &mut ExprSetOp)
803where
804    V: VisitMut + ?Sized,
805{
806    for operand in &mut node.operands {
807        v.visit_expr_set_mut(operand);
808    }
809}
810
811pub fn visit_expr_stmt_mut<V>(v: &mut V, node: &mut ExprStmt)
812where
813    V: VisitMut + ?Sized,
814{
815    v.visit_stmt_mut(&mut node.stmt);
816}
817
818pub fn visit_expr_project_mut<V>(v: &mut V, node: &mut ExprProject)
819where
820    V: VisitMut + ?Sized,
821{
822    v.visit_expr_mut(&mut node.base);
823    v.visit_projection_mut(&mut node.projection);
824}
825
826pub fn visit_filter_mut<V>(v: &mut V, node: &mut Filter)
827where
828    V: VisitMut + ?Sized,
829{
830    if let Some(expr) = &mut node.expr {
831        v.visit_expr_mut(expr);
832    }
833}
834
835pub fn visit_condition_mut<V>(v: &mut V, node: &mut Condition)
836where
837    V: VisitMut + ?Sized,
838{
839    if let Some(expr) = &mut node.expr {
840        v.visit_expr_mut(expr);
841    }
842}
843
844pub fn visit_insert_target_mut<V>(v: &mut V, node: &mut InsertTarget)
845where
846    V: VisitMut + ?Sized,
847{
848    if let InsertTarget::Scope(stmt) = node {
849        v.visit_stmt_query_mut(stmt)
850    }
851}
852
853pub fn visit_join_mut<V>(v: &mut V, node: &mut Join)
854where
855    V: VisitMut + ?Sized,
856{
857    v.visit_source_table_id_mut(&mut node.table);
858    match &mut node.constraint {
859        JoinOp::Left(expr) => v.visit_expr_mut(expr),
860    }
861}
862
863pub fn visit_limit_mut<V>(v: &mut V, node: &mut Limit)
864where
865    V: VisitMut + ?Sized,
866{
867    v.visit_expr_mut(&mut node.limit);
868
869    if let Some(offset) = &mut node.offset {
870        v.visit_offset_mut(offset);
871    }
872}
873
874pub fn visit_offset_mut<V>(v: &mut V, node: &mut Offset)
875where
876    V: VisitMut + ?Sized,
877{
878    match node {
879        Offset::After(expr) => v.visit_expr_mut(expr),
880        Offset::Count(expr) => v.visit_expr_mut(expr),
881    }
882}
883
884pub fn visit_order_by_mut<V>(v: &mut V, node: &mut OrderBy)
885where
886    V: VisitMut + ?Sized,
887{
888    for expr in &mut node.exprs {
889        v.visit_order_by_expr_mut(expr);
890    }
891}
892
893pub fn visit_order_by_expr_mut<V>(v: &mut V, node: &mut OrderByExpr)
894where
895    V: VisitMut + ?Sized,
896{
897    v.visit_expr_mut(&mut node.expr);
898}
899
900pub fn visit_path_mut<V>(v: &mut V, node: &mut Path)
901where
902    V: VisitMut + ?Sized,
903{
904    v.visit_projection_mut(&mut node.projection);
905}
906
907pub fn visit_projection_mut<V>(v: &mut V, node: &mut Projection)
908where
909    V: VisitMut + ?Sized,
910{
911}
912
913pub fn visit_returning_mut<V>(v: &mut V, node: &mut Returning)
914where
915    V: VisitMut + ?Sized,
916{
917    match node {
918        Returning::Model { include } => {
919            for path in include {
920                v.visit_path_mut(path);
921            }
922        }
923        Returning::Changed => {}
924        Returning::Expr(expr) => v.visit_expr_mut(expr),
925        Returning::Value(expr) => v.visit_expr_mut(expr),
926    }
927}
928
929pub fn visit_source_mut<V>(v: &mut V, node: &mut Source)
930where
931    V: VisitMut + ?Sized,
932{
933    match node {
934        Source::Model(source_model) => v.visit_source_model_mut(source_model),
935        Source::Table(source_table) => v.visit_source_table_mut(source_table),
936    }
937}
938
939pub fn visit_source_model_mut<V>(v: &mut V, node: &mut SourceModel)
940where
941    V: VisitMut + ?Sized,
942{
943    if let Some(association) = &mut node.via {
944        v.visit_association_mut(association);
945    }
946}
947
948pub fn visit_source_table_mut<V>(v: &mut V, node: &mut SourceTable)
949where
950    V: VisitMut + ?Sized,
951{
952    for table_ref in &mut node.tables {
953        v.visit_table_ref_mut(table_ref);
954    }
955    for table_with_joins in &mut node.from {
956        v.visit_table_with_joins_mut(table_with_joins);
957    }
958}
959
960pub fn visit_source_table_id_mut<V>(v: &mut V, node: &mut SourceTableId)
961where
962    V: VisitMut + ?Sized,
963{
964    // SourceTableId is just an index, nothing to visit
965}
966
967pub fn visit_table_factor_mut<V>(v: &mut V, node: &mut TableFactor)
968where
969    V: VisitMut + ?Sized,
970{
971    match node {
972        TableFactor::Table(table_id) => v.visit_source_table_id_mut(table_id),
973    }
974}
975
976pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Statement)
977where
978    V: VisitMut + ?Sized,
979{
980    match node {
981        Statement::Delete(stmt) => v.visit_stmt_delete_mut(stmt),
982        Statement::Insert(stmt) => v.visit_stmt_insert_mut(stmt),
983        Statement::Query(stmt) => v.visit_stmt_query_mut(stmt),
984        Statement::Update(stmt) => v.visit_stmt_update_mut(stmt),
985    }
986}
987
988pub fn visit_stmt_delete_mut<V>(v: &mut V, node: &mut Delete)
989where
990    V: VisitMut + ?Sized,
991{
992    v.visit_source_mut(&mut node.from);
993    v.visit_filter_mut(&mut node.filter);
994
995    if let Some(returning) = &mut node.returning {
996        v.visit_returning_mut(returning);
997    }
998}
999
1000pub fn visit_stmt_insert_mut<V>(v: &mut V, node: &mut Insert)
1001where
1002    V: VisitMut + ?Sized,
1003{
1004    v.visit_insert_target_mut(&mut node.target);
1005    v.visit_stmt_query_mut(&mut node.source);
1006
1007    if let Some(returning) = &mut node.returning {
1008        v.visit_returning_mut(returning);
1009    }
1010}
1011
1012pub fn visit_stmt_query_mut<V>(v: &mut V, node: &mut Query)
1013where
1014    V: VisitMut + ?Sized,
1015{
1016    if let Some(with) = &mut node.with {
1017        v.visit_with_mut(with);
1018    }
1019
1020    v.visit_expr_set_mut(&mut node.body);
1021
1022    if let Some(order_by) = &mut node.order_by {
1023        v.visit_order_by_mut(order_by);
1024    }
1025
1026    if let Some(limit) = &mut node.limit {
1027        v.visit_limit_mut(limit);
1028    }
1029}
1030
1031pub fn visit_stmt_select_mut<V>(v: &mut V, node: &mut Select)
1032where
1033    V: VisitMut + ?Sized,
1034{
1035    v.visit_source_mut(&mut node.source);
1036    v.visit_filter_mut(&mut node.filter);
1037    v.visit_returning_mut(&mut node.returning);
1038}
1039
1040pub fn visit_stmt_update_mut<V>(v: &mut V, node: &mut Update)
1041where
1042    V: VisitMut + ?Sized,
1043{
1044    v.visit_update_target_mut(&mut node.target);
1045    v.visit_assignments_mut(&mut node.assignments);
1046    v.visit_filter_mut(&mut node.filter);
1047    v.visit_condition_mut(&mut node.condition);
1048
1049    if let Some(returning) = &mut node.returning {
1050        v.visit_returning_mut(returning);
1051    }
1052}
1053
1054pub fn visit_table_derived_mut<V>(v: &mut V, node: &mut TableDerived)
1055where
1056    V: VisitMut + ?Sized,
1057{
1058    v.visit_stmt_query_mut(&mut node.subquery);
1059}
1060
1061pub fn visit_table_ref_mut<V>(v: &mut V, node: &mut TableRef)
1062where
1063    V: VisitMut + ?Sized,
1064{
1065    match node {
1066        TableRef::Cte { .. } => {}
1067        TableRef::Derived(table_derived) => v.visit_table_derived_mut(table_derived),
1068        TableRef::Table(_) => {}
1069        TableRef::Arg(expr_arg) => v.visit_expr_arg_mut(expr_arg),
1070    }
1071}
1072
1073pub fn visit_table_with_joins_mut<V>(v: &mut V, node: &mut TableWithJoins)
1074where
1075    V: VisitMut + ?Sized,
1076{
1077    v.visit_table_factor_mut(&mut node.relation);
1078    for join in &mut node.joins {
1079        v.visit_join_mut(join);
1080    }
1081}
1082
1083pub fn visit_type_mut<V>(v: &mut V, node: &mut Type)
1084where
1085    V: VisitMut + ?Sized,
1086{
1087    // Type is just type information, no traversal needed
1088}
1089
1090pub fn visit_update_target_mut<V>(v: &mut V, node: &mut UpdateTarget)
1091where
1092    V: VisitMut + ?Sized,
1093{
1094    if let UpdateTarget::Query(stmt) = node {
1095        v.visit_stmt_query_mut(stmt)
1096    }
1097}
1098
1099pub fn visit_value_mut<V>(v: &mut V, node: &mut Value)
1100where
1101    V: VisitMut + ?Sized,
1102{
1103    if let Value::Record(node) = node {
1104        v.visit_value_record(node);
1105    }
1106}
1107
1108pub fn visit_value_record<V>(v: &mut V, node: &mut ValueRecord)
1109where
1110    V: VisitMut + ?Sized,
1111{
1112    for expr in &mut node.fields {
1113        v.visit_value_mut(expr);
1114    }
1115}
1116
1117pub fn visit_values_mut<V>(v: &mut V, node: &mut Values)
1118where
1119    V: VisitMut + ?Sized,
1120{
1121    for expr in &mut node.rows {
1122        v.visit_expr_mut(expr);
1123    }
1124}
1125
1126pub fn visit_with_mut<V>(v: &mut V, node: &mut With)
1127where
1128    V: VisitMut + ?Sized,
1129{
1130    for cte in &mut node.ctes {
1131        v.visit_cte_mut(cte);
1132    }
1133}
1134
1135pub fn for_each_expr_mut<F>(node: &mut impl Node, f: F)
1136where
1137    F: FnMut(&mut Expr),
1138{
1139    struct ForEach<F> {
1140        f: F,
1141    }
1142
1143    impl<F> VisitMut for ForEach<F>
1144    where
1145        F: FnMut(&mut Expr),
1146    {
1147        fn visit_expr_mut(&mut self, node: &mut Expr) {
1148            visit_expr_mut(self, node);
1149            (self.f)(node);
1150        }
1151    }
1152
1153    node.visit_mut(ForEach { f });
1154}
1155
1156/// Walk an expression tree in pre-order, tracking scope depth through
1157/// Let/Map scopes.
1158///
1159/// For each node, calls `f(expr, scope_depth)`:
1160/// - If `f` returns `true`, recursion into children continues.
1161/// - If `f` returns `false`, children are skipped (e.g., when the callback
1162///   has replaced the expression and doesn't want to recurse into the
1163///   replacement).
1164///
1165/// Scope depth rules:
1166/// - `Let` bindings are visited at the current depth; the body at `depth + 1`
1167/// - `Map` base is visited at the current depth; the map function at `depth + 1`
1168/// - All other compound expressions: children at the same depth
1169///
1170/// This matches the semantics of `ExprArg.nesting`: an arg with
1171/// `nesting == scope_depth` references the outermost (statement-level) scope,
1172/// while `nesting < scope_depth` references a Let/Map binding.
1173pub fn walk_expr_scoped_mut<F>(expr: &mut Expr, scope_depth: usize, mut f: F)
1174where
1175    F: FnMut(&mut Expr, usize) -> bool,
1176{
1177    walk_expr_scoped_mut_ref(expr, scope_depth, &mut f);
1178}
1179
1180fn walk_expr_scoped_mut_ref<F>(expr: &mut Expr, scope_depth: usize, f: &mut F)
1181where
1182    F: FnMut(&mut Expr, usize) -> bool,
1183{
1184    struct ScopedWalk<'a, F> {
1185        f: &'a mut F,
1186        scope_depth: usize,
1187    }
1188
1189    impl<F> VisitMut for ScopedWalk<'_, F>
1190    where
1191        F: FnMut(&mut Expr, usize) -> bool,
1192    {
1193        fn visit_expr_mut(&mut self, node: &mut Expr) {
1194            if !(self.f)(node, self.scope_depth) {
1195                return;
1196            }
1197            visit_expr_mut(self, node);
1198        }
1199
1200        fn visit_expr_let_mut(&mut self, node: &mut ExprLet) {
1201            for binding in &mut node.bindings {
1202                self.visit_expr_mut(binding);
1203            }
1204            self.scope_depth += 1;
1205            self.visit_expr_mut(&mut node.body);
1206            self.scope_depth -= 1;
1207        }
1208
1209        fn visit_expr_map_mut(&mut self, node: &mut ExprMap) {
1210            self.visit_expr_mut(&mut node.base);
1211            self.scope_depth += 1;
1212            self.visit_expr_mut(&mut node.map);
1213            self.scope_depth -= 1;
1214        }
1215    }
1216
1217    ScopedWalk { f, scope_depth }.visit_expr_mut(expr);
1218}
toasty_core/stmt/visit_mut.rs

toasty_core/stmt/
visit_mut.rs
