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

toasty_core/stmt/
visit_mut.rs
