Trait moore_svlog_syntax::ast::Visitor

pub trait Visitor<'a> {
    fn pre_visit_node(&mut self, node: &'a dyn AnyNode<'a>) -> bool { ... }
    fn post_visit_node(&mut self, node: &'a dyn AnyNode<'a>) { ... }
    fn pre_visit_root(&mut self, node: &'a Root<'a>) -> bool { ... }
    fn pre_visit_source_file(&mut self, node: &'a SourceFile<'a>) -> bool { ... }
    fn pre_visit_item(&mut self, node: &'a Item<'a>) -> bool { ... }
    fn pre_visit_module(&mut self, node: &'a Module<'a>) -> bool { ... }
    fn pre_visit_interface(&mut self, node: &'a Interface<'a>) -> bool { ... }
    fn pre_visit_package(&mut self, node: &'a Package<'a>) -> bool { ... }
    fn pre_visit_lifetime(&mut self, node: &'a Lifetime) -> bool { ... }
    fn pre_visit_timeunit(&mut self, node: &'a Timeunit) -> bool { ... }
    fn pre_visit_type(&mut self, node: &'a Type<'a>) -> bool { ... }
    fn pre_visit_type_kind(&mut self, node: &'a TypeKind<'a>) -> bool { ... }
    fn pre_visit_type_sign(&mut self, node: &'a TypeSign) -> bool { ... }
    fn pre_visit_type_dim(&mut self, node: &'a TypeDim<'a>) -> bool { ... }
    fn pre_visit_enum(&mut self, node: &'a Enum<'a>) -> bool { ... }
    fn pre_visit_enum_name(&mut self, node: &'a EnumName<'a>) -> bool { ... }
    fn pre_visit_struct(&mut self, node: &'a Struct<'a>) -> bool { ... }
    fn pre_visit_struct_kind(&mut self, node: &'a StructKind) -> bool { ... }
    fn pre_visit_struct_member(&mut self, node: &'a StructMember<'a>) -> bool { ... }
    fn pre_visit_port(&mut self, node: &'a Port<'a>) -> bool { ... }
    fn pre_visit_port_decl(&mut self, node: &'a PortDecl<'a>) -> bool { ... }
    fn pre_visit_var_kind(&mut self, node: &'a VarKind) -> bool { ... }
    fn pre_visit_port_dir(&mut self, node: &'a PortDir) -> bool { ... }
    fn pre_visit_net_type(&mut self, node: &'a NetType) -> bool { ... }
    fn pre_visit_procedure(&mut self, node: &'a Procedure<'a>) -> bool { ... }
    fn pre_visit_procedure_kind(&mut self, node: &'a ProcedureKind) -> bool { ... }
    fn pre_visit_stmt(&mut self, node: &'a Stmt<'a>) -> bool { ... }
    fn pre_visit_stmt_kind(&mut self, node: &'a StmtKind<'a>) -> bool { ... }
    fn pre_visit_join_kind(&mut self, node: &'a JoinKind) -> bool { ... }
    fn pre_visit_unique_priority(&mut self, node: &'a UniquePriority) -> bool { ... }
    fn pre_visit_case_kind(&mut self, node: &'a CaseKind) -> bool { ... }
    fn pre_visit_case_mode(&mut self, node: &'a CaseMode) -> bool { ... }
    fn pre_visit_case_item(&mut self, node: &'a CaseItem<'a>) -> bool { ... }
    fn pre_visit_delay_control(&mut self, node: &'a DelayControl<'a>) -> bool { ... }
    fn pre_visit_event_control(&mut self, node: &'a EventControl<'a>) -> bool { ... }
    fn pre_visit_event_control_data(
        &mut self, 
        node: &'a EventControlData<'a>
    ) -> bool { ... }
    fn pre_visit_cycle_delay(&mut self, node: &'a CycleDelay) -> bool { ... }
    fn pre_visit_timing_control(&mut self, node: &'a TimingControl<'a>) -> bool { ... }
    fn pre_visit_assign_op(&mut self, node: &'a AssignOp) -> bool { ... }
    fn pre_visit_var_decl(&mut self, node: &'a VarDecl<'a>) -> bool { ... }
    fn pre_visit_var_decl_name(&mut self, node: &'a VarDeclName<'a>) -> bool { ... }
    fn pre_visit_genvar_decl(&mut self, node: &'a GenvarDecl<'a>) -> bool { ... }
    fn pre_visit_foreach_index(&mut self, node: &'a ForeachIndex<'a>) -> bool { ... }
    fn pre_visit_expr(&mut self, node: &'a Expr<'a>) -> bool { ... }
    fn pre_visit_type_or_expr(&mut self, node: &'a TypeOrExpr<'a>) -> bool { ... }
    fn pre_visit_value_range(&mut self, node: &'a ValueRange<'a>) -> bool { ... }
    fn pre_visit_range_mode(&mut self, node: &'a RangeMode) -> bool { ... }
    fn pre_visit_call_arg(&mut self, node: &'a CallArg<'a>) -> bool { ... }
    fn pre_visit_stream_concat_slice(
        &mut self, 
        node: &'a StreamConcatSlice<'a>
    ) -> bool { ... }
    fn pre_visit_stream_expr(&mut self, node: &'a StreamExpr<'a>) -> bool { ... }
    fn pre_visit_event_expr(&mut self, node: &'a EventExpr<'a>) -> bool { ... }
    fn pre_visit_edge_ident(&mut self, node: &'a EdgeIdent) -> bool { ... }
    fn pre_visit_class_decl(&mut self, node: &'a ClassDecl<'a>) -> bool { ... }
    fn pre_visit_class_item(&mut self, node: &'a ClassItem<'a>) -> bool { ... }
    fn pre_visit_class_item_qualifier(
        &mut self, 
        node: &'a ClassItemQualifier
    ) -> bool { ... }
    fn pre_visit_class_item_data(&mut self, node: &'a ClassItemData<'a>) -> bool { ... }
    fn pre_visit_random_qualifier(&mut self, node: &'a RandomQualifier) -> bool { ... }
    fn pre_visit_typedef(&mut self, node: &'a Typedef<'a>) -> bool { ... }
    fn pre_visit_constraint(&mut self, node: &'a Constraint<'a>) -> bool { ... }
    fn pre_visit_constraint_kind(&mut self, node: &'a ConstraintKind) -> bool { ... }
    fn pre_visit_constraint_item(
        &mut self, 
        node: &'a ConstraintItem<'a>
    ) -> bool { ... }
    fn pre_visit_constraint_item_data(
        &mut self, 
        node: &'a ConstraintItemData<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_decl(
        &mut self, 
        node: &'a SubroutineDecl<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_prototype(
        &mut self, 
        node: &'a SubroutinePrototype<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_kind(&mut self, node: &'a SubroutineKind) -> bool { ... }
    fn pre_visit_subroutine_port(
        &mut self, 
        node: &'a SubroutinePort<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_port_name(
        &mut self, 
        node: &'a SubroutinePortName<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_item(
        &mut self, 
        node: &'a SubroutineItem<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_port_decl(
        &mut self, 
        node: &'a SubroutinePortDecl<'a>
    ) -> bool { ... }
    fn pre_visit_subroutine_port_dir(
        &mut self, 
        node: &'a SubroutinePortDir
    ) -> bool { ... }
    fn pre_visit_net_decl(&mut self, node: &'a NetDecl<'a>) -> bool { ... }
    fn pre_visit_net_kind(&mut self, node: &'a NetKind) -> bool { ... }
    fn pre_visit_net_strength(&mut self, node: &'a NetStrength) -> bool { ... }
    fn pre_visit_drive_strength(&mut self, node: &'a DriveStrength) -> bool { ... }
    fn pre_visit_charge_strength(&mut self, node: &'a ChargeStrength) -> bool { ... }
    fn pre_visit_pattern_field(&mut self, node: &'a PatternField<'a>) -> bool { ... }
    fn pre_visit_import_decl(&mut self, node: &'a ImportDecl<'a>) -> bool { ... }
    fn pre_visit_import_item(&mut self, node: &'a ImportItem<'a>) -> bool { ... }
    fn pre_visit_assertion(&mut self, node: &'a Assertion<'a>) -> bool { ... }
    fn pre_visit_assertion_data(&mut self, node: &'a AssertionData<'a>) -> bool { ... }
    fn pre_visit_assertion_deferred(
        &mut self, 
        node: &'a AssertionDeferred
    ) -> bool { ... }
    fn pre_visit_blocking_assertion(
        &mut self, 
        node: &'a BlockingAssertion<'a>
    ) -> bool { ... }
    fn pre_visit_concurrent_assertion(
        &mut self, 
        node: &'a ConcurrentAssertion<'a>
    ) -> bool { ... }
    fn pre_visit_assertion_action_block(
        &mut self, 
        node: &'a AssertionActionBlock<'a>
    ) -> bool { ... }
    fn pre_visit_seq_expr(&mut self, node: &'a SeqExpr<'a>) -> bool { ... }
    fn pre_visit_seq_expr_data(&mut self, node: &'a SeqExprData<'a>) -> bool { ... }
    fn pre_visit_seq_rep(&mut self, node: &'a SeqRep<'a>) -> bool { ... }
    fn pre_visit_seq_bin_op(&mut self, node: &'a SeqBinOp) -> bool { ... }
    fn pre_visit_prop_spec(&mut self, node: &'a PropSpec) -> bool { ... }
    fn pre_visit_prop_expr(&mut self, node: &'a PropExpr<'a>) -> bool { ... }
    fn pre_visit_prop_expr_data(&mut self, node: &'a PropExprData<'a>) -> bool { ... }
    fn pre_visit_prop_seq_op(&mut self, node: &'a PropSeqOp) -> bool { ... }
    fn pre_visit_prop_seq_bin_op(&mut self, node: &'a PropSeqBinOp) -> bool { ... }
    fn pre_visit_prop_bin_op(&mut self, node: &'a PropBinOp) -> bool { ... }
    fn pre_visit_inst(&mut self, node: &'a Inst<'a>) -> bool { ... }
    fn pre_visit_inst_name(&mut self, node: &'a InstName<'a>) -> bool { ... }
    fn pre_visit_modport(&mut self, node: &'a Modport<'a>) -> bool { ... }
    fn pre_visit_modport_name(&mut self, node: &'a ModportName<'a>) -> bool { ... }
    fn pre_visit_modport_port(&mut self, node: &'a ModportPort<'a>) -> bool { ... }
    fn pre_visit_modport_simple_port(
        &mut self, 
        node: &'a ModportSimplePort<'a>
    ) -> bool { ... }
    fn pre_visit_param_decl(&mut self, node: &'a ParamDecl<'a>) -> bool { ... }
    fn pre_visit_param_kind(&mut self, node: &'a ParamKind<'a>) -> bool { ... }
    fn pre_visit_param_type_decl(&mut self, node: &'a ParamTypeDecl<'a>) -> bool { ... }
    fn pre_visit_param_value_decl(
        &mut self, 
        node: &'a ParamValueDecl<'a>
    ) -> bool { ... }
    fn pre_visit_cont_assign(&mut self, node: &'a ContAssign<'a>) -> bool { ... }
    fn pre_visit_generate_for(&mut self, node: &'a GenerateFor<'a>) -> bool { ... }
    fn pre_visit_generate_if(&mut self, node: &'a GenerateIf<'a>) -> bool { ... }
    fn pre_visit_generate_case(&mut self, node: &'a GenerateCase<'a>) -> bool { ... }
    fn pre_visit_generate_block(&mut self, node: &'a GenerateBlock<'a>) -> bool { ... }
    fn pre_visit_param_assignment(
        &mut self, 
        node: &'a ParamAssignment<'a>
    ) -> bool { ... }
    fn pre_visit_port_conn(&mut self, node: &'a PortConn<'a>) -> bool { ... }
    fn pre_visit_port_conn_mode(&mut self, node: &'a PortConnMode<'a>) -> bool { ... }
    fn pre_visit_dpi_decl(&mut self, node: &'a DpiDecl<'a>) -> bool { ... }
    fn pre_visit_dpi_property(&mut self, node: &'a DpiProperty) -> bool { ... }
    fn pre_visit_data_type(&mut self, node: &'a DataType<'a>) -> bool { ... }
    fn pre_visit_int_type(&mut self, node: &'a IntType) -> bool { ... }
    fn pre_visit_real_type(&mut self, node: &'a RealType) -> bool { ... }
    fn pre_visit_implicit_data_type(
        &mut self, 
        node: &'a ImplicitDataType<'a>
    ) -> bool { ... }
    fn pre_visit_data_type_or_implicit(
        &mut self, 
        node: &'a DataTypeOrImplicit<'a>
    ) -> bool { ... }
    fn pre_visit_var_dim(&mut self, node: &'a VarDim<'a>) -> bool { ... }
    fn pre_visit_packed_dim(&mut self, node: &'a PackedDim<'a>) -> bool { ... }
    fn pre_visit_unpacked_dim(&mut self, node: &'a UnpackedDim<'a>) -> bool { ... }
    fn pre_visit_path_segment(&mut self, node: &'a PathSegment<'a>) -> bool { ... }
    fn post_visit_root(&mut self, node: &'a Root<'a>) { ... }
    fn post_visit_source_file(&mut self, node: &'a SourceFile<'a>) { ... }
    fn post_visit_item(&mut self, node: &'a Item<'a>) { ... }
    fn post_visit_module(&mut self, node: &'a Module<'a>) { ... }
    fn post_visit_interface(&mut self, node: &'a Interface<'a>) { ... }
    fn post_visit_package(&mut self, node: &'a Package<'a>) { ... }
    fn post_visit_lifetime(&mut self, node: &'a Lifetime) { ... }
    fn post_visit_timeunit(&mut self, node: &'a Timeunit) { ... }
    fn post_visit_type(&mut self, node: &'a Type<'a>) { ... }
    fn post_visit_type_kind(&mut self, node: &'a TypeKind<'a>) { ... }
    fn post_visit_type_sign(&mut self, node: &'a TypeSign) { ... }
    fn post_visit_type_dim(&mut self, node: &'a TypeDim<'a>) { ... }
    fn post_visit_enum(&mut self, node: &'a Enum<'a>) { ... }
    fn post_visit_enum_name(&mut self, node: &'a EnumName<'a>) { ... }
    fn post_visit_struct(&mut self, node: &'a Struct<'a>) { ... }
    fn post_visit_struct_kind(&mut self, node: &'a StructKind) { ... }
    fn post_visit_struct_member(&mut self, node: &'a StructMember<'a>) { ... }
    fn post_visit_port(&mut self, node: &'a Port<'a>) { ... }
    fn post_visit_port_decl(&mut self, node: &'a PortDecl<'a>) { ... }
    fn post_visit_var_kind(&mut self, node: &'a VarKind) { ... }
    fn post_visit_port_dir(&mut self, node: &'a PortDir) { ... }
    fn post_visit_net_type(&mut self, node: &'a NetType) { ... }
    fn post_visit_procedure(&mut self, node: &'a Procedure<'a>) { ... }
    fn post_visit_procedure_kind(&mut self, node: &'a ProcedureKind) { ... }
    fn post_visit_stmt(&mut self, node: &'a Stmt<'a>) { ... }
    fn post_visit_stmt_kind(&mut self, node: &'a StmtKind<'a>) { ... }
    fn post_visit_join_kind(&mut self, node: &'a JoinKind) { ... }
    fn post_visit_unique_priority(&mut self, node: &'a UniquePriority) { ... }
    fn post_visit_case_kind(&mut self, node: &'a CaseKind) { ... }
    fn post_visit_case_mode(&mut self, node: &'a CaseMode) { ... }
    fn post_visit_case_item(&mut self, node: &'a CaseItem<'a>) { ... }
    fn post_visit_delay_control(&mut self, node: &'a DelayControl<'a>) { ... }
    fn post_visit_event_control(&mut self, node: &'a EventControl<'a>) { ... }
    fn post_visit_event_control_data(&mut self, node: &'a EventControlData<'a>) { ... }
    fn post_visit_cycle_delay(&mut self, node: &'a CycleDelay) { ... }
    fn post_visit_timing_control(&mut self, node: &'a TimingControl<'a>) { ... }
    fn post_visit_assign_op(&mut self, node: &'a AssignOp) { ... }
    fn post_visit_var_decl(&mut self, node: &'a VarDecl<'a>) { ... }
    fn post_visit_var_decl_name(&mut self, node: &'a VarDeclName<'a>) { ... }
    fn post_visit_genvar_decl(&mut self, node: &'a GenvarDecl<'a>) { ... }
    fn post_visit_foreach_index(&mut self, node: &'a ForeachIndex<'a>) { ... }
    fn post_visit_expr(&mut self, node: &'a Expr<'a>) { ... }
    fn post_visit_type_or_expr(&mut self, node: &'a TypeOrExpr<'a>) { ... }
    fn post_visit_value_range(&mut self, node: &'a ValueRange<'a>) { ... }
    fn post_visit_range_mode(&mut self, node: &'a RangeMode) { ... }
    fn post_visit_call_arg(&mut self, node: &'a CallArg<'a>) { ... }
    fn post_visit_stream_concat_slice(
        &mut self, 
        node: &'a StreamConcatSlice<'a>
    ) { ... }
    fn post_visit_stream_expr(&mut self, node: &'a StreamExpr<'a>) { ... }
    fn post_visit_event_expr(&mut self, node: &'a EventExpr<'a>) { ... }
    fn post_visit_edge_ident(&mut self, node: &'a EdgeIdent) { ... }
    fn post_visit_class_decl(&mut self, node: &'a ClassDecl<'a>) { ... }
    fn post_visit_class_item(&mut self, node: &'a ClassItem<'a>) { ... }
    fn post_visit_class_item_qualifier(&mut self, node: &'a ClassItemQualifier) { ... }
    fn post_visit_class_item_data(&mut self, node: &'a ClassItemData<'a>) { ... }
    fn post_visit_random_qualifier(&mut self, node: &'a RandomQualifier) { ... }
    fn post_visit_typedef(&mut self, node: &'a Typedef<'a>) { ... }
    fn post_visit_constraint(&mut self, node: &'a Constraint<'a>) { ... }
    fn post_visit_constraint_kind(&mut self, node: &'a ConstraintKind) { ... }
    fn post_visit_constraint_item(&mut self, node: &'a ConstraintItem<'a>) { ... }
    fn post_visit_constraint_item_data(
        &mut self, 
        node: &'a ConstraintItemData<'a>
    ) { ... }
    fn post_visit_subroutine_decl(&mut self, node: &'a SubroutineDecl<'a>) { ... }
    fn post_visit_subroutine_prototype(
        &mut self, 
        node: &'a SubroutinePrototype<'a>
    ) { ... }
    fn post_visit_subroutine_kind(&mut self, node: &'a SubroutineKind) { ... }
    fn post_visit_subroutine_port(&mut self, node: &'a SubroutinePort<'a>) { ... }
    fn post_visit_subroutine_port_name(
        &mut self, 
        node: &'a SubroutinePortName<'a>
    ) { ... }
    fn post_visit_subroutine_item(&mut self, node: &'a SubroutineItem<'a>) { ... }
    fn post_visit_subroutine_port_decl(
        &mut self, 
        node: &'a SubroutinePortDecl<'a>
    ) { ... }
    fn post_visit_subroutine_port_dir(&mut self, node: &'a SubroutinePortDir) { ... }
    fn post_visit_net_decl(&mut self, node: &'a NetDecl<'a>) { ... }
    fn post_visit_net_kind(&mut self, node: &'a NetKind) { ... }
    fn post_visit_net_strength(&mut self, node: &'a NetStrength) { ... }
    fn post_visit_drive_strength(&mut self, node: &'a DriveStrength) { ... }
    fn post_visit_charge_strength(&mut self, node: &'a ChargeStrength) { ... }
    fn post_visit_pattern_field(&mut self, node: &'a PatternField<'a>) { ... }
    fn post_visit_import_decl(&mut self, node: &'a ImportDecl<'a>) { ... }
    fn post_visit_import_item(&mut self, node: &'a ImportItem<'a>) { ... }
    fn post_visit_assertion(&mut self, node: &'a Assertion<'a>) { ... }
    fn post_visit_assertion_data(&mut self, node: &'a AssertionData<'a>) { ... }
    fn post_visit_assertion_deferred(&mut self, node: &'a AssertionDeferred) { ... }
    fn post_visit_blocking_assertion(&mut self, node: &'a BlockingAssertion<'a>) { ... }
    fn post_visit_concurrent_assertion(
        &mut self, 
        node: &'a ConcurrentAssertion<'a>
    ) { ... }
    fn post_visit_assertion_action_block(
        &mut self, 
        node: &'a AssertionActionBlock<'a>
    ) { ... }
    fn post_visit_seq_expr(&mut self, node: &'a SeqExpr<'a>) { ... }
    fn post_visit_seq_expr_data(&mut self, node: &'a SeqExprData<'a>) { ... }
    fn post_visit_seq_rep(&mut self, node: &'a SeqRep<'a>) { ... }
    fn post_visit_seq_bin_op(&mut self, node: &'a SeqBinOp) { ... }
    fn post_visit_prop_spec(&mut self, node: &'a PropSpec) { ... }
    fn post_visit_prop_expr(&mut self, node: &'a PropExpr<'a>) { ... }
    fn post_visit_prop_expr_data(&mut self, node: &'a PropExprData<'a>) { ... }
    fn post_visit_prop_seq_op(&mut self, node: &'a PropSeqOp) { ... }
    fn post_visit_prop_seq_bin_op(&mut self, node: &'a PropSeqBinOp) { ... }
    fn post_visit_prop_bin_op(&mut self, node: &'a PropBinOp) { ... }
    fn post_visit_inst(&mut self, node: &'a Inst<'a>) { ... }
    fn post_visit_inst_name(&mut self, node: &'a InstName<'a>) { ... }
    fn post_visit_modport(&mut self, node: &'a Modport<'a>) { ... }
    fn post_visit_modport_name(&mut self, node: &'a ModportName<'a>) { ... }
    fn post_visit_modport_port(&mut self, node: &'a ModportPort<'a>) { ... }
    fn post_visit_modport_simple_port(
        &mut self, 
        node: &'a ModportSimplePort<'a>
    ) { ... }
    fn post_visit_param_decl(&mut self, node: &'a ParamDecl<'a>) { ... }
    fn post_visit_param_kind(&mut self, node: &'a ParamKind<'a>) { ... }
    fn post_visit_param_type_decl(&mut self, node: &'a ParamTypeDecl<'a>) { ... }
    fn post_visit_param_value_decl(&mut self, node: &'a ParamValueDecl<'a>) { ... }
    fn post_visit_cont_assign(&mut self, node: &'a ContAssign<'a>) { ... }
    fn post_visit_generate_for(&mut self, node: &'a GenerateFor<'a>) { ... }
    fn post_visit_generate_if(&mut self, node: &'a GenerateIf<'a>) { ... }
    fn post_visit_generate_case(&mut self, node: &'a GenerateCase<'a>) { ... }
    fn post_visit_generate_block(&mut self, node: &'a GenerateBlock<'a>) { ... }
    fn post_visit_param_assignment(&mut self, node: &'a ParamAssignment<'a>) { ... }
    fn post_visit_port_conn(&mut self, node: &'a PortConn<'a>) { ... }
    fn post_visit_port_conn_mode(&mut self, node: &'a PortConnMode<'a>) { ... }
    fn post_visit_dpi_decl(&mut self, node: &'a DpiDecl<'a>) { ... }
    fn post_visit_dpi_property(&mut self, node: &'a DpiProperty) { ... }
    fn post_visit_data_type(&mut self, node: &'a DataType<'a>) { ... }
    fn post_visit_int_type(&mut self, node: &'a IntType) { ... }
    fn post_visit_real_type(&mut self, node: &'a RealType) { ... }
    fn post_visit_implicit_data_type(&mut self, node: &'a ImplicitDataType<'a>) { ... }
    fn post_visit_data_type_or_implicit(
        &mut self, 
        node: &'a DataTypeOrImplicit<'a>
    ) { ... }
    fn post_visit_var_dim(&mut self, node: &'a VarDim<'a>) { ... }
    fn post_visit_packed_dim(&mut self, node: &'a PackedDim<'a>) { ... }
    fn post_visit_unpacked_dim(&mut self, node: &'a UnpackedDim<'a>) { ... }
    fn post_visit_path_segment(&mut self, node: &'a PathSegment<'a>) { ... }
}

A visitor.

Use the accept() function to start visiting nodes. For example:

struct MagicVisitor;

impl Visitor for MagicVisitor {
}

node.accept(&mut MagicVisitor);

Implements the visitor pattern over the following nodes:

• Root
• SourceFile
• Item
• Module
• Interface
• Package
• Lifetime
• Timeunit
• Type
• TypeKind
• TypeSign
• TypeDim
• Enum
• EnumName
• Struct
• StructKind
• StructMember
• Port
• PortDecl
• VarKind
• PortDir
• NetType
• Procedure
• ProcedureKind
• Stmt
• StmtKind
• JoinKind
• UniquePriority
• CaseKind
• CaseMode
• CaseItem
• DelayControl
• EventControl
• EventControlData
• CycleDelay
• TimingControl
• AssignOp
• VarDecl
• VarDeclName
• GenvarDecl
• ForeachIndex
• Expr
• TypeOrExpr
• ValueRange
• RangeMode
• CallArg
• StreamConcatSlice
• StreamExpr
• EventExpr
• EdgeIdent
• ClassDecl
• ClassItem
• ClassItemQualifier
• ClassItemData
• RandomQualifier
• Typedef
• Constraint
• ConstraintKind
• ConstraintItem
• ConstraintItemData
• SubroutineDecl
• SubroutinePrototype
• SubroutineKind
• SubroutinePort
• SubroutinePortName
• SubroutineItem
• SubroutinePortDecl
• SubroutinePortDir
• NetDecl
• NetKind
• NetStrength
• DriveStrength
• ChargeStrength
• PatternField
• ImportDecl
• ImportItem
• Assertion
• AssertionData
• AssertionDeferred
• BlockingAssertion
• ConcurrentAssertion
• AssertionActionBlock
• SeqExpr
• SeqExprData
• SeqRep
• SeqBinOp
• PropSpec
• PropExpr
• PropExprData
• PropSeqOp
• PropSeqBinOp
• PropBinOp
• Inst
• InstName
• Modport
• ModportName
• ModportPort
• ModportSimplePort
• ParamDecl
• ParamKind
• ParamTypeDecl
• ParamValueDecl
• ContAssign
• GenerateFor
• GenerateIf
• GenerateCase
• GenerateBlock
• ParamAssignment
• PortConn
• PortConnMode
• DpiDecl
• DpiProperty
• DataType
• IntType
• RealType
• ImplicitDataType
• DataTypeOrImplicit
• VarDim
• PackedDim
• UnpackedDim
• PathSegment

Provided methods

fn pre_visit_node(&mut self, node: &'a dyn AnyNode<'a>) -> bool

Called for every node before visiting its children.

Return false from this function to not visit the node's children.

fn post_visit_node(&mut self, node: &'a dyn AnyNode<'a>)

Called for every node after visiting its children.

fn pre_visit_root(&mut self, node: &'a Root<'a>) -> bool

Called for every Root node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_source_file(&mut self, node: &'a SourceFile<'a>) -> bool

Called for every SourceFile node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_item(&mut self, node: &'a Item<'a>) -> bool

Called for every Item node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_module(&mut self, node: &'a Module<'a>) -> bool

Called for every Module node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_interface(&mut self, node: &'a Interface<'a>) -> bool

Called for every Interface node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_package(&mut self, node: &'a Package<'a>) -> bool

Called for every Package node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_lifetime(&mut self, node: &'a Lifetime) -> bool

Called for every Lifetime node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_timeunit(&mut self, node: &'a Timeunit) -> bool

Called for every Timeunit node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_type(&mut self, node: &'a Type<'a>) -> bool

Called for every Type node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_type_kind(&mut self, node: &'a TypeKind<'a>) -> bool

Called for every TypeKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_type_sign(&mut self, node: &'a TypeSign) -> bool

Called for every TypeSign node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_type_dim(&mut self, node: &'a TypeDim<'a>) -> bool

Called for every TypeDim node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_enum(&mut self, node: &'a Enum<'a>) -> bool

Called for every Enum node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_enum_name(&mut self, node: &'a EnumName<'a>) -> bool

Called for every EnumName node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_struct(&mut self, node: &'a Struct<'a>) -> bool

Called for every Struct node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_struct_kind(&mut self, node: &'a StructKind) -> bool

Called for every StructKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_struct_member(&mut self, node: &'a StructMember<'a>) -> bool

Called for every StructMember node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_port(&mut self, node: &'a Port<'a>) -> bool

Called for every Port node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_port_decl(&mut self, node: &'a PortDecl<'a>) -> bool

Called for every PortDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_var_kind(&mut self, node: &'a VarKind) -> bool

Called for every VarKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_port_dir(&mut self, node: &'a PortDir) -> bool

Called for every PortDir node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_net_type(&mut self, node: &'a NetType) -> bool

Called for every NetType node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_procedure(&mut self, node: &'a Procedure<'a>) -> bool

Called for every Procedure node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_procedure_kind(&mut self, node: &'a ProcedureKind) -> bool

Called for every ProcedureKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_stmt(&mut self, node: &'a Stmt<'a>) -> bool

Called for every Stmt node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_stmt_kind(&mut self, node: &'a StmtKind<'a>) -> bool

Called for every StmtKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_join_kind(&mut self, node: &'a JoinKind) -> bool

Called for every JoinKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_unique_priority(&mut self, node: &'a UniquePriority) -> bool

Called for every UniquePriority node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_case_kind(&mut self, node: &'a CaseKind) -> bool

Called for every CaseKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_case_mode(&mut self, node: &'a CaseMode) -> bool

Called for every CaseMode node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_case_item(&mut self, node: &'a CaseItem<'a>) -> bool

Called for every CaseItem node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_delay_control(&mut self, node: &'a DelayControl<'a>) -> bool

Called for every DelayControl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_event_control(&mut self, node: &'a EventControl<'a>) -> bool

Called for every EventControl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_event_control_data(
    &mut self,
    node: &'a EventControlData<'a>
) -> bool

Called for every EventControlData node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_cycle_delay(&mut self, node: &'a CycleDelay) -> bool

Called for every CycleDelay node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_timing_control(&mut self, node: &'a TimingControl<'a>) -> bool

Called for every TimingControl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_assign_op(&mut self, node: &'a AssignOp) -> bool

Called for every AssignOp node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_var_decl(&mut self, node: &'a VarDecl<'a>) -> bool

Called for every VarDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_var_decl_name(&mut self, node: &'a VarDeclName<'a>) -> bool

Called for every VarDeclName node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_genvar_decl(&mut self, node: &'a GenvarDecl<'a>) -> bool

Called for every GenvarDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_foreach_index(&mut self, node: &'a ForeachIndex<'a>) -> bool

Called for every ForeachIndex node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_expr(&mut self, node: &'a Expr<'a>) -> bool

Called for every Expr node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_type_or_expr(&mut self, node: &'a TypeOrExpr<'a>) -> bool

Called for every TypeOrExpr node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_value_range(&mut self, node: &'a ValueRange<'a>) -> bool

Called for every ValueRange node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_range_mode(&mut self, node: &'a RangeMode) -> bool

Called for every RangeMode node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_call_arg(&mut self, node: &'a CallArg<'a>) -> bool

Called for every CallArg node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_stream_concat_slice(
    &mut self,
    node: &'a StreamConcatSlice<'a>
) -> bool

Called for every StreamConcatSlice node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_stream_expr(&mut self, node: &'a StreamExpr<'a>) -> bool

Called for every StreamExpr node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_event_expr(&mut self, node: &'a EventExpr<'a>) -> bool

Called for every EventExpr node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_edge_ident(&mut self, node: &'a EdgeIdent) -> bool

Called for every EdgeIdent node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_class_decl(&mut self, node: &'a ClassDecl<'a>) -> bool

Called for every ClassDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_class_item(&mut self, node: &'a ClassItem<'a>) -> bool

Called for every ClassItem node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_class_item_qualifier(
    &mut self,
    node: &'a ClassItemQualifier
) -> bool

Called for every ClassItemQualifier node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_class_item_data(&mut self, node: &'a ClassItemData<'a>) -> bool

Called for every ClassItemData node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_random_qualifier(&mut self, node: &'a RandomQualifier) -> bool

Called for every RandomQualifier node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_typedef(&mut self, node: &'a Typedef<'a>) -> bool

Called for every Typedef node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_constraint(&mut self, node: &'a Constraint<'a>) -> bool

Called for every Constraint node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_constraint_kind(&mut self, node: &'a ConstraintKind) -> bool

Called for every ConstraintKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_constraint_item(&mut self, node: &'a ConstraintItem<'a>) -> bool

Called for every ConstraintItem node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_constraint_item_data(
    &mut self,
    node: &'a ConstraintItemData<'a>
) -> bool

Called for every ConstraintItemData node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_decl(&mut self, node: &'a SubroutineDecl<'a>) -> bool

Called for every SubroutineDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_prototype(
    &mut self,
    node: &'a SubroutinePrototype<'a>
) -> bool

Called for every SubroutinePrototype node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_kind(&mut self, node: &'a SubroutineKind) -> bool

Called for every SubroutineKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_port(&mut self, node: &'a SubroutinePort<'a>) -> bool

Called for every SubroutinePort node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_port_name(
    &mut self,
    node: &'a SubroutinePortName<'a>
) -> bool

Called for every SubroutinePortName node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_item(&mut self, node: &'a SubroutineItem<'a>) -> bool

Called for every SubroutineItem node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_port_decl(
    &mut self,
    node: &'a SubroutinePortDecl<'a>
) -> bool

Called for every SubroutinePortDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_subroutine_port_dir(&mut self, node: &'a SubroutinePortDir) -> bool

Called for every SubroutinePortDir node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_net_decl(&mut self, node: &'a NetDecl<'a>) -> bool

Called for every NetDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_net_kind(&mut self, node: &'a NetKind) -> bool

Called for every NetKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_net_strength(&mut self, node: &'a NetStrength) -> bool

Called for every NetStrength node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_drive_strength(&mut self, node: &'a DriveStrength) -> bool

Called for every DriveStrength node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_charge_strength(&mut self, node: &'a ChargeStrength) -> bool

Called for every ChargeStrength node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_pattern_field(&mut self, node: &'a PatternField<'a>) -> bool

Called for every PatternField node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_import_decl(&mut self, node: &'a ImportDecl<'a>) -> bool

Called for every ImportDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_import_item(&mut self, node: &'a ImportItem<'a>) -> bool

Called for every ImportItem node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_assertion(&mut self, node: &'a Assertion<'a>) -> bool

Called for every Assertion node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_assertion_data(&mut self, node: &'a AssertionData<'a>) -> bool

Called for every AssertionData node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_assertion_deferred(&mut self, node: &'a AssertionDeferred) -> bool

Called for every AssertionDeferred node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_blocking_assertion(
    &mut self,
    node: &'a BlockingAssertion<'a>
) -> bool

Called for every BlockingAssertion node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_concurrent_assertion(
    &mut self,
    node: &'a ConcurrentAssertion<'a>
) -> bool

Called for every ConcurrentAssertion node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_assertion_action_block(
    &mut self,
    node: &'a AssertionActionBlock<'a>
) -> bool

Called for every AssertionActionBlock node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_seq_expr(&mut self, node: &'a SeqExpr<'a>) -> bool

Called for every SeqExpr node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_seq_expr_data(&mut self, node: &'a SeqExprData<'a>) -> bool

Called for every SeqExprData node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_seq_rep(&mut self, node: &'a SeqRep<'a>) -> bool

Called for every SeqRep node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_seq_bin_op(&mut self, node: &'a SeqBinOp) -> bool

Called for every SeqBinOp node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_prop_spec(&mut self, node: &'a PropSpec) -> bool

Called for every PropSpec node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_prop_expr(&mut self, node: &'a PropExpr<'a>) -> bool

Called for every PropExpr node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_prop_expr_data(&mut self, node: &'a PropExprData<'a>) -> bool

Called for every PropExprData node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_prop_seq_op(&mut self, node: &'a PropSeqOp) -> bool

Called for every PropSeqOp node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_prop_seq_bin_op(&mut self, node: &'a PropSeqBinOp) -> bool

Called for every PropSeqBinOp node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_prop_bin_op(&mut self, node: &'a PropBinOp) -> bool

Called for every PropBinOp node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_inst(&mut self, node: &'a Inst<'a>) -> bool

Called for every Inst node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_inst_name(&mut self, node: &'a InstName<'a>) -> bool

Called for every InstName node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_modport(&mut self, node: &'a Modport<'a>) -> bool

Called for every Modport node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_modport_name(&mut self, node: &'a ModportName<'a>) -> bool

Called for every ModportName node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_modport_port(&mut self, node: &'a ModportPort<'a>) -> bool

Called for every ModportPort node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_modport_simple_port(
    &mut self,
    node: &'a ModportSimplePort<'a>
) -> bool

Called for every ModportSimplePort node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_param_decl(&mut self, node: &'a ParamDecl<'a>) -> bool

Called for every ParamDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_param_kind(&mut self, node: &'a ParamKind<'a>) -> bool

Called for every ParamKind node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_param_type_decl(&mut self, node: &'a ParamTypeDecl<'a>) -> bool

Called for every ParamTypeDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_param_value_decl(&mut self, node: &'a ParamValueDecl<'a>) -> bool

Called for every ParamValueDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_cont_assign(&mut self, node: &'a ContAssign<'a>) -> bool

Called for every ContAssign node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_generate_for(&mut self, node: &'a GenerateFor<'a>) -> bool

Called for every GenerateFor node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_generate_if(&mut self, node: &'a GenerateIf<'a>) -> bool

Called for every GenerateIf node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_generate_case(&mut self, node: &'a GenerateCase<'a>) -> bool

Called for every GenerateCase node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_generate_block(&mut self, node: &'a GenerateBlock<'a>) -> bool

Called for every GenerateBlock node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_param_assignment(&mut self, node: &'a ParamAssignment<'a>) -> bool

Called for every ParamAssignment node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_port_conn(&mut self, node: &'a PortConn<'a>) -> bool

Called for every PortConn node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_port_conn_mode(&mut self, node: &'a PortConnMode<'a>) -> bool

Called for every PortConnMode node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_dpi_decl(&mut self, node: &'a DpiDecl<'a>) -> bool

Called for every DpiDecl node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_dpi_property(&mut self, node: &'a DpiProperty) -> bool

Called for every DpiProperty node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_data_type(&mut self, node: &'a DataType<'a>) -> bool

Called for every DataType node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_int_type(&mut self, node: &'a IntType) -> bool

Called for every IntType node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_real_type(&mut self, node: &'a RealType) -> bool

Called for every RealType node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_implicit_data_type(
    &mut self,
    node: &'a ImplicitDataType<'a>
) -> bool

Called for every ImplicitDataType node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_data_type_or_implicit(
    &mut self,
    node: &'a DataTypeOrImplicit<'a>
) -> bool

Called for every DataTypeOrImplicit node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_var_dim(&mut self, node: &'a VarDim<'a>) -> bool

Called for every VarDim node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_packed_dim(&mut self, node: &'a PackedDim<'a>) -> bool

Called for every PackedDim node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_unpacked_dim(&mut self, node: &'a UnpackedDim<'a>) -> bool

Called for every UnpackedDim node before visiting its children.

Return false from this function to not visit the node's children.

fn pre_visit_path_segment(&mut self, node: &'a PathSegment<'a>) -> bool

Called for every PathSegment node before visiting its children.

Return false from this function to not visit the node's children.

fn post_visit_root(&mut self, node: &'a Root<'a>)

Called for every Root node after visiting its children.

fn post_visit_source_file(&mut self, node: &'a SourceFile<'a>)

Called for every SourceFile node after visiting its children.

fn post_visit_item(&mut self, node: &'a Item<'a>)

Called for every Item node after visiting its children.

fn post_visit_module(&mut self, node: &'a Module<'a>)

Called for every Module node after visiting its children.

fn post_visit_interface(&mut self, node: &'a Interface<'a>)

Called for every Interface node after visiting its children.

fn post_visit_package(&mut self, node: &'a Package<'a>)

Called for every Package node after visiting its children.

fn post_visit_lifetime(&mut self, node: &'a Lifetime)

Called for every Lifetime node after visiting its children.

fn post_visit_timeunit(&mut self, node: &'a Timeunit)

Called for every Timeunit node after visiting its children.

fn post_visit_type(&mut self, node: &'a Type<'a>)

Called for every Type node after visiting its children.

fn post_visit_type_kind(&mut self, node: &'a TypeKind<'a>)

Called for every TypeKind node after visiting its children.

fn post_visit_type_sign(&mut self, node: &'a TypeSign)

Called for every TypeSign node after visiting its children.

fn post_visit_type_dim(&mut self, node: &'a TypeDim<'a>)

Called for every TypeDim node after visiting its children.

fn post_visit_enum(&mut self, node: &'a Enum<'a>)

Called for every Enum node after visiting its children.

fn post_visit_enum_name(&mut self, node: &'a EnumName<'a>)

Called for every EnumName node after visiting its children.

fn post_visit_struct(&mut self, node: &'a Struct<'a>)

Called for every Struct node after visiting its children.

fn post_visit_struct_kind(&mut self, node: &'a StructKind)

Called for every StructKind node after visiting its children.

fn post_visit_struct_member(&mut self, node: &'a StructMember<'a>)

Called for every StructMember node after visiting its children.

fn post_visit_port(&mut self, node: &'a Port<'a>)

Called for every Port node after visiting its children.

fn post_visit_port_decl(&mut self, node: &'a PortDecl<'a>)

Called for every PortDecl node after visiting its children.

fn post_visit_var_kind(&mut self, node: &'a VarKind)

Called for every VarKind node after visiting its children.

fn post_visit_port_dir(&mut self, node: &'a PortDir)

Called for every PortDir node after visiting its children.

fn post_visit_net_type(&mut self, node: &'a NetType)

Called for every NetType node after visiting its children.

fn post_visit_procedure(&mut self, node: &'a Procedure<'a>)

Called for every Procedure node after visiting its children.

fn post_visit_procedure_kind(&mut self, node: &'a ProcedureKind)

Called for every ProcedureKind node after visiting its children.

fn post_visit_stmt(&mut self, node: &'a Stmt<'a>)

Called for every Stmt node after visiting its children.

fn post_visit_stmt_kind(&mut self, node: &'a StmtKind<'a>)

Called for every StmtKind node after visiting its children.

fn post_visit_join_kind(&mut self, node: &'a JoinKind)

Called for every JoinKind node after visiting its children.

fn post_visit_unique_priority(&mut self, node: &'a UniquePriority)

Called for every UniquePriority node after visiting its children.

fn post_visit_case_kind(&mut self, node: &'a CaseKind)

Called for every CaseKind node after visiting its children.

fn post_visit_case_mode(&mut self, node: &'a CaseMode)

Called for every CaseMode node after visiting its children.

fn post_visit_case_item(&mut self, node: &'a CaseItem<'a>)

Called for every CaseItem node after visiting its children.

fn post_visit_delay_control(&mut self, node: &'a DelayControl<'a>)

Called for every DelayControl node after visiting its children.

fn post_visit_event_control(&mut self, node: &'a EventControl<'a>)

Called for every EventControl node after visiting its children.

fn post_visit_event_control_data(&mut self, node: &'a EventControlData<'a>)

Called for every EventControlData node after visiting its children.

fn post_visit_cycle_delay(&mut self, node: &'a CycleDelay)

Called for every CycleDelay node after visiting its children.

fn post_visit_timing_control(&mut self, node: &'a TimingControl<'a>)

Called for every TimingControl node after visiting its children.

fn post_visit_assign_op(&mut self, node: &'a AssignOp)

Called for every AssignOp node after visiting its children.

fn post_visit_var_decl(&mut self, node: &'a VarDecl<'a>)

Called for every VarDecl node after visiting its children.

fn post_visit_var_decl_name(&mut self, node: &'a VarDeclName<'a>)

Called for every VarDeclName node after visiting its children.

fn post_visit_genvar_decl(&mut self, node: &'a GenvarDecl<'a>)

Called for every GenvarDecl node after visiting its children.

fn post_visit_foreach_index(&mut self, node: &'a ForeachIndex<'a>)

Called for every ForeachIndex node after visiting its children.

fn post_visit_expr(&mut self, node: &'a Expr<'a>)

Called for every Expr node after visiting its children.

fn post_visit_type_or_expr(&mut self, node: &'a TypeOrExpr<'a>)

Called for every TypeOrExpr node after visiting its children.

fn post_visit_value_range(&mut self, node: &'a ValueRange<'a>)

Called for every ValueRange node after visiting its children.

fn post_visit_range_mode(&mut self, node: &'a RangeMode)

Called for every RangeMode node after visiting its children.

fn post_visit_call_arg(&mut self, node: &'a CallArg<'a>)

Called for every CallArg node after visiting its children.

fn post_visit_stream_concat_slice(&mut self, node: &'a StreamConcatSlice<'a>)

Called for every StreamConcatSlice node after visiting its children.

fn post_visit_stream_expr(&mut self, node: &'a StreamExpr<'a>)

Called for every StreamExpr node after visiting its children.

fn post_visit_event_expr(&mut self, node: &'a EventExpr<'a>)

Called for every EventExpr node after visiting its children.

fn post_visit_edge_ident(&mut self, node: &'a EdgeIdent)

Called for every EdgeIdent node after visiting its children.

fn post_visit_class_decl(&mut self, node: &'a ClassDecl<'a>)

Called for every ClassDecl node after visiting its children.

fn post_visit_class_item(&mut self, node: &'a ClassItem<'a>)

Called for every ClassItem node after visiting its children.

fn post_visit_class_item_qualifier(&mut self, node: &'a ClassItemQualifier)

Called for every ClassItemQualifier node after visiting its children.

fn post_visit_class_item_data(&mut self, node: &'a ClassItemData<'a>)

Called for every ClassItemData node after visiting its children.

fn post_visit_random_qualifier(&mut self, node: &'a RandomQualifier)

Called for every RandomQualifier node after visiting its children.

fn post_visit_typedef(&mut self, node: &'a Typedef<'a>)

Called for every Typedef node after visiting its children.

fn post_visit_constraint(&mut self, node: &'a Constraint<'a>)

Called for every Constraint node after visiting its children.

fn post_visit_constraint_kind(&mut self, node: &'a ConstraintKind)

Called for every ConstraintKind node after visiting its children.

fn post_visit_constraint_item(&mut self, node: &'a ConstraintItem<'a>)

Called for every ConstraintItem node after visiting its children.

fn post_visit_constraint_item_data(&mut self, node: &'a ConstraintItemData<'a>)

Called for every ConstraintItemData node after visiting its children.

fn post_visit_subroutine_decl(&mut self, node: &'a SubroutineDecl<'a>)

Called for every SubroutineDecl node after visiting its children.

fn post_visit_subroutine_prototype(&mut self, node: &'a SubroutinePrototype<'a>)

Called for every SubroutinePrototype node after visiting its children.

fn post_visit_subroutine_kind(&mut self, node: &'a SubroutineKind)

Called for every SubroutineKind node after visiting its children.

fn post_visit_subroutine_port(&mut self, node: &'a SubroutinePort<'a>)

Called for every SubroutinePort node after visiting its children.

fn post_visit_subroutine_port_name(&mut self, node: &'a SubroutinePortName<'a>)

Called for every SubroutinePortName node after visiting its children.

fn post_visit_subroutine_item(&mut self, node: &'a SubroutineItem<'a>)

Called for every SubroutineItem node after visiting its children.

fn post_visit_subroutine_port_decl(&mut self, node: &'a SubroutinePortDecl<'a>)

Called for every SubroutinePortDecl node after visiting its children.

fn post_visit_subroutine_port_dir(&mut self, node: &'a SubroutinePortDir)

Called for every SubroutinePortDir node after visiting its children.

fn post_visit_net_decl(&mut self, node: &'a NetDecl<'a>)

Called for every NetDecl node after visiting its children.

fn post_visit_net_kind(&mut self, node: &'a NetKind)

Called for every NetKind node after visiting its children.

fn post_visit_net_strength(&mut self, node: &'a NetStrength)

Called for every NetStrength node after visiting its children.

fn post_visit_drive_strength(&mut self, node: &'a DriveStrength)

Called for every DriveStrength node after visiting its children.

fn post_visit_charge_strength(&mut self, node: &'a ChargeStrength)

Called for every ChargeStrength node after visiting its children.

fn post_visit_pattern_field(&mut self, node: &'a PatternField<'a>)

Called for every PatternField node after visiting its children.

fn post_visit_import_decl(&mut self, node: &'a ImportDecl<'a>)

Called for every ImportDecl node after visiting its children.

fn post_visit_import_item(&mut self, node: &'a ImportItem<'a>)

Called for every ImportItem node after visiting its children.

fn post_visit_assertion(&mut self, node: &'a Assertion<'a>)

Called for every Assertion node after visiting its children.

fn post_visit_assertion_data(&mut self, node: &'a AssertionData<'a>)

Called for every AssertionData node after visiting its children.

fn post_visit_assertion_deferred(&mut self, node: &'a AssertionDeferred)

Called for every AssertionDeferred node after visiting its children.

fn post_visit_blocking_assertion(&mut self, node: &'a BlockingAssertion<'a>)

Called for every BlockingAssertion node after visiting its children.

fn post_visit_concurrent_assertion(&mut self, node: &'a ConcurrentAssertion<'a>)

Called for every ConcurrentAssertion node after visiting its children.

fn post_visit_assertion_action_block(
    &mut self,
    node: &'a AssertionActionBlock<'a>
)

Called for every AssertionActionBlock node after visiting its children.

fn post_visit_seq_expr(&mut self, node: &'a SeqExpr<'a>)

Called for every SeqExpr node after visiting its children.

fn post_visit_seq_expr_data(&mut self, node: &'a SeqExprData<'a>)

Called for every SeqExprData node after visiting its children.

fn post_visit_seq_rep(&mut self, node: &'a SeqRep<'a>)

Called for every SeqRep node after visiting its children.

fn post_visit_seq_bin_op(&mut self, node: &'a SeqBinOp)

Called for every SeqBinOp node after visiting its children.

fn post_visit_prop_spec(&mut self, node: &'a PropSpec)

Called for every PropSpec node after visiting its children.

fn post_visit_prop_expr(&mut self, node: &'a PropExpr<'a>)

Called for every PropExpr node after visiting its children.

fn post_visit_prop_expr_data(&mut self, node: &'a PropExprData<'a>)

Called for every PropExprData node after visiting its children.

fn post_visit_prop_seq_op(&mut self, node: &'a PropSeqOp)

Called for every PropSeqOp node after visiting its children.

fn post_visit_prop_seq_bin_op(&mut self, node: &'a PropSeqBinOp)

Called for every PropSeqBinOp node after visiting its children.

fn post_visit_prop_bin_op(&mut self, node: &'a PropBinOp)

Called for every PropBinOp node after visiting its children.

fn post_visit_inst(&mut self, node: &'a Inst<'a>)

Called for every Inst node after visiting its children.

fn post_visit_inst_name(&mut self, node: &'a InstName<'a>)

Called for every InstName node after visiting its children.

fn post_visit_modport(&mut self, node: &'a Modport<'a>)

Called for every Modport node after visiting its children.

fn post_visit_modport_name(&mut self, node: &'a ModportName<'a>)

Called for every ModportName node after visiting its children.

fn post_visit_modport_port(&mut self, node: &'a ModportPort<'a>)

Called for every ModportPort node after visiting its children.

fn post_visit_modport_simple_port(&mut self, node: &'a ModportSimplePort<'a>)

Called for every ModportSimplePort node after visiting its children.

fn post_visit_param_decl(&mut self, node: &'a ParamDecl<'a>)

Called for every ParamDecl node after visiting its children.

fn post_visit_param_kind(&mut self, node: &'a ParamKind<'a>)

Called for every ParamKind node after visiting its children.

fn post_visit_param_type_decl(&mut self, node: &'a ParamTypeDecl<'a>)

Called for every ParamTypeDecl node after visiting its children.

fn post_visit_param_value_decl(&mut self, node: &'a ParamValueDecl<'a>)

Called for every ParamValueDecl node after visiting its children.

fn post_visit_cont_assign(&mut self, node: &'a ContAssign<'a>)

Called for every ContAssign node after visiting its children.

fn post_visit_generate_for(&mut self, node: &'a GenerateFor<'a>)

Called for every GenerateFor node after visiting its children.

fn post_visit_generate_if(&mut self, node: &'a GenerateIf<'a>)

Called for every GenerateIf node after visiting its children.

fn post_visit_generate_case(&mut self, node: &'a GenerateCase<'a>)

Called for every GenerateCase node after visiting its children.

fn post_visit_generate_block(&mut self, node: &'a GenerateBlock<'a>)

Called for every GenerateBlock node after visiting its children.

fn post_visit_param_assignment(&mut self, node: &'a ParamAssignment<'a>)

Called for every ParamAssignment node after visiting its children.

fn post_visit_port_conn(&mut self, node: &'a PortConn<'a>)

Called for every PortConn node after visiting its children.

fn post_visit_port_conn_mode(&mut self, node: &'a PortConnMode<'a>)

Called for every PortConnMode node after visiting its children.

fn post_visit_dpi_decl(&mut self, node: &'a DpiDecl<'a>)

Called for every DpiDecl node after visiting its children.

fn post_visit_dpi_property(&mut self, node: &'a DpiProperty)

Called for every DpiProperty node after visiting its children.

fn post_visit_data_type(&mut self, node: &'a DataType<'a>)

Called for every DataType node after visiting its children.

fn post_visit_int_type(&mut self, node: &'a IntType)

Called for every IntType node after visiting its children.

fn post_visit_real_type(&mut self, node: &'a RealType)

Called for every RealType node after visiting its children.

fn post_visit_implicit_data_type(&mut self, node: &'a ImplicitDataType<'a>)

Called for every ImplicitDataType node after visiting its children.

fn post_visit_data_type_or_implicit(&mut self, node: &'a DataTypeOrImplicit<'a>)

Called for every DataTypeOrImplicit node after visiting its children.

fn post_visit_var_dim(&mut self, node: &'a VarDim<'a>)

Called for every VarDim node after visiting its children.

fn post_visit_packed_dim(&mut self, node: &'a PackedDim<'a>)

Called for every PackedDim node after visiting its children.

fn post_visit_unpacked_dim(&mut self, node: &'a UnpackedDim<'a>)

Called for every UnpackedDim node after visiting its children.

fn post_visit_path_segment(&mut self, node: &'a PathSegment<'a>)

Called for every PathSegment node after visiting its children.

Loading content...

Implementors

Loading content...