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

toasty_core/stmt/
visit_mut.rs
