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

toasty_core/stmt/
visit_mut.rs
