flux_syntax/surface/
visit.rs

1//! A visitor for types in [`surface`]
2//!
3//! In general there's no specific order except that [refinement parameters] should be
4//! visited in an order that matches their scope. Name resolution relies on this gurantee.
5//!
6//! [`surface`]: crate::surface
7//! [refinement parameters]: crate::surface::RefineParam
8use rustc_span::symbol::Ident;
9
10use super::{
11    Async, BaseSort, BaseTy, BaseTyKind, ConstArg, ConstantInfo, ConstructorArg, Ensures, EnumDef,
12    Expr, ExprKind, ExprPath, ExprPathSegment, FieldExpr, FnInput, FnOutput, FnRetTy, FnSig,
13    GenericArg, GenericArgKind, GenericParam, Generics, Impl, ImplAssocReft, Indices, ItemKind,
14    Lit, Path, PathSegment, Qualifier, RefineArg, RefineParam, Sort, SortPath, SpecFunc, StructDef,
15    Trait, TraitAssocReft, TraitRef, Ty, TyAlias, TyKind, VariantDef, VariantRet,
16    WhereBoundPredicate,
17};
18use crate::surface::{FluxItem, ImplItemFn, Item, PrimOpProp, SortDecl, TraitItemFn};
19
20#[macro_export]
21macro_rules! walk_list {
22    ($visitor: expr, $method: ident, $list: expr $(, $($extra_args: expr),* )?) => {
23        {
24            #[allow(for_loops_over_fallibles)]
25            for elem in $list {
26                $visitor.$method(elem $(, $($extra_args,)* )?)
27            }
28        }
29    }
30}
31
32pub trait Visitor: Sized {
33    fn visit_flux_item(&mut self, item: &FluxItem) {
34        walk_flux_item(self, item);
35    }
36
37    fn visit_qualifier(&mut self, qualifier: &Qualifier) {
38        walk_qualifier(self, qualifier);
39    }
40
41    fn visit_sort_decl(&mut self, sort_decl: &SortDecl) {
42        walk_sort_decl(self, sort_decl);
43    }
44
45    fn visit_defn(&mut self, defn: &SpecFunc) {
46        walk_defn(self, defn);
47    }
48
49    fn visit_primop_prop(&mut self, prop: &PrimOpProp) {
50        walk_primop_prop(self, prop);
51    }
52
53    fn visit_refine_param(&mut self, param: &RefineParam) {
54        walk_refine_param(self, param);
55    }
56
57    fn visit_generic_param(&mut self, param: &GenericParam) {
58        walk_generic_param(self, param);
59    }
60
61    fn visit_sort(&mut self, sort: &Sort) {
62        walk_sort(self, sort);
63    }
64
65    fn visit_item(&mut self, item: &Item) {
66        walk_item(self, item);
67    }
68
69    fn visit_trait_item(&mut self, item: &TraitItemFn) {
70        walk_trait_item(self, item);
71    }
72
73    fn visit_impl_item(&mut self, item: &ImplItemFn) {
74        walk_impl_item(self, item);
75    }
76
77    fn visit_trait(&mut self, trait_: &Trait) {
78        walk_trait(self, trait_);
79    }
80
81    fn visit_trait_assoc_reft(&mut self, assoc_reft: &TraitAssocReft) {
82        walk_trait_assoc_reft(self, assoc_reft);
83    }
84
85    fn visit_impl(&mut self, impl_: &Impl) {
86        walk_impl(self, impl_);
87    }
88
89    fn visit_impl_assoc_reft(&mut self, assoc_reft: &ImplAssocReft) {
90        walk_impl_assoc_reft(self, assoc_reft);
91    }
92
93    fn visit_trait_ref(&mut self, trait_ref: &TraitRef) {
94        walk_trait_ref(self, trait_ref);
95    }
96
97    fn visit_base_sort(&mut self, bsort: &BaseSort) {
98        walk_base_sort(self, bsort);
99    }
100
101    fn visit_sort_path(&mut self, path: &SortPath) {
102        walk_sort_path(self, path);
103    }
104
105    fn visit_ty_alias(&mut self, ty_alias: &TyAlias) {
106        walk_ty_alias(self, ty_alias);
107    }
108
109    fn visit_struct_def(&mut self, struct_def: &StructDef) {
110        walk_struct_def(self, struct_def);
111    }
112
113    fn visit_constant(&mut self, _constant: &ConstantInfo) {
114        walk_constant(self, _constant);
115    }
116
117    fn visit_enum_def(&mut self, enum_def: &EnumDef) {
118        walk_enum_def(self, enum_def);
119    }
120
121    fn visit_variant(&mut self, variant: &VariantDef) {
122        walk_variant(self, variant);
123    }
124
125    fn visit_variant_ret(&mut self, ret: &VariantRet) {
126        walk_variant_ret(self, ret);
127    }
128
129    fn visit_fn_sig(&mut self, fn_sig: &FnSig) {
130        walk_fn_sig(self, fn_sig);
131    }
132
133    fn visit_fn_output(&mut self, fn_output: &FnOutput) {
134        walk_fn_output(self, fn_output);
135    }
136
137    fn visit_async(&mut self, _asyncness: &Async) {}
138
139    fn visit_generics(&mut self, generics: &Generics) {
140        walk_generics(self, generics);
141    }
142
143    fn visit_fn_input(&mut self, input: &FnInput) {
144        walk_fn_input(self, input);
145    }
146
147    fn visit_fn_ret_ty(&mut self, fn_ret_ty: &FnRetTy) {
148        walk_fn_ret_ty(self, fn_ret_ty);
149    }
150
151    fn visit_ensures(&mut self, ensures: &Ensures) {
152        walk_ensures(self, ensures);
153    }
154
155    fn visit_where_predicate(&mut self, predicate: &WhereBoundPredicate) {
156        walk_where_predicate(self, predicate);
157    }
158
159    fn visit_generic_arg(&mut self, arg: &GenericArg) {
160        walk_generic_arg(self, arg);
161    }
162
163    fn visit_refine_arg(&mut self, arg: &RefineArg) {
164        walk_refine_arg(self, arg);
165    }
166
167    fn visit_indices(&mut self, indices: &Indices) {
168        walk_indices(self, indices);
169    }
170
171    fn visit_ty(&mut self, ty: &Ty) {
172        walk_ty(self, ty);
173    }
174
175    fn visit_const_arg(&mut self, _const_arg: &ConstArg) {}
176
177    fn visit_bty(&mut self, bty: &BaseTy) {
178        walk_bty(self, bty);
179    }
180
181    fn visit_path(&mut self, path: &Path) {
182        walk_path(self, path);
183    }
184
185    fn visit_path_segment(&mut self, segment: &PathSegment) {
186        walk_path_segment(self, segment);
187    }
188
189    fn visit_expr(&mut self, expr: &Expr) {
190        walk_expr(self, expr);
191    }
192
193    fn visit_constructor_args(&mut self, expr: &ConstructorArg) {
194        match expr {
195            ConstructorArg::FieldExpr(field_expr) => walk_field_expr(self, field_expr),
196            ConstructorArg::Spread(spread) => self.visit_expr(&spread.expr),
197        }
198    }
199
200    fn visit_path_expr(&mut self, qpath: &ExprPath) {
201        walk_path_expr(self, qpath);
202    }
203
204    fn visit_path_expr_segment(&mut self, segment: &ExprPathSegment) {
205        walk_path_expr_segment(self, segment);
206    }
207
208    fn visit_ident(&mut self, _ident: Ident) {}
209
210    fn visit_literal(&mut self, _lit: Lit) {}
211}
212
213pub fn walk_flux_item<V: Visitor>(vis: &mut V, item: &FluxItem) {
214    match item {
215        FluxItem::Qualifier(qualifier) => vis.visit_qualifier(qualifier),
216        FluxItem::FuncDef(spec_func) => vis.visit_defn(spec_func),
217        FluxItem::SortDecl(sort_decl) => vis.visit_sort_decl(sort_decl),
218        FluxItem::PrimOpProp(prim_op_prop) => vis.visit_primop_prop(prim_op_prop),
219    }
220}
221
222pub fn walk_qualifier<V: Visitor>(vis: &mut V, qualifier: &Qualifier) {
223    vis.visit_ident(qualifier.name);
224    walk_list!(vis, visit_refine_param, &qualifier.params);
225    vis.visit_expr(&qualifier.expr);
226}
227
228pub fn walk_sort_decl<V: Visitor>(vis: &mut V, sort_decl: &SortDecl) {
229    vis.visit_ident(sort_decl.name);
230    walk_list!(vis, visit_ident, sort_decl.sort_vars.iter().copied());
231}
232
233pub fn walk_defn<V: Visitor>(vis: &mut V, defn: &SpecFunc) {
234    vis.visit_ident(defn.name);
235    walk_list!(vis, visit_ident, defn.sort_vars.iter().copied());
236    walk_list!(vis, visit_refine_param, &defn.params);
237    vis.visit_sort(&defn.output);
238    if let Some(body) = &defn.body {
239        vis.visit_expr(body);
240    }
241}
242
243pub fn walk_primop_prop<V: Visitor>(vis: &mut V, prop: &PrimOpProp) {
244    vis.visit_ident(prop.name);
245    walk_list!(vis, visit_refine_param, &prop.params);
246    vis.visit_expr(&prop.body);
247}
248
249pub fn walk_refine_param<V: Visitor>(vis: &mut V, param: &RefineParam) {
250    vis.visit_ident(param.ident);
251    vis.visit_sort(&param.sort);
252}
253
254pub fn walk_generic_param<V: Visitor>(vis: &mut V, param: &GenericParam) {
255    vis.visit_ident(param.name);
256}
257
258pub fn walk_sort<V: Visitor>(vis: &mut V, sort: &Sort) {
259    match sort {
260        Sort::Base(bsort) => vis.visit_base_sort(bsort),
261        Sort::Func { inputs, output } => {
262            walk_list!(vis, visit_base_sort, inputs);
263            vis.visit_base_sort(output);
264        }
265        Sort::Infer => {}
266    }
267}
268
269pub fn walk_item<V: Visitor>(vis: &mut V, item: &Item) {
270    match &item.kind {
271        ItemKind::Fn(fn_sig) => {
272            if let Some(fn_sig) = fn_sig {
273                vis.visit_fn_sig(fn_sig);
274            }
275        }
276        ItemKind::Struct(struct_def) => vis.visit_struct_def(struct_def),
277        ItemKind::Enum(enum_def) => vis.visit_enum_def(enum_def),
278        ItemKind::Trait(trait_) => vis.visit_trait(trait_),
279        ItemKind::Impl(impl_) => vis.visit_impl(impl_),
280        ItemKind::Const(cst) => vis.visit_constant(cst),
281        ItemKind::Static(static_info) => vis.visit_ty(&static_info.ty),
282        ItemKind::TyAlias(ty_alias) => vis.visit_ty_alias(ty_alias),
283        ItemKind::Mod => {}
284    }
285}
286
287pub fn walk_trait_item<V: Visitor>(vis: &mut V, item: &TraitItemFn) {
288    if let Some(fn_sig) = item.sig.as_ref() {
289        vis.visit_fn_sig(fn_sig);
290    }
291}
292
293pub fn walk_impl_item<V: Visitor>(vis: &mut V, item: &ImplItemFn) {
294    if let Some(fn_sig) = item.sig.as_ref() {
295        vis.visit_fn_sig(fn_sig);
296    }
297}
298
299pub fn walk_trait<V: Visitor>(vis: &mut V, trait_: &Trait) {
300    if let Some(generics) = &trait_.generics {
301        vis.visit_generics(generics);
302    }
303    walk_list!(vis, visit_trait_assoc_reft, &trait_.assoc_refinements);
304}
305
306pub fn walk_trait_assoc_reft<V: Visitor>(vis: &mut V, assoc_reft: &TraitAssocReft) {
307    vis.visit_ident(assoc_reft.name);
308    walk_list!(vis, visit_refine_param, &assoc_reft.params);
309    vis.visit_base_sort(&assoc_reft.output);
310    if let Some(expr) = &assoc_reft.body {
311        vis.visit_expr(expr);
312    }
313}
314
315pub fn walk_impl<V: Visitor>(vis: &mut V, impl_: &Impl) {
316    if let Some(generics) = &impl_.generics {
317        vis.visit_generics(generics);
318    }
319    walk_list!(vis, visit_impl_assoc_reft, &impl_.assoc_refinements);
320}
321
322pub fn walk_impl_assoc_reft<V: Visitor>(vis: &mut V, assoc_reft: &ImplAssocReft) {
323    vis.visit_ident(assoc_reft.name);
324    walk_list!(vis, visit_refine_param, &assoc_reft.params);
325    vis.visit_expr(&assoc_reft.body);
326    vis.visit_base_sort(&assoc_reft.output);
327}
328
329pub fn walk_trait_ref<V: Visitor>(vis: &mut V, trait_ref: &TraitRef) {
330    vis.visit_path(&trait_ref.path);
331}
332
333pub fn walk_base_sort<V: Visitor>(vis: &mut V, bsort: &BaseSort) {
334    match bsort {
335        BaseSort::BitVec(_len) => {}
336        BaseSort::Path(path) => vis.visit_sort_path(path),
337        BaseSort::SortOf(qself, path) => {
338            vis.visit_ty(qself);
339            vis.visit_path(path);
340        }
341        BaseSort::Tuple(sorts) => {
342            walk_list!(vis, visit_base_sort, sorts);
343        }
344    }
345}
346
347pub fn walk_sort_path<V: Visitor>(vis: &mut V, path: &SortPath) {
348    walk_list!(vis, visit_ident, path.segments.iter().copied());
349    walk_list!(vis, visit_base_sort, &path.args);
350}
351
352pub fn walk_ty_alias<V: Visitor>(vis: &mut V, ty_alias: &TyAlias) {
353    vis.visit_ident(ty_alias.ident);
354    vis.visit_generics(&ty_alias.generics);
355    walk_list!(vis, visit_refine_param, &ty_alias.params);
356    if let Some(index) = &ty_alias.index {
357        vis.visit_refine_param(index);
358    }
359    vis.visit_ty(&ty_alias.ty);
360}
361pub fn walk_constant<V: Visitor>(vis: &mut V, constant_info: &ConstantInfo) {
362    if let Some(expr) = &constant_info.expr {
363        vis.visit_expr(expr);
364    }
365}
366
367pub fn walk_struct_def<V: Visitor>(vis: &mut V, struct_def: &StructDef) {
368    if let Some(generics) = &struct_def.generics {
369        vis.visit_generics(generics);
370    }
371    if let Some(refined_by) = &struct_def.refined_by {
372        walk_list!(vis, visit_refine_param, refined_by);
373    }
374    walk_list!(vis, visit_expr, &struct_def.invariants);
375    struct_def.fields.iter().flatten().for_each(|field| {
376        vis.visit_ty(field);
377    });
378}
379
380pub fn walk_enum_def<V: Visitor>(vis: &mut V, enum_def: &EnumDef) {
381    if let Some(refined_by) = &enum_def.refined_by {
382        walk_list!(vis, visit_refine_param, refined_by);
383    }
384    walk_list!(vis, visit_expr, &enum_def.invariants);
385    enum_def
386        .variants
387        .iter()
388        .flatten()
389        .for_each(|variant| vis.visit_variant(variant));
390}
391
392pub fn walk_variant<V: Visitor>(vis: &mut V, variant: &VariantDef) {
393    walk_list!(vis, visit_ty, &variant.fields);
394    if let Some(ret) = &variant.ret {
395        vis.visit_variant_ret(ret);
396    }
397}
398
399pub fn walk_fn_trait_ref<V: Visitor>(vis: &mut V, in_arg: &GenericArg, out_arg: &GenericArg) {
400    vis.visit_generic_arg(in_arg);
401    vis.visit_generic_arg(out_arg);
402}
403
404pub fn walk_variant_ret<V: Visitor>(vis: &mut V, ret: &VariantRet) {
405    vis.visit_path(&ret.path);
406    vis.visit_indices(&ret.indices);
407}
408
409pub fn walk_fn_sig<V: Visitor>(vis: &mut V, fn_sig: &FnSig) {
410    vis.visit_async(&fn_sig.asyncness);
411    vis.visit_generics(&fn_sig.generics);
412    walk_list!(vis, visit_refine_param, &fn_sig.params);
413    for requires in &fn_sig.requires {
414        walk_list!(vis, visit_refine_param, &requires.params);
415        vis.visit_expr(&requires.pred);
416    }
417    walk_list!(vis, visit_fn_input, &fn_sig.inputs);
418    if let Some(no_panic_expr) = &fn_sig.no_panic {
419        vis.visit_expr(no_panic_expr);
420    }
421    vis.visit_fn_output(&fn_sig.output);
422}
423
424pub fn walk_fn_output<V: Visitor>(vis: &mut V, fn_output: &FnOutput) {
425    vis.visit_fn_ret_ty(&fn_output.returns);
426    walk_list!(vis, visit_ensures, &fn_output.ensures);
427}
428
429pub fn walk_generics<V: Visitor>(vis: &mut V, generics: &Generics) {
430    walk_list!(vis, visit_generic_param, &generics.params);
431    if let Some(predicates) = &generics.predicates {
432        walk_list!(vis, visit_where_predicate, predicates);
433    }
434}
435
436pub fn walk_fn_input<V: Visitor>(vis: &mut V, arg: &FnInput) {
437    match arg {
438        FnInput::Constr(bind, path, pred, _node_id) => {
439            vis.visit_ident(*bind);
440            vis.visit_path(path);
441            vis.visit_expr(pred);
442        }
443        FnInput::StrgRef(bind, ty, _node_id) => {
444            vis.visit_ident(*bind);
445            vis.visit_ty(ty);
446        }
447        FnInput::Ty(bind, ty, _node_id) => {
448            if let Some(bind) = bind {
449                vis.visit_ident(*bind);
450            }
451            vis.visit_ty(ty);
452        }
453    }
454}
455
456pub fn walk_fn_ret_ty<V: Visitor>(vis: &mut V, fn_ret_ty: &FnRetTy) {
457    match fn_ret_ty {
458        FnRetTy::Default(_span) => {}
459        FnRetTy::Ty(ty) => vis.visit_ty(ty),
460    }
461}
462
463pub fn walk_ensures<V: Visitor>(vis: &mut V, ensures: &Ensures) {
464    match ensures {
465        Ensures::Type(bind, ty, _node_id) => {
466            vis.visit_ident(*bind);
467            vis.visit_ty(ty);
468        }
469        Ensures::Pred(pred) => {
470            vis.visit_expr(pred);
471        }
472    }
473}
474
475pub fn walk_where_predicate<V: Visitor>(vis: &mut V, predicate: &WhereBoundPredicate) {
476    vis.visit_ty(&predicate.bounded_ty);
477    walk_list!(vis, visit_trait_ref, &predicate.bounds);
478}
479
480pub fn walk_generic_arg<V: Visitor>(vis: &mut V, arg: &GenericArg) {
481    match &arg.kind {
482        GenericArgKind::Type(ty) => {
483            vis.visit_ty(ty);
484        }
485        GenericArgKind::Constraint(ident, ty) => {
486            vis.visit_ident(*ident);
487            vis.visit_ty(ty);
488        }
489    }
490}
491
492pub fn walk_refine_arg<V: Visitor>(vis: &mut V, arg: &RefineArg) {
493    match arg {
494        RefineArg::Bind(ident, _kind, _span, _node_id) => {
495            vis.visit_ident(*ident);
496        }
497        RefineArg::Expr(e) => {
498            vis.visit_expr(e);
499        }
500        RefineArg::Abs(params, e, _node_id, _span) => {
501            walk_list!(vis, visit_refine_param, params);
502            vis.visit_expr(e);
503        }
504    }
505}
506
507pub fn walk_indices<V: Visitor>(vis: &mut V, indices: &Indices) {
508    walk_list!(vis, visit_refine_arg, &indices.indices);
509}
510
511pub fn walk_ty<V: Visitor>(vis: &mut V, ty: &Ty) {
512    match &ty.kind {
513        TyKind::Base(bty) => vis.visit_bty(bty),
514        TyKind::Indexed { bty, indices } => {
515            vis.visit_indices(indices);
516            vis.visit_bty(bty);
517        }
518        TyKind::Exists { bind, bty, pred } => {
519            vis.visit_ident(*bind);
520            vis.visit_bty(bty);
521            vis.visit_expr(pred);
522        }
523        TyKind::GeneralExists { params, ty, pred } => {
524            walk_list!(vis, visit_refine_param, params);
525            vis.visit_ty(ty);
526            if let Some(pred) = pred {
527                vis.visit_expr(pred);
528            }
529        }
530        TyKind::Ref(_mutbl, ty) => {
531            vis.visit_ty(ty);
532        }
533        TyKind::Constr(pred, ty) => {
534            vis.visit_expr(pred);
535            vis.visit_ty(ty);
536        }
537        TyKind::Tuple(tys) => {
538            walk_list!(vis, visit_ty, tys);
539        }
540        TyKind::Array(ty, len) => {
541            vis.visit_const_arg(len);
542            vis.visit_ty(ty);
543        }
544        TyKind::ImplTrait(_node_id, trait_ref) => {
545            walk_list!(vis, visit_trait_ref, trait_ref);
546        }
547        TyKind::Hole => {}
548    }
549}
550
551pub fn walk_bty<V: Visitor>(vis: &mut V, bty: &BaseTy) {
552    match &bty.kind {
553        BaseTyKind::Path(qself, path) => {
554            if let Some(qself) = qself {
555                vis.visit_ty(qself);
556            }
557            vis.visit_path(path);
558        }
559        BaseTyKind::Slice(ty) => vis.visit_ty(ty),
560        BaseTyKind::Ptr(_, ty) => vis.visit_ty(ty),
561    }
562}
563
564pub fn walk_path<V: Visitor>(vis: &mut V, path: &Path) {
565    walk_list!(vis, visit_path_segment, &path.segments);
566    walk_list!(vis, visit_refine_arg, &path.refine);
567}
568
569pub fn walk_path_segment<V: Visitor>(vis: &mut V, segment: &PathSegment) {
570    vis.visit_ident(segment.ident);
571    walk_list!(vis, visit_generic_arg, &segment.args);
572}
573
574pub fn walk_field_expr<V: Visitor>(vis: &mut V, expr: &FieldExpr) {
575    vis.visit_ident(expr.ident);
576    vis.visit_expr(&expr.expr);
577}
578
579pub fn walk_expr<V: Visitor>(vis: &mut V, expr: &Expr) {
580    match &expr.kind {
581        ExprKind::Path(qpath) => vis.visit_path_expr(qpath),
582        ExprKind::Dot(base, fld) => {
583            vis.visit_expr(base);
584            vis.visit_ident(*fld);
585        }
586        ExprKind::Literal(lit) => {
587            vis.visit_literal(*lit);
588        }
589        ExprKind::BinaryOp(_bin_op, box exprs) => {
590            walk_list!(vis, visit_expr, exprs);
591        }
592        ExprKind::UnaryOp(_un_op, e) => {
593            vis.visit_expr(e);
594        }
595        ExprKind::PrimUIF(_) => {}
596        ExprKind::Call(callee, args) => {
597            vis.visit_expr(callee);
598            walk_list!(vis, visit_expr, args);
599        }
600        ExprKind::AssocReft(qself, path, name) => {
601            vis.visit_ty(qself);
602            vis.visit_path(path);
603            vis.visit_ident(*name);
604        }
605        ExprKind::IfThenElse(box exprs) => {
606            walk_list!(vis, visit_expr, exprs);
607        }
608        ExprKind::Constructor(path, exprs) => {
609            if let Some(path) = path {
610                vis.visit_path_expr(path);
611            }
612            walk_list!(vis, visit_constructor_args, exprs);
613        }
614        ExprKind::BoundedQuant(_, i, _, e) => {
615            vis.visit_refine_param(i);
616            vis.visit_expr(e);
617        }
618        ExprKind::Block(decls, body) => {
619            for decl in decls {
620                // the order here is important because the parameter is not in scope
621                // in the initializer
622                vis.visit_expr(&decl.init);
623                vis.visit_refine_param(&decl.param);
624            }
625            vis.visit_expr(body);
626        }
627        ExprKind::SetLiteral(exprs) => {
628            walk_list!(vis, visit_expr, exprs);
629        }
630        ExprKind::Tuple(exprs) => {
631            walk_list!(vis, visit_expr, exprs);
632        }
633    }
634}
635
636pub fn walk_path_expr<V: Visitor>(vis: &mut V, qpath: &ExprPath) {
637    walk_list!(vis, visit_path_expr_segment, &qpath.segments);
638}
639
640pub fn walk_path_expr_segment<V: Visitor>(vis: &mut V, segment: &ExprPathSegment) {
641    vis.visit_ident(segment.ident);
642}
flux_syntax/surface/visit.rs

flux_syntax/surface/
visit.rs
