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

toasty_core/stmt/
visit_mut.rs
