toasty_core/stmt/
visit.rs

1#![allow(unused_variables)]
2
3use super::{
4    Assignment, Assignments, Association, Condition, Cte, Delete, Expr, ExprAnd, ExprAny, ExprArg,
5    ExprBinaryOp, ExprCast, ExprColumn, ExprError, ExprExists, ExprFunc, ExprInList,
6    ExprInSubquery, ExprIsNull, ExprIsVariant, ExprLet, ExprList, ExprMap, ExprMatch, ExprNot,
7    ExprOr, ExprProject, ExprRecord, ExprReference, ExprSet, ExprSetOp, ExprStmt, Filter,
8    FuncCount, FuncLastInsertId, Insert, InsertTarget, Join, JoinOp, Limit, LimitCursor,
9    LimitOffset, Node, OrderBy, OrderByExpr, Path, Projection, Query, Returning, Select, Source,
10    SourceModel, SourceTable, SourceTableId, Statement, TableDerived, TableFactor, TableRef,
11    TableWithJoins, Type, Update, UpdateTarget, Value, ValueRecord, Values, With,
12};
13
14/// Immutable visitor trait for the statement AST.
15///
16/// Implement this trait to walk the AST without modifying it. Each
17/// `visit_*` method has a default implementation that recurses into
18/// child nodes via the corresponding free function (e.g.,
19/// [`visit_expr`]). Override specific methods to inspect nodes of
20/// interest.
21///
22/// The companion [`for_each_expr`] helper visits every expression node
23/// in post-order.
24///
25/// # Examples
26///
27/// ```ignore
28/// use toasty_core::stmt::{visit, Expr, Value, Node};
29///
30/// let expr = Expr::from(Value::from(42_i64));
31/// let mut count = 0;
32/// visit::for_each_expr(&expr, |_| count += 1);
33/// assert_eq!(count, 1);
34/// ```
35pub trait Visit {
36    /// Dispatches to the appropriate `visit_*` method via [`Node::visit`].
37    fn visit<N: Node>(&mut self, i: &N)
38    where
39        Self: Sized,
40    {
41        i.visit(self);
42    }
43
44    /// Visits an [`Assignment`] node.
45    ///
46    /// The default implementation delegates to [`visit_assignment`].
47    fn visit_assignment(&mut self, i: &Assignment) {
48        visit_assignment(self, i);
49    }
50
51    /// Visits an [`Assignments`] node.
52    ///
53    /// The default implementation delegates to [`visit_assignments`].
54    fn visit_assignments(&mut self, i: &Assignments) {
55        visit_assignments(self, i);
56    }
57
58    /// Visits an [`Association`] node.
59    ///
60    /// The default implementation delegates to [`visit_association`].
61    fn visit_association(&mut self, i: &Association) {
62        visit_association(self, i);
63    }
64
65    /// Visits a [`Cte`] (common table expression) node.
66    ///
67    /// The default implementation delegates to [`visit_cte`].
68    fn visit_cte(&mut self, i: &Cte) {
69        visit_cte(self, i);
70    }
71
72    /// Visits an [`Expr`] node.
73    ///
74    /// The default implementation delegates to [`visit_expr`].
75    fn visit_expr(&mut self, i: &Expr) {
76        visit_expr(self, i);
77    }
78
79    /// Visits an [`ExprAnd`] node.
80    ///
81    /// The default implementation delegates to [`visit_expr_and`].
82    fn visit_expr_and(&mut self, i: &ExprAnd) {
83        visit_expr_and(self, i);
84    }
85
86    /// Visits an [`ExprAny`] node.
87    ///
88    /// The default implementation delegates to [`visit_expr_any`].
89    fn visit_expr_any(&mut self, i: &ExprAny) {
90        visit_expr_any(self, i);
91    }
92
93    /// Visits an [`ExprArg`] node.
94    ///
95    /// The default implementation delegates to [`visit_expr_arg`].
96    fn visit_expr_arg(&mut self, i: &ExprArg) {
97        visit_expr_arg(self, i);
98    }
99
100    /// Visits an [`ExprBinaryOp`] node.
101    ///
102    /// The default implementation delegates to [`visit_expr_binary_op`].
103    fn visit_expr_binary_op(&mut self, i: &ExprBinaryOp) {
104        visit_expr_binary_op(self, i);
105    }
106
107    /// Visits an [`ExprCast`] node.
108    ///
109    /// The default implementation delegates to [`visit_expr_cast`].
110    fn visit_expr_cast(&mut self, i: &ExprCast) {
111        visit_expr_cast(self, i);
112    }
113
114    /// Visits an [`ExprColumn`] node.
115    ///
116    /// The default implementation delegates to [`visit_expr_column`].
117    fn visit_expr_column(&mut self, i: &ExprColumn) {
118        visit_expr_column(self, i);
119    }
120
121    /// Visits a default expression (no associated data).
122    ///
123    /// The default implementation delegates to [`visit_expr_default`].
124    fn visit_expr_default(&mut self) {
125        visit_expr_default(self);
126    }
127
128    /// Visits an [`ExprError`] node.
129    ///
130    /// The default implementation delegates to [`visit_expr_error`].
131    fn visit_expr_error(&mut self, i: &ExprError) {
132        visit_expr_error(self, i);
133    }
134
135    /// Visits an [`ExprExists`] node.
136    ///
137    /// The default implementation delegates to [`visit_expr_exists`].
138    fn visit_expr_exists(&mut self, i: &ExprExists) {
139        visit_expr_exists(self, i);
140    }
141
142    /// Visits an [`ExprFunc`] node.
143    ///
144    /// The default implementation delegates to [`visit_expr_func`].
145    fn visit_expr_func(&mut self, i: &ExprFunc) {
146        visit_expr_func(self, i);
147    }
148
149    /// Visits a [`FuncCount`] node.
150    ///
151    /// The default implementation delegates to [`visit_expr_func_count`].
152    fn visit_expr_func_count(&mut self, i: &FuncCount) {
153        visit_expr_func_count(self, i);
154    }
155
156    /// Visits a [`FuncLastInsertId`] node.
157    ///
158    /// The default implementation delegates to [`visit_expr_func_last_insert_id`].
159    fn visit_expr_func_last_insert_id(&mut self, i: &FuncLastInsertId) {
160        visit_expr_func_last_insert_id(self, i);
161    }
162
163    /// Visits an [`ExprInList`] node.
164    ///
165    /// The default implementation delegates to [`visit_expr_in_list`].
166    fn visit_expr_in_list(&mut self, i: &ExprInList) {
167        visit_expr_in_list(self, i);
168    }
169
170    /// Visits an [`ExprInSubquery`] node.
171    ///
172    /// The default implementation delegates to [`visit_expr_in_subquery`].
173    fn visit_expr_in_subquery(&mut self, i: &ExprInSubquery) {
174        visit_expr_in_subquery(self, i);
175    }
176
177    /// Visits an [`ExprIsNull`] node.
178    ///
179    /// The default implementation delegates to [`visit_expr_is_null`].
180    fn visit_expr_is_null(&mut self, i: &ExprIsNull) {
181        visit_expr_is_null(self, i);
182    }
183
184    /// Visits an [`ExprIsVariant`] node.
185    ///
186    /// The default implementation delegates to [`visit_expr_is_variant`].
187    fn visit_expr_is_variant(&mut self, i: &ExprIsVariant) {
188        visit_expr_is_variant(self, i);
189    }
190
191    /// Visits an [`ExprLet`] node.
192    ///
193    /// The default implementation delegates to [`visit_expr_let`].
194    fn visit_expr_let(&mut self, i: &ExprLet) {
195        visit_expr_let(self, i);
196    }
197
198    /// Visits an [`ExprMap`] node.
199    ///
200    /// The default implementation delegates to [`visit_expr_map`].
201    fn visit_expr_map(&mut self, i: &ExprMap) {
202        visit_expr_map(self, i);
203    }
204
205    /// Visits an [`ExprMatch`] node.
206    ///
207    /// The default implementation delegates to [`visit_expr_match`].
208    fn visit_expr_match(&mut self, i: &ExprMatch) {
209        visit_expr_match(self, i);
210    }
211
212    /// Visits an [`ExprNot`] node.
213    ///
214    /// The default implementation delegates to [`visit_expr_not`].
215    fn visit_expr_not(&mut self, i: &ExprNot) {
216        visit_expr_not(self, i);
217    }
218
219    /// Visits an [`ExprOr`] node.
220    ///
221    /// The default implementation delegates to [`visit_expr_or`].
222    fn visit_expr_or(&mut self, i: &ExprOr) {
223        visit_expr_or(self, i);
224    }
225
226    /// Visits an [`ExprList`] node.
227    ///
228    /// The default implementation delegates to [`visit_expr_list`].
229    fn visit_expr_list(&mut self, i: &ExprList) {
230        visit_expr_list(self, i);
231    }
232
233    /// Visits an [`ExprRecord`] node.
234    ///
235    /// The default implementation delegates to [`visit_expr_record`].
236    fn visit_expr_record(&mut self, i: &ExprRecord) {
237        visit_expr_record(self, i);
238    }
239
240    /// Visits an [`ExprReference`] node.
241    ///
242    /// The default implementation delegates to [`visit_expr_reference`].
243    fn visit_expr_reference(&mut self, i: &ExprReference) {
244        visit_expr_reference(self, i);
245    }
246
247    /// Visits an [`ExprSet`] node.
248    ///
249    /// The default implementation delegates to [`visit_expr_set`].
250    fn visit_expr_set(&mut self, i: &ExprSet) {
251        visit_expr_set(self, i);
252    }
253
254    /// Visits an [`ExprSetOp`] node.
255    ///
256    /// The default implementation delegates to [`visit_expr_set_op`].
257    fn visit_expr_set_op(&mut self, i: &ExprSetOp) {
258        visit_expr_set_op(self, i);
259    }
260
261    /// Visits an [`ExprStmt`] node.
262    ///
263    /// The default implementation delegates to [`visit_expr_stmt`].
264    fn visit_expr_stmt(&mut self, i: &ExprStmt) {
265        visit_expr_stmt(self, i);
266    }
267
268    /// Visits a [`Filter`] node.
269    ///
270    /// The default implementation delegates to [`visit_filter`].
271    fn visit_filter(&mut self, i: &Filter) {
272        visit_filter(self, i);
273    }
274
275    /// Visits a [`Condition`] node.
276    ///
277    /// The default implementation delegates to [`visit_condition`].
278    fn visit_condition(&mut self, i: &Condition) {
279        visit_condition(self, i);
280    }
281
282    /// Visits an [`ExprProject`] node.
283    ///
284    /// The default implementation delegates to [`visit_expr_project`].
285    fn visit_expr_project(&mut self, i: &ExprProject) {
286        visit_expr_project(self, i);
287    }
288
289    /// Visits an [`InsertTarget`] node.
290    ///
291    /// The default implementation delegates to [`visit_insert_target`].
292    fn visit_insert_target(&mut self, i: &InsertTarget) {
293        visit_insert_target(self, i);
294    }
295
296    /// Visits a [`Join`] node.
297    ///
298    /// The default implementation delegates to [`visit_join`].
299    fn visit_join(&mut self, i: &Join) {
300        visit_join(self, i);
301    }
302
303    /// Visits a [`Limit`] node.
304    ///
305    /// The default implementation delegates to [`visit_limit`].
306    fn visit_limit(&mut self, i: &Limit) {
307        visit_limit(self, i);
308    }
309
310    /// Visits a [`LimitCursor`] node.
311    ///
312    /// The default implementation delegates to [`visit_limit_cursor`].
313    fn visit_limit_cursor(&mut self, i: &LimitCursor) {
314        visit_limit_cursor(self, i);
315    }
316
317    /// Visits a [`LimitOffset`] node.
318    ///
319    /// The default implementation delegates to [`visit_limit_offset`].
320    fn visit_limit_offset(&mut self, i: &LimitOffset) {
321        visit_limit_offset(self, i);
322    }
323
324    /// Visits an [`OrderBy`] node.
325    ///
326    /// The default implementation delegates to [`visit_order_by`].
327    fn visit_order_by(&mut self, i: &OrderBy) {
328        visit_order_by(self, i);
329    }
330
331    /// Visits an [`OrderByExpr`] node.
332    ///
333    /// The default implementation delegates to [`visit_order_by_expr`].
334    fn visit_order_by_expr(&mut self, i: &OrderByExpr) {
335        visit_order_by_expr(self, i);
336    }
337
338    /// Visits a [`Path`] node.
339    ///
340    /// The default implementation delegates to [`visit_path`].
341    fn visit_path(&mut self, i: &Path) {
342        visit_path(self, i);
343    }
344
345    /// Visits a [`Projection`] node.
346    ///
347    /// The default implementation delegates to [`visit_projection`].
348    fn visit_projection(&mut self, i: &Projection) {
349        visit_projection(self, i);
350    }
351
352    /// Visits a [`Returning`] node.
353    ///
354    /// The default implementation delegates to [`visit_returning`].
355    fn visit_returning(&mut self, i: &Returning) {
356        visit_returning(self, i);
357    }
358
359    /// Visits a [`Source`] node.
360    ///
361    /// The default implementation delegates to [`visit_source`].
362    fn visit_source(&mut self, i: &Source) {
363        visit_source(self, i);
364    }
365
366    /// Visits a [`SourceModel`] node.
367    ///
368    /// The default implementation delegates to [`visit_source_model`].
369    fn visit_source_model(&mut self, i: &SourceModel) {
370        visit_source_model(self, i);
371    }
372
373    /// Visits a [`SourceTable`] node.
374    ///
375    /// The default implementation delegates to [`visit_source_table`].
376    fn visit_source_table(&mut self, i: &SourceTable) {
377        visit_source_table(self, i);
378    }
379
380    /// Visits a [`SourceTableId`] node.
381    ///
382    /// The default implementation delegates to [`visit_source_table_id`].
383    fn visit_source_table_id(&mut self, i: &SourceTableId) {
384        visit_source_table_id(self, i);
385    }
386
387    /// Visits a [`Statement`] node.
388    ///
389    /// The default implementation delegates to [`visit_stmt`].
390    fn visit_stmt(&mut self, i: &Statement) {
391        visit_stmt(self, i);
392    }
393
394    /// Visits a [`Delete`] statement node.
395    ///
396    /// The default implementation delegates to [`visit_stmt_delete`].
397    fn visit_stmt_delete(&mut self, i: &Delete) {
398        visit_stmt_delete(self, i);
399    }
400
401    /// Visits an [`Insert`] statement node.
402    ///
403    /// The default implementation delegates to [`visit_stmt_insert`].
404    fn visit_stmt_insert(&mut self, i: &Insert) {
405        visit_stmt_insert(self, i);
406    }
407
408    /// Visits a [`Query`] statement node.
409    ///
410    /// The default implementation delegates to [`visit_stmt_query`].
411    fn visit_stmt_query(&mut self, i: &Query) {
412        visit_stmt_query(self, i);
413    }
414
415    /// Visits a [`Select`] statement node.
416    ///
417    /// The default implementation delegates to [`visit_stmt_select`].
418    fn visit_stmt_select(&mut self, i: &Select) {
419        visit_stmt_select(self, i);
420    }
421
422    /// Visits an [`Update`] statement node.
423    ///
424    /// The default implementation delegates to [`visit_stmt_update`].
425    fn visit_stmt_update(&mut self, i: &Update) {
426        visit_stmt_update(self, i);
427    }
428
429    /// Visits a [`TableDerived`] node.
430    ///
431    /// The default implementation delegates to [`visit_table_derived`].
432    fn visit_table_derived(&mut self, i: &TableDerived) {
433        visit_table_derived(self, i);
434    }
435
436    /// Visits a [`TableRef`] node.
437    ///
438    /// The default implementation delegates to [`visit_table_ref`].
439    fn visit_table_ref(&mut self, i: &TableRef) {
440        visit_table_ref(self, i);
441    }
442
443    /// Visits a [`TableFactor`] node.
444    ///
445    /// The default implementation delegates to [`visit_table_factor`].
446    fn visit_table_factor(&mut self, i: &TableFactor) {
447        visit_table_factor(self, i);
448    }
449
450    /// Visits a [`TableWithJoins`] node.
451    ///
452    /// The default implementation delegates to [`visit_table_with_joins`].
453    fn visit_table_with_joins(&mut self, i: &TableWithJoins) {
454        visit_table_with_joins(self, i);
455    }
456
457    /// Visits a [`Type`] node.
458    ///
459    /// The default implementation delegates to [`visit_type`].
460    fn visit_type(&mut self, i: &Type) {
461        visit_type(self, i);
462    }
463
464    /// Visits an [`UpdateTarget`] node.
465    ///
466    /// The default implementation delegates to [`visit_update_target`].
467    fn visit_update_target(&mut self, i: &UpdateTarget) {
468        visit_update_target(self, i);
469    }
470
471    /// Visits a [`Value`] node.
472    ///
473    /// The default implementation delegates to [`visit_value`].
474    fn visit_value(&mut self, i: &Value) {
475        visit_value(self, i);
476    }
477
478    /// Visits a [`ValueRecord`] node.
479    ///
480    /// The default implementation delegates to [`visit_value_record`].
481    fn visit_value_record(&mut self, i: &ValueRecord) {
482        visit_value_record(self, i);
483    }
484
485    /// Visits a [`Values`] node.
486    ///
487    /// The default implementation delegates to [`visit_values`].
488    fn visit_values(&mut self, i: &Values) {
489        visit_values(self, i);
490    }
491
492    /// Visits a [`With`] node.
493    ///
494    /// The default implementation delegates to [`visit_with`].
495    fn visit_with(&mut self, i: &With) {
496        visit_with(self, i);
497    }
498}
499
500impl<V: Visit> Visit for &mut V {
501    fn visit_assignment(&mut self, i: &Assignment) {
502        Visit::visit_assignment(&mut **self, i);
503    }
504
505    fn visit_assignments(&mut self, i: &Assignments) {
506        Visit::visit_assignments(&mut **self, i);
507    }
508
509    fn visit_association(&mut self, i: &Association) {
510        Visit::visit_association(&mut **self, i);
511    }
512
513    fn visit_cte(&mut self, i: &Cte) {
514        Visit::visit_cte(&mut **self, i);
515    }
516
517    fn visit_expr(&mut self, i: &Expr) {
518        Visit::visit_expr(&mut **self, i);
519    }
520
521    fn visit_expr_and(&mut self, i: &ExprAnd) {
522        Visit::visit_expr_and(&mut **self, i);
523    }
524
525    fn visit_expr_arg(&mut self, i: &ExprArg) {
526        Visit::visit_expr_arg(&mut **self, i);
527    }
528
529    fn visit_expr_binary_op(&mut self, i: &ExprBinaryOp) {
530        Visit::visit_expr_binary_op(&mut **self, i);
531    }
532
533    fn visit_expr_cast(&mut self, i: &ExprCast) {
534        Visit::visit_expr_cast(&mut **self, i);
535    }
536
537    fn visit_expr_column(&mut self, i: &ExprColumn) {
538        Visit::visit_expr_column(&mut **self, i);
539    }
540
541    fn visit_expr_default(&mut self) {
542        Visit::visit_expr_default(&mut **self);
543    }
544
545    fn visit_expr_error(&mut self, i: &ExprError) {
546        Visit::visit_expr_error(&mut **self, i);
547    }
548
549    fn visit_expr_exists(&mut self, i: &ExprExists) {
550        Visit::visit_expr_exists(&mut **self, i);
551    }
552
553    fn visit_expr_func(&mut self, i: &ExprFunc) {
554        Visit::visit_expr_func(&mut **self, i);
555    }
556
557    fn visit_expr_func_count(&mut self, i: &FuncCount) {
558        Visit::visit_expr_func_count(&mut **self, i);
559    }
560
561    fn visit_expr_in_list(&mut self, i: &ExprInList) {
562        Visit::visit_expr_in_list(&mut **self, i);
563    }
564
565    fn visit_expr_in_subquery(&mut self, i: &ExprInSubquery) {
566        Visit::visit_expr_in_subquery(&mut **self, i);
567    }
568
569    fn visit_expr_is_null(&mut self, i: &ExprIsNull) {
570        Visit::visit_expr_is_null(&mut **self, i);
571    }
572
573    fn visit_expr_is_variant(&mut self, i: &ExprIsVariant) {
574        Visit::visit_expr_is_variant(&mut **self, i);
575    }
576
577    fn visit_expr_let(&mut self, i: &ExprLet) {
578        Visit::visit_expr_let(&mut **self, i);
579    }
580
581    fn visit_expr_map(&mut self, i: &ExprMap) {
582        Visit::visit_expr_map(&mut **self, i);
583    }
584
585    fn visit_expr_match(&mut self, i: &ExprMatch) {
586        Visit::visit_expr_match(&mut **self, i);
587    }
588
589    fn visit_expr_not(&mut self, i: &ExprNot) {
590        Visit::visit_expr_not(&mut **self, i);
591    }
592
593    fn visit_expr_or(&mut self, i: &ExprOr) {
594        Visit::visit_expr_or(&mut **self, i);
595    }
596
597    fn visit_expr_list(&mut self, i: &ExprList) {
598        Visit::visit_expr_list(&mut **self, i);
599    }
600
601    fn visit_expr_record(&mut self, i: &ExprRecord) {
602        Visit::visit_expr_record(&mut **self, i);
603    }
604
605    fn visit_expr_reference(&mut self, i: &ExprReference) {
606        Visit::visit_expr_reference(&mut **self, i);
607    }
608
609    fn visit_expr_set(&mut self, i: &ExprSet) {
610        Visit::visit_expr_set(&mut **self, i);
611    }
612
613    fn visit_expr_set_op(&mut self, i: &ExprSetOp) {
614        Visit::visit_expr_set_op(&mut **self, i);
615    }
616
617    fn visit_expr_stmt(&mut self, i: &ExprStmt) {
618        Visit::visit_expr_stmt(&mut **self, i);
619    }
620
621    fn visit_filter(&mut self, i: &Filter) {
622        Visit::visit_filter(&mut **self, i);
623    }
624
625    fn visit_condition(&mut self, i: &Condition) {
626        Visit::visit_condition(&mut **self, i);
627    }
628
629    fn visit_expr_project(&mut self, i: &ExprProject) {
630        Visit::visit_expr_project(&mut **self, i);
631    }
632
633    fn visit_insert_target(&mut self, i: &InsertTarget) {
634        Visit::visit_insert_target(&mut **self, i);
635    }
636
637    fn visit_join(&mut self, i: &Join) {
638        Visit::visit_join(&mut **self, i);
639    }
640
641    fn visit_limit(&mut self, i: &Limit) {
642        Visit::visit_limit(&mut **self, i);
643    }
644
645    fn visit_limit_cursor(&mut self, i: &LimitCursor) {
646        Visit::visit_limit_cursor(&mut **self, i);
647    }
648
649    fn visit_limit_offset(&mut self, i: &LimitOffset) {
650        Visit::visit_limit_offset(&mut **self, i);
651    }
652
653    fn visit_order_by(&mut self, i: &OrderBy) {
654        Visit::visit_order_by(&mut **self, i);
655    }
656
657    fn visit_order_by_expr(&mut self, i: &OrderByExpr) {
658        Visit::visit_order_by_expr(&mut **self, i);
659    }
660
661    fn visit_path(&mut self, i: &Path) {
662        Visit::visit_path(&mut **self, i);
663    }
664
665    fn visit_projection(&mut self, i: &Projection) {
666        Visit::visit_projection(&mut **self, i);
667    }
668
669    fn visit_returning(&mut self, i: &Returning) {
670        Visit::visit_returning(&mut **self, i);
671    }
672
673    fn visit_source(&mut self, i: &Source) {
674        Visit::visit_source(&mut **self, i);
675    }
676
677    fn visit_source_model(&mut self, i: &SourceModel) {
678        Visit::visit_source_model(&mut **self, i);
679    }
680
681    fn visit_source_table(&mut self, i: &SourceTable) {
682        Visit::visit_source_table(&mut **self, i);
683    }
684
685    fn visit_source_table_id(&mut self, i: &SourceTableId) {
686        Visit::visit_source_table_id(&mut **self, i);
687    }
688
689    fn visit_stmt(&mut self, i: &Statement) {
690        Visit::visit_stmt(&mut **self, i);
691    }
692
693    fn visit_stmt_delete(&mut self, i: &Delete) {
694        Visit::visit_stmt_delete(&mut **self, i);
695    }
696
697    fn visit_stmt_insert(&mut self, i: &Insert) {
698        Visit::visit_stmt_insert(&mut **self, i);
699    }
700
701    fn visit_stmt_query(&mut self, i: &Query) {
702        Visit::visit_stmt_query(&mut **self, i);
703    }
704
705    fn visit_stmt_select(&mut self, i: &Select) {
706        Visit::visit_stmt_select(&mut **self, i);
707    }
708
709    fn visit_stmt_update(&mut self, i: &Update) {
710        Visit::visit_stmt_update(&mut **self, i);
711    }
712
713    fn visit_table_derived(&mut self, i: &TableDerived) {
714        Visit::visit_table_derived(&mut **self, i);
715    }
716
717    fn visit_table_ref(&mut self, i: &TableRef) {
718        Visit::visit_table_ref(&mut **self, i);
719    }
720
721    fn visit_table_factor(&mut self, i: &TableFactor) {
722        Visit::visit_table_factor(&mut **self, i);
723    }
724
725    fn visit_table_with_joins(&mut self, i: &TableWithJoins) {
726        Visit::visit_table_with_joins(&mut **self, i);
727    }
728
729    fn visit_type(&mut self, i: &Type) {
730        Visit::visit_type(&mut **self, i);
731    }
732
733    fn visit_update_target(&mut self, i: &UpdateTarget) {
734        Visit::visit_update_target(&mut **self, i);
735    }
736
737    fn visit_value(&mut self, i: &Value) {
738        Visit::visit_value(&mut **self, i);
739    }
740
741    fn visit_value_record(&mut self, i: &ValueRecord) {
742        Visit::visit_value_record(&mut **self, i);
743    }
744
745    fn visit_values(&mut self, i: &Values) {
746        Visit::visit_values(&mut **self, i);
747    }
748
749    fn visit_with(&mut self, i: &With) {
750        Visit::visit_with(&mut **self, i);
751    }
752}
753
754/// Default traversal for [`Assignment`] nodes. Visits the assignment's expression(s).
755pub fn visit_assignment<V>(v: &mut V, node: &Assignment)
756where
757    V: Visit + ?Sized,
758{
759    match node {
760        Assignment::Set(expr) | Assignment::Insert(expr) | Assignment::Remove(expr) => {
761            v.visit_expr(expr);
762        }
763        Assignment::Batch(entries) => {
764            for entry in entries {
765                visit_assignment(v, entry);
766            }
767        }
768    }
769}
770
771/// Default traversal for [`Assignments`] nodes. Visits each assignment in the collection.
772pub fn visit_assignments<V>(v: &mut V, node: &Assignments)
773where
774    V: Visit + ?Sized,
775{
776    for (_, assignment) in node.iter() {
777        v.visit_assignment(assignment);
778    }
779}
780
781/// Default traversal for [`Association`] nodes. Visits the association's source query.
782pub fn visit_association<V>(v: &mut V, node: &Association)
783where
784    V: Visit + ?Sized,
785{
786    v.visit_stmt_query(&node.source);
787}
788
789/// Default traversal for [`Cte`] nodes. Visits the CTE's query.
790pub fn visit_cte<V>(v: &mut V, node: &Cte)
791where
792    V: Visit + ?Sized,
793{
794    v.visit_stmt_query(&node.query);
795}
796
797/// Default traversal for [`Expr`] nodes. Dispatches to the appropriate expression visitor based on variant.
798pub fn visit_expr<V>(v: &mut V, node: &Expr)
799where
800    V: Visit + ?Sized,
801{
802    match node {
803        Expr::And(expr) => v.visit_expr_and(expr),
804        Expr::Any(expr) => v.visit_expr_any(expr),
805        Expr::Arg(expr) => v.visit_expr_arg(expr),
806        Expr::BinaryOp(expr) => v.visit_expr_binary_op(expr),
807        Expr::Cast(expr) => v.visit_expr_cast(expr),
808        Expr::Default => v.visit_expr_default(),
809        Expr::Error(expr) => v.visit_expr_error(expr),
810        Expr::Exists(expr) => v.visit_expr_exists(expr),
811        Expr::Func(expr) => v.visit_expr_func(expr),
812        Expr::InList(expr) => v.visit_expr_in_list(expr),
813        Expr::InSubquery(expr) => v.visit_expr_in_subquery(expr),
814        Expr::IsNull(expr) => v.visit_expr_is_null(expr),
815        Expr::IsVariant(expr) => v.visit_expr_is_variant(expr),
816        Expr::Let(expr) => v.visit_expr_let(expr),
817        Expr::Map(expr) => v.visit_expr_map(expr),
818        Expr::Match(expr) => v.visit_expr_match(expr),
819        Expr::Not(expr) => v.visit_expr_not(expr),
820        Expr::Or(expr) => v.visit_expr_or(expr),
821        Expr::Project(expr) => v.visit_expr_project(expr),
822        Expr::Record(expr) => v.visit_expr_record(expr),
823        Expr::Reference(expr) => v.visit_expr_reference(expr),
824        Expr::List(expr) => v.visit_expr_list(expr),
825        Expr::Stmt(expr) => v.visit_expr_stmt(expr),
826        Expr::Value(expr) => v.visit_value(expr),
827    }
828}
829
830/// Default traversal for [`ExprAnd`] nodes. Visits each operand expression.
831pub fn visit_expr_and<V>(v: &mut V, node: &ExprAnd)
832where
833    V: Visit + ?Sized,
834{
835    for expr in node {
836        v.visit_expr(expr);
837    }
838}
839
840/// Default traversal for [`ExprAny`] nodes. Visits the inner expression.
841pub fn visit_expr_any<V>(v: &mut V, node: &ExprAny)
842where
843    V: Visit + ?Sized,
844{
845    v.visit_expr(&node.expr);
846}
847
848/// Default traversal for [`ExprArg`] nodes. This is a leaf node with no children to visit.
849pub fn visit_expr_arg<V>(v: &mut V, node: &ExprArg)
850where
851    V: Visit + ?Sized,
852{
853}
854
855/// Default traversal for [`ExprBinaryOp`] nodes. Visits left and right operands.
856pub fn visit_expr_binary_op<V>(v: &mut V, node: &ExprBinaryOp)
857where
858    V: Visit + ?Sized,
859{
860    v.visit_expr(&node.lhs);
861    v.visit_expr(&node.rhs);
862}
863
864/// Default traversal for [`ExprCast`] nodes. Visits the inner expression and target type.
865pub fn visit_expr_cast<V>(v: &mut V, node: &ExprCast)
866where
867    V: Visit + ?Sized,
868{
869    v.visit_expr(&node.expr);
870    v.visit_type(&node.ty);
871}
872
873/// Default traversal for [`ExprColumn`] nodes. This is a leaf node with no children to visit.
874pub fn visit_expr_column<V>(v: &mut V, node: &ExprColumn)
875where
876    V: Visit + ?Sized,
877{
878}
879
880/// Default traversal for [`Expr::Default`] nodes. This is a leaf node with no children to visit.
881pub fn visit_expr_default<V>(v: &mut V)
882where
883    V: Visit + ?Sized,
884{
885}
886
887/// Default traversal for [`ExprError`] nodes. This is a leaf node with no children to visit.
888pub fn visit_expr_error<V>(v: &mut V, node: &ExprError)
889where
890    V: Visit + ?Sized,
891{
892    // ExprError has no child expressions to visit
893}
894
895/// Default traversal for [`ExprExists`] nodes. Visits the subquery.
896pub fn visit_expr_exists<V>(v: &mut V, node: &ExprExists)
897where
898    V: Visit + ?Sized,
899{
900    v.visit_stmt_query(&node.subquery);
901}
902
903/// Default traversal for [`ExprFunc`] nodes. Dispatches to the specific function visitor.
904pub fn visit_expr_func<V>(v: &mut V, node: &ExprFunc)
905where
906    V: Visit + ?Sized,
907{
908    match node {
909        ExprFunc::Count(func) => v.visit_expr_func_count(func),
910        ExprFunc::LastInsertId(func) => v.visit_expr_func_last_insert_id(func),
911    }
912}
913
914/// Default traversal for [`FuncCount`] nodes. Visits the optional argument and filter expressions.
915pub fn visit_expr_func_count<V>(v: &mut V, node: &FuncCount)
916where
917    V: Visit + ?Sized,
918{
919    if let Some(expr) = &node.arg {
920        v.visit_expr(expr);
921    }
922
923    if let Some(expr) = &node.filter {
924        v.visit_expr(expr);
925    }
926}
927
928/// Default traversal for [`FuncLastInsertId`] nodes. This is a leaf node with no children to visit.
929pub fn visit_expr_func_last_insert_id<V>(_v: &mut V, _node: &FuncLastInsertId)
930where
931    V: Visit + ?Sized,
932{
933    // FuncLastInsertId has no fields to visit
934}
935
936/// Default traversal for [`ExprInList`] nodes. Visits the expression and list.
937pub fn visit_expr_in_list<V>(v: &mut V, node: &ExprInList)
938where
939    V: Visit + ?Sized,
940{
941    v.visit_expr(&node.expr);
942    v.visit_expr(&node.list);
943}
944
945/// Default traversal for [`ExprInSubquery`] nodes. Visits the expression and subquery.
946pub fn visit_expr_in_subquery<V>(v: &mut V, node: &ExprInSubquery)
947where
948    V: Visit + ?Sized,
949{
950    v.visit_expr(&node.expr);
951    v.visit_stmt_query(&node.query);
952}
953
954/// Default traversal for [`ExprIsNull`] nodes. Visits the inner expression.
955pub fn visit_expr_is_null<V>(v: &mut V, node: &ExprIsNull)
956where
957    V: Visit + ?Sized,
958{
959    v.visit_expr(&node.expr);
960}
961
962/// Default traversal for [`ExprIsVariant`] nodes. Visits the inner expression.
963pub fn visit_expr_is_variant<V>(v: &mut V, node: &ExprIsVariant)
964where
965    V: Visit + ?Sized,
966{
967    v.visit_expr(&node.expr);
968}
969
970/// Default traversal for [`ExprLet`] nodes. Visits bindings and body.
971pub fn visit_expr_let<V>(v: &mut V, node: &ExprLet)
972where
973    V: Visit + ?Sized,
974{
975    for binding in &node.bindings {
976        v.visit_expr(binding);
977    }
978    v.visit_expr(&node.body);
979}
980
981/// Default traversal for [`ExprMap`] nodes. Visits base and map expressions.
982pub fn visit_expr_map<V>(v: &mut V, node: &ExprMap)
983where
984    V: Visit + ?Sized,
985{
986    v.visit_expr(&node.base);
987    v.visit_expr(&node.map);
988}
989
990/// Default traversal for [`ExprMatch`] nodes. Visits subject, arms, and else expression.
991pub fn visit_expr_match<V>(v: &mut V, node: &ExprMatch)
992where
993    V: Visit + ?Sized,
994{
995    v.visit_expr(&node.subject);
996    for arm in &node.arms {
997        v.visit_expr(&arm.expr);
998    }
999    v.visit_expr(&node.else_expr);
1000}
1001
1002/// Default traversal for [`ExprNot`] nodes. Visits the inner expression.
1003pub fn visit_expr_not<V>(v: &mut V, node: &ExprNot)
1004where
1005    V: Visit + ?Sized,
1006{
1007    v.visit_expr(&node.expr);
1008}
1009
1010/// Default traversal for [`ExprOr`] nodes. Visits each operand expression.
1011pub fn visit_expr_or<V>(v: &mut V, node: &ExprOr)
1012where
1013    V: Visit + ?Sized,
1014{
1015    for expr in node {
1016        v.visit_expr(expr);
1017    }
1018}
1019
1020/// Default traversal for [`ExprList`] nodes. Visits each item expression.
1021pub fn visit_expr_list<V>(v: &mut V, node: &ExprList)
1022where
1023    V: Visit + ?Sized,
1024{
1025    for expr in &node.items {
1026        v.visit_expr(expr);
1027    }
1028}
1029
1030/// Default traversal for [`ExprRecord`] nodes. Visits each field expression.
1031pub fn visit_expr_record<V>(v: &mut V, node: &ExprRecord)
1032where
1033    V: Visit + ?Sized,
1034{
1035    for expr in &**node {
1036        v.visit_expr(expr);
1037    }
1038}
1039
1040/// Default traversal for [`ExprReference`] nodes. Dispatches based on reference kind.
1041pub fn visit_expr_reference<V>(v: &mut V, node: &ExprReference)
1042where
1043    V: Visit + ?Sized,
1044{
1045    match node {
1046        ExprReference::Model { .. } => {}
1047        ExprReference::Field { .. } => {}
1048        ExprReference::Column(expr_column) => v.visit_expr_column(expr_column),
1049    }
1050}
1051
1052/// Default traversal for [`ExprSet`] nodes. Dispatches to the appropriate set expression visitor.
1053pub fn visit_expr_set<V>(v: &mut V, node: &ExprSet)
1054where
1055    V: Visit + ?Sized,
1056{
1057    match node {
1058        ExprSet::Select(expr) => v.visit_stmt_select(expr),
1059        ExprSet::SetOp(expr) => v.visit_expr_set_op(expr),
1060        ExprSet::Update(expr) => v.visit_stmt_update(expr),
1061        ExprSet::Values(expr) => v.visit_values(expr),
1062        ExprSet::Insert(expr) => v.visit_stmt_insert(expr),
1063    }
1064}
1065
1066/// Default traversal for [`ExprSetOp`] nodes. Visits each operand.
1067pub fn visit_expr_set_op<V>(v: &mut V, node: &ExprSetOp)
1068where
1069    V: Visit + ?Sized,
1070{
1071    for operand in &node.operands {
1072        v.visit_expr_set(operand);
1073    }
1074}
1075
1076/// Default traversal for [`ExprStmt`] nodes. Visits the inner statement.
1077pub fn visit_expr_stmt<V>(v: &mut V, node: &ExprStmt)
1078where
1079    V: Visit + ?Sized,
1080{
1081    v.visit_stmt(&node.stmt);
1082}
1083
1084/// Default traversal for [`ExprProject`] nodes. Visits the base expression and projection.
1085pub fn visit_expr_project<V>(v: &mut V, node: &ExprProject)
1086where
1087    V: Visit + ?Sized,
1088{
1089    v.visit_expr(&node.base);
1090    v.visit_projection(&node.projection);
1091}
1092
1093/// Default traversal for [`Filter`] nodes. Visits the optional filter expression.
1094pub fn visit_filter<V>(v: &mut V, node: &Filter)
1095where
1096    V: Visit + ?Sized,
1097{
1098    if let Some(expr) = &node.expr {
1099        v.visit_expr(expr);
1100    }
1101}
1102
1103/// Default traversal for [`Condition`] nodes. Visits the optional condition expression.
1104pub fn visit_condition<V>(v: &mut V, node: &Condition)
1105where
1106    V: Visit + ?Sized,
1107{
1108    if let Some(expr) = &node.expr {
1109        v.visit_expr(expr);
1110    }
1111}
1112
1113/// Default traversal for [`InsertTarget`] nodes. Visits the scope query if present.
1114pub fn visit_insert_target<V>(v: &mut V, node: &InsertTarget)
1115where
1116    V: Visit + ?Sized,
1117{
1118    if let InsertTarget::Scope(stmt) = node {
1119        v.visit_stmt_query(stmt);
1120    }
1121}
1122
1123/// Default traversal for [`Join`] nodes. Visits the table and join constraint.
1124pub fn visit_join<V>(v: &mut V, node: &Join)
1125where
1126    V: Visit + ?Sized,
1127{
1128    v.visit_source_table_id(&node.table);
1129    match &node.constraint {
1130        JoinOp::Left(expr) => v.visit_expr(expr),
1131    }
1132}
1133
1134/// Default traversal for [`Limit`] nodes.
1135pub fn visit_limit<V>(v: &mut V, node: &Limit)
1136where
1137    V: Visit + ?Sized,
1138{
1139    match node {
1140        Limit::Cursor(cursor) => v.visit_limit_cursor(cursor),
1141        Limit::Offset(offset) => v.visit_limit_offset(offset),
1142    }
1143}
1144
1145/// Default traversal for [`LimitCursor`] nodes.
1146pub fn visit_limit_cursor<V>(v: &mut V, node: &LimitCursor)
1147where
1148    V: Visit + ?Sized,
1149{
1150    v.visit_expr(&node.page_size);
1151    if let Some(after) = &node.after {
1152        v.visit_expr(after);
1153    }
1154}
1155
1156/// Default traversal for [`LimitOffset`] nodes.
1157pub fn visit_limit_offset<V>(v: &mut V, node: &LimitOffset)
1158where
1159    V: Visit + ?Sized,
1160{
1161    v.visit_expr(&node.limit);
1162    if let Some(offset) = &node.offset {
1163        v.visit_expr(offset);
1164    }
1165}
1166
1167/// Default traversal for [`OrderBy`] nodes. Visits each ordering expression.
1168pub fn visit_order_by<V>(v: &mut V, node: &OrderBy)
1169where
1170    V: Visit + ?Sized,
1171{
1172    for expr in &node.exprs {
1173        v.visit_order_by_expr(expr);
1174    }
1175}
1176
1177/// Default traversal for [`OrderByExpr`] nodes. Visits the ordering expression.
1178pub fn visit_order_by_expr<V>(v: &mut V, node: &OrderByExpr)
1179where
1180    V: Visit + ?Sized,
1181{
1182    v.visit_expr(&node.expr);
1183}
1184
1185/// Default traversal for [`Path`] nodes. Visits the path's projection.
1186pub fn visit_path<V>(v: &mut V, node: &Path)
1187where
1188    V: Visit + ?Sized,
1189{
1190    v.visit_projection(&node.projection);
1191}
1192
1193/// Default traversal for [`Projection`] nodes. This is a leaf node with no children to visit.
1194pub fn visit_projection<V>(v: &mut V, node: &Projection)
1195where
1196    V: Visit + ?Sized,
1197{
1198}
1199
1200/// Default traversal for [`Returning`] nodes. Visits included paths or expressions based on variant.
1201pub fn visit_returning<V>(v: &mut V, node: &Returning)
1202where
1203    V: Visit + ?Sized,
1204{
1205    match node {
1206        Returning::Model { include } => {
1207            for path in include {
1208                v.visit_path(path);
1209            }
1210        }
1211        Returning::Changed => {}
1212        Returning::Expr(expr) => v.visit_expr(expr),
1213        Returning::Value(expr) => v.visit_expr(expr),
1214    }
1215}
1216
1217/// Default traversal for [`Source`] nodes. Dispatches to model or table source visitor.
1218pub fn visit_source<V>(v: &mut V, node: &Source)
1219where
1220    V: Visit + ?Sized,
1221{
1222    match node {
1223        Source::Model(source_model) => v.visit_source_model(source_model),
1224        Source::Table(source_table) => v.visit_source_table(source_table),
1225    }
1226}
1227
1228/// Default traversal for [`SourceModel`] nodes. Visits the optional association.
1229pub fn visit_source_model<V>(v: &mut V, node: &SourceModel)
1230where
1231    V: Visit + ?Sized,
1232{
1233    if let Some(association) = &node.via {
1234        v.visit_association(association);
1235    }
1236}
1237
1238/// Default traversal for [`SourceTable`] nodes. Visits table references and FROM clauses.
1239pub fn visit_source_table<V>(v: &mut V, node: &SourceTable)
1240where
1241    V: Visit + ?Sized,
1242{
1243    for table_ref in &node.tables {
1244        v.visit_table_ref(table_ref);
1245    }
1246    for table_with_joins in &node.from {
1247        v.visit_table_with_joins(table_with_joins);
1248    }
1249}
1250
1251/// Default traversal for [`SourceTableId`] nodes. This is a leaf node with no children to visit.
1252pub fn visit_source_table_id<V>(v: &mut V, node: &SourceTableId)
1253where
1254    V: Visit + ?Sized,
1255{
1256    // SourceTableId is just an index, nothing to visit
1257}
1258
1259/// Default traversal for [`TableFactor`] nodes. Dispatches based on factor type.
1260pub fn visit_table_factor<V>(v: &mut V, node: &TableFactor)
1261where
1262    V: Visit + ?Sized,
1263{
1264    match node {
1265        TableFactor::Table(table_id) => v.visit_source_table_id(table_id),
1266    }
1267}
1268
1269/// Default traversal for [`Statement`] nodes. Dispatches to the appropriate statement visitor.
1270pub fn visit_stmt<V>(v: &mut V, node: &Statement)
1271where
1272    V: Visit + ?Sized,
1273{
1274    match node {
1275        Statement::Delete(stmt) => v.visit_stmt_delete(stmt),
1276        Statement::Insert(stmt) => v.visit_stmt_insert(stmt),
1277        Statement::Query(stmt) => v.visit_stmt_query(stmt),
1278        Statement::Update(stmt) => v.visit_stmt_update(stmt),
1279    }
1280}
1281
1282/// Default traversal for [`Delete`] nodes. Visits source, filter, and optional returning.
1283pub fn visit_stmt_delete<V>(v: &mut V, node: &Delete)
1284where
1285    V: Visit + ?Sized,
1286{
1287    v.visit_source(&node.from);
1288    v.visit_filter(&node.filter);
1289
1290    if let Some(returning) = &node.returning {
1291        v.visit_returning(returning);
1292    }
1293}
1294
1295/// Default traversal for [`Insert`] nodes. Visits target, source query, and optional returning.
1296pub fn visit_stmt_insert<V>(v: &mut V, node: &Insert)
1297where
1298    V: Visit + ?Sized,
1299{
1300    if let InsertTarget::Scope(scope) = &node.target {
1301        v.visit_stmt_query(scope);
1302    }
1303    v.visit_stmt_query(&node.source);
1304
1305    if let Some(returning) = &node.returning {
1306        v.visit_returning(returning);
1307    }
1308}
1309
1310/// Default traversal for [`Query`] nodes. Visits optional WITH, body, order by, and limit.
1311pub fn visit_stmt_query<V>(v: &mut V, node: &Query)
1312where
1313    V: Visit + ?Sized,
1314{
1315    if let Some(with) = &node.with {
1316        v.visit_with(with);
1317    }
1318
1319    v.visit_expr_set(&node.body);
1320
1321    if let Some(order_by) = &node.order_by {
1322        v.visit_order_by(order_by);
1323    }
1324
1325    if let Some(limit) = &node.limit {
1326        v.visit_limit(limit);
1327    }
1328}
1329
1330/// Default traversal for [`Select`] nodes. Visits source, filter, and returning.
1331pub fn visit_stmt_select<V>(v: &mut V, node: &Select)
1332where
1333    V: Visit + ?Sized,
1334{
1335    v.visit_source(&node.source);
1336    v.visit_filter(&node.filter);
1337    v.visit_returning(&node.returning);
1338}
1339
1340/// Default traversal for [`Update`] nodes. Visits target, assignments, filter, and condition.
1341pub fn visit_stmt_update<V>(v: &mut V, node: &Update)
1342where
1343    V: Visit + ?Sized,
1344{
1345    v.visit_update_target(&node.target);
1346    v.visit_assignments(&node.assignments);
1347    v.visit_filter(&node.filter);
1348    v.visit_condition(&node.condition);
1349}
1350
1351/// Default traversal for [`TableDerived`] nodes. Visits the subquery.
1352pub fn visit_table_derived<V>(v: &mut V, node: &TableDerived)
1353where
1354    V: Visit + ?Sized,
1355{
1356    v.visit_stmt_query(&node.subquery);
1357}
1358
1359/// Default traversal for [`TableRef`] nodes. Dispatches based on reference kind.
1360pub fn visit_table_ref<V>(v: &mut V, node: &TableRef)
1361where
1362    V: Visit + ?Sized,
1363{
1364    match node {
1365        TableRef::Cte { .. } => {}
1366        TableRef::Derived(table_derived) => v.visit_table_derived(table_derived),
1367        TableRef::Table(_) => {}
1368        TableRef::Arg(expr_arg) => v.visit_expr_arg(expr_arg),
1369    }
1370}
1371
1372/// Default traversal for [`TableWithJoins`] nodes. Visits the relation and each join.
1373pub fn visit_table_with_joins<V>(v: &mut V, node: &TableWithJoins)
1374where
1375    V: Visit + ?Sized,
1376{
1377    v.visit_table_factor(&node.relation);
1378    for join in &node.joins {
1379        v.visit_join(join);
1380    }
1381}
1382
1383/// Default traversal for [`Type`] nodes. This is a leaf node with no children to visit.
1384pub fn visit_type<V>(v: &mut V, node: &Type)
1385where
1386    V: Visit + ?Sized,
1387{
1388    // Type is just type information, no traversal needed
1389}
1390
1391/// Default traversal for [`UpdateTarget`] nodes. Visits the query if target is a query.
1392pub fn visit_update_target<V>(v: &mut V, node: &UpdateTarget)
1393where
1394    V: Visit + ?Sized,
1395{
1396    if let UpdateTarget::Query(query) = node {
1397        v.visit_stmt_query(query)
1398    }
1399}
1400
1401/// Default traversal for [`Value`] nodes. Visits inner record if value is a record.
1402pub fn visit_value<V>(v: &mut V, node: &Value)
1403where
1404    V: Visit + ?Sized,
1405{
1406    if let Value::Record(node) = node {
1407        v.visit_value_record(node)
1408    }
1409}
1410
1411/// Default traversal for [`ValueRecord`] nodes. Visits each value in the record.
1412pub fn visit_value_record<V>(v: &mut V, node: &ValueRecord)
1413where
1414    V: Visit + ?Sized,
1415{
1416    for value in node.iter() {
1417        v.visit_value(value);
1418    }
1419}
1420
1421/// Default traversal for [`Values`] nodes. Visits each row expression.
1422pub fn visit_values<V>(v: &mut V, node: &Values)
1423where
1424    V: Visit + ?Sized,
1425{
1426    for expr in &node.rows {
1427        v.visit_expr(expr);
1428    }
1429}
1430
1431/// Default traversal for [`With`] nodes. Visits each CTE.
1432pub fn visit_with<V>(v: &mut V, node: &With)
1433where
1434    V: Visit + ?Sized,
1435{
1436    for cte in &node.ctes {
1437        v.visit_cte(cte);
1438    }
1439}
1440
1441/// Calls `f` for every [`Expr`] node reachable from `node`, in post-order.
1442///
1443/// This is a convenience wrapper that constructs a [`Visit`] implementation
1444/// internally and walks the full AST rooted at `node`.
1445pub fn for_each_expr<F>(node: &impl Node, f: F)
1446where
1447    F: FnMut(&Expr),
1448{
1449    struct ForEach<F> {
1450        f: F,
1451    }
1452
1453    impl<F> Visit for ForEach<F>
1454    where
1455        F: FnMut(&Expr),
1456    {
1457        fn visit_expr(&mut self, node: &Expr) {
1458            visit_expr(self, node);
1459            (self.f)(node);
1460        }
1461    }
1462
1463    node.visit(ForEach { f });
1464}
toasty_core/stmt/visit.rs

toasty_core/stmt/
visit.rs
