Trait moore_svlog::ast::WalkVisitor

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

A node that walks a Visitor over itself.

Required methods

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

Walk a visitor over self.

Loading content...

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

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

pub 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>

pub 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

pub 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

pub 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>

pub 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>

pub 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

pub 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

pub 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

pub 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>

pub 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

pub 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>

pub 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>

pub 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

pub 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>

pub 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

pub 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

pub 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

pub 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>

pub 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>

pub 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

pub 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

pub 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

pub 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

pub 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

pub 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

pub 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>

pub 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>

pub 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

pub 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

pub 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

pub 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>

pub 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

pub 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

pub 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

pub 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

pub 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

pub 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

pub 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>

pub 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>

pub 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>

pub 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>

pub 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

pub 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>

pub 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

pub 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

pub 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>

pub 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>

pub 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>

pub 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

pub 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

pub 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>

pub 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

pub 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

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

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

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

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

pub 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>

pub 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>

pub 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>

pub 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>

pub 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

pub 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>

pub 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>

pub 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

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

impl<'a> WalkVisitor<'a> for Node<'a, DataTypeData<'a>>

pub 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 Node<'a, DpiDeclData<'a>>

pub 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 Node<'a, ExprData<'a>>

pub 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 Node<'a, ItemData<'a>>

pub 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 Node<'a, ModportPortData<'a>>

pub 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 Node<'a, PackedDimData<'a>>

pub 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 Node<'a, PathSegmentData<'a>>

pub 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 Node<'a, PatternFieldData<'a>>

pub 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 Node<'a, PortConnData<'a>>

pub 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 Node<'a, PortData<'a>>

pub 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 Node<'a, TypeKindData<'a>>

pub 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 Node<'a, UnpackedDimData<'a>>

pub 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 Node<'a, VarDimData<'a>>

pub 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);

impl<'a> WalkVisitor<'a> for Node<'a, ClassDeclData<'a>>

pub 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 Node<'a, ContAssignData<'a>>

pub 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 Node<'a, EnumData<'a>>

pub 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 Node<'a, EnumNameData<'a>>

pub 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 Node<'a, ForeachIndexData>

pub 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 Node<'a, GenerateBlockData<'a>>

pub 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 Node<'a, GenerateCaseData>

pub 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 Node<'a, GenerateForData<'a>>

pub 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 Node<'a, GenerateIfData<'a>>

pub 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 Node<'a, GenvarDeclData<'a>>

pub 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 Node<'a, ImplicitDataTypeData<'a>>

pub 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 Node<'a, ImportDeclData<'a>>

pub 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 Node<'a, ImportItemData>

pub 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 Node<'a, InstData<'a>>

pub 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 Node<'a, InstNameData<'a>>

pub 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 Node<'a, InterfaceData<'a>>

pub 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 Node<'a, ModportData<'a>>

pub 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 Node<'a, ModportNameData<'a>>

pub 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 Node<'a, ModportSimplePortData<'a>>

pub 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 Node<'a, ModuleData<'a>>

pub 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 Node<'a, NetDeclData<'a>>

pub 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 Node<'a, PackageData<'a>>

pub 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 Node<'a, ParamDeclData<'a>>

pub 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 Node<'a, ParamTypeDeclData<'a>>

pub 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 Node<'a, ParamValueDeclData<'a>>

pub 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 Node<'a, PortDeclData<'a>>

pub 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 Node<'a, ProcedureData<'a>>

pub 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 Node<'a, RootData<'a>>

pub 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 Node<'a, SourceFileData<'a>>

pub 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 Node<'a, StmtData<'a>>

pub 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 Node<'a, StructData<'a>>

pub 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 Node<'a, StructMemberData<'a>>

pub 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 Node<'a, SubroutineDeclData<'a>>

pub 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 Node<'a, SubroutinePortData<'a>>

pub 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 Node<'a, SubroutinePrototypeData<'a>>

pub 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 Node<'a, TypeData<'a>>

pub 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 Node<'a, TypedefData<'a>>

pub 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 Node<'a, VarDeclData<'a>>

pub 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 Node<'a, VarDeclNameData<'a>>

pub 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 ParamAssignment<'a>

pub 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>

pub 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

pub 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>

pub 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>

pub 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>

pub 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>

pub 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

pub 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 Name

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

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

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

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

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

Loading content...