cl_ast/ast_visitor/
walk.rs

1//! Accepts an AST Visitor. Walks the AST, calling the visitor on each step.
2
3use super::visit::Visit;
4use crate::ast::*;
5use cl_structures::span::Span;
6
7/// Helps a [Visitor](Visit) walk through `Self`.
8pub trait Walk {
9    /// Calls the respective `visit_*` function in V
10    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V);
11
12    #[allow(unused)]
13    /// Walks the children of self, visiting them in V
14    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {}
15}
16
17impl Walk for Span {
18    #[inline]
19    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
20        v.visit_span(self);
21    }
22}
23impl Walk for Sym {
24    #[inline]
25    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
26        v.visit_sym(self);
27    }
28}
29impl Walk for Mutability {
30    #[inline]
31    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
32        v.visit_mutability(self);
33    }
34}
35impl Walk for Visibility {
36    #[inline]
37    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
38        v.visit_visibility(self);
39    }
40}
41impl Walk for bool {
42    #[inline]
43    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
44        v.visit_bool(self);
45    }
46}
47impl Walk for char {
48    #[inline]
49    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
50        v.visit_char(self);
51    }
52}
53impl Walk for u128 {
54    #[inline]
55    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
56        v.visit_int(self);
57    }
58}
59impl Walk for u64 {
60    #[inline]
61    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
62        v.visit_smuggled_float(self);
63    }
64}
65impl Walk for str {
66    #[inline]
67    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
68        v.visit_string(self);
69    }
70}
71impl Walk for Literal {
72    #[inline]
73    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
74        v.visit_literal(self);
75    }
76    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
77        match self {
78            Literal::Bool(value) => value.children(v),
79            Literal::Char(value) => value.children(v),
80            Literal::Int(value) => value.children(v),
81            Literal::Float(value) => value.children(v),
82            Literal::String(value) => value.children(v),
83        };
84    }
85}
86impl Walk for File {
87    #[inline]
88    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
89        v.visit_file(self);
90    }
91    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
92        let File { name: _, items } = self;
93        items.iter().for_each(|i| v.visit_item(i));
94    }
95}
96impl Walk for Attrs {
97    #[inline]
98    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
99        v.visit_attrs(self);
100    }
101    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
102        let Attrs { meta } = self;
103        meta.children(v);
104    }
105}
106impl Walk for Meta {
107    #[inline]
108    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
109        v.visit_meta(self);
110    }
111    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
112        let Meta { name, kind } = self;
113        name.visit_in(v);
114        kind.visit_in(v);
115    }
116}
117impl Walk for MetaKind {
118    #[inline]
119    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
120        v.visit_meta_kind(self);
121    }
122    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
123        match self {
124            MetaKind::Plain => {}
125            MetaKind::Equals(lit) => lit.visit_in(v),
126            MetaKind::Func(lits) => lits.visit_in(v),
127        }
128    }
129}
130impl Walk for Item {
131    #[inline]
132    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
133        v.visit_item(self);
134    }
135    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
136        let Item { span, attrs, vis, kind } = self;
137        span.visit_in(v);
138        attrs.visit_in(v);
139        vis.visit_in(v);
140        kind.visit_in(v);
141    }
142}
143impl Walk for ItemKind {
144    #[inline]
145    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
146        v.visit_item_kind(self);
147    }
148    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
149        match self {
150            ItemKind::Module(value) => value.visit_in(v),
151            ItemKind::Alias(value) => value.visit_in(v),
152            ItemKind::Enum(value) => value.visit_in(v),
153            ItemKind::Struct(value) => value.visit_in(v),
154            ItemKind::Const(value) => value.visit_in(v),
155            ItemKind::Static(value) => value.visit_in(v),
156            ItemKind::Function(value) => value.visit_in(v),
157            ItemKind::Impl(value) => value.visit_in(v),
158            ItemKind::Use(value) => value.visit_in(v),
159        }
160    }
161}
162impl Walk for Generics {
163    #[inline]
164    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
165        v.visit_generics(self);
166    }
167    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
168        let Self { vars } = self;
169        vars.visit_in(v);
170    }
171}
172impl Walk for Module {
173    #[inline]
174    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
175        v.visit_module(self);
176    }
177    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
178        let Module { name, file } = self;
179        name.visit_in(v);
180        file.visit_in(v);
181    }
182}
183impl Walk for Alias {
184    #[inline]
185    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
186        v.visit_alias(self);
187    }
188    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
189        let Alias { name, from } = self;
190        name.visit_in(v);
191        from.visit_in(v);
192    }
193}
194impl Walk for Const {
195    #[inline]
196    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
197        v.visit_const(self);
198    }
199    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
200        let Const { name, ty, init } = self;
201        name.visit_in(v);
202        ty.visit_in(v);
203        init.visit_in(v);
204    }
205}
206impl Walk for Static {
207    #[inline]
208    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
209        v.visit_static(self);
210    }
211    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
212        let Static { mutable, name, ty, init } = self;
213        mutable.visit_in(v);
214        name.visit_in(v);
215        ty.visit_in(v);
216        init.visit_in(v);
217    }
218}
219impl Walk for Function {
220    #[inline]
221    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
222        v.visit_function(self);
223    }
224    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
225        let Function { name, gens, sign, bind, body } = self;
226        name.visit_in(v);
227        gens.visit_in(v);
228        sign.visit_in(v);
229        bind.visit_in(v);
230        body.visit_in(v);
231    }
232}
233impl Walk for Struct {
234    #[inline]
235    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
236        v.visit_struct(self);
237    }
238    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
239        let Struct { name, gens, kind } = self;
240        name.visit_in(v);
241        gens.visit_in(v);
242        kind.visit_in(v);
243    }
244}
245impl Walk for StructKind {
246    #[inline]
247    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
248        v.visit_struct_kind(self);
249    }
250    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
251        match self {
252            StructKind::Empty => {}
253            StructKind::Tuple(tys) => tys.visit_in(v),
254            StructKind::Struct(ms) => ms.visit_in(v),
255        }
256    }
257}
258impl Walk for StructMember {
259    #[inline]
260    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
261        v.visit_struct_member(self);
262    }
263    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
264        let StructMember { vis, name, ty } = self;
265        vis.visit_in(v);
266        name.visit_in(v);
267        ty.visit_in(v);
268    }
269}
270impl Walk for Enum {
271    #[inline]
272    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
273        v.visit_enum(self);
274    }
275    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
276        let Enum { name, gens, variants } = self;
277        name.visit_in(v);
278        gens.visit_in(v);
279        variants.visit_in(v);
280    }
281}
282impl Walk for Variant {
283    #[inline]
284    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
285        v.visit_variant(self);
286    }
287    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
288        let Variant { name, kind, body } = self;
289        name.visit_in(v);
290        kind.visit_in(v);
291        body.visit_in(v);
292    }
293}
294impl Walk for Impl {
295    #[inline]
296    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
297        v.visit_impl(self);
298    }
299    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
300        let Impl { gens, target, body } = self;
301        gens.visit_in(v);
302        target.visit_in(v);
303        body.visit_in(v);
304    }
305}
306impl Walk for ImplKind {
307    #[inline]
308    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
309        v.visit_impl_kind(self);
310    }
311    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
312        match self {
313            ImplKind::Type(t) => t.visit_in(v),
314            ImplKind::Trait { impl_trait, for_type } => {
315                impl_trait.visit_in(v);
316                for_type.visit_in(v);
317            }
318        }
319    }
320}
321impl Walk for Use {
322    #[inline]
323    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
324        v.visit_use(self);
325    }
326    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
327        let Use { absolute: _, tree } = self;
328        tree.visit_in(v);
329    }
330}
331impl Walk for UseTree {
332    #[inline]
333    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
334        v.visit_use_tree(self);
335    }
336    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
337        match self {
338            UseTree::Tree(tree) => tree.iter().for_each(|t| t.visit_in(v)),
339            UseTree::Path(part, tree) => {
340                part.visit_in(v);
341                tree.visit_in(v);
342            }
343            UseTree::Alias(from, to) => {
344                from.visit_in(v);
345                to.visit_in(v);
346            }
347            UseTree::Name(name) => name.visit_in(v),
348            UseTree::Glob => {}
349        }
350    }
351}
352impl Walk for Ty {
353    #[inline]
354    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
355        v.visit_ty(self);
356    }
357    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
358        let Ty { span, kind, gens } = self;
359        span.visit_in(v);
360        kind.visit_in(v);
361        gens.visit_in(v);
362    }
363}
364impl Walk for TyKind {
365    #[inline]
366    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
367        v.visit_ty_kind(self);
368    }
369    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
370        match self {
371            TyKind::Never => {}
372            TyKind::Infer => {}
373            TyKind::Path(value) => value.visit_in(v),
374            TyKind::Array(value) => value.visit_in(v),
375            TyKind::Slice(value) => value.visit_in(v),
376            TyKind::Tuple(value) => value.visit_in(v),
377            TyKind::Ref(value) => value.visit_in(v),
378            TyKind::Ptr(value) => value.visit_in(v),
379            TyKind::Fn(value) => value.visit_in(v),
380        }
381    }
382}
383impl Walk for TyArray {
384    #[inline]
385    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
386        v.visit_ty_array(self);
387    }
388    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
389        let TyArray { ty, count: _ } = self;
390        ty.visit_in(v);
391        // count.walk(v); // not available
392    }
393}
394impl Walk for TySlice {
395    #[inline]
396    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
397        v.visit_ty_slice(self);
398    }
399    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
400        let TySlice { ty } = self;
401        ty.visit_in(v);
402    }
403}
404impl Walk for TyTuple {
405    #[inline]
406    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
407        v.visit_ty_tuple(self);
408    }
409    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
410        let TyTuple { types } = self;
411        types.visit_in(v);
412    }
413}
414impl Walk for TyRef {
415    #[inline]
416    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
417        v.visit_ty_ref(self);
418    }
419    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
420        let TyRef { mutable, count: _, to } = self;
421        mutable.children(v);
422        to.children(v);
423    }
424}
425impl Walk for TyPtr {
426    #[inline]
427    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
428        v.visit_ty_ptr(self);
429    }
430    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
431        let TyPtr { to } = self;
432        to.children(v);
433    }
434}
435impl Walk for TyFn {
436    #[inline]
437    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
438        v.visit_ty_fn(self);
439    }
440    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
441        let TyFn { args, rety } = self;
442        args.visit_in(v);
443        rety.visit_in(v);
444    }
445}
446impl Walk for Path {
447    #[inline]
448    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
449        v.visit_path(self);
450    }
451    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
452        let Path { absolute: _, parts } = self;
453        parts.visit_in(v);
454    }
455}
456impl Walk for PathPart {
457    #[inline]
458    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
459        v.visit_path_part(self);
460    }
461    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
462        match self {
463            PathPart::SuperKw => {}
464            PathPart::SelfTy => {}
465            PathPart::Ident(sym) => sym.visit_in(v),
466        }
467    }
468}
469impl Walk for Stmt {
470    #[inline]
471    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
472        v.visit_stmt(self);
473    }
474    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
475        let Stmt { span, kind, semi } = self;
476        span.visit_in(v);
477        kind.visit_in(v);
478        semi.visit_in(v);
479    }
480}
481impl Walk for StmtKind {
482    #[inline]
483    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
484        v.visit_stmt_kind(self);
485    }
486    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
487        match self {
488            StmtKind::Empty => {}
489            StmtKind::Item(value) => value.visit_in(v),
490            StmtKind::Expr(value) => value.visit_in(v),
491        }
492    }
493}
494impl Walk for Semi {
495    #[inline]
496    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
497        v.visit_semi(self);
498    }
499}
500impl Walk for Expr {
501    #[inline]
502    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
503        v.visit_expr(self);
504    }
505    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
506        let Expr { span, kind } = self;
507        span.visit_in(v);
508        kind.visit_in(v);
509    }
510}
511impl Walk for ExprKind {
512    #[inline]
513    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
514        v.visit_expr_kind(self);
515    }
516    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
517        match self {
518            ExprKind::Empty => {}
519            ExprKind::Closure(value) => value.visit_in(v),
520            ExprKind::Tuple(value) => value.visit_in(v),
521            ExprKind::Structor(value) => value.visit_in(v),
522            ExprKind::Array(value) => value.visit_in(v),
523            ExprKind::ArrayRep(value) => value.visit_in(v),
524            ExprKind::AddrOf(value) => value.visit_in(v),
525            ExprKind::Quote(value) => value.visit_in(v),
526            ExprKind::Literal(value) => value.visit_in(v),
527            ExprKind::Group(value) => value.visit_in(v),
528            ExprKind::Block(value) => value.visit_in(v),
529            ExprKind::Assign(value) => value.visit_in(v),
530            ExprKind::Modify(value) => value.visit_in(v),
531            ExprKind::Binary(value) => value.visit_in(v),
532            ExprKind::Unary(value) => value.visit_in(v),
533            ExprKind::Member(value) => value.visit_in(v),
534            ExprKind::Index(value) => value.visit_in(v),
535            ExprKind::Cast(value) => value.visit_in(v),
536            ExprKind::Path(value) => value.visit_in(v),
537            ExprKind::Let(value) => value.visit_in(v),
538            ExprKind::Match(value) => value.visit_in(v),
539            ExprKind::While(value) => value.visit_in(v),
540            ExprKind::If(value) => value.visit_in(v),
541            ExprKind::For(value) => value.visit_in(v),
542            ExprKind::Break(value) => value.visit_in(v),
543            ExprKind::Return(value) => value.visit_in(v),
544            ExprKind::Continue => v.visit_continue(),
545        }
546    }
547}
548
549impl Walk for Closure {
550    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
551        v.visit_closure(self);
552    }
553
554    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
555        let Self { arg, body } = self;
556        v.visit_pattern(arg);
557        v.visit_expr(body);
558    }
559}
560
561impl Walk for Tuple {
562    #[inline]
563    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
564        v.visit_tuple(self);
565    }
566    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
567        let Tuple { exprs } = self;
568        exprs.visit_in(v);
569    }
570}
571impl Walk for Structor {
572    #[inline]
573    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
574        v.visit_structor(self);
575    }
576    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
577        let Structor { to, init } = self;
578        to.visit_in(v);
579        init.visit_in(v);
580    }
581}
582impl Walk for Fielder {
583    #[inline]
584    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
585        v.visit_fielder(self);
586    }
587    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
588        let Fielder { name, init } = self;
589        name.visit_in(v);
590        init.visit_in(v);
591    }
592}
593impl Walk for Array {
594    #[inline]
595    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
596        v.visit_array(self);
597    }
598    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
599        let Array { values } = self;
600        values.visit_in(v);
601    }
602}
603impl Walk for ArrayRep {
604    #[inline]
605    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
606        v.visit_array_rep(self);
607    }
608    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
609        let ArrayRep { value, repeat: _ } = self;
610        value.visit_in(v);
611        // repeat.visit_in(v) // TODO
612    }
613}
614impl Walk for AddrOf {
615    #[inline]
616    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
617        v.visit_addrof(self);
618    }
619    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
620        let AddrOf { mutable, expr } = self;
621        mutable.visit_in(v);
622        expr.visit_in(v);
623    }
624}
625impl Walk for Cast {
626    #[inline]
627    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
628        v.visit_cast(self);
629    }
630    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
631        let Cast { head, ty } = self;
632        head.visit_in(v);
633        ty.visit_in(v);
634    }
635}
636impl Walk for Quote {
637    #[inline]
638    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
639        v.visit_quote(self);
640    }
641    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
642        let Quote { quote } = self;
643        quote.visit_in(v);
644    }
645}
646impl Walk for Group {
647    #[inline]
648    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
649        v.visit_group(self);
650    }
651    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
652        let Group { expr } = self;
653        expr.visit_in(v);
654    }
655}
656impl Walk for Block {
657    #[inline]
658    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
659        v.visit_block(self);
660    }
661    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
662        let Block { stmts } = self;
663        stmts.visit_in(v);
664    }
665}
666impl Walk for Assign {
667    #[inline]
668    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
669        v.visit_assign(self);
670    }
671    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
672        let Assign { parts } = self;
673        parts.visit_in(v);
674    }
675}
676impl Walk for Modify {
677    #[inline]
678    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
679        v.visit_modify(self);
680    }
681    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
682        let Modify { kind, parts } = self;
683        kind.visit_in(v);
684        parts.visit_in(v);
685    }
686}
687impl Walk for ModifyKind {
688    #[inline]
689    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
690        v.visit_modify_kind(self);
691    }
692}
693impl Walk for Binary {
694    #[inline]
695    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
696        v.visit_binary(self);
697    }
698    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
699        let Binary { kind, parts } = self;
700        kind.visit_in(v);
701        parts.visit_in(v);
702    }
703}
704impl Walk for BinaryKind {
705    #[inline]
706    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
707        v.visit_binary_kind(self);
708    }
709}
710impl Walk for Unary {
711    #[inline]
712    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
713        v.visit_unary(self);
714    }
715    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
716        let Unary { kind, tail } = self;
717        kind.visit_in(v);
718        tail.visit_in(v);
719    }
720}
721impl Walk for UnaryKind {
722    #[inline]
723    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
724        v.visit_unary_kind(self);
725    }
726}
727impl Walk for Member {
728    #[inline]
729    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
730        v.visit_member(self);
731    }
732    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
733        let Member { head, kind } = self;
734        head.visit_in(v);
735        kind.visit_in(v);
736    }
737}
738impl Walk for MemberKind {
739    #[inline]
740    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
741        v.visit_member_kind(self);
742    }
743    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
744        match self {
745            MemberKind::Call(sym, tuple) => {
746                sym.visit_in(v);
747                tuple.visit_in(v);
748            }
749            MemberKind::Struct(sym) => sym.visit_in(v),
750            MemberKind::Tuple(literal) => literal.visit_in(v),
751        }
752    }
753}
754impl Walk for Index {
755    #[inline]
756    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
757        v.visit_index(self);
758    }
759    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
760        let Index { head, indices } = self;
761        head.visit_in(v);
762        indices.visit_in(v);
763    }
764}
765impl Walk for Let {
766    #[inline]
767    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
768        v.visit_let(self);
769    }
770    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
771        let Let { mutable, name, ty, init } = self;
772        mutable.visit_in(v);
773        name.visit_in(v);
774        ty.visit_in(v);
775        init.visit_in(v);
776    }
777}
778impl Walk for Match {
779    #[inline]
780    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
781        v.visit_match(self);
782    }
783    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
784        let Match { scrutinee, arms } = self;
785        scrutinee.visit_in(v);
786        arms.visit_in(v);
787    }
788}
789impl Walk for MatchArm {
790    #[inline]
791    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
792        v.visit_match_arm(self);
793    }
794    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
795        let MatchArm(pat, expr) = self;
796        pat.visit_in(v);
797        expr.visit_in(v);
798    }
799}
800impl Walk for Pattern {
801    #[inline]
802    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
803        v.visit_pattern(self);
804    }
805    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
806        match self {
807            Pattern::Name(sym) => sym.visit_in(v),
808            Pattern::Path(path) => path.visit_in(v),
809            Pattern::Literal(literal) => literal.visit_in(v),
810            Pattern::Rest(pattern) => pattern.visit_in(v),
811            Pattern::Ref(mutability, pattern) => {
812                mutability.visit_in(v);
813                pattern.visit_in(v);
814            }
815            Pattern::RangeExc(from, to) => {
816                from.visit_in(v);
817                to.visit_in(v);
818            }
819            Pattern::RangeInc(from, to) => {
820                from.visit_in(v);
821                to.visit_in(v);
822            }
823            Pattern::Tuple(patterns) => patterns.visit_in(v),
824            Pattern::Array(patterns) => patterns.visit_in(v),
825            Pattern::Struct(path, items) => {
826                path.visit_in(v);
827                items.visit_in(v);
828            }
829            Pattern::TupleStruct(path, patterns) => {
830                path.visit_in(v);
831                patterns.visit_in(v);
832            }
833        }
834    }
835}
836impl Walk for While {
837    #[inline]
838    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
839        v.visit_while(self);
840    }
841    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
842        let While { cond, pass, fail } = self;
843        cond.visit_in(v);
844        pass.visit_in(v);
845        fail.visit_in(v);
846    }
847}
848impl Walk for If {
849    #[inline]
850    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
851        v.visit_if(self);
852    }
853    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
854        let If { cond, pass, fail } = self;
855        cond.visit_in(v);
856        pass.visit_in(v);
857        fail.visit_in(v);
858    }
859}
860impl Walk for For {
861    #[inline]
862    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
863        v.visit_for(self);
864    }
865    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
866        let For { bind, cond, pass, fail } = self;
867        cond.visit_in(v);
868        fail.visit_in(v);
869        bind.visit_in(v);
870        pass.visit_in(v);
871    }
872}
873impl Walk for Else {
874    #[inline]
875    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
876        v.visit_else(self);
877    }
878    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
879        let Else { body } = self;
880        body.visit_in(v);
881    }
882}
883impl Walk for Break {
884    #[inline]
885    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
886        v.visit_break(self);
887    }
888    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
889        let Break { body } = self;
890        body.visit_in(v);
891    }
892}
893impl Walk for Return {
894    #[inline]
895    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
896        v.visit_return(self);
897    }
898    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
899        let Return { body } = self;
900        body.visit_in(v);
901    }
902}
903
904// --- BLANKET IMPLEMENTATIONS
905
906impl<T: Walk> Walk for [T] {
907    #[inline]
908    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
909        self.iter().for_each(|value| value.visit_in(v));
910    }
911    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
912        self.iter().for_each(|value| value.children(v));
913    }
914}
915
916impl<T: Walk> Walk for Vec<T> {
917    #[inline]
918    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
919        self.as_slice().visit_in(v);
920    }
921
922    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
923        self.as_slice().children(v);
924    }
925}
926
927impl<A: Walk, B: Walk> Walk for (A, B) {
928    #[inline]
929    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
930        let (a, b) = self;
931        a.visit_in(v);
932        b.visit_in(v);
933    }
934    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
935        let (a, b) = self;
936        a.children(v);
937        b.children(v);
938    }
939}
940
941impl<T: Walk> Walk for Option<T> {
942    #[inline]
943    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
944        if let Some(value) = self.as_ref() {
945            value.visit_in(v)
946        }
947    }
948    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
949        if let Some(value) = self {
950            value.children(v)
951        }
952    }
953}
954
955impl<T: Walk> Walk for Box<T> {
956    #[inline]
957    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
958        self.as_ref().visit_in(v)
959    }
960    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
961        self.as_ref().children(v)
962    }
963}
cl_ast/ast_visitor/walk.rs

cl_ast/ast_visitor/
walk.rs
