Trait moore_svlog_syntax::ast::WalkVisitor

pub trait WalkVisitor<'a> {
    fn walk(&'a self, visitor: &mut dyn Visitor<'a>);
}

A node that walks a Visitor over itself.

Required methods

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Loading content...

Implementations on Foreign Types

impl<'a, T, '_> WalkVisitor<'a> for &'_ T where
    T: WalkVisitor<'a>, 

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T> WalkVisitor<'a> for Vec<T> where
    T: WalkVisitor<'a>, 

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T> WalkVisitor<'a> for Option<T> where
    T: WalkVisitor<'a>, 

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T> WalkVisitor<'a> for Spanned<T> where
    T: WalkVisitor<'a>, 

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T> WalkVisitor<'a> for Box<T> where
    T: WalkVisitor<'a>, 

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for Span

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for Name

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for bool

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for usize

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for ()

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T0: WalkVisitor<'a>, T1: WalkVisitor<'a>> WalkVisitor<'a> for (T0, T1)

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T0: WalkVisitor<'a>, T1: WalkVisitor<'a>, T2: WalkVisitor<'a>> WalkVisitor<'a> for (T0, T1, T2)

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a, T0: WalkVisitor<'a>, T1: WalkVisitor<'a>, T2: WalkVisitor<'a>, T3: WalkVisitor<'a>> WalkVisitor<'a> for (T0, T1, T2, T3)

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Loading content...

Implementors

impl<'a> WalkVisitor<'a> for AssertionActionBlock<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_assertion_action_block(self)
• self.accept(visitor)
• visitor.post_visit_assertion_action_block(self);

impl<'a> WalkVisitor<'a> for AssertionData<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_assertion_data(self)
• self.accept(visitor)
• visitor.post_visit_assertion_data(self);

impl<'a> WalkVisitor<'a> for AssertionDeferred

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_assertion_deferred(self)
• self.accept(visitor)
• visitor.post_visit_assertion_deferred(self);

impl<'a> WalkVisitor<'a> for AssignOp

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_assign_op(self)
• self.accept(visitor)
• visitor.post_visit_assign_op(self);

impl<'a> WalkVisitor<'a> for BlockingAssertion<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_blocking_assertion(self)
• self.accept(visitor)
• visitor.post_visit_blocking_assertion(self);

impl<'a> WalkVisitor<'a> for CaseItem<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_case_item(self)
• self.accept(visitor)
• visitor.post_visit_case_item(self);

impl<'a> WalkVisitor<'a> for CaseKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_case_kind(self)
• self.accept(visitor)
• visitor.post_visit_case_kind(self);

impl<'a> WalkVisitor<'a> for CaseMode

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_case_mode(self)
• self.accept(visitor)
• visitor.post_visit_case_mode(self);

impl<'a> WalkVisitor<'a> for ChargeStrength

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_charge_strength(self)
• self.accept(visitor)
• visitor.post_visit_charge_strength(self);

impl<'a> WalkVisitor<'a> for ClassItemData<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_class_item_data(self)
• self.accept(visitor)
• visitor.post_visit_class_item_data(self);

impl<'a> WalkVisitor<'a> for ClassItemQualifier

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_class_item_qualifier(self)
• self.accept(visitor)
• visitor.post_visit_class_item_qualifier(self);

impl<'a> WalkVisitor<'a> for ConcurrentAssertion<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_concurrent_assertion(self)
• self.accept(visitor)
• visitor.post_visit_concurrent_assertion(self);

impl<'a> WalkVisitor<'a> for ConstraintItemData<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_constraint_item_data(self)
• self.accept(visitor)
• visitor.post_visit_constraint_item_data(self);

impl<'a> WalkVisitor<'a> for ConstraintKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_constraint_kind(self)
• self.accept(visitor)
• visitor.post_visit_constraint_kind(self);

impl<'a> WalkVisitor<'a> for DataTypeOrImplicit<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_data_type_or_implicit(self)
• self.accept(visitor)
• visitor.post_visit_data_type_or_implicit(self);

impl<'a> WalkVisitor<'a> for DpiProperty

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_dpi_property(self)
• self.accept(visitor)
• visitor.post_visit_dpi_property(self);

impl<'a> WalkVisitor<'a> for DriveStrength

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_drive_strength(self)
• self.accept(visitor)
• visitor.post_visit_drive_strength(self);

impl<'a> WalkVisitor<'a> for EdgeIdent

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_edge_ident(self)
• self.accept(visitor)
• visitor.post_visit_edge_ident(self);

impl<'a> WalkVisitor<'a> for EventControlData<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_event_control_data(self)
• self.accept(visitor)
• visitor.post_visit_event_control_data(self);

impl<'a> WalkVisitor<'a> for EventExpr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_event_expr(self)
• self.accept(visitor)
• visitor.post_visit_event_expr(self);

impl<'a> WalkVisitor<'a> for IntType

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_int_type(self)
• self.accept(visitor)
• visitor.post_visit_int_type(self);

impl<'a> WalkVisitor<'a> for JoinKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_join_kind(self)
• self.accept(visitor)
• visitor.post_visit_join_kind(self);

impl<'a> WalkVisitor<'a> for Lifetime

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_lifetime(self)
• self.accept(visitor)
• visitor.post_visit_lifetime(self);

impl<'a> WalkVisitor<'a> for NetKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_net_kind(self)
• self.accept(visitor)
• visitor.post_visit_net_kind(self);

impl<'a> WalkVisitor<'a> for NetStrength

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_net_strength(self)
• self.accept(visitor)
• visitor.post_visit_net_strength(self);

impl<'a> WalkVisitor<'a> for NetType

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_net_type(self)
• self.accept(visitor)
• visitor.post_visit_net_type(self);

impl<'a> WalkVisitor<'a> for ParamKind<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_param_kind(self)
• self.accept(visitor)
• visitor.post_visit_param_kind(self);

impl<'a> WalkVisitor<'a> for PortConnMode<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_port_conn_mode(self)
• self.accept(visitor)
• visitor.post_visit_port_conn_mode(self);

impl<'a> WalkVisitor<'a> for PortDir

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_port_dir(self)
• self.accept(visitor)
• visitor.post_visit_port_dir(self);

impl<'a> WalkVisitor<'a> for ProcedureKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_procedure_kind(self)
• self.accept(visitor)
• visitor.post_visit_procedure_kind(self);

impl<'a> WalkVisitor<'a> for PropBinOp

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_prop_bin_op(self)
• self.accept(visitor)
• visitor.post_visit_prop_bin_op(self);

impl<'a> WalkVisitor<'a> for PropExprData<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_prop_expr_data(self)
• self.accept(visitor)
• visitor.post_visit_prop_expr_data(self);

impl<'a> WalkVisitor<'a> for PropSeqBinOp

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_prop_seq_bin_op(self)
• self.accept(visitor)
• visitor.post_visit_prop_seq_bin_op(self);

impl<'a> WalkVisitor<'a> for PropSeqOp

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_prop_seq_op(self)
• self.accept(visitor)
• visitor.post_visit_prop_seq_op(self);

impl<'a> WalkVisitor<'a> for RandomQualifier

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_random_qualifier(self)
• self.accept(visitor)
• visitor.post_visit_random_qualifier(self);

impl<'a> WalkVisitor<'a> for RangeMode

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_range_mode(self)
• self.accept(visitor)
• visitor.post_visit_range_mode(self);

impl<'a> WalkVisitor<'a> for RealType

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_real_type(self)
• self.accept(visitor)
• visitor.post_visit_real_type(self);

impl<'a> WalkVisitor<'a> for SeqBinOp

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_seq_bin_op(self)
• self.accept(visitor)
• visitor.post_visit_seq_bin_op(self);

impl<'a> WalkVisitor<'a> for SeqExprData<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_seq_expr_data(self)
• self.accept(visitor)
• visitor.post_visit_seq_expr_data(self);

impl<'a> WalkVisitor<'a> for SeqRep<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_seq_rep(self)
• self.accept(visitor)
• visitor.post_visit_seq_rep(self);

impl<'a> WalkVisitor<'a> for StmtKind<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_stmt_kind(self)
• self.accept(visitor)
• visitor.post_visit_stmt_kind(self);

impl<'a> WalkVisitor<'a> for StreamConcatSlice<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_stream_concat_slice(self)
• self.accept(visitor)
• visitor.post_visit_stream_concat_slice(self);

impl<'a> WalkVisitor<'a> for StructKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_struct_kind(self)
• self.accept(visitor)
• visitor.post_visit_struct_kind(self);

impl<'a> WalkVisitor<'a> for SubroutineItem<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_item(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_item(self);

impl<'a> WalkVisitor<'a> for SubroutineKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_kind(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_kind(self);

impl<'a> WalkVisitor<'a> for SubroutinePortDir

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_port_dir(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_port_dir(self);

impl<'a> WalkVisitor<'a> for TimingControl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_timing_control(self)
• self.accept(visitor)
• visitor.post_visit_timing_control(self);

impl<'a> WalkVisitor<'a> for TypeDim<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_type_dim(self)
• self.accept(visitor)
• visitor.post_visit_type_dim(self);

impl<'a> WalkVisitor<'a> for TypeOrExpr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_type_or_expr(self)
• self.accept(visitor)
• visitor.post_visit_type_or_expr(self);

impl<'a> WalkVisitor<'a> for TypeSign

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_type_sign(self)
• self.accept(visitor)
• visitor.post_visit_type_sign(self);

impl<'a> WalkVisitor<'a> for UniquePriority

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_unique_priority(self)
• self.accept(visitor)
• visitor.post_visit_unique_priority(self);

impl<'a> WalkVisitor<'a> for ValueRange<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_value_range(self)
• self.accept(visitor)
• visitor.post_visit_value_range(self);

impl<'a> WalkVisitor<'a> for VarKind

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_var_kind(self)
• self.accept(visitor)
• visitor.post_visit_var_kind(self);

impl<'a> WalkVisitor<'a> for Lit

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for Op

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for Assertion<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_assertion(self)
• self.accept(visitor)
• visitor.post_visit_assertion(self);

impl<'a> WalkVisitor<'a> for CallArg<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_call_arg(self)
• self.accept(visitor)
• visitor.post_visit_call_arg(self);

impl<'a> WalkVisitor<'a> for ClassItem<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_class_item(self)
• self.accept(visitor)
• visitor.post_visit_class_item(self);

impl<'a> WalkVisitor<'a> for Constraint<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_constraint(self)
• self.accept(visitor)
• visitor.post_visit_constraint(self);

impl<'a> WalkVisitor<'a> for ConstraintItem<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_constraint_item(self)
• self.accept(visitor)
• visitor.post_visit_constraint_item(self);

impl<'a> WalkVisitor<'a> for CycleDelay

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_cycle_delay(self)
• self.accept(visitor)
• visitor.post_visit_cycle_delay(self);

impl<'a> WalkVisitor<'a> for DelayControl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_delay_control(self)
• self.accept(visitor)
• visitor.post_visit_delay_control(self);

impl<'a> WalkVisitor<'a> for EventControl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_event_control(self)
• self.accept(visitor)
• visitor.post_visit_event_control(self);

impl<'a> WalkVisitor<'a> for Identifier

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

impl<'a> WalkVisitor<'a> for ParamAssignment<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_param_assignment(self)
• self.accept(visitor)
• visitor.post_visit_param_assignment(self);

impl<'a> WalkVisitor<'a> for PropExpr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_prop_expr(self)
• self.accept(visitor)
• visitor.post_visit_prop_expr(self);

impl<'a> WalkVisitor<'a> for PropSpec

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_prop_spec(self)
• self.accept(visitor)
• visitor.post_visit_prop_spec(self);

impl<'a> WalkVisitor<'a> for SeqExpr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_seq_expr(self)
• self.accept(visitor)
• visitor.post_visit_seq_expr(self);

impl<'a> WalkVisitor<'a> for StreamExpr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_stream_expr(self)
• self.accept(visitor)
• visitor.post_visit_stream_expr(self);

impl<'a> WalkVisitor<'a> for SubroutinePortDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_port_decl(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_port_decl(self);

impl<'a> WalkVisitor<'a> for SubroutinePortName<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_port_name(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_port_name(self);

impl<'a> WalkVisitor<'a> for Timeunit

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_timeunit(self)
• self.accept(visitor)
• visitor.post_visit_timeunit(self);

impl<'a> WalkVisitor<'a> for ClassDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_class_decl(self)
• self.accept(visitor)
• visitor.post_visit_class_decl(self);

impl<'a> WalkVisitor<'a> for ContAssign<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_cont_assign(self)
• self.accept(visitor)
• visitor.post_visit_cont_assign(self);

impl<'a> WalkVisitor<'a> for DataType<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_data_type(self)
• self.accept(visitor)
• visitor.post_visit_data_type(self);

impl<'a> WalkVisitor<'a> for DpiDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_dpi_decl(self)
• self.accept(visitor)
• visitor.post_visit_dpi_decl(self);

impl<'a> WalkVisitor<'a> for Enum<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_enum(self)
• self.accept(visitor)
• visitor.post_visit_enum(self);

impl<'a> WalkVisitor<'a> for EnumName<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_enum_name(self)
• self.accept(visitor)
• visitor.post_visit_enum_name(self);

impl<'a> WalkVisitor<'a> for Expr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_expr(self)
• self.accept(visitor)
• visitor.post_visit_expr(self);

impl<'a> WalkVisitor<'a> for ForeachIndex<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_foreach_index(self)
• self.accept(visitor)
• visitor.post_visit_foreach_index(self);

impl<'a> WalkVisitor<'a> for GenerateBlock<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_generate_block(self)
• self.accept(visitor)
• visitor.post_visit_generate_block(self);

impl<'a> WalkVisitor<'a> for GenerateCase<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_generate_case(self)
• self.accept(visitor)
• visitor.post_visit_generate_case(self);

impl<'a> WalkVisitor<'a> for GenerateFor<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_generate_for(self)
• self.accept(visitor)
• visitor.post_visit_generate_for(self);

impl<'a> WalkVisitor<'a> for GenerateIf<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_generate_if(self)
• self.accept(visitor)
• visitor.post_visit_generate_if(self);

impl<'a> WalkVisitor<'a> for GenvarDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_genvar_decl(self)
• self.accept(visitor)
• visitor.post_visit_genvar_decl(self);

impl<'a> WalkVisitor<'a> for ImplicitDataType<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_implicit_data_type(self)
• self.accept(visitor)
• visitor.post_visit_implicit_data_type(self);

impl<'a> WalkVisitor<'a> for ImportDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_import_decl(self)
• self.accept(visitor)
• visitor.post_visit_import_decl(self);

impl<'a> WalkVisitor<'a> for ImportItem<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_import_item(self)
• self.accept(visitor)
• visitor.post_visit_import_item(self);

impl<'a> WalkVisitor<'a> for Inst<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_inst(self)
• self.accept(visitor)
• visitor.post_visit_inst(self);

impl<'a> WalkVisitor<'a> for InstName<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_inst_name(self)
• self.accept(visitor)
• visitor.post_visit_inst_name(self);

impl<'a> WalkVisitor<'a> for Interface<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_interface(self)
• self.accept(visitor)
• visitor.post_visit_interface(self);

impl<'a> WalkVisitor<'a> for Item<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_item(self)
• self.accept(visitor)
• visitor.post_visit_item(self);

impl<'a> WalkVisitor<'a> for Modport<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_modport(self)
• self.accept(visitor)
• visitor.post_visit_modport(self);

impl<'a> WalkVisitor<'a> for ModportName<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_modport_name(self)
• self.accept(visitor)
• visitor.post_visit_modport_name(self);

impl<'a> WalkVisitor<'a> for ModportPort<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_modport_port(self)
• self.accept(visitor)
• visitor.post_visit_modport_port(self);

impl<'a> WalkVisitor<'a> for ModportSimplePort<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_modport_simple_port(self)
• self.accept(visitor)
• visitor.post_visit_modport_simple_port(self);

impl<'a> WalkVisitor<'a> for Module<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_module(self)
• self.accept(visitor)
• visitor.post_visit_module(self);

impl<'a> WalkVisitor<'a> for NetDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_net_decl(self)
• self.accept(visitor)
• visitor.post_visit_net_decl(self);

impl<'a> WalkVisitor<'a> for Package<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_package(self)
• self.accept(visitor)
• visitor.post_visit_package(self);

impl<'a> WalkVisitor<'a> for PackedDim<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_packed_dim(self)
• self.accept(visitor)
• visitor.post_visit_packed_dim(self);

impl<'a> WalkVisitor<'a> for ParamDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_param_decl(self)
• self.accept(visitor)
• visitor.post_visit_param_decl(self);

impl<'a> WalkVisitor<'a> for ParamTypeDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_param_type_decl(self)
• self.accept(visitor)
• visitor.post_visit_param_type_decl(self);

impl<'a> WalkVisitor<'a> for ParamValueDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_param_value_decl(self)
• self.accept(visitor)
• visitor.post_visit_param_value_decl(self);

impl<'a> WalkVisitor<'a> for PathSegment<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_path_segment(self)
• self.accept(visitor)
• visitor.post_visit_path_segment(self);

impl<'a> WalkVisitor<'a> for PatternField<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_pattern_field(self)
• self.accept(visitor)
• visitor.post_visit_pattern_field(self);

impl<'a> WalkVisitor<'a> for Port<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_port(self)
• self.accept(visitor)
• visitor.post_visit_port(self);

impl<'a> WalkVisitor<'a> for PortConn<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_port_conn(self)
• self.accept(visitor)
• visitor.post_visit_port_conn(self);

impl<'a> WalkVisitor<'a> for PortDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_port_decl(self)
• self.accept(visitor)
• visitor.post_visit_port_decl(self);

impl<'a> WalkVisitor<'a> for Procedure<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_procedure(self)
• self.accept(visitor)
• visitor.post_visit_procedure(self);

impl<'a> WalkVisitor<'a> for Root<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_root(self)
• self.accept(visitor)
• visitor.post_visit_root(self);

impl<'a> WalkVisitor<'a> for SourceFile<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_source_file(self)
• self.accept(visitor)
• visitor.post_visit_source_file(self);

impl<'a> WalkVisitor<'a> for Stmt<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_stmt(self)
• self.accept(visitor)
• visitor.post_visit_stmt(self);

impl<'a> WalkVisitor<'a> for Struct<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_struct(self)
• self.accept(visitor)
• visitor.post_visit_struct(self);

impl<'a> WalkVisitor<'a> for StructMember<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_struct_member(self)
• self.accept(visitor)
• visitor.post_visit_struct_member(self);

impl<'a> WalkVisitor<'a> for SubroutineDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_decl(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_decl(self);

impl<'a> WalkVisitor<'a> for SubroutinePort<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_port(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_port(self);

impl<'a> WalkVisitor<'a> for SubroutinePrototype<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_subroutine_prototype(self)
• self.accept(visitor)
• visitor.post_visit_subroutine_prototype(self);

impl<'a> WalkVisitor<'a> for Type<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_type(self)
• self.accept(visitor)
• visitor.post_visit_type(self);

impl<'a> WalkVisitor<'a> for TypeKind<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_type_kind(self)
• self.accept(visitor)
• visitor.post_visit_type_kind(self);

impl<'a> WalkVisitor<'a> for Typedef<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_typedef(self)
• self.accept(visitor)
• visitor.post_visit_typedef(self);

impl<'a> WalkVisitor<'a> for UnpackedDim<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_unpacked_dim(self)
• self.accept(visitor)
• visitor.post_visit_unpacked_dim(self);

impl<'a> WalkVisitor<'a> for VarDecl<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_var_decl(self)
• self.accept(visitor)
• visitor.post_visit_var_decl(self);

impl<'a> WalkVisitor<'a> for VarDeclName<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_var_decl_name(self)
• self.accept(visitor)
• visitor.post_visit_var_decl_name(self);

impl<'a> WalkVisitor<'a> for VarDim<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_var_dim(self)
• self.accept(visitor)
• visitor.post_visit_var_dim(self);

Loading content...