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 { target, body } = self;
301        target.visit_in(v);
302        body.visit_in(v);
303    }
304}
305impl Walk for ImplKind {
306    #[inline]
307    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
308        v.visit_impl_kind(self);
309    }
310    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
311        match self {
312            ImplKind::Type(t) => t.visit_in(v),
313            ImplKind::Trait { impl_trait, for_type } => {
314                impl_trait.visit_in(v);
315                for_type.visit_in(v);
316            }
317        }
318    }
319}
320impl Walk for Use {
321    #[inline]
322    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
323        v.visit_use(self);
324    }
325    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
326        let Use { absolute: _, tree } = self;
327        tree.visit_in(v);
328    }
329}
330impl Walk for UseTree {
331    #[inline]
332    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
333        v.visit_use_tree(self);
334    }
335    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
336        match self {
337            UseTree::Tree(tree) => tree.iter().for_each(|t| t.visit_in(v)),
338            UseTree::Path(part, tree) => {
339                part.visit_in(v);
340                tree.visit_in(v);
341            }
342            UseTree::Alias(from, to) => {
343                from.visit_in(v);
344                to.visit_in(v);
345            }
346            UseTree::Name(name) => name.visit_in(v),
347            UseTree::Glob => {}
348        }
349    }
350}
351impl Walk for Ty {
352    #[inline]
353    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
354        v.visit_ty(self);
355    }
356    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
357        let Ty { span, kind } = self;
358        span.visit_in(v);
359        kind.visit_in(v);
360    }
361}
362impl Walk for TyKind {
363    #[inline]
364    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
365        v.visit_ty_kind(self);
366    }
367    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
368        match self {
369            TyKind::Never => {}
370            TyKind::Empty => {}
371            TyKind::Infer => {}
372            TyKind::Path(value) => value.visit_in(v),
373            TyKind::Array(value) => value.visit_in(v),
374            TyKind::Slice(value) => value.visit_in(v),
375            TyKind::Tuple(value) => value.visit_in(v),
376            TyKind::Ref(value) => value.visit_in(v),
377            TyKind::Fn(value) => value.visit_in(v),
378        }
379    }
380}
381impl Walk for TyArray {
382    #[inline]
383    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
384        v.visit_ty_array(self);
385    }
386    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
387        let TyArray { ty, count: _ } = self;
388        ty.visit_in(v);
389        // count.walk(v); // not available
390    }
391}
392impl Walk for TySlice {
393    #[inline]
394    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
395        v.visit_ty_slice(self);
396    }
397    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
398        let TySlice { ty } = self;
399        ty.visit_in(v);
400    }
401}
402impl Walk for TyTuple {
403    #[inline]
404    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
405        v.visit_ty_tuple(self);
406    }
407    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
408        let TyTuple { types } = self;
409        types.visit_in(v);
410    }
411}
412impl Walk for TyRef {
413    #[inline]
414    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
415        v.visit_ty_ref(self);
416    }
417    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
418        let TyRef { mutable, count: _, to } = self;
419        mutable.children(v);
420        to.children(v);
421    }
422}
423impl Walk for TyFn {
424    #[inline]
425    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
426        v.visit_ty_fn(self);
427    }
428    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
429        let TyFn { args, rety } = self;
430        args.visit_in(v);
431        rety.visit_in(v);
432    }
433}
434impl Walk for Path {
435    #[inline]
436    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
437        v.visit_path(self);
438    }
439    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
440        let Path { absolute: _, parts } = self;
441        parts.visit_in(v);
442    }
443}
444impl Walk for PathPart {
445    #[inline]
446    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
447        v.visit_path_part(self);
448    }
449    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
450        match self {
451            PathPart::SuperKw => {}
452            PathPart::SelfTy => {}
453            PathPart::Ident(sym) => sym.visit_in(v),
454        }
455    }
456}
457impl Walk for Stmt {
458    #[inline]
459    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
460        v.visit_stmt(self);
461    }
462    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
463        let Stmt { span, kind, semi } = self;
464        span.visit_in(v);
465        kind.visit_in(v);
466        semi.visit_in(v);
467    }
468}
469impl Walk for StmtKind {
470    #[inline]
471    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
472        v.visit_stmt_kind(self);
473    }
474    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
475        match self {
476            StmtKind::Empty => {}
477            StmtKind::Item(value) => value.visit_in(v),
478            StmtKind::Expr(value) => value.visit_in(v),
479        }
480    }
481}
482impl Walk for Semi {
483    #[inline]
484    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
485        v.visit_semi(self);
486    }
487}
488impl Walk for Expr {
489    #[inline]
490    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
491        v.visit_expr(self);
492    }
493    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
494        let Expr { span, kind } = self;
495        span.visit_in(v);
496        kind.visit_in(v);
497    }
498}
499impl Walk for ExprKind {
500    #[inline]
501    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
502        v.visit_expr_kind(self);
503    }
504    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
505        match self {
506            ExprKind::Empty => {}
507            ExprKind::Closure(value) => value.visit_in(v),
508            ExprKind::Tuple(value) => value.visit_in(v),
509            ExprKind::Structor(value) => value.visit_in(v),
510            ExprKind::Array(value) => value.visit_in(v),
511            ExprKind::ArrayRep(value) => value.visit_in(v),
512            ExprKind::AddrOf(value) => value.visit_in(v),
513            ExprKind::Quote(value) => value.visit_in(v),
514            ExprKind::Literal(value) => value.visit_in(v),
515            ExprKind::Group(value) => value.visit_in(v),
516            ExprKind::Block(value) => value.visit_in(v),
517            ExprKind::Assign(value) => value.visit_in(v),
518            ExprKind::Modify(value) => value.visit_in(v),
519            ExprKind::Binary(value) => value.visit_in(v),
520            ExprKind::Unary(value) => value.visit_in(v),
521            ExprKind::Member(value) => value.visit_in(v),
522            ExprKind::Index(value) => value.visit_in(v),
523            ExprKind::Cast(value) => value.visit_in(v),
524            ExprKind::Path(value) => value.visit_in(v),
525            ExprKind::Let(value) => value.visit_in(v),
526            ExprKind::Match(value) => value.visit_in(v),
527            ExprKind::While(value) => value.visit_in(v),
528            ExprKind::If(value) => value.visit_in(v),
529            ExprKind::For(value) => value.visit_in(v),
530            ExprKind::Break(value) => value.visit_in(v),
531            ExprKind::Return(value) => value.visit_in(v),
532            ExprKind::Continue => v.visit_continue(),
533        }
534    }
535}
536
537impl Walk for Closure {
538    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
539        v.visit_closure(self);
540    }
541
542    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
543        let Self { arg, body } = self;
544        v.visit_pattern(arg);
545        v.visit_expr(body);
546    }
547}
548
549impl Walk for Tuple {
550    #[inline]
551    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
552        v.visit_tuple(self);
553    }
554    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
555        let Tuple { exprs } = self;
556        exprs.visit_in(v);
557    }
558}
559impl Walk for Structor {
560    #[inline]
561    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
562        v.visit_structor(self);
563    }
564    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
565        let Structor { to, init } = self;
566        to.visit_in(v);
567        init.visit_in(v);
568    }
569}
570impl Walk for Fielder {
571    #[inline]
572    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
573        v.visit_fielder(self);
574    }
575    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
576        let Fielder { name, init } = self;
577        name.visit_in(v);
578        init.visit_in(v);
579    }
580}
581impl Walk for Array {
582    #[inline]
583    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
584        v.visit_array(self);
585    }
586    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
587        let Array { values } = self;
588        values.visit_in(v);
589    }
590}
591impl Walk for ArrayRep {
592    #[inline]
593    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
594        v.visit_array_rep(self);
595    }
596    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
597        let ArrayRep { value, repeat: _ } = self;
598        value.visit_in(v);
599        // repeat.visit_in(v) // TODO
600    }
601}
602impl Walk for AddrOf {
603    #[inline]
604    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
605        v.visit_addrof(self);
606    }
607    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
608        let AddrOf { mutable, expr } = self;
609        mutable.visit_in(v);
610        expr.visit_in(v);
611    }
612}
613impl Walk for Cast {
614    #[inline]
615    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
616        v.visit_cast(self);
617    }
618    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
619        let Cast { head, ty } = self;
620        head.visit_in(v);
621        ty.visit_in(v);
622    }
623}
624impl Walk for Quote {
625    #[inline]
626    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
627        v.visit_quote(self);
628    }
629    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
630        let Quote { quote } = self;
631        quote.visit_in(v);
632    }
633}
634impl Walk for Group {
635    #[inline]
636    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
637        v.visit_group(self);
638    }
639    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
640        let Group { expr } = self;
641        expr.visit_in(v);
642    }
643}
644impl Walk for Block {
645    #[inline]
646    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
647        v.visit_block(self);
648    }
649    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
650        let Block { stmts } = self;
651        stmts.visit_in(v);
652    }
653}
654impl Walk for Assign {
655    #[inline]
656    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
657        v.visit_assign(self);
658    }
659    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
660        let Assign { parts } = self;
661        parts.visit_in(v);
662    }
663}
664impl Walk for Modify {
665    #[inline]
666    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
667        v.visit_modify(self);
668    }
669    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
670        let Modify { kind, parts } = self;
671        kind.visit_in(v);
672        parts.visit_in(v);
673    }
674}
675impl Walk for ModifyKind {
676    #[inline]
677    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
678        v.visit_modify_kind(self);
679    }
680}
681impl Walk for Binary {
682    #[inline]
683    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
684        v.visit_binary(self);
685    }
686    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
687        let Binary { kind, parts } = self;
688        kind.visit_in(v);
689        parts.visit_in(v);
690    }
691}
692impl Walk for BinaryKind {
693    #[inline]
694    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
695        v.visit_binary_kind(self);
696    }
697}
698impl Walk for Unary {
699    #[inline]
700    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
701        v.visit_unary(self);
702    }
703    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
704        let Unary { kind, tail } = self;
705        kind.visit_in(v);
706        tail.visit_in(v);
707    }
708}
709impl Walk for UnaryKind {
710    #[inline]
711    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
712        v.visit_unary_kind(self);
713    }
714}
715impl Walk for Member {
716    #[inline]
717    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
718        v.visit_member(self);
719    }
720    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
721        let Member { head, kind } = self;
722        head.visit_in(v);
723        kind.visit_in(v);
724    }
725}
726impl Walk for MemberKind {
727    #[inline]
728    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
729        v.visit_member_kind(self);
730    }
731    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
732        match self {
733            MemberKind::Call(sym, tuple) => {
734                sym.visit_in(v);
735                tuple.visit_in(v);
736            }
737            MemberKind::Struct(sym) => sym.visit_in(v),
738            MemberKind::Tuple(literal) => literal.visit_in(v),
739        }
740    }
741}
742impl Walk for Index {
743    #[inline]
744    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
745        v.visit_index(self);
746    }
747    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
748        let Index { head, indices } = self;
749        head.visit_in(v);
750        indices.visit_in(v);
751    }
752}
753impl Walk for Let {
754    #[inline]
755    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
756        v.visit_let(self);
757    }
758    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
759        let Let { mutable, name, ty, init } = self;
760        mutable.visit_in(v);
761        name.visit_in(v);
762        ty.visit_in(v);
763        init.visit_in(v);
764    }
765}
766impl Walk for Match {
767    #[inline]
768    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
769        v.visit_match(self);
770    }
771    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
772        let Match { scrutinee, arms } = self;
773        scrutinee.visit_in(v);
774        arms.visit_in(v);
775    }
776}
777impl Walk for MatchArm {
778    #[inline]
779    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
780        v.visit_match_arm(self);
781    }
782    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
783        let MatchArm(pat, expr) = self;
784        pat.visit_in(v);
785        expr.visit_in(v);
786    }
787}
788impl Walk for Pattern {
789    #[inline]
790    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
791        v.visit_pattern(self);
792    }
793    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
794        match self {
795            Pattern::Name(sym) => sym.visit_in(v),
796            Pattern::Path(path) => path.visit_in(v),
797            Pattern::Literal(literal) => literal.visit_in(v),
798            Pattern::Rest(pattern) => pattern.visit_in(v),
799            Pattern::Ref(mutability, pattern) => {
800                mutability.visit_in(v);
801                pattern.visit_in(v);
802            }
803            Pattern::RangeExc(from, to) => {
804                from.visit_in(v);
805                to.visit_in(v);
806            }
807            Pattern::RangeInc(from, to) => {
808                from.visit_in(v);
809                to.visit_in(v);
810            }
811            Pattern::Tuple(patterns) => patterns.visit_in(v),
812            Pattern::Array(patterns) => patterns.visit_in(v),
813            Pattern::Struct(path, items) => {
814                path.visit_in(v);
815                items.visit_in(v);
816            }
817            Pattern::TupleStruct(path, patterns) => {
818                path.visit_in(v);
819                patterns.visit_in(v);
820            }
821        }
822    }
823}
824impl Walk for While {
825    #[inline]
826    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
827        v.visit_while(self);
828    }
829    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
830        let While { cond, pass, fail } = self;
831        cond.visit_in(v);
832        pass.visit_in(v);
833        fail.visit_in(v);
834    }
835}
836impl Walk for If {
837    #[inline]
838    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
839        v.visit_if(self);
840    }
841    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
842        let If { cond, pass, fail } = self;
843        cond.visit_in(v);
844        pass.visit_in(v);
845        fail.visit_in(v);
846    }
847}
848impl Walk for For {
849    #[inline]
850    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
851        v.visit_for(self);
852    }
853    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
854        let For { bind, cond, pass, fail } = self;
855        bind.visit_in(v);
856        cond.visit_in(v);
857        pass.visit_in(v);
858        fail.visit_in(v);
859    }
860}
861impl Walk for Else {
862    #[inline]
863    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
864        v.visit_else(self);
865    }
866    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
867        let Else { body } = self;
868        body.visit_in(v);
869    }
870}
871impl Walk for Break {
872    #[inline]
873    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
874        v.visit_break(self);
875    }
876    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
877        let Break { body } = self;
878        body.visit_in(v);
879    }
880}
881impl Walk for Return {
882    #[inline]
883    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
884        v.visit_return(self);
885    }
886    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
887        let Return { body } = self;
888        body.visit_in(v);
889    }
890}
891
892// --- BLANKET IMPLEMENTATIONS
893
894impl<T: Walk> Walk for [T] {
895    #[inline]
896    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
897        self.iter().for_each(|value| value.visit_in(v));
898    }
899    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
900        self.iter().for_each(|value| value.children(v));
901    }
902}
903
904impl<T: Walk> Walk for Vec<T> {
905    #[inline]
906    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
907        self.as_slice().visit_in(v);
908    }
909
910    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
911        self.as_slice().children(v);
912    }
913}
914
915impl<A: Walk, B: Walk> Walk for (A, B) {
916    #[inline]
917    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
918        let (a, b) = self;
919        a.visit_in(v);
920        b.visit_in(v);
921    }
922    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
923        let (a, b) = self;
924        a.children(v);
925        b.children(v);
926    }
927}
928
929impl<T: Walk> Walk for Option<T> {
930    #[inline]
931    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
932        if let Some(value) = self.as_ref() {
933            value.visit_in(v)
934        }
935    }
936    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
937        if let Some(value) = self {
938            value.children(v)
939        }
940    }
941}
942
943impl<T: Walk> Walk for Box<T> {
944    #[inline]
945    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
946        self.as_ref().visit_in(v)
947    }
948    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
949        self.as_ref().children(v)
950    }
951}
cl_ast/ast_visitor/walk.rs

cl_ast/ast_visitor/
walk.rs
