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

toasty_core/stmt/
visit_mut.rs
