Trait VisitAstMut

pub trait VisitAstMut: Visitor + Sized {
    // Provided methods
    fn visit<'a, T: AstVisitable>(
        &'a mut self,
        x: &mut T,
    ) -> ControlFlow<Self::Break> { ... }
    fn visit_by_val<T: AstVisitable>(
        self,
        x: &mut T,
    ) -> ControlFlow<Self::Break, Self> { ... }
    fn visit_by_val_infallible<T: AstVisitable>(self, x: &mut T) -> Self
       where Self: Visitor<Break = Infallible> + Sized { ... }
    fn visit_inner<T>(&mut self, x: &mut T) -> ControlFlow<Self::Break>
       where T: for<'s> DriveMut<'s, AstVisitableWrapper<Self>> { ... }
    fn visit_de_bruijn_id(
        &mut self,
        x: &mut DeBruijnId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_de_bruijn_id(&mut self, x: &mut DeBruijnId) { ... }
    fn exit_de_bruijn_id(&mut self, x: &mut DeBruijnId) { ... }
    fn visit_ty(&mut self, x: &mut Ty) -> ControlFlow<Self::Break> { ... }
    fn enter_ty(&mut self, x: &mut Ty) { ... }
    fn exit_ty(&mut self, x: &mut Ty) { ... }
    fn visit_ty_kind(&mut self, x: &mut TyKind) -> ControlFlow<Self::Break> { ... }
    fn enter_ty_kind(&mut self, x: &mut TyKind) { ... }
    fn exit_ty_kind(&mut self, x: &mut TyKind) { ... }
    fn visit_region(&mut self, x: &mut Region) -> ControlFlow<Self::Break> { ... }
    fn enter_region(&mut self, x: &mut Region) { ... }
    fn exit_region(&mut self, x: &mut Region) { ... }
    fn visit_const_generic(
        &mut self,
        x: &mut ConstGeneric,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_const_generic(&mut self, x: &mut ConstGeneric) { ... }
    fn exit_const_generic(&mut self, x: &mut ConstGeneric) { ... }
    fn visit_trait_ref(&mut self, x: &mut TraitRef) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_ref(&mut self, x: &mut TraitRef) { ... }
    fn exit_trait_ref(&mut self, x: &mut TraitRef) { ... }
    fn visit_trait_ref_kind(
        &mut self,
        x: &mut TraitRefKind,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_ref_kind(&mut self, x: &mut TraitRefKind) { ... }
    fn exit_trait_ref_kind(&mut self, x: &mut TraitRefKind) { ... }
    fn visit_fun_decl_ref(
        &mut self,
        x: &mut FunDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_fun_decl_ref(&mut self, x: &mut FunDeclRef) { ... }
    fn exit_fun_decl_ref(&mut self, x: &mut FunDeclRef) { ... }
    fn visit_global_decl_ref(
        &mut self,
        x: &mut GlobalDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_global_decl_ref(&mut self, x: &mut GlobalDeclRef) { ... }
    fn exit_global_decl_ref(&mut self, x: &mut GlobalDeclRef) { ... }
    fn visit_trait_decl_ref(
        &mut self,
        x: &mut TraitDeclRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_decl_ref(&mut self, x: &mut TraitDeclRef) { ... }
    fn exit_trait_decl_ref(&mut self, x: &mut TraitDeclRef) { ... }
    fn visit_trait_impl_ref(
        &mut self,
        x: &mut TraitImplRef,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_impl_ref(&mut self, x: &mut TraitImplRef) { ... }
    fn exit_trait_impl_ref(&mut self, x: &mut TraitImplRef) { ... }
    fn visit_generic_args(
        &mut self,
        x: &mut GenericArgs,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_generic_args(&mut self, x: &mut GenericArgs) { ... }
    fn exit_generic_args(&mut self, x: &mut GenericArgs) { ... }
    fn visit_generic_params(
        &mut self,
        x: &mut GenericParams,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_generic_params(&mut self, x: &mut GenericParams) { ... }
    fn exit_generic_params(&mut self, x: &mut GenericParams) { ... }
    fn visit_trait_clause(
        &mut self,
        x: &mut TraitClause,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_clause(&mut self, x: &mut TraitClause) { ... }
    fn exit_trait_clause(&mut self, x: &mut TraitClause) { ... }
    fn visit_trait_type_constraint(
        &mut self,
        x: &mut TraitTypeConstraint,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_type_constraint(&mut self, x: &mut TraitTypeConstraint) { ... }
    fn exit_trait_type_constraint(&mut self, x: &mut TraitTypeConstraint) { ... }
    fn visit_de_bruijn_var<T: AstVisitable + Idx>(
        &mut self,
        x: &mut DeBruijnVar<T>,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_de_bruijn_var<T: AstVisitable + Idx>(
        &mut self,
        x: &mut DeBruijnVar<T>,
    ) { ... }
    fn exit_de_bruijn_var<T: AstVisitable + Idx>(
        &mut self,
        x: &mut DeBruijnVar<T>,
    ) { ... }
    fn visit_region_binder<T: AstVisitable>(
        &mut self,
        x: &mut RegionBinder<T>,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_region_binder<T: AstVisitable>(&mut self, x: &mut RegionBinder<T>) { ... }
    fn exit_region_binder<T: AstVisitable>(&mut self, x: &mut RegionBinder<T>) { ... }
    fn visit_binder<T: AstVisitable>(
        &mut self,
        x: &mut Binder<T>,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_binder<T: AstVisitable>(&mut self, x: &mut Binder<T>) { ... }
    fn exit_binder<T: AstVisitable>(&mut self, x: &mut Binder<T>) { ... }
    fn visit_llbc_statement(
        &mut self,
        x: &mut Statement,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_llbc_statement(&mut self, x: &mut Statement) { ... }
    fn exit_llbc_statement(&mut self, x: &mut Statement) { ... }
    fn visit_ullbc_statement(
        &mut self,
        x: &mut Statement,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_ullbc_statement(&mut self, x: &mut Statement) { ... }
    fn exit_ullbc_statement(&mut self, x: &mut Statement) { ... }
    fn visit_aggregate_kind(
        &mut self,
        x: &mut AggregateKind,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_aggregate_kind(&mut self, x: &mut AggregateKind) { ... }
    fn exit_aggregate_kind(&mut self, x: &mut AggregateKind) { ... }
    fn visit_fn_ptr(&mut self, x: &mut FnPtr) -> ControlFlow<Self::Break> { ... }
    fn enter_fn_ptr(&mut self, x: &mut FnPtr) { ... }
    fn exit_fn_ptr(&mut self, x: &mut FnPtr) { ... }
    fn visit_item_kind(&mut self, x: &mut ItemKind) -> ControlFlow<Self::Break> { ... }
    fn enter_item_kind(&mut self, x: &mut ItemKind) { ... }
    fn exit_item_kind(&mut self, x: &mut ItemKind) { ... }
    fn visit_item_meta(&mut self, x: &mut ItemMeta) -> ControlFlow<Self::Break> { ... }
    fn enter_item_meta(&mut self, x: &mut ItemMeta) { ... }
    fn exit_item_meta(&mut self, x: &mut ItemMeta) { ... }
    fn visit_span(&mut self, x: &mut Span) -> ControlFlow<Self::Break> { ... }
    fn enter_span(&mut self, x: &mut Span) { ... }
    fn exit_span(&mut self, x: &mut Span) { ... }
    fn visit_fun_decl_id(
        &mut self,
        x: &mut FunDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_fun_decl_id(&mut self, x: &mut FunDeclId) { ... }
    fn exit_fun_decl_id(&mut self, x: &mut FunDeclId) { ... }
    fn visit_global_decl_id(
        &mut self,
        x: &mut GlobalDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_global_decl_id(&mut self, x: &mut GlobalDeclId) { ... }
    fn exit_global_decl_id(&mut self, x: &mut GlobalDeclId) { ... }
    fn visit_type_decl_id(
        &mut self,
        x: &mut TypeDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_type_decl_id(&mut self, x: &mut TypeDeclId) { ... }
    fn exit_type_decl_id(&mut self, x: &mut TypeDeclId) { ... }
    fn visit_trait_decl_id(
        &mut self,
        x: &mut TraitDeclId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_decl_id(&mut self, x: &mut TraitDeclId) { ... }
    fn exit_trait_decl_id(&mut self, x: &mut TraitDeclId) { ... }
    fn visit_trait_impl_id(
        &mut self,
        x: &mut TraitImplId,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_impl_id(&mut self, x: &mut TraitImplId) { ... }
    fn exit_trait_impl_id(&mut self, x: &mut TraitImplId) { ... }
    fn visit_fun_decl(&mut self, x: &mut FunDecl) -> ControlFlow<Self::Break> { ... }
    fn enter_fun_decl(&mut self, x: &mut FunDecl) { ... }
    fn exit_fun_decl(&mut self, x: &mut FunDecl) { ... }
    fn visit_global_decl(
        &mut self,
        x: &mut GlobalDecl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_global_decl(&mut self, x: &mut GlobalDecl) { ... }
    fn exit_global_decl(&mut self, x: &mut GlobalDecl) { ... }
    fn visit_type_decl(&mut self, x: &mut TypeDecl) -> ControlFlow<Self::Break> { ... }
    fn enter_type_decl(&mut self, x: &mut TypeDecl) { ... }
    fn exit_type_decl(&mut self, x: &mut TypeDecl) { ... }
    fn visit_trait_decl(
        &mut self,
        x: &mut TraitDecl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_decl(&mut self, x: &mut TraitDecl) { ... }
    fn exit_trait_decl(&mut self, x: &mut TraitDecl) { ... }
    fn visit_trait_impl(
        &mut self,
        x: &mut TraitImpl,
    ) -> ControlFlow<Self::Break> { ... }
    fn enter_trait_impl(&mut self, x: &mut TraitImpl) { ... }
    fn exit_trait_impl(&mut self, x: &mut TraitImpl) { ... }
}

Provided Methods

fn visit<'a, T: AstVisitable>( &'a mut self, x: &mut 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: &mut T, ) -> ControlFlow<Self::Break, Self>

Convenience alias for method chaining.

fn visit_by_val_infallible<T: AstVisitable>(self, x: &mut T) -> Self

where Self: Visitor<Break = Infallible> + Sized,

Convenience when the visitor does not return early.

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

where T: for<'s> DriveMut<'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: &mut 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: &mut DeBruijnId)

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

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

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

fn visit_ty(&mut self, x: &mut 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: &mut Ty)

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

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

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

fn visit_ty_kind(&mut self, x: &mut 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: &mut TyKind)

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

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

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

fn visit_region(&mut self, x: &mut 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: &mut Region)

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

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

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

fn visit_const_generic( &mut self, x: &mut ConstGeneric, ) -> 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_const_generic(&mut self, x: &mut ConstGeneric)

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

fn exit_const_generic(&mut self, x: &mut ConstGeneric)

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

fn visit_trait_ref(&mut self, x: &mut 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: &mut TraitRef)

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

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

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

fn visit_trait_ref_kind( &mut self, x: &mut 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: &mut TraitRefKind)

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

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

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

fn visit_fun_decl_ref(&mut self, x: &mut 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: &mut FunDeclRef)

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

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

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

fn visit_global_decl_ref( &mut self, x: &mut 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: &mut GlobalDeclRef)

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

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

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

fn visit_trait_decl_ref( &mut self, x: &mut 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: &mut TraitDeclRef)

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

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

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

fn visit_trait_impl_ref( &mut self, x: &mut 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: &mut TraitImplRef)

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

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

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

fn visit_generic_args( &mut self, x: &mut 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: &mut GenericArgs)

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

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

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

fn visit_generic_params( &mut self, x: &mut 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: &mut GenericParams)

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

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

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

fn visit_trait_clause( &mut self, x: &mut TraitClause, ) -> 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(&mut self, x: &mut TraitClause)

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

fn exit_trait_clause(&mut self, x: &mut TraitClause)

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

fn visit_trait_type_constraint( &mut self, x: &mut 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: &mut TraitTypeConstraint)

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

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

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

fn visit_de_bruijn_var<T: AstVisitable + Idx>( &mut self, x: &mut 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: &mut 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: &mut DeBruijnVar<T>)

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

fn visit_region_binder<T: AstVisitable>( &mut self, x: &mut 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: &mut RegionBinder<T>)

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

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

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

fn visit_binder<T: AstVisitable>( &mut self, x: &mut 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: &mut Binder<T>)

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

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

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

fn visit_llbc_statement( &mut self, x: &mut 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: &mut Statement)

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

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

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

fn visit_ullbc_statement( &mut self, x: &mut 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: &mut Statement)

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

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

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

fn visit_aggregate_kind( &mut self, x: &mut 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: &mut AggregateKind)

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

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

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

fn visit_fn_ptr(&mut self, x: &mut 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: &mut FnPtr)

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

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

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

fn visit_item_kind(&mut self, x: &mut ItemKind) -> 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_kind(&mut self, x: &mut ItemKind)

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

fn exit_item_kind(&mut self, x: &mut ItemKind)

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

fn visit_item_meta(&mut self, x: &mut 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: &mut ItemMeta)

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

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

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

fn visit_span(&mut self, x: &mut 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: &mut Span)

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

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

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

fn visit_fun_decl_id(&mut self, x: &mut 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: &mut FunDeclId)

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

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

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

fn visit_global_decl_id( &mut self, x: &mut 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: &mut GlobalDeclId)

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

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

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

fn visit_type_decl_id(&mut self, x: &mut 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: &mut TypeDeclId)

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

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

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

fn visit_trait_decl_id( &mut self, x: &mut 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: &mut TraitDeclId)

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

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

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

fn visit_trait_impl_id( &mut self, x: &mut 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: &mut TraitImplId)

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

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

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

fn visit_fun_decl(&mut self, x: &mut 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: &mut FunDecl)

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

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

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

fn visit_global_decl(&mut self, x: &mut 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: &mut GlobalDecl)

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

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

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

fn visit_type_decl(&mut self, x: &mut 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: &mut TypeDecl)

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

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

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

fn visit_trait_decl(&mut self, x: &mut 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: &mut TraitDecl)

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

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

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

fn visit_trait_impl(&mut self, x: &mut 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: &mut TraitImpl)

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

fn exit_trait_impl(&mut self, x: &mut 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", so this trait is not object safe.

Implementors

impl VisitAstMut for UpdateItemBody<'_>

impl VisitAstMut for RemoveMarkersVisitor

impl VisitAstMut for UnbindVarVisitor

impl VisitAstMut for InsertRegions<'_>

impl VisitAstMut for SubstVisitor<'_>

impl<F> VisitAstMut for DynVisitor<F>

where F: FnMut(&mut dyn Any),