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::TyAlias(ty_alias) => vis.visit_ty_alias(ty_alias),
282        ItemKind::Mod => {}
283    }
284}
285
286pub fn walk_trait_item<V: Visitor>(vis: &mut V, item: &TraitItemFn) {
287    if let Some(fn_sig) = item.sig.as_ref() {
288        vis.visit_fn_sig(fn_sig);
289    }
290}
291
292pub fn walk_impl_item<V: Visitor>(vis: &mut V, item: &ImplItemFn) {
293    if let Some(fn_sig) = item.sig.as_ref() {
294        vis.visit_fn_sig(fn_sig);
295    }
296}
297
298pub fn walk_trait<V: Visitor>(vis: &mut V, trait_: &Trait) {
299    if let Some(generics) = &trait_.generics {
300        vis.visit_generics(generics);
301    }
302    walk_list!(vis, visit_trait_assoc_reft, &trait_.assoc_refinements);
303}
304
305pub fn walk_trait_assoc_reft<V: Visitor>(vis: &mut V, assoc_reft: &TraitAssocReft) {
306    vis.visit_ident(assoc_reft.name);
307    walk_list!(vis, visit_refine_param, &assoc_reft.params);
308    vis.visit_base_sort(&assoc_reft.output);
309    if let Some(expr) = &assoc_reft.body {
310        vis.visit_expr(expr);
311    }
312}
313
314pub fn walk_impl<V: Visitor>(vis: &mut V, impl_: &Impl) {
315    if let Some(generics) = &impl_.generics {
316        vis.visit_generics(generics);
317    }
318    walk_list!(vis, visit_impl_assoc_reft, &impl_.assoc_refinements);
319}
320
321pub fn walk_impl_assoc_reft<V: Visitor>(vis: &mut V, assoc_reft: &ImplAssocReft) {
322    vis.visit_ident(assoc_reft.name);
323    walk_list!(vis, visit_refine_param, &assoc_reft.params);
324    vis.visit_expr(&assoc_reft.body);
325    vis.visit_base_sort(&assoc_reft.output);
326}
327
328pub fn walk_trait_ref<V: Visitor>(vis: &mut V, trait_ref: &TraitRef) {
329    vis.visit_path(&trait_ref.path);
330}
331
332pub fn walk_base_sort<V: Visitor>(vis: &mut V, bsort: &BaseSort) {
333    match bsort {
334        BaseSort::BitVec(_len) => {}
335        BaseSort::Path(path) => vis.visit_sort_path(path),
336        BaseSort::SortOf(qself, path) => {
337            vis.visit_ty(qself);
338            vis.visit_path(path);
339        }
340    }
341}
342
343pub fn walk_sort_path<V: Visitor>(vis: &mut V, path: &SortPath) {
344    walk_list!(vis, visit_ident, path.segments.iter().copied());
345    walk_list!(vis, visit_base_sort, &path.args);
346}
347
348pub fn walk_ty_alias<V: Visitor>(vis: &mut V, ty_alias: &TyAlias) {
349    vis.visit_ident(ty_alias.ident);
350    vis.visit_generics(&ty_alias.generics);
351    walk_list!(vis, visit_refine_param, &ty_alias.params);
352    if let Some(index) = &ty_alias.index {
353        vis.visit_refine_param(index);
354    }
355    vis.visit_ty(&ty_alias.ty);
356}
357pub fn walk_constant<V: Visitor>(vis: &mut V, constant_info: &ConstantInfo) {
358    if let Some(expr) = &constant_info.expr {
359        vis.visit_expr(expr);
360    }
361}
362
363pub fn walk_struct_def<V: Visitor>(vis: &mut V, struct_def: &StructDef) {
364    if let Some(generics) = &struct_def.generics {
365        vis.visit_generics(generics);
366    }
367    if let Some(refined_by) = &struct_def.refined_by {
368        walk_list!(vis, visit_refine_param, refined_by);
369    }
370    walk_list!(vis, visit_expr, &struct_def.invariants);
371    struct_def.fields.iter().flatten().for_each(|field| {
372        vis.visit_ty(field);
373    });
374}
375
376pub fn walk_enum_def<V: Visitor>(vis: &mut V, enum_def: &EnumDef) {
377    if let Some(refined_by) = &enum_def.refined_by {
378        walk_list!(vis, visit_refine_param, refined_by);
379    }
380    walk_list!(vis, visit_expr, &enum_def.invariants);
381    enum_def
382        .variants
383        .iter()
384        .flatten()
385        .for_each(|variant| vis.visit_variant(variant));
386}
387
388pub fn walk_variant<V: Visitor>(vis: &mut V, variant: &VariantDef) {
389    walk_list!(vis, visit_ty, &variant.fields);
390    if let Some(ret) = &variant.ret {
391        vis.visit_variant_ret(ret);
392    }
393}
394
395pub fn walk_fn_trait_ref<V: Visitor>(vis: &mut V, in_arg: &GenericArg, out_arg: &GenericArg) {
396    vis.visit_generic_arg(in_arg);
397    vis.visit_generic_arg(out_arg);
398}
399
400pub fn walk_variant_ret<V: Visitor>(vis: &mut V, ret: &VariantRet) {
401    vis.visit_path(&ret.path);
402    vis.visit_indices(&ret.indices);
403}
404
405pub fn walk_fn_sig<V: Visitor>(vis: &mut V, fn_sig: &FnSig) {
406    vis.visit_async(&fn_sig.asyncness);
407    vis.visit_generics(&fn_sig.generics);
408    walk_list!(vis, visit_refine_param, &fn_sig.params);
409    for requires in &fn_sig.requires {
410        walk_list!(vis, visit_refine_param, &requires.params);
411        vis.visit_expr(&requires.pred);
412    }
413    walk_list!(vis, visit_fn_input, &fn_sig.inputs);
414    vis.visit_fn_output(&fn_sig.output);
415}
416
417pub fn walk_fn_output<V: Visitor>(vis: &mut V, fn_output: &FnOutput) {
418    vis.visit_fn_ret_ty(&fn_output.returns);
419    walk_list!(vis, visit_ensures, &fn_output.ensures);
420}
421
422pub fn walk_generics<V: Visitor>(vis: &mut V, generics: &Generics) {
423    walk_list!(vis, visit_generic_param, &generics.params);
424    if let Some(predicates) = &generics.predicates {
425        walk_list!(vis, visit_where_predicate, predicates);
426    }
427}
428
429pub fn walk_fn_input<V: Visitor>(vis: &mut V, arg: &FnInput) {
430    match arg {
431        FnInput::Constr(bind, path, pred, _node_id) => {
432            vis.visit_ident(*bind);
433            vis.visit_path(path);
434            vis.visit_expr(pred);
435        }
436        FnInput::StrgRef(bind, ty, _node_id) => {
437            vis.visit_ident(*bind);
438            vis.visit_ty(ty);
439        }
440        FnInput::Ty(bind, ty, _node_id) => {
441            if let Some(bind) = bind {
442                vis.visit_ident(*bind);
443            }
444            vis.visit_ty(ty);
445        }
446    }
447}
448
449pub fn walk_fn_ret_ty<V: Visitor>(vis: &mut V, fn_ret_ty: &FnRetTy) {
450    match fn_ret_ty {
451        FnRetTy::Default(_span) => {}
452        FnRetTy::Ty(ty) => vis.visit_ty(ty),
453    }
454}
455
456pub fn walk_ensures<V: Visitor>(vis: &mut V, ensures: &Ensures) {
457    match ensures {
458        Ensures::Type(bind, ty, _node_id) => {
459            vis.visit_ident(*bind);
460            vis.visit_ty(ty);
461        }
462        Ensures::Pred(pred) => {
463            vis.visit_expr(pred);
464        }
465    }
466}
467
468pub fn walk_where_predicate<V: Visitor>(vis: &mut V, predicate: &WhereBoundPredicate) {
469    vis.visit_ty(&predicate.bounded_ty);
470    walk_list!(vis, visit_trait_ref, &predicate.bounds);
471}
472
473pub fn walk_generic_arg<V: Visitor>(vis: &mut V, arg: &GenericArg) {
474    match &arg.kind {
475        GenericArgKind::Type(ty) => {
476            vis.visit_ty(ty);
477        }
478        GenericArgKind::Constraint(ident, ty) => {
479            vis.visit_ident(*ident);
480            vis.visit_ty(ty);
481        }
482    }
483}
484
485pub fn walk_refine_arg<V: Visitor>(vis: &mut V, arg: &RefineArg) {
486    match arg {
487        RefineArg::Bind(ident, _kind, _span, _node_id) => {
488            vis.visit_ident(*ident);
489        }
490        RefineArg::Expr(e) => {
491            vis.visit_expr(e);
492        }
493        RefineArg::Abs(params, e, _node_id, _span) => {
494            walk_list!(vis, visit_refine_param, params);
495            vis.visit_expr(e);
496        }
497    }
498}
499
500pub fn walk_indices<V: Visitor>(vis: &mut V, indices: &Indices) {
501    walk_list!(vis, visit_refine_arg, &indices.indices);
502}
503
504pub fn walk_ty<V: Visitor>(vis: &mut V, ty: &Ty) {
505    match &ty.kind {
506        TyKind::Base(bty) => vis.visit_bty(bty),
507        TyKind::Indexed { bty, indices } => {
508            vis.visit_indices(indices);
509            vis.visit_bty(bty);
510        }
511        TyKind::Exists { bind, bty, pred } => {
512            vis.visit_ident(*bind);
513            vis.visit_bty(bty);
514            vis.visit_expr(pred);
515        }
516        TyKind::GeneralExists { params, ty, pred } => {
517            walk_list!(vis, visit_refine_param, params);
518            vis.visit_ty(ty);
519            if let Some(pred) = pred {
520                vis.visit_expr(pred);
521            }
522        }
523        TyKind::Ref(_mutbl, ty) => {
524            vis.visit_ty(ty);
525        }
526        TyKind::Constr(pred, ty) => {
527            vis.visit_expr(pred);
528            vis.visit_ty(ty);
529        }
530        TyKind::Tuple(tys) => {
531            walk_list!(vis, visit_ty, tys);
532        }
533        TyKind::Array(ty, len) => {
534            vis.visit_const_arg(len);
535            vis.visit_ty(ty);
536        }
537        TyKind::ImplTrait(_node_id, trait_ref) => {
538            walk_list!(vis, visit_trait_ref, trait_ref);
539        }
540        TyKind::Hole => {}
541    }
542}
543
544pub fn walk_bty<V: Visitor>(vis: &mut V, bty: &BaseTy) {
545    match &bty.kind {
546        BaseTyKind::Path(qself, path) => {
547            if let Some(qself) = qself {
548                vis.visit_ty(qself);
549            }
550            vis.visit_path(path);
551        }
552        BaseTyKind::Slice(ty) => vis.visit_ty(ty),
553    }
554}
555
556pub fn walk_path<V: Visitor>(vis: &mut V, path: &Path) {
557    walk_list!(vis, visit_path_segment, &path.segments);
558    walk_list!(vis, visit_refine_arg, &path.refine);
559}
560
561pub fn walk_path_segment<V: Visitor>(vis: &mut V, segment: &PathSegment) {
562    vis.visit_ident(segment.ident);
563    walk_list!(vis, visit_generic_arg, &segment.args);
564}
565
566pub fn walk_field_expr<V: Visitor>(vis: &mut V, expr: &FieldExpr) {
567    vis.visit_ident(expr.ident);
568    vis.visit_expr(&expr.expr);
569}
570
571pub fn walk_expr<V: Visitor>(vis: &mut V, expr: &Expr) {
572    match &expr.kind {
573        ExprKind::Path(qpath) => vis.visit_path_expr(qpath),
574        ExprKind::Dot(base, fld) => {
575            vis.visit_expr(base);
576            vis.visit_ident(*fld);
577        }
578        ExprKind::Literal(lit) => {
579            vis.visit_literal(*lit);
580        }
581        ExprKind::BinaryOp(_bin_op, box exprs) => {
582            walk_list!(vis, visit_expr, exprs);
583        }
584        ExprKind::UnaryOp(_un_op, e) => {
585            vis.visit_expr(e);
586        }
587        ExprKind::PrimUIF(_) => {}
588        ExprKind::Call(callee, args) => {
589            vis.visit_expr(callee);
590            walk_list!(vis, visit_expr, args);
591        }
592        ExprKind::AssocReft(qself, path, name) => {
593            vis.visit_ty(qself);
594            vis.visit_path(path);
595            vis.visit_ident(*name);
596        }
597        ExprKind::IfThenElse(box exprs) => {
598            walk_list!(vis, visit_expr, exprs);
599        }
600        ExprKind::Constructor(path, exprs) => {
601            if let Some(path) = path {
602                vis.visit_path_expr(path);
603            }
604            walk_list!(vis, visit_constructor_args, exprs);
605        }
606        ExprKind::BoundedQuant(_, i, _, e) => {
607            vis.visit_refine_param(i);
608            vis.visit_expr(e);
609        }
610        ExprKind::Block(decls, body) => {
611            for decl in decls {
612                // the order here is important because the parameter is not in scope
613                // in the initializer
614                vis.visit_expr(&decl.init);
615                vis.visit_refine_param(&decl.param);
616            }
617            vis.visit_expr(body);
618        }
619    }
620}
621
622pub fn walk_path_expr<V: Visitor>(vis: &mut V, qpath: &ExprPath) {
623    walk_list!(vis, visit_path_expr_segment, &qpath.segments);
624}
625
626pub fn walk_path_expr_segment<V: Visitor>(vis: &mut V, segment: &ExprPathSegment) {
627    vis.visit_ident(segment.ident);
628}
flux_syntax/surface/visit.rs

flux_syntax/surface/
visit.rs
