toasty_core/stmt/
visit_mut.rs

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

toasty_core/stmt/
visit_mut.rs
