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, LimitCursor,
9    LimitOffset, Node, OrderBy, OrderByExpr, Path, Projection, Query, Returning, Select, Source,
10    SourceModel, SourceTable, SourceTableId, Statement, TableDerived, TableFactor, TableRef,
11    TableWithJoins, Type, Update, UpdateTarget, Value, ValueRecord, Values, With,
12};
13
14/// Mutable visitor trait for the statement AST.
15///
16/// Implement this trait to walk and modify the AST in place. Each
17/// `visit_*_mut` method has a default implementation that recurses into
18/// child nodes via the corresponding free function (e.g.,
19/// [`visit_expr_mut`]). Override specific methods to transform nodes of
20/// interest.
21///
22/// Companion helpers:
23/// - [`for_each_expr_mut`] -- visits every expression node in post-order.
24/// - [`walk_expr_scoped_mut`] -- walks expressions while tracking
25///   `Let`/`Map` scope depth.
26///
27/// # Examples
28///
29/// ```ignore
30/// use toasty_core::stmt::{visit_mut, Expr, Value, Node};
31///
32/// let mut expr = Expr::from(Value::from(42_i64));
33/// visit_mut::for_each_expr_mut(&mut expr, |e| {
34///     // transform expressions in place
35/// });
36/// ```
37pub trait VisitMut {
38    /// Dispatches to the appropriate `visit_*_mut` method via [`Node::visit_mut`].
39    fn visit_mut<N: Node>(&mut self, i: &mut N)
40    where
41        Self: Sized,
42    {
43        i.visit_mut(self);
44    }
45
46    /// Visits an [`Assignment`] node mutably.
47    ///
48    /// The default implementation delegates to [`visit_assignment_mut`].
49    fn visit_assignment_mut(&mut self, i: &mut Assignment) {
50        visit_assignment_mut(self, i);
51    }
52
53    /// Visits an [`Assignments`] node mutably.
54    ///
55    /// The default implementation delegates to [`visit_assignments_mut`].
56    fn visit_assignments_mut(&mut self, i: &mut Assignments) {
57        visit_assignments_mut(self, i);
58    }
59
60    /// Visits an [`Association`] node mutably.
61    ///
62    /// The default implementation delegates to [`visit_association_mut`].
63    fn visit_association_mut(&mut self, i: &mut Association) {
64        visit_association_mut(self, i);
65    }
66
67    /// Visits a [`Cte`] (common table expression) node mutably.
68    ///
69    /// The default implementation delegates to [`visit_cte_mut`].
70    fn visit_cte_mut(&mut self, i: &mut Cte) {
71        visit_cte_mut(self, i);
72    }
73
74    /// Visits an [`Expr`] node mutably.
75    ///
76    /// The default implementation delegates to [`visit_expr_mut`].
77    fn visit_expr_mut(&mut self, i: &mut Expr) {
78        visit_expr_mut(self, i);
79    }
80
81    /// Visits an [`ExprAnd`] node mutably.
82    ///
83    /// The default implementation delegates to [`visit_expr_and_mut`].
84    fn visit_expr_and_mut(&mut self, i: &mut ExprAnd) {
85        visit_expr_and_mut(self, i);
86    }
87
88    /// Visits an [`ExprAny`] node mutably.
89    ///
90    /// The default implementation delegates to [`visit_expr_any_mut`].
91    fn visit_expr_any_mut(&mut self, i: &mut ExprAny) {
92        visit_expr_any_mut(self, i);
93    }
94
95    /// Visits an [`ExprArg`] node mutably.
96    ///
97    /// The default implementation delegates to [`visit_expr_arg_mut`].
98    fn visit_expr_arg_mut(&mut self, i: &mut ExprArg) {
99        visit_expr_arg_mut(self, i);
100    }
101
102    /// Visits an [`ExprBinaryOp`] node mutably.
103    ///
104    /// The default implementation delegates to [`visit_expr_binary_op_mut`].
105    fn visit_expr_binary_op_mut(&mut self, i: &mut ExprBinaryOp) {
106        visit_expr_binary_op_mut(self, i);
107    }
108
109    /// Visits an [`ExprCast`] node mutably.
110    ///
111    /// The default implementation delegates to [`visit_expr_cast_mut`].
112    fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
113        visit_expr_cast_mut(self, i);
114    }
115
116    /// Visits an [`ExprColumn`] node mutably.
117    ///
118    /// The default implementation delegates to [`visit_expr_column_mut`].
119    fn visit_expr_column_mut(&mut self, i: &mut ExprColumn) {
120        visit_expr_column_mut(self, i);
121    }
122
123    /// Visits a default expression node mutably.
124    ///
125    /// The default implementation delegates to [`visit_expr_default_mut`].
126    fn visit_expr_default_mut(&mut self) {
127        visit_expr_default_mut(self);
128    }
129
130    /// Visits an [`ExprError`] node mutably.
131    ///
132    /// The default implementation delegates to [`visit_expr_error_mut`].
133    fn visit_expr_error_mut(&mut self, i: &mut ExprError) {
134        visit_expr_error_mut(self, i);
135    }
136
137    /// Visits an [`ExprExists`] node mutably.
138    ///
139    /// The default implementation delegates to [`visit_expr_exists_mut`].
140    fn visit_expr_exists_mut(&mut self, i: &mut ExprExists) {
141        visit_expr_exists_mut(self, i);
142    }
143
144    /// Visits an [`ExprFunc`] node mutably.
145    ///
146    /// The default implementation delegates to [`visit_expr_func_mut`].
147    fn visit_expr_func_mut(&mut self, i: &mut ExprFunc) {
148        visit_expr_func_mut(self, i);
149    }
150
151    /// Visits a [`FuncCount`] node mutably.
152    ///
153    /// The default implementation delegates to [`visit_expr_func_count_mut`].
154    fn visit_expr_func_count_mut(&mut self, i: &mut FuncCount) {
155        visit_expr_func_count_mut(self, i);
156    }
157
158    /// Visits a [`FuncLastInsertId`] node mutably.
159    ///
160    /// The default implementation delegates to [`visit_expr_func_last_insert_id_mut`].
161    fn visit_expr_func_last_insert_id_mut(&mut self, i: &mut FuncLastInsertId) {
162        visit_expr_func_last_insert_id_mut(self, i);
163    }
164
165    /// Visits an [`ExprInList`] node mutably.
166    ///
167    /// The default implementation delegates to [`visit_expr_in_list_mut`].
168    fn visit_expr_in_list_mut(&mut self, i: &mut ExprInList) {
169        visit_expr_in_list_mut(self, i);
170    }
171
172    /// Visits an [`ExprInSubquery`] node mutably.
173    ///
174    /// The default implementation delegates to [`visit_expr_in_subquery_mut`].
175    fn visit_expr_in_subquery_mut(&mut self, i: &mut ExprInSubquery) {
176        visit_expr_in_subquery_mut(self, i);
177    }
178
179    /// Visits an [`ExprIsNull`] node mutably.
180    ///
181    /// The default implementation delegates to [`visit_expr_is_null_mut`].
182    fn visit_expr_is_null_mut(&mut self, i: &mut ExprIsNull) {
183        visit_expr_is_null_mut(self, i);
184    }
185
186    /// Visits an [`ExprIsVariant`] node mutably.
187    ///
188    /// The default implementation delegates to [`visit_expr_is_variant_mut`].
189    fn visit_expr_is_variant_mut(&mut self, i: &mut ExprIsVariant) {
190        visit_expr_is_variant_mut(self, i);
191    }
192
193    /// Visits an [`ExprLet`] node mutably.
194    ///
195    /// The default implementation delegates to [`visit_expr_let_mut`].
196    fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
197        visit_expr_let_mut(self, i);
198    }
199
200    /// Visits an [`ExprMap`] node mutably.
201    ///
202    /// The default implementation delegates to [`visit_expr_map_mut`].
203    fn visit_expr_map_mut(&mut self, i: &mut ExprMap) {
204        visit_expr_map_mut(self, i);
205    }
206
207    /// Visits an [`ExprMatch`] node mutably.
208    ///
209    /// The default implementation delegates to [`visit_expr_match_mut`].
210    fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
211        visit_expr_match_mut(self, i);
212    }
213
214    /// Visits an [`ExprNot`] node mutably.
215    ///
216    /// The default implementation delegates to [`visit_expr_not_mut`].
217    fn visit_expr_not_mut(&mut self, i: &mut ExprNot) {
218        visit_expr_not_mut(self, i);
219    }
220
221    /// Visits an [`ExprOr`] node mutably.
222    ///
223    /// The default implementation delegates to [`visit_expr_or_mut`].
224    fn visit_expr_or_mut(&mut self, i: &mut ExprOr) {
225        visit_expr_or_mut(self, i);
226    }
227
228    /// Visits an [`ExprList`] node mutably.
229    ///
230    /// The default implementation delegates to [`visit_expr_list_mut`].
231    fn visit_expr_list_mut(&mut self, i: &mut ExprList) {
232        visit_expr_list_mut(self, i);
233    }
234
235    /// Visits an [`ExprRecord`] node mutably.
236    ///
237    /// The default implementation delegates to [`visit_expr_record_mut`].
238    fn visit_expr_record_mut(&mut self, i: &mut ExprRecord) {
239        visit_expr_record_mut(self, i);
240    }
241
242    /// Visits an [`ExprReference`] node mutably.
243    ///
244    /// The default implementation delegates to [`visit_expr_reference_mut`].
245    fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
246        visit_expr_reference_mut(self, i);
247    }
248
249    /// Visits an [`ExprSet`] node mutably.
250    ///
251    /// The default implementation delegates to [`visit_expr_set_mut`].
252    fn visit_expr_set_mut(&mut self, i: &mut ExprSet) {
253        visit_expr_set_mut(self, i);
254    }
255
256    /// Visits an [`ExprSetOp`] node mutably.
257    ///
258    /// The default implementation delegates to [`visit_expr_set_op_mut`].
259    fn visit_expr_set_op_mut(&mut self, i: &mut ExprSetOp) {
260        visit_expr_set_op_mut(self, i);
261    }
262
263    /// Visits an [`ExprStmt`] node mutably.
264    ///
265    /// The default implementation delegates to [`visit_expr_stmt_mut`].
266    fn visit_expr_stmt_mut(&mut self, i: &mut ExprStmt) {
267        visit_expr_stmt_mut(self, i);
268    }
269
270    /// Visits a [`Filter`] node mutably.
271    ///
272    /// The default implementation delegates to [`visit_filter_mut`].
273    fn visit_filter_mut(&mut self, i: &mut Filter) {
274        visit_filter_mut(self, i);
275    }
276
277    /// Visits a [`Condition`] node mutably.
278    ///
279    /// The default implementation delegates to [`visit_condition_mut`].
280    fn visit_condition_mut(&mut self, i: &mut Condition) {
281        visit_condition_mut(self, i);
282    }
283
284    /// Visits an [`ExprProject`] node mutably.
285    ///
286    /// The default implementation delegates to [`visit_expr_project_mut`].
287    fn visit_expr_project_mut(&mut self, i: &mut ExprProject) {
288        visit_expr_project_mut(self, i);
289    }
290
291    /// Visits an [`InsertTarget`] node mutably.
292    ///
293    /// The default implementation delegates to [`visit_insert_target_mut`].
294    fn visit_insert_target_mut(&mut self, i: &mut InsertTarget) {
295        visit_insert_target_mut(self, i);
296    }
297
298    /// Visits a [`Join`] node mutably.
299    ///
300    /// The default implementation delegates to [`visit_join_mut`].
301    fn visit_join_mut(&mut self, i: &mut Join) {
302        visit_join_mut(self, i);
303    }
304
305    /// Visits a [`Limit`] node mutably.
306    ///
307    /// The default implementation delegates to [`visit_limit_mut`].
308    fn visit_limit_mut(&mut self, i: &mut Limit) {
309        visit_limit_mut(self, i);
310    }
311
312    /// Visits a [`LimitCursor`] node mutably.
313    ///
314    /// The default implementation delegates to [`visit_limit_cursor_mut`].
315    fn visit_limit_cursor_mut(&mut self, i: &mut LimitCursor) {
316        visit_limit_cursor_mut(self, i);
317    }
318
319    /// Visits a [`LimitOffset`] node mutably.
320    ///
321    /// The default implementation delegates to [`visit_limit_offset_mut`].
322    fn visit_limit_offset_mut(&mut self, i: &mut LimitOffset) {
323        visit_limit_offset_mut(self, i);
324    }
325
326    /// Visits an [`OrderBy`] node mutably.
327    ///
328    /// The default implementation delegates to [`visit_order_by_mut`].
329    fn visit_order_by_mut(&mut self, i: &mut OrderBy) {
330        visit_order_by_mut(self, i);
331    }
332
333    /// Visits an [`OrderByExpr`] node mutably.
334    ///
335    /// The default implementation delegates to [`visit_order_by_expr_mut`].
336    fn visit_order_by_expr_mut(&mut self, i: &mut OrderByExpr) {
337        visit_order_by_expr_mut(self, i);
338    }
339
340    /// Visits a [`Path`] node mutably.
341    ///
342    /// The default implementation delegates to [`visit_path_mut`].
343    fn visit_path_mut(&mut self, i: &mut Path) {
344        visit_path_mut(self, i);
345    }
346
347    /// Visits a [`Projection`] node mutably.
348    ///
349    /// The default implementation delegates to [`visit_projection_mut`].
350    fn visit_projection_mut(&mut self, i: &mut Projection) {
351        visit_projection_mut(self, i);
352    }
353
354    /// Visits a [`Returning`] node mutably.
355    ///
356    /// The default implementation delegates to [`visit_returning_mut`].
357    fn visit_returning_mut(&mut self, i: &mut Returning) {
358        visit_returning_mut(self, i);
359    }
360
361    /// Visits a [`Source`] node mutably.
362    ///
363    /// The default implementation delegates to [`visit_source_mut`].
364    fn visit_source_mut(&mut self, i: &mut Source) {
365        visit_source_mut(self, i);
366    }
367
368    /// Visits a [`SourceModel`] node mutably.
369    ///
370    /// The default implementation delegates to [`visit_source_model_mut`].
371    fn visit_source_model_mut(&mut self, i: &mut SourceModel) {
372        visit_source_model_mut(self, i);
373    }
374
375    /// Visits a [`SourceTable`] node mutably.
376    ///
377    /// The default implementation delegates to [`visit_source_table_mut`].
378    fn visit_source_table_mut(&mut self, i: &mut SourceTable) {
379        visit_source_table_mut(self, i);
380    }
381
382    /// Visits a [`SourceTableId`] node mutably.
383    ///
384    /// The default implementation delegates to [`visit_source_table_id_mut`].
385    fn visit_source_table_id_mut(&mut self, i: &mut SourceTableId) {
386        visit_source_table_id_mut(self, i);
387    }
388
389    /// Visits a [`Statement`] node mutably.
390    ///
391    /// The default implementation delegates to [`visit_stmt_mut`].
392    fn visit_stmt_mut(&mut self, i: &mut Statement) {
393        visit_stmt_mut(self, i);
394    }
395
396    /// Visits a [`Delete`] statement node mutably.
397    ///
398    /// The default implementation delegates to [`visit_stmt_delete_mut`].
399    fn visit_stmt_delete_mut(&mut self, i: &mut Delete) {
400        visit_stmt_delete_mut(self, i);
401    }
402
403    /// Visits an [`Insert`] statement node mutably.
404    ///
405    /// The default implementation delegates to [`visit_stmt_insert_mut`].
406    fn visit_stmt_insert_mut(&mut self, i: &mut Insert) {
407        visit_stmt_insert_mut(self, i);
408    }
409
410    /// Visits a [`Query`] statement node mutably.
411    ///
412    /// The default implementation delegates to [`visit_stmt_query_mut`].
413    fn visit_stmt_query_mut(&mut self, i: &mut Query) {
414        visit_stmt_query_mut(self, i);
415    }
416
417    /// Visits a [`Select`] statement node mutably.
418    ///
419    /// The default implementation delegates to [`visit_stmt_select_mut`].
420    fn visit_stmt_select_mut(&mut self, i: &mut Select) {
421        visit_stmt_select_mut(self, i);
422    }
423
424    /// Visits an [`Update`] statement node mutably.
425    ///
426    /// The default implementation delegates to [`visit_stmt_update_mut`].
427    fn visit_stmt_update_mut(&mut self, i: &mut Update) {
428        visit_stmt_update_mut(self, i);
429    }
430
431    /// Visits a [`TableDerived`] node mutably.
432    ///
433    /// The default implementation delegates to [`visit_table_derived_mut`].
434    fn visit_table_derived_mut(&mut self, i: &mut TableDerived) {
435        visit_table_derived_mut(self, i);
436    }
437
438    /// Visits a [`TableRef`] node mutably.
439    ///
440    /// The default implementation delegates to [`visit_table_ref_mut`].
441    fn visit_table_ref_mut(&mut self, i: &mut TableRef) {
442        visit_table_ref_mut(self, i);
443    }
444
445    /// Visits a [`TableFactor`] node mutably.
446    ///
447    /// The default implementation delegates to [`visit_table_factor_mut`].
448    fn visit_table_factor_mut(&mut self, i: &mut TableFactor) {
449        visit_table_factor_mut(self, i);
450    }
451
452    /// Visits a [`TableWithJoins`] node mutably.
453    ///
454    /// The default implementation delegates to [`visit_table_with_joins_mut`].
455    fn visit_table_with_joins_mut(&mut self, i: &mut TableWithJoins) {
456        visit_table_with_joins_mut(self, i);
457    }
458
459    /// Visits a [`Type`] node mutably.
460    ///
461    /// The default implementation delegates to [`visit_type_mut`].
462    fn visit_type_mut(&mut self, i: &mut Type) {
463        visit_type_mut(self, i);
464    }
465
466    /// Visits an [`UpdateTarget`] node mutably.
467    ///
468    /// The default implementation delegates to [`visit_update_target_mut`].
469    fn visit_update_target_mut(&mut self, i: &mut UpdateTarget) {
470        visit_update_target_mut(self, i);
471    }
472
473    /// Visits a [`Value`] node mutably.
474    ///
475    /// The default implementation delegates to [`visit_value_mut`].
476    fn visit_value_mut(&mut self, i: &mut Value) {
477        visit_value_mut(self, i);
478    }
479
480    /// Visits a [`ValueRecord`] node mutably.
481    ///
482    /// The default implementation delegates to [`visit_value_record`].
483    fn visit_value_record(&mut self, i: &mut ValueRecord) {
484        visit_value_record(self, i);
485    }
486
487    /// Visits a [`Values`] node mutably.
488    ///
489    /// The default implementation delegates to [`visit_values_mut`].
490    fn visit_values_mut(&mut self, i: &mut Values) {
491        visit_values_mut(self, i);
492    }
493
494    /// Visits a [`With`] node mutably.
495    ///
496    /// The default implementation delegates to [`visit_with_mut`].
497    fn visit_with_mut(&mut self, i: &mut With) {
498        visit_with_mut(self, i);
499    }
500}
501
502impl<V: VisitMut> VisitMut for &mut V {
503    fn visit_assignment_mut(&mut self, i: &mut Assignment) {
504        VisitMut::visit_assignment_mut(&mut **self, i);
505    }
506
507    fn visit_assignments_mut(&mut self, i: &mut Assignments) {
508        VisitMut::visit_assignments_mut(&mut **self, i);
509    }
510
511    fn visit_association_mut(&mut self, i: &mut Association) {
512        VisitMut::visit_association_mut(&mut **self, i);
513    }
514
515    fn visit_cte_mut(&mut self, i: &mut Cte) {
516        VisitMut::visit_cte_mut(&mut **self, i);
517    }
518
519    fn visit_expr_mut(&mut self, i: &mut Expr) {
520        VisitMut::visit_expr_mut(&mut **self, i);
521    }
522
523    fn visit_expr_and_mut(&mut self, i: &mut ExprAnd) {
524        VisitMut::visit_expr_and_mut(&mut **self, i);
525    }
526
527    fn visit_expr_arg_mut(&mut self, i: &mut ExprArg) {
528        VisitMut::visit_expr_arg_mut(&mut **self, i);
529    }
530
531    fn visit_expr_binary_op_mut(&mut self, i: &mut ExprBinaryOp) {
532        VisitMut::visit_expr_binary_op_mut(&mut **self, i);
533    }
534
535    fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
536        VisitMut::visit_expr_cast_mut(&mut **self, i);
537    }
538
539    fn visit_expr_column_mut(&mut self, i: &mut ExprColumn) {
540        VisitMut::visit_expr_column_mut(&mut **self, i);
541    }
542
543    fn visit_expr_default_mut(&mut self) {
544        VisitMut::visit_expr_default_mut(&mut **self);
545    }
546
547    fn visit_expr_error_mut(&mut self, i: &mut ExprError) {
548        VisitMut::visit_expr_error_mut(&mut **self, i);
549    }
550
551    fn visit_expr_exists_mut(&mut self, i: &mut ExprExists) {
552        VisitMut::visit_expr_exists_mut(&mut **self, i);
553    }
554
555    fn visit_expr_func_mut(&mut self, i: &mut ExprFunc) {
556        VisitMut::visit_expr_func_mut(&mut **self, i);
557    }
558
559    fn visit_expr_func_count_mut(&mut self, i: &mut FuncCount) {
560        VisitMut::visit_expr_func_count_mut(&mut **self, i);
561    }
562
563    fn visit_expr_in_list_mut(&mut self, i: &mut ExprInList) {
564        VisitMut::visit_expr_in_list_mut(&mut **self, i);
565    }
566
567    fn visit_expr_in_subquery_mut(&mut self, i: &mut ExprInSubquery) {
568        VisitMut::visit_expr_in_subquery_mut(&mut **self, i);
569    }
570
571    fn visit_expr_is_null_mut(&mut self, i: &mut ExprIsNull) {
572        VisitMut::visit_expr_is_null_mut(&mut **self, i);
573    }
574
575    fn visit_expr_is_variant_mut(&mut self, i: &mut ExprIsVariant) {
576        VisitMut::visit_expr_is_variant_mut(&mut **self, i);
577    }
578
579    fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
580        VisitMut::visit_expr_let_mut(&mut **self, i);
581    }
582
583    fn visit_expr_map_mut(&mut self, i: &mut ExprMap) {
584        VisitMut::visit_expr_map_mut(&mut **self, i);
585    }
586
587    fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
588        VisitMut::visit_expr_match_mut(&mut **self, i);
589    }
590
591    fn visit_expr_not_mut(&mut self, i: &mut ExprNot) {
592        VisitMut::visit_expr_not_mut(&mut **self, i);
593    }
594
595    fn visit_expr_or_mut(&mut self, i: &mut ExprOr) {
596        VisitMut::visit_expr_or_mut(&mut **self, i);
597    }
598
599    fn visit_expr_list_mut(&mut self, i: &mut ExprList) {
600        VisitMut::visit_expr_list_mut(&mut **self, i);
601    }
602
603    fn visit_expr_record_mut(&mut self, i: &mut ExprRecord) {
604        VisitMut::visit_expr_record_mut(&mut **self, i);
605    }
606
607    fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
608        VisitMut::visit_expr_reference_mut(&mut **self, i);
609    }
610
611    fn visit_expr_set_mut(&mut self, i: &mut ExprSet) {
612        VisitMut::visit_expr_set_mut(&mut **self, i);
613    }
614
615    fn visit_expr_set_op_mut(&mut self, i: &mut ExprSetOp) {
616        VisitMut::visit_expr_set_op_mut(&mut **self, i);
617    }
618
619    fn visit_expr_stmt_mut(&mut self, i: &mut ExprStmt) {
620        VisitMut::visit_expr_stmt_mut(&mut **self, i);
621    }
622
623    fn visit_filter_mut(&mut self, i: &mut Filter) {
624        VisitMut::visit_filter_mut(&mut **self, i);
625    }
626
627    fn visit_condition_mut(&mut self, i: &mut Condition) {
628        VisitMut::visit_condition_mut(&mut **self, i);
629    }
630
631    fn visit_expr_project_mut(&mut self, i: &mut ExprProject) {
632        VisitMut::visit_expr_project_mut(&mut **self, i);
633    }
634
635    fn visit_insert_target_mut(&mut self, i: &mut InsertTarget) {
636        VisitMut::visit_insert_target_mut(&mut **self, i);
637    }
638
639    fn visit_join_mut(&mut self, i: &mut Join) {
640        VisitMut::visit_join_mut(&mut **self, i);
641    }
642
643    fn visit_limit_mut(&mut self, i: &mut Limit) {
644        VisitMut::visit_limit_mut(&mut **self, i);
645    }
646
647    fn visit_limit_cursor_mut(&mut self, i: &mut LimitCursor) {
648        VisitMut::visit_limit_cursor_mut(&mut **self, i);
649    }
650
651    fn visit_limit_offset_mut(&mut self, i: &mut LimitOffset) {
652        VisitMut::visit_limit_offset_mut(&mut **self, i);
653    }
654
655    fn visit_order_by_mut(&mut self, i: &mut OrderBy) {
656        VisitMut::visit_order_by_mut(&mut **self, i);
657    }
658
659    fn visit_order_by_expr_mut(&mut self, i: &mut OrderByExpr) {
660        VisitMut::visit_order_by_expr_mut(&mut **self, i);
661    }
662
663    fn visit_path_mut(&mut self, i: &mut Path) {
664        VisitMut::visit_path_mut(&mut **self, i);
665    }
666
667    fn visit_projection_mut(&mut self, i: &mut Projection) {
668        VisitMut::visit_projection_mut(&mut **self, i);
669    }
670
671    fn visit_returning_mut(&mut self, i: &mut Returning) {
672        VisitMut::visit_returning_mut(&mut **self, i);
673    }
674
675    fn visit_source_mut(&mut self, i: &mut Source) {
676        VisitMut::visit_source_mut(&mut **self, i);
677    }
678
679    fn visit_source_model_mut(&mut self, i: &mut SourceModel) {
680        VisitMut::visit_source_model_mut(&mut **self, i);
681    }
682
683    fn visit_source_table_mut(&mut self, i: &mut SourceTable) {
684        VisitMut::visit_source_table_mut(&mut **self, i);
685    }
686
687    fn visit_source_table_id_mut(&mut self, i: &mut SourceTableId) {
688        VisitMut::visit_source_table_id_mut(&mut **self, i);
689    }
690
691    fn visit_stmt_mut(&mut self, i: &mut Statement) {
692        VisitMut::visit_stmt_mut(&mut **self, i);
693    }
694
695    fn visit_stmt_delete_mut(&mut self, i: &mut Delete) {
696        VisitMut::visit_stmt_delete_mut(&mut **self, i);
697    }
698
699    fn visit_stmt_insert_mut(&mut self, i: &mut Insert) {
700        VisitMut::visit_stmt_insert_mut(&mut **self, i);
701    }
702
703    fn visit_stmt_query_mut(&mut self, i: &mut Query) {
704        VisitMut::visit_stmt_query_mut(&mut **self, i);
705    }
706
707    fn visit_stmt_select_mut(&mut self, i: &mut Select) {
708        VisitMut::visit_stmt_select_mut(&mut **self, i);
709    }
710
711    fn visit_stmt_update_mut(&mut self, i: &mut Update) {
712        VisitMut::visit_stmt_update_mut(&mut **self, i);
713    }
714
715    fn visit_table_derived_mut(&mut self, i: &mut TableDerived) {
716        VisitMut::visit_table_derived_mut(&mut **self, i);
717    }
718
719    fn visit_table_ref_mut(&mut self, i: &mut TableRef) {
720        VisitMut::visit_table_ref_mut(&mut **self, i);
721    }
722
723    fn visit_table_factor_mut(&mut self, i: &mut TableFactor) {
724        VisitMut::visit_table_factor_mut(&mut **self, i);
725    }
726
727    fn visit_table_with_joins_mut(&mut self, i: &mut TableWithJoins) {
728        VisitMut::visit_table_with_joins_mut(&mut **self, i);
729    }
730
731    fn visit_type_mut(&mut self, i: &mut Type) {
732        VisitMut::visit_type_mut(&mut **self, i);
733    }
734
735    fn visit_update_target_mut(&mut self, i: &mut UpdateTarget) {
736        VisitMut::visit_update_target_mut(&mut **self, i);
737    }
738
739    fn visit_value_mut(&mut self, i: &mut Value) {
740        VisitMut::visit_value_mut(&mut **self, i);
741    }
742
743    fn visit_value_record(&mut self, i: &mut ValueRecord) {
744        VisitMut::visit_value_record(&mut **self, i);
745    }
746
747    fn visit_values_mut(&mut self, i: &mut Values) {
748        VisitMut::visit_values_mut(&mut **self, i);
749    }
750
751    fn visit_with_mut(&mut self, i: &mut With) {
752        VisitMut::visit_with_mut(&mut **self, i);
753    }
754}
755
756/// Default mutable traversal for [`Assignment`] nodes. Visits the assignment's expression(s).
757pub fn visit_assignment_mut<V>(v: &mut V, node: &mut Assignment)
758where
759    V: VisitMut + ?Sized,
760{
761    match node {
762        Assignment::Set(expr) | Assignment::Insert(expr) | Assignment::Remove(expr) => {
763            v.visit_expr_mut(expr);
764        }
765        Assignment::Batch(entries) => {
766            for entry in entries {
767                visit_assignment_mut(v, entry);
768            }
769        }
770    }
771}
772
773/// Default mutable traversal for [`Assignments`] nodes. Visits each assignment.
774pub fn visit_assignments_mut<V>(v: &mut V, node: &mut Assignments)
775where
776    V: VisitMut + ?Sized,
777{
778    for (_, assignment) in node.iter_mut() {
779        v.visit_assignment_mut(assignment);
780    }
781}
782
783/// Default mutable traversal for [`Association`] nodes. Visits the source query.
784pub fn visit_association_mut<V>(v: &mut V, node: &mut Association)
785where
786    V: VisitMut + ?Sized,
787{
788    v.visit_stmt_query_mut(&mut node.source);
789}
790
791/// Default mutable traversal for [`Cte`] nodes. Visits the CTE's query.
792pub fn visit_cte_mut<V>(v: &mut V, node: &mut Cte)
793where
794    V: VisitMut + ?Sized,
795{
796    v.visit_stmt_query_mut(&mut node.query);
797}
798
799/// Default mutable traversal for [`Expr`] nodes. Dispatches to variant-specific visitor.
800pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr)
801where
802    V: VisitMut + ?Sized,
803{
804    match node {
805        Expr::And(expr) => v.visit_expr_and_mut(expr),
806        Expr::Any(expr) => v.visit_expr_any_mut(expr),
807        Expr::Arg(expr) => v.visit_expr_arg_mut(expr),
808        Expr::BinaryOp(expr) => v.visit_expr_binary_op_mut(expr),
809        Expr::Cast(expr) => v.visit_expr_cast_mut(expr),
810        Expr::Default => v.visit_expr_default_mut(),
811        Expr::Error(expr) => v.visit_expr_error_mut(expr),
812        Expr::Exists(expr) => v.visit_expr_exists_mut(expr),
813        Expr::Func(expr) => v.visit_expr_func_mut(expr),
814        Expr::InList(expr) => v.visit_expr_in_list_mut(expr),
815        Expr::InSubquery(expr) => v.visit_expr_in_subquery_mut(expr),
816        Expr::IsNull(expr) => v.visit_expr_is_null_mut(expr),
817        Expr::IsVariant(expr) => v.visit_expr_is_variant_mut(expr),
818        Expr::Let(expr) => v.visit_expr_let_mut(expr),
819        Expr::Map(expr) => v.visit_expr_map_mut(expr),
820        Expr::Match(expr) => v.visit_expr_match_mut(expr),
821        Expr::Not(expr) => v.visit_expr_not_mut(expr),
822        Expr::Or(expr) => v.visit_expr_or_mut(expr),
823        Expr::Project(expr) => v.visit_expr_project_mut(expr),
824        Expr::Record(expr) => v.visit_expr_record_mut(expr),
825        Expr::Reference(expr) => v.visit_expr_reference_mut(expr),
826        Expr::List(expr) => v.visit_expr_list_mut(expr),
827        Expr::Stmt(expr) => v.visit_expr_stmt_mut(expr),
828        Expr::Value(expr) => v.visit_value_mut(expr),
829    }
830}
831
832/// Default mutable traversal for [`ExprAnd`] nodes. Visits each operand.
833pub fn visit_expr_and_mut<V>(v: &mut V, node: &mut ExprAnd)
834where
835    V: VisitMut + ?Sized,
836{
837    for expr in node {
838        v.visit_expr_mut(expr);
839    }
840}
841
842/// Default mutable traversal for [`ExprAny`] nodes. Visits the inner expression.
843pub fn visit_expr_any_mut<V>(v: &mut V, node: &mut ExprAny)
844where
845    V: VisitMut + ?Sized,
846{
847    v.visit_expr_mut(&mut node.expr);
848}
849
850/// Default mutable traversal for [`ExprArg`] nodes. This is a leaf node with no children to visit.
851pub fn visit_expr_arg_mut<V>(v: &mut V, node: &mut ExprArg)
852where
853    V: VisitMut + ?Sized,
854{
855}
856
857/// Default mutable traversal for [`ExprBinaryOp`] nodes. Visits the lhs and rhs expressions.
858pub fn visit_expr_binary_op_mut<V>(v: &mut V, node: &mut ExprBinaryOp)
859where
860    V: VisitMut + ?Sized,
861{
862    v.visit_expr_mut(&mut node.lhs);
863    v.visit_expr_mut(&mut node.rhs);
864}
865
866/// Default mutable traversal for [`ExprCast`] nodes. Visits the expression and its target type.
867pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast)
868where
869    V: VisitMut + ?Sized,
870{
871    v.visit_expr_mut(&mut node.expr);
872    v.visit_type_mut(&mut node.ty);
873}
874
875/// Default mutable traversal for [`ExprColumn`] nodes. This is a leaf node with no children to visit.
876pub fn visit_expr_column_mut<V>(v: &mut V, node: &mut ExprColumn)
877where
878    V: VisitMut + ?Sized,
879{
880}
881
882/// Default mutable traversal for [`Expr::Default`] nodes. This is a leaf node with no children to visit.
883pub fn visit_expr_default_mut<V>(v: &mut V)
884where
885    V: VisitMut + ?Sized,
886{
887}
888
889/// Default mutable traversal for [`ExprError`] nodes. This is a leaf node with no children to visit.
890pub fn visit_expr_error_mut<V>(v: &mut V, node: &mut ExprError)
891where
892    V: VisitMut + ?Sized,
893{
894    // ExprError has no child expressions to visit
895}
896
897/// Default mutable traversal for [`ExprExists`] nodes. Visits the subquery.
898pub fn visit_expr_exists_mut<V>(v: &mut V, node: &mut ExprExists)
899where
900    V: VisitMut + ?Sized,
901{
902    v.visit_stmt_query_mut(&mut node.subquery);
903}
904
905/// Default mutable traversal for [`ExprFunc`] nodes. Dispatches to the function-specific visitor.
906pub fn visit_expr_func_mut<V>(v: &mut V, node: &mut ExprFunc)
907where
908    V: VisitMut + ?Sized,
909{
910    match node {
911        ExprFunc::Count(func) => v.visit_expr_func_count_mut(func),
912        ExprFunc::LastInsertId(func) => v.visit_expr_func_last_insert_id_mut(func),
913    }
914}
915
916/// Default mutable traversal for [`FuncCount`] nodes. Visits the optional argument and optional filter expressions.
917pub fn visit_expr_func_count_mut<V>(v: &mut V, node: &mut FuncCount)
918where
919    V: VisitMut + ?Sized,
920{
921    if let Some(expr) = &mut node.arg {
922        v.visit_expr_mut(expr);
923    }
924
925    if let Some(expr) = &mut node.filter {
926        v.visit_expr_mut(expr);
927    }
928}
929
930/// Default mutable traversal for [`FuncLastInsertId`] nodes. This is a leaf node with no children to visit.
931pub fn visit_expr_func_last_insert_id_mut<V>(_v: &mut V, _node: &mut FuncLastInsertId)
932where
933    V: VisitMut + ?Sized,
934{
935    // FuncLastInsertId has no fields to visit
936}
937
938/// Default mutable traversal for [`ExprInList`] nodes. Visits the expression and the list expression.
939pub fn visit_expr_in_list_mut<V>(v: &mut V, node: &mut ExprInList)
940where
941    V: VisitMut + ?Sized,
942{
943    v.visit_expr_mut(&mut node.expr);
944    v.visit_expr_mut(&mut node.list);
945}
946
947/// Default mutable traversal for [`ExprInSubquery`] nodes. Visits the expression and the subquery.
948pub fn visit_expr_in_subquery_mut<V>(v: &mut V, node: &mut ExprInSubquery)
949where
950    V: VisitMut + ?Sized,
951{
952    v.visit_expr_mut(&mut node.expr);
953    v.visit_stmt_query_mut(&mut node.query);
954}
955
956/// Default mutable traversal for [`ExprIsNull`] nodes. Visits the inner expression.
957pub fn visit_expr_is_null_mut<V>(v: &mut V, node: &mut ExprIsNull)
958where
959    V: VisitMut + ?Sized,
960{
961    v.visit_expr_mut(&mut node.expr);
962}
963
964/// Default mutable traversal for [`ExprIsVariant`] nodes. Visits the inner expression.
965pub fn visit_expr_is_variant_mut<V>(v: &mut V, node: &mut ExprIsVariant)
966where
967    V: VisitMut + ?Sized,
968{
969    v.visit_expr_mut(&mut node.expr);
970}
971
972/// Default mutable traversal for [`ExprLet`] nodes. Visits each binding expression and the body.
973pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet)
974where
975    V: VisitMut + ?Sized,
976{
977    for binding in &mut node.bindings {
978        v.visit_expr_mut(binding);
979    }
980    v.visit_expr_mut(&mut node.body);
981}
982
983/// Default mutable traversal for [`ExprMap`] nodes. Visits the base expression and the map expression.
984pub fn visit_expr_map_mut<V>(v: &mut V, node: &mut ExprMap)
985where
986    V: VisitMut + ?Sized,
987{
988    v.visit_expr_mut(&mut node.base);
989    v.visit_expr_mut(&mut node.map);
990}
991
992/// Default mutable traversal for [`ExprMatch`] nodes. Visits the subject, each arm's expression, and the else expression.
993pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch)
994where
995    V: VisitMut + ?Sized,
996{
997    v.visit_expr_mut(&mut node.subject);
998    for arm in &mut node.arms {
999        v.visit_expr_mut(&mut arm.expr);
1000    }
1001    v.visit_expr_mut(&mut node.else_expr);
1002}
1003
1004/// Default mutable traversal for [`ExprNot`] nodes. Visits the inner expression.
1005pub fn visit_expr_not_mut<V>(v: &mut V, node: &mut ExprNot)
1006where
1007    V: VisitMut + ?Sized,
1008{
1009    v.visit_expr_mut(&mut node.expr);
1010}
1011
1012/// Default mutable traversal for [`ExprOr`] nodes. Visits each operand.
1013pub fn visit_expr_or_mut<V>(v: &mut V, node: &mut ExprOr)
1014where
1015    V: VisitMut + ?Sized,
1016{
1017    for expr in node {
1018        v.visit_expr_mut(expr);
1019    }
1020}
1021
1022/// Default mutable traversal for [`ExprList`] nodes. Visits each item expression.
1023pub fn visit_expr_list_mut<V>(v: &mut V, node: &mut ExprList)
1024where
1025    V: VisitMut + ?Sized,
1026{
1027    for e in &mut node.items {
1028        v.visit_expr_mut(e);
1029    }
1030}
1031
1032/// Default mutable traversal for [`ExprRecord`] nodes. Visits each field expression.
1033pub fn visit_expr_record_mut<V>(v: &mut V, node: &mut ExprRecord)
1034where
1035    V: VisitMut + ?Sized,
1036{
1037    for expr in &mut **node {
1038        v.visit_expr_mut(expr);
1039    }
1040}
1041
1042/// Default mutable traversal for [`ExprReference`] nodes. Dispatches based on the reference kind.
1043pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference)
1044where
1045    V: VisitMut + ?Sized,
1046{
1047    match node {
1048        ExprReference::Model { .. } => {}
1049        ExprReference::Field { .. } => {}
1050        ExprReference::Column(expr_column) => v.visit_expr_column_mut(expr_column),
1051    }
1052}
1053
1054/// Default mutable traversal for [`ExprSet`] nodes. Dispatches to the set expression variant visitor.
1055pub fn visit_expr_set_mut<V>(v: &mut V, node: &mut ExprSet)
1056where
1057    V: VisitMut + ?Sized,
1058{
1059    match node {
1060        ExprSet::Select(expr) => v.visit_stmt_select_mut(expr),
1061        ExprSet::SetOp(expr) => v.visit_expr_set_op_mut(expr),
1062        ExprSet::Update(expr) => v.visit_stmt_update_mut(expr),
1063        ExprSet::Values(expr) => v.visit_values_mut(expr),
1064        ExprSet::Insert(expr) => v.visit_stmt_insert_mut(expr),
1065    }
1066}
1067
1068/// Default mutable traversal for [`ExprSetOp`] nodes. Visits each operand.
1069pub fn visit_expr_set_op_mut<V>(v: &mut V, node: &mut ExprSetOp)
1070where
1071    V: VisitMut + ?Sized,
1072{
1073    for operand in &mut node.operands {
1074        v.visit_expr_set_mut(operand);
1075    }
1076}
1077
1078/// Default mutable traversal for [`ExprStmt`] nodes. Visits the inner statement.
1079pub fn visit_expr_stmt_mut<V>(v: &mut V, node: &mut ExprStmt)
1080where
1081    V: VisitMut + ?Sized,
1082{
1083    v.visit_stmt_mut(&mut node.stmt);
1084}
1085
1086/// Default mutable traversal for [`ExprProject`] nodes. Visits the base expression and the projection.
1087pub fn visit_expr_project_mut<V>(v: &mut V, node: &mut ExprProject)
1088where
1089    V: VisitMut + ?Sized,
1090{
1091    v.visit_expr_mut(&mut node.base);
1092    v.visit_projection_mut(&mut node.projection);
1093}
1094
1095/// Default mutable traversal for [`Filter`] nodes. Visits the optional filter expression.
1096pub fn visit_filter_mut<V>(v: &mut V, node: &mut Filter)
1097where
1098    V: VisitMut + ?Sized,
1099{
1100    if let Some(expr) = &mut node.expr {
1101        v.visit_expr_mut(expr);
1102    }
1103}
1104
1105/// Default mutable traversal for [`Condition`] nodes. Visits the optional condition expression.
1106pub fn visit_condition_mut<V>(v: &mut V, node: &mut Condition)
1107where
1108    V: VisitMut + ?Sized,
1109{
1110    if let Some(expr) = &mut node.expr {
1111        v.visit_expr_mut(expr);
1112    }
1113}
1114
1115/// Default mutable traversal for [`InsertTarget`] nodes. Visits the scope query if present.
1116pub fn visit_insert_target_mut<V>(v: &mut V, node: &mut InsertTarget)
1117where
1118    V: VisitMut + ?Sized,
1119{
1120    if let InsertTarget::Scope(stmt) = node {
1121        v.visit_stmt_query_mut(stmt)
1122    }
1123}
1124
1125/// Default mutable traversal for [`Join`] nodes. Visits the table and the join constraint expression.
1126pub fn visit_join_mut<V>(v: &mut V, node: &mut Join)
1127where
1128    V: VisitMut + ?Sized,
1129{
1130    v.visit_source_table_id_mut(&mut node.table);
1131    match &mut node.constraint {
1132        JoinOp::Left(expr) => v.visit_expr_mut(expr),
1133    }
1134}
1135
1136/// Default mutable traversal for [`Limit`] nodes.
1137pub fn visit_limit_mut<V>(v: &mut V, node: &mut Limit)
1138where
1139    V: VisitMut + ?Sized,
1140{
1141    match node {
1142        Limit::Cursor(cursor) => v.visit_limit_cursor_mut(cursor),
1143        Limit::Offset(offset) => v.visit_limit_offset_mut(offset),
1144    }
1145}
1146
1147/// Default mutable traversal for [`LimitCursor`] nodes.
1148pub fn visit_limit_cursor_mut<V>(v: &mut V, node: &mut LimitCursor)
1149where
1150    V: VisitMut + ?Sized,
1151{
1152    v.visit_expr_mut(&mut node.page_size);
1153    if let Some(after) = &mut node.after {
1154        v.visit_expr_mut(after);
1155    }
1156}
1157
1158/// Default mutable traversal for [`LimitOffset`] nodes.
1159pub fn visit_limit_offset_mut<V>(v: &mut V, node: &mut LimitOffset)
1160where
1161    V: VisitMut + ?Sized,
1162{
1163    v.visit_expr_mut(&mut node.limit);
1164    if let Some(offset) = &mut node.offset {
1165        v.visit_expr_mut(offset);
1166    }
1167}
1168
1169/// Default mutable traversal for [`OrderBy`] nodes. Visits each ordering expression.
1170pub fn visit_order_by_mut<V>(v: &mut V, node: &mut OrderBy)
1171where
1172    V: VisitMut + ?Sized,
1173{
1174    for expr in &mut node.exprs {
1175        v.visit_order_by_expr_mut(expr);
1176    }
1177}
1178
1179/// Default mutable traversal for [`OrderByExpr`] nodes. Visits the ordering expression.
1180pub fn visit_order_by_expr_mut<V>(v: &mut V, node: &mut OrderByExpr)
1181where
1182    V: VisitMut + ?Sized,
1183{
1184    v.visit_expr_mut(&mut node.expr);
1185}
1186
1187/// Default mutable traversal for [`Path`] nodes. Visits the projection.
1188pub fn visit_path_mut<V>(v: &mut V, node: &mut Path)
1189where
1190    V: VisitMut + ?Sized,
1191{
1192    v.visit_projection_mut(&mut node.projection);
1193}
1194
1195/// Default mutable traversal for [`Projection`] nodes. This is a leaf node with no children to visit.
1196pub fn visit_projection_mut<V>(v: &mut V, node: &mut Projection)
1197where
1198    V: VisitMut + ?Sized,
1199{
1200}
1201
1202/// Default mutable traversal for [`Returning`] nodes. Visits each path for model variants, or the expression for expr and value variants.
1203pub fn visit_returning_mut<V>(v: &mut V, node: &mut Returning)
1204where
1205    V: VisitMut + ?Sized,
1206{
1207    match node {
1208        Returning::Model { include } => {
1209            for path in include {
1210                v.visit_path_mut(path);
1211            }
1212        }
1213        Returning::Changed => {}
1214        Returning::Expr(expr) => v.visit_expr_mut(expr),
1215        Returning::Value(expr) => v.visit_expr_mut(expr),
1216    }
1217}
1218
1219/// Default mutable traversal for [`Source`] nodes. Dispatches to the model or table source visitor.
1220pub fn visit_source_mut<V>(v: &mut V, node: &mut Source)
1221where
1222    V: VisitMut + ?Sized,
1223{
1224    match node {
1225        Source::Model(source_model) => v.visit_source_model_mut(source_model),
1226        Source::Table(source_table) => v.visit_source_table_mut(source_table),
1227    }
1228}
1229
1230/// Default mutable traversal for [`SourceModel`] nodes. Visits the optional association.
1231pub fn visit_source_model_mut<V>(v: &mut V, node: &mut SourceModel)
1232where
1233    V: VisitMut + ?Sized,
1234{
1235    if let Some(association) = &mut node.via {
1236        v.visit_association_mut(association);
1237    }
1238}
1239
1240/// Default mutable traversal for [`SourceTable`] nodes. Visits each table reference and each FROM clause table-with-joins.
1241pub fn visit_source_table_mut<V>(v: &mut V, node: &mut SourceTable)
1242where
1243    V: VisitMut + ?Sized,
1244{
1245    for table_ref in &mut node.tables {
1246        v.visit_table_ref_mut(table_ref);
1247    }
1248    for table_with_joins in &mut node.from {
1249        v.visit_table_with_joins_mut(table_with_joins);
1250    }
1251}
1252
1253/// Default mutable traversal for [`SourceTableId`] nodes. This is a leaf node with no children to visit.
1254pub fn visit_source_table_id_mut<V>(v: &mut V, node: &mut SourceTableId)
1255where
1256    V: VisitMut + ?Sized,
1257{
1258    // SourceTableId is just an index, nothing to visit
1259}
1260
1261/// Default mutable traversal for [`TableFactor`] nodes. Dispatches by factor type.
1262pub fn visit_table_factor_mut<V>(v: &mut V, node: &mut TableFactor)
1263where
1264    V: VisitMut + ?Sized,
1265{
1266    match node {
1267        TableFactor::Table(table_id) => v.visit_source_table_id_mut(table_id),
1268    }
1269}
1270
1271/// Default mutable traversal for [`Statement`] nodes. Dispatches to the statement-specific visitor.
1272pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Statement)
1273where
1274    V: VisitMut + ?Sized,
1275{
1276    match node {
1277        Statement::Delete(stmt) => v.visit_stmt_delete_mut(stmt),
1278        Statement::Insert(stmt) => v.visit_stmt_insert_mut(stmt),
1279        Statement::Query(stmt) => v.visit_stmt_query_mut(stmt),
1280        Statement::Update(stmt) => v.visit_stmt_update_mut(stmt),
1281    }
1282}
1283
1284/// Default mutable traversal for [`Delete`] nodes. Visits the source, filter, and optional returning clause.
1285pub fn visit_stmt_delete_mut<V>(v: &mut V, node: &mut Delete)
1286where
1287    V: VisitMut + ?Sized,
1288{
1289    v.visit_source_mut(&mut node.from);
1290    v.visit_filter_mut(&mut node.filter);
1291
1292    if let Some(returning) = &mut node.returning {
1293        v.visit_returning_mut(returning);
1294    }
1295}
1296
1297/// Default mutable traversal for [`Insert`] nodes. Visits the target, source query, and optional returning clause.
1298pub fn visit_stmt_insert_mut<V>(v: &mut V, node: &mut Insert)
1299where
1300    V: VisitMut + ?Sized,
1301{
1302    v.visit_insert_target_mut(&mut node.target);
1303    v.visit_stmt_query_mut(&mut node.source);
1304
1305    if let Some(returning) = &mut node.returning {
1306        v.visit_returning_mut(returning);
1307    }
1308}
1309
1310/// Default mutable traversal for [`Query`] nodes. Visits the optional WITH clause, body, optional ORDER BY, and optional LIMIT.
1311pub fn visit_stmt_query_mut<V>(v: &mut V, node: &mut Query)
1312where
1313    V: VisitMut + ?Sized,
1314{
1315    if let Some(with) = &mut node.with {
1316        v.visit_with_mut(with);
1317    }
1318
1319    v.visit_expr_set_mut(&mut node.body);
1320
1321    if let Some(order_by) = &mut node.order_by {
1322        v.visit_order_by_mut(order_by);
1323    }
1324
1325    if let Some(limit) = &mut node.limit {
1326        v.visit_limit_mut(limit);
1327    }
1328}
1329
1330/// Default mutable traversal for [`Select`] nodes. Visits the source, filter, and returning clause.
1331pub fn visit_stmt_select_mut<V>(v: &mut V, node: &mut Select)
1332where
1333    V: VisitMut + ?Sized,
1334{
1335    v.visit_source_mut(&mut node.source);
1336    v.visit_filter_mut(&mut node.filter);
1337    v.visit_returning_mut(&mut node.returning);
1338}
1339
1340/// Default mutable traversal for [`Update`] nodes. Visits the target, assignments, filter, condition, and optional returning clause.
1341pub fn visit_stmt_update_mut<V>(v: &mut V, node: &mut Update)
1342where
1343    V: VisitMut + ?Sized,
1344{
1345    v.visit_update_target_mut(&mut node.target);
1346    v.visit_assignments_mut(&mut node.assignments);
1347    v.visit_filter_mut(&mut node.filter);
1348    v.visit_condition_mut(&mut node.condition);
1349
1350    if let Some(returning) = &mut node.returning {
1351        v.visit_returning_mut(returning);
1352    }
1353}
1354
1355/// Default mutable traversal for [`TableDerived`] nodes. Visits the subquery.
1356pub fn visit_table_derived_mut<V>(v: &mut V, node: &mut TableDerived)
1357where
1358    V: VisitMut + ?Sized,
1359{
1360    v.visit_stmt_query_mut(&mut node.subquery);
1361}
1362
1363/// Default mutable traversal for [`TableRef`] nodes. Dispatches by reference kind, visiting derived tables and arg expressions.
1364pub fn visit_table_ref_mut<V>(v: &mut V, node: &mut TableRef)
1365where
1366    V: VisitMut + ?Sized,
1367{
1368    match node {
1369        TableRef::Cte { .. } => {}
1370        TableRef::Derived(table_derived) => v.visit_table_derived_mut(table_derived),
1371        TableRef::Table(_) => {}
1372        TableRef::Arg(expr_arg) => v.visit_expr_arg_mut(expr_arg),
1373    }
1374}
1375
1376/// Default mutable traversal for [`TableWithJoins`] nodes. Visits the relation and each join.
1377pub fn visit_table_with_joins_mut<V>(v: &mut V, node: &mut TableWithJoins)
1378where
1379    V: VisitMut + ?Sized,
1380{
1381    v.visit_table_factor_mut(&mut node.relation);
1382    for join in &mut node.joins {
1383        v.visit_join_mut(join);
1384    }
1385}
1386
1387/// Default mutable traversal for [`Type`] nodes. This is a leaf node with no children to visit.
1388pub fn visit_type_mut<V>(v: &mut V, node: &mut Type)
1389where
1390    V: VisitMut + ?Sized,
1391{
1392    // Type is just type information, no traversal needed
1393}
1394
1395/// Default mutable traversal for [`UpdateTarget`] nodes. Visits the query if present.
1396pub fn visit_update_target_mut<V>(v: &mut V, node: &mut UpdateTarget)
1397where
1398    V: VisitMut + ?Sized,
1399{
1400    if let UpdateTarget::Query(stmt) = node {
1401        v.visit_stmt_query_mut(stmt)
1402    }
1403}
1404
1405/// Default mutable traversal for [`Value`] nodes. Visits the inner record if the value is a record variant.
1406pub fn visit_value_mut<V>(v: &mut V, node: &mut Value)
1407where
1408    V: VisitMut + ?Sized,
1409{
1410    if let Value::Record(node) = node {
1411        v.visit_value_record(node);
1412    }
1413}
1414
1415/// Default mutable traversal for [`ValueRecord`] nodes. Visits each value field.
1416pub fn visit_value_record<V>(v: &mut V, node: &mut ValueRecord)
1417where
1418    V: VisitMut + ?Sized,
1419{
1420    for expr in &mut node.fields {
1421        v.visit_value_mut(expr);
1422    }
1423}
1424
1425/// Default mutable traversal for [`Values`] nodes. Visits each row expression.
1426pub fn visit_values_mut<V>(v: &mut V, node: &mut Values)
1427where
1428    V: VisitMut + ?Sized,
1429{
1430    for expr in &mut node.rows {
1431        v.visit_expr_mut(expr);
1432    }
1433}
1434
1435/// Default mutable traversal for [`With`] nodes. Visits each CTE.
1436pub fn visit_with_mut<V>(v: &mut V, node: &mut With)
1437where
1438    V: VisitMut + ?Sized,
1439{
1440    for cte in &mut node.ctes {
1441        v.visit_cte_mut(cte);
1442    }
1443}
1444
1445/// Calls `f` for every [`Expr`] node reachable from `node`, in post-order,
1446/// allowing mutation.
1447pub fn for_each_expr_mut<F>(node: &mut impl Node, f: F)
1448where
1449    F: FnMut(&mut Expr),
1450{
1451    struct ForEach<F> {
1452        f: F,
1453    }
1454
1455    impl<F> VisitMut for ForEach<F>
1456    where
1457        F: FnMut(&mut Expr),
1458    {
1459        fn visit_expr_mut(&mut self, node: &mut Expr) {
1460            visit_expr_mut(self, node);
1461            (self.f)(node);
1462        }
1463    }
1464
1465    node.visit_mut(ForEach { f });
1466}
1467
1468/// Walk an expression tree in pre-order, tracking scope depth through
1469/// Let/Map scopes.
1470///
1471/// For each node, calls `f(expr, scope_depth)`:
1472/// - If `f` returns `true`, recursion into children continues.
1473/// - If `f` returns `false`, children are skipped (e.g., when the callback
1474///   has replaced the expression and doesn't want to recurse into the
1475///   replacement).
1476///
1477/// Scope depth rules:
1478/// - `Let` bindings are visited at the current depth; the body at `depth + 1`
1479/// - `Map` base is visited at the current depth; the map function at `depth + 1`
1480/// - All other compound expressions: children at the same depth
1481///
1482/// This matches the semantics of `ExprArg.nesting`: an arg with
1483/// `nesting == scope_depth` references the outermost (statement-level) scope,
1484/// while `nesting < scope_depth` references a Let/Map binding.
1485pub fn walk_expr_scoped_mut<F>(expr: &mut Expr, scope_depth: usize, mut f: F)
1486where
1487    F: FnMut(&mut Expr, usize) -> bool,
1488{
1489    walk_expr_scoped_mut_ref(expr, scope_depth, &mut f);
1490}
1491
1492fn walk_expr_scoped_mut_ref<F>(expr: &mut Expr, scope_depth: usize, f: &mut F)
1493where
1494    F: FnMut(&mut Expr, usize) -> bool,
1495{
1496    struct ScopedWalk<'a, F> {
1497        f: &'a mut F,
1498        scope_depth: usize,
1499    }
1500
1501    impl<F> VisitMut for ScopedWalk<'_, F>
1502    where
1503        F: FnMut(&mut Expr, usize) -> bool,
1504    {
1505        fn visit_expr_mut(&mut self, node: &mut Expr) {
1506            if !(self.f)(node, self.scope_depth) {
1507                return;
1508            }
1509            visit_expr_mut(self, node);
1510        }
1511
1512        fn visit_expr_let_mut(&mut self, node: &mut ExprLet) {
1513            for binding in &mut node.bindings {
1514                self.visit_expr_mut(binding);
1515            }
1516            self.scope_depth += 1;
1517            self.visit_expr_mut(&mut node.body);
1518            self.scope_depth -= 1;
1519        }
1520
1521        fn visit_expr_map_mut(&mut self, node: &mut ExprMap) {
1522            self.visit_expr_mut(&mut node.base);
1523            self.scope_depth += 1;
1524            self.visit_expr_mut(&mut node.map);
1525            self.scope_depth -= 1;
1526        }
1527    }
1528
1529    ScopedWalk { f, scope_depth }.visit_expr_mut(expr);
1530}
toasty_core/stmt/visit_mut.rs

toasty_core/stmt/
visit_mut.rs
