Trait ZipAst 

pub trait ZipAst: Visitor<Break: Default> + Sized {
    // Provided methods
    fn visit<'a, T: AstVisitable>(
        &'a mut self,
        x: &T,
        y: &T,
    ) -> ControlFlow<Self::Break> { ... }
    fn visit_by_val<T: AstVisitable>(
        self,
        x: &T,
        y: &T,
    ) -> ControlFlow<Self::Break, Self> { ... }
    fn visit_inner<T>(&mut self, x: &T, y: &T) -> ControlFlow<Self::Break>
       where T: AstVisitable + for<'s> DriveTwo<'s, AstVisitableWrapper<Self>> { ... }
    fn visit_de_bruijn_id(
        &mut self,
        x: &DeBruijnId,
        y: &DeBruijnId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_de_bruijn_id(&mut self, x: &DeBruijnId, y: &DeBruijnId) { ... }
    fn exit_de_bruijn_id(&mut self, x: &DeBruijnId, y: &DeBruijnId) { ... }
    fn visit_ty(&mut self, x: &Ty, y: &Ty) -> ControlFlow<Self::Break> { ... }
    fn enter_ty(&mut self, x: &Ty, y: &Ty) { ... }
    fn exit_ty(&mut self, x: &Ty, y: &Ty) { ... }
    fn visit_ty_kind(
        &mut self,
        x: &TyKind,
        y: &TyKind,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_ty_kind(&mut self, x: &TyKind, y: &TyKind) { ... }
    fn exit_ty_kind(&mut self, x: &TyKind, y: &TyKind) { ... }
    fn visit_region(
        &mut self,
        x: &Region,
        y: &Region,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_region(&mut self, x: &Region, y: &Region) { ... }
    fn exit_region(&mut self, x: &Region, y: &Region) { ... }
    fn visit_trait_ref(
        &mut self,
        x: &TraitRef,
        y: &TraitRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_ref(&mut self, x: &TraitRef, y: &TraitRef) { ... }
    fn exit_trait_ref(&mut self, x: &TraitRef, y: &TraitRef) { ... }
    fn visit_trait_ref_contents(
        &mut self,
        x: &TraitRefContents,
        y: &TraitRefContents,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_ref_contents(
        &mut self,
        x: &TraitRefContents,
        y: &TraitRefContents,
    ) { ... }
    fn exit_trait_ref_contents(
        &mut self,
        x: &TraitRefContents,
        y: &TraitRefContents,
    ) { ... }
    fn visit_trait_ref_kind(
        &mut self,
        x: &TraitRefKind,
        y: &TraitRefKind,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_ref_kind(&mut self, x: &TraitRefKind, y: &TraitRefKind) { ... }
    fn exit_trait_ref_kind(&mut self, x: &TraitRefKind, y: &TraitRefKind) { ... }
    fn visit_type_decl_ref(
        &mut self,
        x: &TypeDeclRef,
        y: &TypeDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_type_decl_ref(&mut self, x: &TypeDeclRef, y: &TypeDeclRef) { ... }
    fn exit_type_decl_ref(&mut self, x: &TypeDeclRef, y: &TypeDeclRef) { ... }
    fn visit_fun_decl_ref(
        &mut self,
        x: &FunDeclRef,
        y: &FunDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_fun_decl_ref(&mut self, x: &FunDeclRef, y: &FunDeclRef) { ... }
    fn exit_fun_decl_ref(&mut self, x: &FunDeclRef, y: &FunDeclRef) { ... }
    fn visit_global_decl_ref(
        &mut self,
        x: &GlobalDeclRef,
        y: &GlobalDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_global_decl_ref(&mut self, x: &GlobalDeclRef, y: &GlobalDeclRef) { ... }
    fn exit_global_decl_ref(&mut self, x: &GlobalDeclRef, y: &GlobalDeclRef) { ... }
    fn visit_trait_decl_ref(
        &mut self,
        x: &TraitDeclRef,
        y: &TraitDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_decl_ref(&mut self, x: &TraitDeclRef, y: &TraitDeclRef) { ... }
    fn exit_trait_decl_ref(&mut self, x: &TraitDeclRef, y: &TraitDeclRef) { ... }
    fn visit_trait_impl_ref(
        &mut self,
        x: &TraitImplRef,
        y: &TraitImplRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_impl_ref(&mut self, x: &TraitImplRef, y: &TraitImplRef) { ... }
    fn exit_trait_impl_ref(&mut self, x: &TraitImplRef, y: &TraitImplRef) { ... }
    fn visit_impl_elem(
        &mut self,
        x: &ImplElem,
        y: &ImplElem,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_impl_elem(&mut self, x: &ImplElem, y: &ImplElem) { ... }
    fn exit_impl_elem(&mut self, x: &ImplElem, y: &ImplElem) { ... }
    fn visit_generic_args(
        &mut self,
        x: &GenericArgs,
        y: &GenericArgs,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_generic_args(&mut self, x: &GenericArgs, y: &GenericArgs) { ... }
    fn exit_generic_args(&mut self, x: &GenericArgs, y: &GenericArgs) { ... }
    fn visit_generic_params(
        &mut self,
        x: &GenericParams,
        y: &GenericParams,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_generic_params(&mut self, x: &GenericParams, y: &GenericParams) { ... }
    fn exit_generic_params(&mut self, x: &GenericParams, y: &GenericParams) { ... }
    fn visit_trait_param(
        &mut self,
        x: &TraitParam,
        y: &TraitParam,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_param(&mut self, x: &TraitParam, y: &TraitParam) { ... }
    fn exit_trait_param(&mut self, x: &TraitParam, y: &TraitParam) { ... }
    fn visit_trait_clause_id(
        &mut self,
        x: &TraitClauseId,
        y: &TraitClauseId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_clause_id(&mut self, x: &TraitClauseId, y: &TraitClauseId) { ... }
    fn exit_trait_clause_id(&mut self, x: &TraitClauseId, y: &TraitClauseId) { ... }
    fn visit_trait_type_constraint(
        &mut self,
        x: &TraitTypeConstraint,
        y: &TraitTypeConstraint,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_type_constraint(
        &mut self,
        x: &TraitTypeConstraint,
        y: &TraitTypeConstraint,
    ) { ... }
    fn exit_trait_type_constraint(
        &mut self,
        x: &TraitTypeConstraint,
        y: &TraitTypeConstraint,
    ) { ... }
    fn visit_place(&mut self, x: &Place, y: &Place) -> ControlFlow<Self::Break> { ... }
    fn enter_place(&mut self, x: &Place, y: &Place) { ... }
    fn exit_place(&mut self, x: &Place, y: &Place) { ... }
    fn visit_rvalue(
        &mut self,
        x: &Rvalue,
        y: &Rvalue,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_rvalue(&mut self, x: &Rvalue, y: &Rvalue) { ... }
    fn exit_rvalue(&mut self, x: &Rvalue, y: &Rvalue) { ... }
    fn visit_body(&mut self, x: &Body, y: &Body) -> ControlFlow<Self::Break> { ... }
    fn enter_body(&mut self, x: &Body, y: &Body) { ... }
    fn exit_body(&mut self, x: &Body, y: &Body) { ... }
    fn visit_de_bruijn_var<T: AstVisitable + Idx>(
        &mut self,
        x: &DeBruijnVar<T>,
        y: &DeBruijnVar<T>,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_de_bruijn_var<T: AstVisitable + Idx>(
        &mut self,
        x: &DeBruijnVar<T>,
        y: &DeBruijnVar<T>,
    ) { ... }
    fn exit_de_bruijn_var<T: AstVisitable + Idx>(
        &mut self,
        x: &DeBruijnVar<T>,
        y: &DeBruijnVar<T>,
    ) { ... }
    fn visit_region_binder<T: AstVisitable>(
        &mut self,
        x: &RegionBinder<T>,
        y: &RegionBinder<T>,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_region_binder<T: AstVisitable>(
        &mut self,
        x: &RegionBinder<T>,
        y: &RegionBinder<T>,
    ) { ... }
    fn exit_region_binder<T: AstVisitable>(
        &mut self,
        x: &RegionBinder<T>,
        y: &RegionBinder<T>,
    ) { ... }
    fn visit_binder<T: AstVisitable>(
        &mut self,
        x: &Binder<T>,
        y: &Binder<T>,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_binder<T: AstVisitable>(&mut self, x: &Binder<T>, y: &Binder<T>) { ... }
    fn exit_binder<T: AstVisitable>(&mut self, x: &Binder<T>, y: &Binder<T>) { ... }
    fn visit_llbc_block(
        &mut self,
        x: &Block,
        y: &Block,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_llbc_block(&mut self, x: &Block, y: &Block) { ... }
    fn exit_llbc_block(&mut self, x: &Block, y: &Block) { ... }
    fn visit_llbc_statement(
        &mut self,
        x: &Statement,
        y: &Statement,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_llbc_statement(&mut self, x: &Statement, y: &Statement) { ... }
    fn exit_llbc_statement(&mut self, x: &Statement, y: &Statement) { ... }
    fn visit_ullbc_statement(
        &mut self,
        x: &Statement,
        y: &Statement,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_ullbc_statement(&mut self, x: &Statement, y: &Statement) { ... }
    fn exit_ullbc_statement(&mut self, x: &Statement, y: &Statement) { ... }
    fn visit_ullbc_terminator(
        &mut self,
        x: &Terminator,
        y: &Terminator,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_ullbc_terminator(&mut self, x: &Terminator, y: &Terminator) { ... }
    fn exit_ullbc_terminator(&mut self, x: &Terminator, y: &Terminator) { ... }
    fn visit_abort_kind(
        &mut self,
        x: &AbortKind,
        y: &AbortKind,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_abort_kind(&mut self, x: &AbortKind, y: &AbortKind) { ... }
    fn exit_abort_kind(&mut self, x: &AbortKind, y: &AbortKind) { ... }
    fn visit_aggregate_kind(
        &mut self,
        x: &AggregateKind,
        y: &AggregateKind,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_aggregate_kind(&mut self, x: &AggregateKind, y: &AggregateKind) { ... }
    fn exit_aggregate_kind(&mut self, x: &AggregateKind, y: &AggregateKind) { ... }
    fn visit_fn_ptr(&mut self, x: &FnPtr, y: &FnPtr) -> ControlFlow<Self::Break> { ... }
    fn enter_fn_ptr(&mut self, x: &FnPtr, y: &FnPtr) { ... }
    fn exit_fn_ptr(&mut self, x: &FnPtr, y: &FnPtr) { ... }
    fn visit_item_source(
        &mut self,
        x: &ItemSource,
        y: &ItemSource,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_item_source(&mut self, x: &ItemSource, y: &ItemSource) { ... }
    fn exit_item_source(&mut self, x: &ItemSource, y: &ItemSource) { ... }
    fn visit_item_meta(
        &mut self,
        x: &ItemMeta,
        y: &ItemMeta,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_item_meta(&mut self, x: &ItemMeta, y: &ItemMeta) { ... }
    fn exit_item_meta(&mut self, x: &ItemMeta, y: &ItemMeta) { ... }
    fn visit_name(&mut self, x: &Name, y: &Name) -> ControlFlow<Self::Break> { ... }
    fn enter_name(&mut self, x: &Name, y: &Name) { ... }
    fn exit_name(&mut self, x: &Name, y: &Name) { ... }
    fn visit_span(&mut self, x: &Span, y: &Span) -> ControlFlow<Self::Break> { ... }
    fn enter_span(&mut self, x: &Span, y: &Span) { ... }
    fn exit_span(&mut self, x: &Span, y: &Span) { ... }
    fn visit_constant_expr(
        &mut self,
        x: &ConstantExpr,
        y: &ConstantExpr,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_constant_expr(&mut self, x: &ConstantExpr, y: &ConstantExpr) { ... }
    fn exit_constant_expr(&mut self, x: &ConstantExpr, y: &ConstantExpr) { ... }
    fn visit_projection_elem(
        &mut self,
        x: &ProjectionElem,
        y: &ProjectionElem,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_projection_elem(&mut self, x: &ProjectionElem, y: &ProjectionElem) { ... }
    fn exit_projection_elem(&mut self, x: &ProjectionElem, y: &ProjectionElem) { ... }
    fn visit_fun_decl_id(
        &mut self,
        x: &FunDeclId,
        y: &FunDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_fun_decl_id(&mut self, x: &FunDeclId, y: &FunDeclId) { ... }
    fn exit_fun_decl_id(&mut self, x: &FunDeclId, y: &FunDeclId) { ... }
    fn visit_global_decl_id(
        &mut self,
        x: &GlobalDeclId,
        y: &GlobalDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_global_decl_id(&mut self, x: &GlobalDeclId, y: &GlobalDeclId) { ... }
    fn exit_global_decl_id(&mut self, x: &GlobalDeclId, y: &GlobalDeclId) { ... }
    fn visit_type_decl_id(
        &mut self,
        x: &TypeDeclId,
        y: &TypeDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_type_decl_id(&mut self, x: &TypeDeclId, y: &TypeDeclId) { ... }
    fn exit_type_decl_id(&mut self, x: &TypeDeclId, y: &TypeDeclId) { ... }
    fn visit_trait_decl_id(
        &mut self,
        x: &TraitDeclId,
        y: &TraitDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_decl_id(&mut self, x: &TraitDeclId, y: &TraitDeclId) { ... }
    fn exit_trait_decl_id(&mut self, x: &TraitDeclId, y: &TraitDeclId) { ... }
    fn visit_trait_impl_id(
        &mut self,
        x: &TraitImplId,
        y: &TraitImplId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_impl_id(&mut self, x: &TraitImplId, y: &TraitImplId) { ... }
    fn exit_trait_impl_id(&mut self, x: &TraitImplId, y: &TraitImplId) { ... }
    fn visit_file_id(
        &mut self,
        x: &FileId,
        y: &FileId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_file_id(&mut self, x: &FileId, y: &FileId) { ... }
    fn exit_file_id(&mut self, x: &FileId, y: &FileId) { ... }
    fn visit_fun_decl(
        &mut self,
        x: &FunDecl,
        y: &FunDecl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_fun_decl(&mut self, x: &FunDecl, y: &FunDecl) { ... }
    fn exit_fun_decl(&mut self, x: &FunDecl, y: &FunDecl) { ... }
    fn visit_global_decl(
        &mut self,
        x: &GlobalDecl,
        y: &GlobalDecl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_global_decl(&mut self, x: &GlobalDecl, y: &GlobalDecl) { ... }
    fn exit_global_decl(&mut self, x: &GlobalDecl, y: &GlobalDecl) { ... }
    fn visit_type_decl(
        &mut self,
        x: &TypeDecl,
        y: &TypeDecl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_type_decl(&mut self, x: &TypeDecl, y: &TypeDecl) { ... }
    fn exit_type_decl(&mut self, x: &TypeDecl, y: &TypeDecl) { ... }
    fn visit_trait_decl(
        &mut self,
        x: &TraitDecl,
        y: &TraitDecl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_decl(&mut self, x: &TraitDecl, y: &TraitDecl) { ... }
    fn exit_trait_decl(&mut self, x: &TraitDecl, y: &TraitDecl) { ... }
    fn visit_trait_impl(
        &mut self,
        x: &TraitImpl,
        y: &TraitImpl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_impl(&mut self, x: &TraitImpl, y: &TraitImpl) { ... }
    fn exit_trait_impl(&mut self, x: &TraitImpl, y: &TraitImpl) { ... }
}

Provided Methods

fn visit<'a, T: AstVisitable>( &'a mut self, x: &T, y: &T, ) -> ControlFlow<Self::Break>

Visit a visitable type. This calls the appropriate method of this trait on x (visit_$ty if it exists, visit_inner if not).

fn visit_by_val<T: AstVisitable>( self, x: &T, y: &T, ) -> ControlFlow<Self::Break, Self>

Convenience alias for method chaining.

fn visit_inner<T>(&mut self, x: &T, y: &T) -> ControlFlow<Self::Break>

where T: AstVisitable + for<'s> DriveTwo<'s, AstVisitableWrapper<Self>>,

Visit the contents of x. This calls self.visit() on each field of T. This is available for any type whose contents are all #trait_name.

fn visit_de_bruijn_id( &mut self, x: &DeBruijnId, y: &DeBruijnId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_de_bruijn_id(&mut self, x: &DeBruijnId, y: &DeBruijnId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_de_bruijn_id(&mut self, x: &DeBruijnId, y: &DeBruijnId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_ty(&mut self, x: &Ty, y: &Ty) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_ty(&mut self, x: &Ty, y: &Ty)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_ty(&mut self, x: &Ty, y: &Ty)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_ty_kind(&mut self, x: &TyKind, y: &TyKind) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_ty_kind(&mut self, x: &TyKind, y: &TyKind)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_ty_kind(&mut self, x: &TyKind, y: &TyKind)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_region(&mut self, x: &Region, y: &Region) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_region(&mut self, x: &Region, y: &Region)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_region(&mut self, x: &Region, y: &Region)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_ref( &mut self, x: &TraitRef, y: &TraitRef, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_ref(&mut self, x: &TraitRef, y: &TraitRef)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_ref(&mut self, x: &TraitRef, y: &TraitRef)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_ref_contents( &mut self, x: &TraitRefContents, y: &TraitRefContents, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_ref_contents( &mut self, x: &TraitRefContents, y: &TraitRefContents, )

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_ref_contents( &mut self, x: &TraitRefContents, y: &TraitRefContents, )

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_ref_kind( &mut self, x: &TraitRefKind, y: &TraitRefKind, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_ref_kind(&mut self, x: &TraitRefKind, y: &TraitRefKind)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_ref_kind(&mut self, x: &TraitRefKind, y: &TraitRefKind)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_type_decl_ref( &mut self, x: &TypeDeclRef, y: &TypeDeclRef, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_type_decl_ref(&mut self, x: &TypeDeclRef, y: &TypeDeclRef)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_type_decl_ref(&mut self, x: &TypeDeclRef, y: &TypeDeclRef)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_fun_decl_ref( &mut self, x: &FunDeclRef, y: &FunDeclRef, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_fun_decl_ref(&mut self, x: &FunDeclRef, y: &FunDeclRef)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_fun_decl_ref(&mut self, x: &FunDeclRef, y: &FunDeclRef)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_global_decl_ref( &mut self, x: &GlobalDeclRef, y: &GlobalDeclRef, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_global_decl_ref(&mut self, x: &GlobalDeclRef, y: &GlobalDeclRef)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_global_decl_ref(&mut self, x: &GlobalDeclRef, y: &GlobalDeclRef)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_decl_ref( &mut self, x: &TraitDeclRef, y: &TraitDeclRef, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_decl_ref(&mut self, x: &TraitDeclRef, y: &TraitDeclRef)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_decl_ref(&mut self, x: &TraitDeclRef, y: &TraitDeclRef)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_impl_ref( &mut self, x: &TraitImplRef, y: &TraitImplRef, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_impl_ref(&mut self, x: &TraitImplRef, y: &TraitImplRef)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_impl_ref(&mut self, x: &TraitImplRef, y: &TraitImplRef)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_impl_elem( &mut self, x: &ImplElem, y: &ImplElem, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_impl_elem(&mut self, x: &ImplElem, y: &ImplElem)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_impl_elem(&mut self, x: &ImplElem, y: &ImplElem)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_generic_args( &mut self, x: &GenericArgs, y: &GenericArgs, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_generic_args(&mut self, x: &GenericArgs, y: &GenericArgs)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_generic_args(&mut self, x: &GenericArgs, y: &GenericArgs)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_generic_params( &mut self, x: &GenericParams, y: &GenericParams, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_generic_params(&mut self, x: &GenericParams, y: &GenericParams)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_generic_params(&mut self, x: &GenericParams, y: &GenericParams)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_param( &mut self, x: &TraitParam, y: &TraitParam, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_param(&mut self, x: &TraitParam, y: &TraitParam)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_param(&mut self, x: &TraitParam, y: &TraitParam)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_clause_id( &mut self, x: &TraitClauseId, y: &TraitClauseId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_clause_id(&mut self, x: &TraitClauseId, y: &TraitClauseId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_clause_id(&mut self, x: &TraitClauseId, y: &TraitClauseId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_type_constraint( &mut self, x: &TraitTypeConstraint, y: &TraitTypeConstraint, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_type_constraint( &mut self, x: &TraitTypeConstraint, y: &TraitTypeConstraint, )

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_type_constraint( &mut self, x: &TraitTypeConstraint, y: &TraitTypeConstraint, )

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_place(&mut self, x: &Place, y: &Place) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_place(&mut self, x: &Place, y: &Place)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_place(&mut self, x: &Place, y: &Place)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_rvalue(&mut self, x: &Rvalue, y: &Rvalue) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_rvalue(&mut self, x: &Rvalue, y: &Rvalue)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_rvalue(&mut self, x: &Rvalue, y: &Rvalue)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_body(&mut self, x: &Body, y: &Body) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_body(&mut self, x: &Body, y: &Body)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_body(&mut self, x: &Body, y: &Body)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_de_bruijn_var<T: AstVisitable + Idx>( &mut self, x: &DeBruijnVar<T>, y: &DeBruijnVar<T>, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_de_bruijn_var<T: AstVisitable + Idx>( &mut self, x: &DeBruijnVar<T>, y: &DeBruijnVar<T>, )

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_de_bruijn_var<T: AstVisitable + Idx>( &mut self, x: &DeBruijnVar<T>, y: &DeBruijnVar<T>, )

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_region_binder<T: AstVisitable>( &mut self, x: &RegionBinder<T>, y: &RegionBinder<T>, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_region_binder<T: AstVisitable>( &mut self, x: &RegionBinder<T>, y: &RegionBinder<T>, )

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_region_binder<T: AstVisitable>( &mut self, x: &RegionBinder<T>, y: &RegionBinder<T>, )

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_binder<T: AstVisitable>( &mut self, x: &Binder<T>, y: &Binder<T>, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_binder<T: AstVisitable>(&mut self, x: &Binder<T>, y: &Binder<T>)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_binder<T: AstVisitable>(&mut self, x: &Binder<T>, y: &Binder<T>)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_llbc_block(&mut self, x: &Block, y: &Block) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_llbc_block(&mut self, x: &Block, y: &Block)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_llbc_block(&mut self, x: &Block, y: &Block)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_llbc_statement( &mut self, x: &Statement, y: &Statement, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_llbc_statement(&mut self, x: &Statement, y: &Statement)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_llbc_statement(&mut self, x: &Statement, y: &Statement)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_ullbc_statement( &mut self, x: &Statement, y: &Statement, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_ullbc_statement(&mut self, x: &Statement, y: &Statement)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_ullbc_statement(&mut self, x: &Statement, y: &Statement)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_ullbc_terminator( &mut self, x: &Terminator, y: &Terminator, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_ullbc_terminator(&mut self, x: &Terminator, y: &Terminator)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_ullbc_terminator(&mut self, x: &Terminator, y: &Terminator)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_abort_kind( &mut self, x: &AbortKind, y: &AbortKind, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_abort_kind(&mut self, x: &AbortKind, y: &AbortKind)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_abort_kind(&mut self, x: &AbortKind, y: &AbortKind)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_aggregate_kind( &mut self, x: &AggregateKind, y: &AggregateKind, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_aggregate_kind(&mut self, x: &AggregateKind, y: &AggregateKind)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_aggregate_kind(&mut self, x: &AggregateKind, y: &AggregateKind)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_fn_ptr(&mut self, x: &FnPtr, y: &FnPtr) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_fn_ptr(&mut self, x: &FnPtr, y: &FnPtr)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_fn_ptr(&mut self, x: &FnPtr, y: &FnPtr)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_item_source( &mut self, x: &ItemSource, y: &ItemSource, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_item_source(&mut self, x: &ItemSource, y: &ItemSource)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_item_source(&mut self, x: &ItemSource, y: &ItemSource)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_item_meta( &mut self, x: &ItemMeta, y: &ItemMeta, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_item_meta(&mut self, x: &ItemMeta, y: &ItemMeta)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_item_meta(&mut self, x: &ItemMeta, y: &ItemMeta)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_name(&mut self, x: &Name, y: &Name) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_name(&mut self, x: &Name, y: &Name)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_name(&mut self, x: &Name, y: &Name)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_span(&mut self, x: &Span, y: &Span) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_span(&mut self, x: &Span, y: &Span)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_span(&mut self, x: &Span, y: &Span)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_constant_expr( &mut self, x: &ConstantExpr, y: &ConstantExpr, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_constant_expr(&mut self, x: &ConstantExpr, y: &ConstantExpr)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_constant_expr(&mut self, x: &ConstantExpr, y: &ConstantExpr)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_projection_elem( &mut self, x: &ProjectionElem, y: &ProjectionElem, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_projection_elem(&mut self, x: &ProjectionElem, y: &ProjectionElem)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_projection_elem(&mut self, x: &ProjectionElem, y: &ProjectionElem)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_fun_decl_id( &mut self, x: &FunDeclId, y: &FunDeclId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_fun_decl_id(&mut self, x: &FunDeclId, y: &FunDeclId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_fun_decl_id(&mut self, x: &FunDeclId, y: &FunDeclId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_global_decl_id( &mut self, x: &GlobalDeclId, y: &GlobalDeclId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_global_decl_id(&mut self, x: &GlobalDeclId, y: &GlobalDeclId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_global_decl_id(&mut self, x: &GlobalDeclId, y: &GlobalDeclId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_type_decl_id( &mut self, x: &TypeDeclId, y: &TypeDeclId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_type_decl_id(&mut self, x: &TypeDeclId, y: &TypeDeclId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_type_decl_id(&mut self, x: &TypeDeclId, y: &TypeDeclId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_decl_id( &mut self, x: &TraitDeclId, y: &TraitDeclId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_decl_id(&mut self, x: &TraitDeclId, y: &TraitDeclId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_decl_id(&mut self, x: &TraitDeclId, y: &TraitDeclId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_impl_id( &mut self, x: &TraitImplId, y: &TraitImplId, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_impl_id(&mut self, x: &TraitImplId, y: &TraitImplId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_impl_id(&mut self, x: &TraitImplId, y: &TraitImplId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_file_id(&mut self, x: &FileId, y: &FileId) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_file_id(&mut self, x: &FileId, y: &FileId)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_file_id(&mut self, x: &FileId, y: &FileId)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_fun_decl( &mut self, x: &FunDecl, y: &FunDecl, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_fun_decl(&mut self, x: &FunDecl, y: &FunDecl)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_fun_decl(&mut self, x: &FunDecl, y: &FunDecl)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_global_decl( &mut self, x: &GlobalDecl, y: &GlobalDecl, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_global_decl(&mut self, x: &GlobalDecl, y: &GlobalDecl)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_global_decl(&mut self, x: &GlobalDecl, y: &GlobalDecl)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_type_decl( &mut self, x: &TypeDecl, y: &TypeDecl, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_type_decl(&mut self, x: &TypeDecl, y: &TypeDecl)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_type_decl(&mut self, x: &TypeDecl, y: &TypeDecl)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_decl( &mut self, x: &TraitDecl, y: &TraitDecl, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_decl(&mut self, x: &TraitDecl, y: &TraitDecl)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_decl(&mut self, x: &TraitDecl, y: &TraitDecl)

Called when finished visiting a $ty (unless visit_$ty is overriden).

fn visit_trait_impl( &mut self, x: &TraitImpl, y: &TraitImpl, ) -> ControlFlow<Self::Break>

Overrideable method called when visiting a $ty. When overriding this method, call self.visit_inner(x) to keep recursively visiting the type, or don’t call it if the contents of x should not be visited.

The default implementation calls enter_$ty then visit_inner then exit_$ty.

fn enter_trait_impl(&mut self, x: &TraitImpl, y: &TraitImpl)

Called when starting to visit a $ty (unless visit_$ty is overriden).

fn exit_trait_impl(&mut self, x: &TraitImpl, y: &TraitImpl)

Called when finished visiting a $ty (unless visit_$ty is overriden).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors