Trait moore_svlog::ast::Visitor

pub trait Visitor<'a> {
    pub fn pre_visit_node(&mut self, node: &'a (dyn AnyNode<'a> + 'a)) -> bool { ... }
    pub fn post_visit_node(&mut self, node: &'a (dyn AnyNode<'a> + 'a)) { ... }
    pub fn pre_visit_root(&mut self, node: &'a Node<'a, RootData<'a>>) -> bool { ... }
    pub fn pre_visit_source_file(
        &mut self, 
        node: &'a Node<'a, SourceFileData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_item(&mut self, node: &'a Node<'a, ItemData<'a>>) -> bool { ... }
    pub fn pre_visit_module(
        &mut self, 
        node: &'a Node<'a, ModuleData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_interface(
        &mut self, 
        node: &'a Node<'a, InterfaceData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_package(
        &mut self, 
        node: &'a Node<'a, PackageData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_lifetime(&mut self, node: &'a Lifetime) -> bool { ... }
    pub fn pre_visit_timeunit(&mut self, node: &'a Timeunit) -> bool { ... }
    pub fn pre_visit_type(&mut self, node: &'a Node<'a, TypeData<'a>>) -> bool { ... }
    pub fn pre_visit_type_kind(
        &mut self, 
        node: &'a Node<'a, TypeKindData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_type_sign(&mut self, node: &'a TypeSign) -> bool { ... }
    pub fn pre_visit_type_dim(&mut self, node: &'a TypeDim<'a>) -> bool { ... }
    pub fn pre_visit_enum(&mut self, node: &'a Node<'a, EnumData<'a>>) -> bool { ... }
    pub fn pre_visit_enum_name(
        &mut self, 
        node: &'a Node<'a, EnumNameData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_struct(
        &mut self, 
        node: &'a Node<'a, StructData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_struct_kind(&mut self, node: &'a StructKind) -> bool { ... }
    pub fn pre_visit_struct_member(
        &mut self, 
        node: &'a Node<'a, StructMemberData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_port(&mut self, node: &'a Node<'a, PortData<'a>>) -> bool { ... }
    pub fn pre_visit_port_decl(
        &mut self, 
        node: &'a Node<'a, PortDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_var_kind(&mut self, node: &'a VarKind) -> bool { ... }
    pub fn pre_visit_port_dir(&mut self, node: &'a PortDir) -> bool { ... }
    pub fn pre_visit_net_type(&mut self, node: &'a NetType) -> bool { ... }
    pub fn pre_visit_procedure(
        &mut self, 
        node: &'a Node<'a, ProcedureData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_procedure_kind(&mut self, node: &'a ProcedureKind) -> bool { ... }
    pub fn pre_visit_stmt(&mut self, node: &'a Node<'a, StmtData<'a>>) -> bool { ... }
    pub fn pre_visit_stmt_kind(&mut self, node: &'a StmtKind<'a>) -> bool { ... }
    pub fn pre_visit_join_kind(&mut self, node: &'a JoinKind) -> bool { ... }
    pub fn pre_visit_unique_priority(
        &mut self, 
        node: &'a UniquePriority
    ) -> bool { ... }
    pub fn pre_visit_case_kind(&mut self, node: &'a CaseKind) -> bool { ... }
    pub fn pre_visit_case_mode(&mut self, node: &'a CaseMode) -> bool { ... }
    pub fn pre_visit_case_item(&mut self, node: &'a CaseItem<'a>) -> bool { ... }
    pub fn pre_visit_delay_control(
        &mut self, 
        node: &'a DelayControl<'a>
    ) -> bool { ... }
    pub fn pre_visit_event_control(
        &mut self, 
        node: &'a EventControl<'a>
    ) -> bool { ... }
    pub fn pre_visit_event_control_data(
        &mut self, 
        node: &'a EventControlData<'a>
    ) -> bool { ... }
    pub fn pre_visit_cycle_delay(&mut self, node: &'a CycleDelay) -> bool { ... }
    pub fn pre_visit_timing_control(
        &mut self, 
        node: &'a TimingControl<'a>
    ) -> bool { ... }
    pub fn pre_visit_assign_op(&mut self, node: &'a AssignOp) -> bool { ... }
    pub fn pre_visit_var_decl(
        &mut self, 
        node: &'a Node<'a, VarDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_var_decl_name(
        &mut self, 
        node: &'a Node<'a, VarDeclNameData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_genvar_decl(
        &mut self, 
        node: &'a Node<'a, GenvarDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_foreach_index(
        &mut self, 
        node: &'a Node<'a, ForeachIndexData>
    ) -> bool { ... }
    pub fn pre_visit_expr(&mut self, node: &'a Node<'a, ExprData<'a>>) -> bool { ... }
    pub fn pre_visit_type_or_expr(&mut self, node: &'a TypeOrExpr<'a>) -> bool { ... }
    pub fn pre_visit_value_range(&mut self, node: &'a ValueRange<'a>) -> bool { ... }
    pub fn pre_visit_range_mode(&mut self, node: &'a RangeMode) -> bool { ... }
    pub fn pre_visit_call_arg(&mut self, node: &'a CallArg<'a>) -> bool { ... }
    pub fn pre_visit_stream_concat_slice(
        &mut self, 
        node: &'a StreamConcatSlice<'a>
    ) -> bool { ... }
    pub fn pre_visit_stream_expr(&mut self, node: &'a StreamExpr<'a>) -> bool { ... }
    pub fn pre_visit_event_expr(&mut self, node: &'a EventExpr<'a>) -> bool { ... }
    pub fn pre_visit_edge_ident(&mut self, node: &'a EdgeIdent) -> bool { ... }
    pub fn pre_visit_class_decl(
        &mut self, 
        node: &'a Node<'a, ClassDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_class_item(&mut self, node: &'a ClassItem<'a>) -> bool { ... }
    pub fn pre_visit_class_item_qualifier(
        &mut self, 
        node: &'a ClassItemQualifier
    ) -> bool { ... }
    pub fn pre_visit_class_item_data(
        &mut self, 
        node: &'a ClassItemData<'a>
    ) -> bool { ... }
    pub fn pre_visit_random_qualifier(
        &mut self, 
        node: &'a RandomQualifier
    ) -> bool { ... }
    pub fn pre_visit_typedef(
        &mut self, 
        node: &'a Node<'a, TypedefData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_constraint(&mut self, node: &'a Constraint<'a>) -> bool { ... }
    pub fn pre_visit_constraint_kind(
        &mut self, 
        node: &'a ConstraintKind
    ) -> bool { ... }
    pub fn pre_visit_constraint_item(
        &mut self, 
        node: &'a ConstraintItem<'a>
    ) -> bool { ... }
    pub fn pre_visit_constraint_item_data(
        &mut self, 
        node: &'a ConstraintItemData<'a>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_decl(
        &mut self, 
        node: &'a Node<'a, SubroutineDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_prototype(
        &mut self, 
        node: &'a Node<'a, SubroutinePrototypeData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_kind(
        &mut self, 
        node: &'a SubroutineKind
    ) -> bool { ... }
    pub fn pre_visit_subroutine_port(
        &mut self, 
        node: &'a Node<'a, SubroutinePortData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_port_name(
        &mut self, 
        node: &'a SubroutinePortName<'a>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_item(
        &mut self, 
        node: &'a SubroutineItem<'a>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_port_decl(
        &mut self, 
        node: &'a SubroutinePortDecl<'a>
    ) -> bool { ... }
    pub fn pre_visit_subroutine_port_dir(
        &mut self, 
        node: &'a SubroutinePortDir
    ) -> bool { ... }
    pub fn pre_visit_net_decl(
        &mut self, 
        node: &'a Node<'a, NetDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_net_kind(&mut self, node: &'a NetKind) -> bool { ... }
    pub fn pre_visit_net_strength(&mut self, node: &'a NetStrength) -> bool { ... }
    pub fn pre_visit_drive_strength(&mut self, node: &'a DriveStrength) -> bool { ... }
    pub fn pre_visit_charge_strength(
        &mut self, 
        node: &'a ChargeStrength
    ) -> bool { ... }
    pub fn pre_visit_pattern_field(
        &mut self, 
        node: &'a Node<'a, PatternFieldData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_import_decl(
        &mut self, 
        node: &'a Node<'a, ImportDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_import_item(
        &mut self, 
        node: &'a Node<'a, ImportItemData>
    ) -> bool { ... }
    pub fn pre_visit_assertion(&mut self, node: &'a Assertion<'a>) -> bool { ... }
    pub fn pre_visit_assertion_data(
        &mut self, 
        node: &'a AssertionData<'a>
    ) -> bool { ... }
    pub fn pre_visit_assertion_deferred(
        &mut self, 
        node: &'a AssertionDeferred
    ) -> bool { ... }
    pub fn pre_visit_blocking_assertion(
        &mut self, 
        node: &'a BlockingAssertion<'a>
    ) -> bool { ... }
    pub fn pre_visit_concurrent_assertion(
        &mut self, 
        node: &'a ConcurrentAssertion<'a>
    ) -> bool { ... }
    pub fn pre_visit_assertion_action_block(
        &mut self, 
        node: &'a AssertionActionBlock<'a>
    ) -> bool { ... }
    pub fn pre_visit_seq_expr(&mut self, node: &'a SeqExpr<'a>) -> bool { ... }
    pub fn pre_visit_seq_expr_data(&mut self, node: &'a SeqExprData<'a>) -> bool { ... }
    pub fn pre_visit_seq_rep(&mut self, node: &'a SeqRep<'a>) -> bool { ... }
    pub fn pre_visit_seq_bin_op(&mut self, node: &'a SeqBinOp) -> bool { ... }
    pub fn pre_visit_prop_spec(&mut self, node: &'a PropSpec) -> bool { ... }
    pub fn pre_visit_prop_expr(&mut self, node: &'a PropExpr<'a>) -> bool { ... }
    pub fn pre_visit_prop_expr_data(
        &mut self, 
        node: &'a PropExprData<'a>
    ) -> bool { ... }
    pub fn pre_visit_prop_seq_op(&mut self, node: &'a PropSeqOp) -> bool { ... }
    pub fn pre_visit_prop_seq_bin_op(&mut self, node: &'a PropSeqBinOp) -> bool { ... }
    pub fn pre_visit_prop_bin_op(&mut self, node: &'a PropBinOp) -> bool { ... }
    pub fn pre_visit_inst(&mut self, node: &'a Node<'a, InstData<'a>>) -> bool { ... }
    pub fn pre_visit_inst_name(
        &mut self, 
        node: &'a Node<'a, InstNameData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_modport(
        &mut self, 
        node: &'a Node<'a, ModportData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_modport_name(
        &mut self, 
        node: &'a Node<'a, ModportNameData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_modport_port(
        &mut self, 
        node: &'a Node<'a, ModportPortData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_modport_simple_port(
        &mut self, 
        node: &'a Node<'a, ModportSimplePortData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_param_decl(
        &mut self, 
        node: &'a Node<'a, ParamDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_param_kind(&mut self, node: &'a ParamKind<'a>) -> bool { ... }
    pub fn pre_visit_param_type_decl(
        &mut self, 
        node: &'a Node<'a, ParamTypeDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_param_value_decl(
        &mut self, 
        node: &'a Node<'a, ParamValueDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_cont_assign(
        &mut self, 
        node: &'a Node<'a, ContAssignData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_generate_for(
        &mut self, 
        node: &'a Node<'a, GenerateForData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_generate_if(
        &mut self, 
        node: &'a Node<'a, GenerateIfData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_generate_case(
        &mut self, 
        node: &'a Node<'a, GenerateCaseData>
    ) -> bool { ... }
    pub fn pre_visit_generate_block(
        &mut self, 
        node: &'a Node<'a, GenerateBlockData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_param_assignment(
        &mut self, 
        node: &'a ParamAssignment<'a>
    ) -> bool { ... }
    pub fn pre_visit_port_conn(
        &mut self, 
        node: &'a Node<'a, PortConnData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_port_conn_mode(
        &mut self, 
        node: &'a PortConnMode<'a>
    ) -> bool { ... }
    pub fn pre_visit_dpi_decl(
        &mut self, 
        node: &'a Node<'a, DpiDeclData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_dpi_property(&mut self, node: &'a DpiProperty) -> bool { ... }
    pub fn pre_visit_data_type(
        &mut self, 
        node: &'a Node<'a, DataTypeData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_int_type(&mut self, node: &'a IntType) -> bool { ... }
    pub fn pre_visit_real_type(&mut self, node: &'a RealType) -> bool { ... }
    pub fn pre_visit_implicit_data_type(
        &mut self, 
        node: &'a Node<'a, ImplicitDataTypeData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_data_type_or_implicit(
        &mut self, 
        node: &'a DataTypeOrImplicit<'a>
    ) -> bool { ... }
    pub fn pre_visit_var_dim(
        &mut self, 
        node: &'a Node<'a, VarDimData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_packed_dim(
        &mut self, 
        node: &'a Node<'a, PackedDimData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_unpacked_dim(
        &mut self, 
        node: &'a Node<'a, UnpackedDimData<'a>>
    ) -> bool { ... }
    pub fn pre_visit_path_segment(
        &mut self, 
        node: &'a Node<'a, PathSegmentData<'a>>
    ) -> bool { ... }
    pub fn post_visit_root(&mut self, node: &'a Node<'a, RootData<'a>>) { ... }
    pub fn post_visit_source_file(
        &mut self, 
        node: &'a Node<'a, SourceFileData<'a>>
    ) { ... }
    pub fn post_visit_item(&mut self, node: &'a Node<'a, ItemData<'a>>) { ... }
    pub fn post_visit_module(&mut self, node: &'a Node<'a, ModuleData<'a>>) { ... }
    pub fn post_visit_interface(
        &mut self, 
        node: &'a Node<'a, InterfaceData<'a>>
    ) { ... }
    pub fn post_visit_package(&mut self, node: &'a Node<'a, PackageData<'a>>) { ... }
    pub fn post_visit_lifetime(&mut self, node: &'a Lifetime) { ... }
    pub fn post_visit_timeunit(&mut self, node: &'a Timeunit) { ... }
    pub fn post_visit_type(&mut self, node: &'a Node<'a, TypeData<'a>>) { ... }
    pub fn post_visit_type_kind(&mut self, node: &'a Node<'a, TypeKindData<'a>>) { ... }
    pub fn post_visit_type_sign(&mut self, node: &'a TypeSign) { ... }
    pub fn post_visit_type_dim(&mut self, node: &'a TypeDim<'a>) { ... }
    pub fn post_visit_enum(&mut self, node: &'a Node<'a, EnumData<'a>>) { ... }
    pub fn post_visit_enum_name(&mut self, node: &'a Node<'a, EnumNameData<'a>>) { ... }
    pub fn post_visit_struct(&mut self, node: &'a Node<'a, StructData<'a>>) { ... }
    pub fn post_visit_struct_kind(&mut self, node: &'a StructKind) { ... }
    pub fn post_visit_struct_member(
        &mut self, 
        node: &'a Node<'a, StructMemberData<'a>>
    ) { ... }
    pub fn post_visit_port(&mut self, node: &'a Node<'a, PortData<'a>>) { ... }
    pub fn post_visit_port_decl(&mut self, node: &'a Node<'a, PortDeclData<'a>>) { ... }
    pub fn post_visit_var_kind(&mut self, node: &'a VarKind) { ... }
    pub fn post_visit_port_dir(&mut self, node: &'a PortDir) { ... }
    pub fn post_visit_net_type(&mut self, node: &'a NetType) { ... }
    pub fn post_visit_procedure(
        &mut self, 
        node: &'a Node<'a, ProcedureData<'a>>
    ) { ... }
    pub fn post_visit_procedure_kind(&mut self, node: &'a ProcedureKind) { ... }
    pub fn post_visit_stmt(&mut self, node: &'a Node<'a, StmtData<'a>>) { ... }
    pub fn post_visit_stmt_kind(&mut self, node: &'a StmtKind<'a>) { ... }
    pub fn post_visit_join_kind(&mut self, node: &'a JoinKind) { ... }
    pub fn post_visit_unique_priority(&mut self, node: &'a UniquePriority) { ... }
    pub fn post_visit_case_kind(&mut self, node: &'a CaseKind) { ... }
    pub fn post_visit_case_mode(&mut self, node: &'a CaseMode) { ... }
    pub fn post_visit_case_item(&mut self, node: &'a CaseItem<'a>) { ... }
    pub fn post_visit_delay_control(&mut self, node: &'a DelayControl<'a>) { ... }
    pub fn post_visit_event_control(&mut self, node: &'a EventControl<'a>) { ... }
    pub fn post_visit_event_control_data(
        &mut self, 
        node: &'a EventControlData<'a>
    ) { ... }
    pub fn post_visit_cycle_delay(&mut self, node: &'a CycleDelay) { ... }
    pub fn post_visit_timing_control(&mut self, node: &'a TimingControl<'a>) { ... }
    pub fn post_visit_assign_op(&mut self, node: &'a AssignOp) { ... }
    pub fn post_visit_var_decl(&mut self, node: &'a Node<'a, VarDeclData<'a>>) { ... }
    pub fn post_visit_var_decl_name(
        &mut self, 
        node: &'a Node<'a, VarDeclNameData<'a>>
    ) { ... }
    pub fn post_visit_genvar_decl(
        &mut self, 
        node: &'a Node<'a, GenvarDeclData<'a>>
    ) { ... }
    pub fn post_visit_foreach_index(
        &mut self, 
        node: &'a Node<'a, ForeachIndexData>
    ) { ... }
    pub fn post_visit_expr(&mut self, node: &'a Node<'a, ExprData<'a>>) { ... }
    pub fn post_visit_type_or_expr(&mut self, node: &'a TypeOrExpr<'a>) { ... }
    pub fn post_visit_value_range(&mut self, node: &'a ValueRange<'a>) { ... }
    pub fn post_visit_range_mode(&mut self, node: &'a RangeMode) { ... }
    pub fn post_visit_call_arg(&mut self, node: &'a CallArg<'a>) { ... }
    pub fn post_visit_stream_concat_slice(
        &mut self, 
        node: &'a StreamConcatSlice<'a>
    ) { ... }
    pub fn post_visit_stream_expr(&mut self, node: &'a StreamExpr<'a>) { ... }
    pub fn post_visit_event_expr(&mut self, node: &'a EventExpr<'a>) { ... }
    pub fn post_visit_edge_ident(&mut self, node: &'a EdgeIdent) { ... }
    pub fn post_visit_class_decl(
        &mut self, 
        node: &'a Node<'a, ClassDeclData<'a>>
    ) { ... }
    pub fn post_visit_class_item(&mut self, node: &'a ClassItem<'a>) { ... }
    pub fn post_visit_class_item_qualifier(
        &mut self, 
        node: &'a ClassItemQualifier
    ) { ... }
    pub fn post_visit_class_item_data(&mut self, node: &'a ClassItemData<'a>) { ... }
    pub fn post_visit_random_qualifier(&mut self, node: &'a RandomQualifier) { ... }
    pub fn post_visit_typedef(&mut self, node: &'a Node<'a, TypedefData<'a>>) { ... }
    pub fn post_visit_constraint(&mut self, node: &'a Constraint<'a>) { ... }
    pub fn post_visit_constraint_kind(&mut self, node: &'a ConstraintKind) { ... }
    pub fn post_visit_constraint_item(&mut self, node: &'a ConstraintItem<'a>) { ... }
    pub fn post_visit_constraint_item_data(
        &mut self, 
        node: &'a ConstraintItemData<'a>
    ) { ... }
    pub fn post_visit_subroutine_decl(
        &mut self, 
        node: &'a Node<'a, SubroutineDeclData<'a>>
    ) { ... }
    pub fn post_visit_subroutine_prototype(
        &mut self, 
        node: &'a Node<'a, SubroutinePrototypeData<'a>>
    ) { ... }
    pub fn post_visit_subroutine_kind(&mut self, node: &'a SubroutineKind) { ... }
    pub fn post_visit_subroutine_port(
        &mut self, 
        node: &'a Node<'a, SubroutinePortData<'a>>
    ) { ... }
    pub fn post_visit_subroutine_port_name(
        &mut self, 
        node: &'a SubroutinePortName<'a>
    ) { ... }
    pub fn post_visit_subroutine_item(&mut self, node: &'a SubroutineItem<'a>) { ... }
    pub fn post_visit_subroutine_port_decl(
        &mut self, 
        node: &'a SubroutinePortDecl<'a>
    ) { ... }
    pub fn post_visit_subroutine_port_dir(
        &mut self, 
        node: &'a SubroutinePortDir
    ) { ... }
    pub fn post_visit_net_decl(&mut self, node: &'a Node<'a, NetDeclData<'a>>) { ... }
    pub fn post_visit_net_kind(&mut self, node: &'a NetKind) { ... }
    pub fn post_visit_net_strength(&mut self, node: &'a NetStrength) { ... }
    pub fn post_visit_drive_strength(&mut self, node: &'a DriveStrength) { ... }
    pub fn post_visit_charge_strength(&mut self, node: &'a ChargeStrength) { ... }
    pub fn post_visit_pattern_field(
        &mut self, 
        node: &'a Node<'a, PatternFieldData<'a>>
    ) { ... }
    pub fn post_visit_import_decl(
        &mut self, 
        node: &'a Node<'a, ImportDeclData<'a>>
    ) { ... }
    pub fn post_visit_import_item(&mut self, node: &'a Node<'a, ImportItemData>) { ... }
    pub fn post_visit_assertion(&mut self, node: &'a Assertion<'a>) { ... }
    pub fn post_visit_assertion_data(&mut self, node: &'a AssertionData<'a>) { ... }
    pub fn post_visit_assertion_deferred(&mut self, node: &'a AssertionDeferred) { ... }
    pub fn post_visit_blocking_assertion(
        &mut self, 
        node: &'a BlockingAssertion<'a>
    ) { ... }
    pub fn post_visit_concurrent_assertion(
        &mut self, 
        node: &'a ConcurrentAssertion<'a>
    ) { ... }
    pub fn post_visit_assertion_action_block(
        &mut self, 
        node: &'a AssertionActionBlock<'a>
    ) { ... }
    pub fn post_visit_seq_expr(&mut self, node: &'a SeqExpr<'a>) { ... }
    pub fn post_visit_seq_expr_data(&mut self, node: &'a SeqExprData<'a>) { ... }
    pub fn post_visit_seq_rep(&mut self, node: &'a SeqRep<'a>) { ... }
    pub fn post_visit_seq_bin_op(&mut self, node: &'a SeqBinOp) { ... }
    pub fn post_visit_prop_spec(&mut self, node: &'a PropSpec) { ... }
    pub fn post_visit_prop_expr(&mut self, node: &'a PropExpr<'a>) { ... }
    pub fn post_visit_prop_expr_data(&mut self, node: &'a PropExprData<'a>) { ... }
    pub fn post_visit_prop_seq_op(&mut self, node: &'a PropSeqOp) { ... }
    pub fn post_visit_prop_seq_bin_op(&mut self, node: &'a PropSeqBinOp) { ... }
    pub fn post_visit_prop_bin_op(&mut self, node: &'a PropBinOp) { ... }
    pub fn post_visit_inst(&mut self, node: &'a Node<'a, InstData<'a>>) { ... }
    pub fn post_visit_inst_name(&mut self, node: &'a Node<'a, InstNameData<'a>>) { ... }
    pub fn post_visit_modport(&mut self, node: &'a Node<'a, ModportData<'a>>) { ... }
    pub fn post_visit_modport_name(
        &mut self, 
        node: &'a Node<'a, ModportNameData<'a>>
    ) { ... }
    pub fn post_visit_modport_port(
        &mut self, 
        node: &'a Node<'a, ModportPortData<'a>>
    ) { ... }
    pub fn post_visit_modport_simple_port(
        &mut self, 
        node: &'a Node<'a, ModportSimplePortData<'a>>
    ) { ... }
    pub fn post_visit_param_decl(
        &mut self, 
        node: &'a Node<'a, ParamDeclData<'a>>
    ) { ... }
    pub fn post_visit_param_kind(&mut self, node: &'a ParamKind<'a>) { ... }
    pub fn post_visit_param_type_decl(
        &mut self, 
        node: &'a Node<'a, ParamTypeDeclData<'a>>
    ) { ... }
    pub fn post_visit_param_value_decl(
        &mut self, 
        node: &'a Node<'a, ParamValueDeclData<'a>>
    ) { ... }
    pub fn post_visit_cont_assign(
        &mut self, 
        node: &'a Node<'a, ContAssignData<'a>>
    ) { ... }
    pub fn post_visit_generate_for(
        &mut self, 
        node: &'a Node<'a, GenerateForData<'a>>
    ) { ... }
    pub fn post_visit_generate_if(
        &mut self, 
        node: &'a Node<'a, GenerateIfData<'a>>
    ) { ... }
    pub fn post_visit_generate_case(
        &mut self, 
        node: &'a Node<'a, GenerateCaseData>
    ) { ... }
    pub fn post_visit_generate_block(
        &mut self, 
        node: &'a Node<'a, GenerateBlockData<'a>>
    ) { ... }
    pub fn post_visit_param_assignment(&mut self, node: &'a ParamAssignment<'a>) { ... }
    pub fn post_visit_port_conn(&mut self, node: &'a Node<'a, PortConnData<'a>>) { ... }
    pub fn post_visit_port_conn_mode(&mut self, node: &'a PortConnMode<'a>) { ... }
    pub fn post_visit_dpi_decl(&mut self, node: &'a Node<'a, DpiDeclData<'a>>) { ... }
    pub fn post_visit_dpi_property(&mut self, node: &'a DpiProperty) { ... }
    pub fn post_visit_data_type(&mut self, node: &'a Node<'a, DataTypeData<'a>>) { ... }
    pub fn post_visit_int_type(&mut self, node: &'a IntType) { ... }
    pub fn post_visit_real_type(&mut self, node: &'a RealType) { ... }
    pub fn post_visit_implicit_data_type(
        &mut self, 
        node: &'a Node<'a, ImplicitDataTypeData<'a>>
    ) { ... }
    pub fn post_visit_data_type_or_implicit(
        &mut self, 
        node: &'a DataTypeOrImplicit<'a>
    ) { ... }
    pub fn post_visit_var_dim(&mut self, node: &'a Node<'a, VarDimData<'a>>) { ... }
    pub fn post_visit_packed_dim(
        &mut self, 
        node: &'a Node<'a, PackedDimData<'a>>
    ) { ... }
    pub fn post_visit_unpacked_dim(
        &mut self, 
        node: &'a Node<'a, UnpackedDimData<'a>>
    ) { ... }
    pub fn post_visit_path_segment(
        &mut self, 
        node: &'a Node<'a, PathSegmentData<'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

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

Called for every node before visiting its children.

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

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

Called for every node after visiting its children.

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

Called for every Root node before visiting its children.

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

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

Called for every SourceFile node before visiting its children.

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

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

Called for every Item node before visiting its children.

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

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

Called for every Module node before visiting its children.

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

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

Called for every Interface node before visiting its children.

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

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

Called for every Package node before visiting its children.

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

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

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

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

Called for every Type node before visiting its children.

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

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

Called for every TypeKind node before visiting its children.

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

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

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

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

Called for every Enum node before visiting its children.

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

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

Called for every EnumName node before visiting its children.

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

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

Called for every Struct node before visiting its children.

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

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

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

Called for every StructMember node before visiting its children.

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

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

Called for every Port node before visiting its children.

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

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

Called for every PortDecl node before visiting its children.

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

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

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

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

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

Called for every Procedure node before visiting its children.

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

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

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

Called for every Stmt node before visiting its children.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Called for every VarDecl node before visiting its children.

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

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

Called for every VarDeclName node before visiting its children.

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

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

Called for every GenvarDecl node before visiting its children.

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

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

Called for every ForeachIndex node before visiting its children.

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

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

Called for every Expr node before visiting its children.

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

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

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

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

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

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

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

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

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

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

Called for every ClassDecl node before visiting its children.

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

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

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

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

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

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

Called for every Typedef node before visiting its children.

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

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

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

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

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

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

Called for every SubroutineDecl node before visiting its children.

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

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

Called for every SubroutinePrototype node before visiting its children.

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

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

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

Called for every SubroutinePort node before visiting its children.

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

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

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

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

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

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

Called for every NetDecl node before visiting its children.

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

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

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

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

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

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

Called for every PatternField node before visiting its children.

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

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

Called for every ImportDecl node before visiting its children.

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

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

Called for every ImportItem node before visiting its children.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Called for every Inst node before visiting its children.

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

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

Called for every InstName node before visiting its children.

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

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

Called for every Modport node before visiting its children.

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

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

Called for every ModportName node before visiting its children.

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

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

Called for every ModportPort node before visiting its children.

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

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

Called for every ModportSimplePort node before visiting its children.

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

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

Called for every ParamDecl node before visiting its children.

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

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

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

Called for every ParamTypeDecl node before visiting its children.

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

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

Called for every ParamValueDecl node before visiting its children.

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

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

Called for every ContAssign node before visiting its children.

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

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

Called for every GenerateFor node before visiting its children.

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

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

Called for every GenerateIf node before visiting its children.

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

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

Called for every GenerateCase node before visiting its children.

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

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

Called for every GenerateBlock node before visiting its children.

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

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

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

Called for every PortConn node before visiting its children.

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

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

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

Called for every DpiDecl node before visiting its children.

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

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

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

Called for every DataType node before visiting its children.

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

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

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

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

Called for every ImplicitDataType node before visiting its children.

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

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

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

Called for every VarDim node before visiting its children.

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

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

Called for every PackedDim node before visiting its children.

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

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

Called for every UnpackedDim node before visiting its children.

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

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

Called for every PathSegment node before visiting its children.

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

pub fn post_visit_root(&mut self, node: &'a Node<'a, RootData<'a>>)

Called for every Root node after visiting its children.

pub fn post_visit_source_file(&mut self, node: &'a Node<'a, SourceFileData<'a>>)

Called for every SourceFile node after visiting its children.

pub fn post_visit_item(&mut self, node: &'a Node<'a, ItemData<'a>>)

Called for every Item node after visiting its children.

pub fn post_visit_module(&mut self, node: &'a Node<'a, ModuleData<'a>>)

Called for every Module node after visiting its children.

pub fn post_visit_interface(&mut self, node: &'a Node<'a, InterfaceData<'a>>)

Called for every Interface node after visiting its children.

pub fn post_visit_package(&mut self, node: &'a Node<'a, PackageData<'a>>)

Called for every Package node after visiting its children.

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

Called for every Lifetime node after visiting its children.

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

Called for every Timeunit node after visiting its children.

pub fn post_visit_type(&mut self, node: &'a Node<'a, TypeData<'a>>)

Called for every Type node after visiting its children.

pub fn post_visit_type_kind(&mut self, node: &'a Node<'a, TypeKindData<'a>>)

Called for every TypeKind node after visiting its children.

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

Called for every TypeSign node after visiting its children.

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

Called for every TypeDim node after visiting its children.

pub fn post_visit_enum(&mut self, node: &'a Node<'a, EnumData<'a>>)

Called for every Enum node after visiting its children.

pub fn post_visit_enum_name(&mut self, node: &'a Node<'a, EnumNameData<'a>>)

Called for every EnumName node after visiting its children.

pub fn post_visit_struct(&mut self, node: &'a Node<'a, StructData<'a>>)

Called for every Struct node after visiting its children.

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

Called for every StructKind node after visiting its children.

pub fn post_visit_struct_member(
    &mut self,
    node: &'a Node<'a, StructMemberData<'a>>
)

Called for every StructMember node after visiting its children.

pub fn post_visit_port(&mut self, node: &'a Node<'a, PortData<'a>>)

Called for every Port node after visiting its children.

pub fn post_visit_port_decl(&mut self, node: &'a Node<'a, PortDeclData<'a>>)

Called for every PortDecl node after visiting its children.

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

Called for every VarKind node after visiting its children.

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

Called for every PortDir node after visiting its children.

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

Called for every NetType node after visiting its children.

pub fn post_visit_procedure(&mut self, node: &'a Node<'a, ProcedureData<'a>>)

Called for every Procedure node after visiting its children.

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

Called for every ProcedureKind node after visiting its children.

pub fn post_visit_stmt(&mut self, node: &'a Node<'a, StmtData<'a>>)

Called for every Stmt node after visiting its children.

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

Called for every StmtKind node after visiting its children.

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

Called for every JoinKind node after visiting its children.

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

Called for every UniquePriority node after visiting its children.

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

Called for every CaseKind node after visiting its children.

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

Called for every CaseMode node after visiting its children.

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

Called for every CaseItem node after visiting its children.

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

Called for every DelayControl node after visiting its children.

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

Called for every EventControl node after visiting its children.

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

Called for every EventControlData node after visiting its children.

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

Called for every CycleDelay node after visiting its children.

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

Called for every TimingControl node after visiting its children.

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

Called for every AssignOp node after visiting its children.

pub fn post_visit_var_decl(&mut self, node: &'a Node<'a, VarDeclData<'a>>)

Called for every VarDecl node after visiting its children.

pub fn post_visit_var_decl_name(
    &mut self,
    node: &'a Node<'a, VarDeclNameData<'a>>
)

Called for every VarDeclName node after visiting its children.

pub fn post_visit_genvar_decl(&mut self, node: &'a Node<'a, GenvarDeclData<'a>>)

Called for every GenvarDecl node after visiting its children.

pub fn post_visit_foreach_index(&mut self, node: &'a Node<'a, ForeachIndexData>)

Called for every ForeachIndex node after visiting its children.

pub fn post_visit_expr(&mut self, node: &'a Node<'a, ExprData<'a>>)

Called for every Expr node after visiting its children.

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

Called for every TypeOrExpr node after visiting its children.

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

Called for every ValueRange node after visiting its children.

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

Called for every RangeMode node after visiting its children.

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

Called for every CallArg node after visiting its children.

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

Called for every StreamConcatSlice node after visiting its children.

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

Called for every StreamExpr node after visiting its children.

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

Called for every EventExpr node after visiting its children.

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

Called for every EdgeIdent node after visiting its children.

pub fn post_visit_class_decl(&mut self, node: &'a Node<'a, ClassDeclData<'a>>)

Called for every ClassDecl node after visiting its children.

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

Called for every ClassItem node after visiting its children.

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

Called for every ClassItemQualifier node after visiting its children.

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

Called for every ClassItemData node after visiting its children.

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

Called for every RandomQualifier node after visiting its children.

pub fn post_visit_typedef(&mut self, node: &'a Node<'a, TypedefData<'a>>)

Called for every Typedef node after visiting its children.

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

Called for every Constraint node after visiting its children.

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

Called for every ConstraintKind node after visiting its children.

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

Called for every ConstraintItem node after visiting its children.

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

Called for every ConstraintItemData node after visiting its children.

pub fn post_visit_subroutine_decl(
    &mut self,
    node: &'a Node<'a, SubroutineDeclData<'a>>
)

Called for every SubroutineDecl node after visiting its children.

pub fn post_visit_subroutine_prototype(
    &mut self,
    node: &'a Node<'a, SubroutinePrototypeData<'a>>
)

Called for every SubroutinePrototype node after visiting its children.

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

Called for every SubroutineKind node after visiting its children.

pub fn post_visit_subroutine_port(
    &mut self,
    node: &'a Node<'a, SubroutinePortData<'a>>
)

Called for every SubroutinePort node after visiting its children.

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

Called for every SubroutinePortName node after visiting its children.

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

Called for every SubroutineItem node after visiting its children.

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

Called for every SubroutinePortDecl node after visiting its children.

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

Called for every SubroutinePortDir node after visiting its children.

pub fn post_visit_net_decl(&mut self, node: &'a Node<'a, NetDeclData<'a>>)

Called for every NetDecl node after visiting its children.

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

Called for every NetKind node after visiting its children.

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

Called for every NetStrength node after visiting its children.

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

Called for every DriveStrength node after visiting its children.

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

Called for every ChargeStrength node after visiting its children.

pub fn post_visit_pattern_field(
    &mut self,
    node: &'a Node<'a, PatternFieldData<'a>>
)

Called for every PatternField node after visiting its children.

pub fn post_visit_import_decl(&mut self, node: &'a Node<'a, ImportDeclData<'a>>)

Called for every ImportDecl node after visiting its children.

pub fn post_visit_import_item(&mut self, node: &'a Node<'a, ImportItemData>)

Called for every ImportItem node after visiting its children.

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

Called for every Assertion node after visiting its children.

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

Called for every AssertionData node after visiting its children.

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

Called for every AssertionDeferred node after visiting its children.

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

Called for every BlockingAssertion node after visiting its children.

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

Called for every ConcurrentAssertion node after visiting its children.

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

Called for every AssertionActionBlock node after visiting its children.

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

Called for every SeqExpr node after visiting its children.

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

Called for every SeqExprData node after visiting its children.

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

Called for every SeqRep node after visiting its children.

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

Called for every SeqBinOp node after visiting its children.

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

Called for every PropSpec node after visiting its children.

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

Called for every PropExpr node after visiting its children.

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

Called for every PropExprData node after visiting its children.

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

Called for every PropSeqOp node after visiting its children.

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

Called for every PropSeqBinOp node after visiting its children.

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

Called for every PropBinOp node after visiting its children.

pub fn post_visit_inst(&mut self, node: &'a Node<'a, InstData<'a>>)

Called for every Inst node after visiting its children.

pub fn post_visit_inst_name(&mut self, node: &'a Node<'a, InstNameData<'a>>)

Called for every InstName node after visiting its children.

pub fn post_visit_modport(&mut self, node: &'a Node<'a, ModportData<'a>>)

Called for every Modport node after visiting its children.

pub fn post_visit_modport_name(
    &mut self,
    node: &'a Node<'a, ModportNameData<'a>>
)

Called for every ModportName node after visiting its children.

pub fn post_visit_modport_port(
    &mut self,
    node: &'a Node<'a, ModportPortData<'a>>
)

Called for every ModportPort node after visiting its children.

pub fn post_visit_modport_simple_port(
    &mut self,
    node: &'a Node<'a, ModportSimplePortData<'a>>
)

Called for every ModportSimplePort node after visiting its children.

pub fn post_visit_param_decl(&mut self, node: &'a Node<'a, ParamDeclData<'a>>)

Called for every ParamDecl node after visiting its children.

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

Called for every ParamKind node after visiting its children.

pub fn post_visit_param_type_decl(
    &mut self,
    node: &'a Node<'a, ParamTypeDeclData<'a>>
)

Called for every ParamTypeDecl node after visiting its children.

pub fn post_visit_param_value_decl(
    &mut self,
    node: &'a Node<'a, ParamValueDeclData<'a>>
)

Called for every ParamValueDecl node after visiting its children.

pub fn post_visit_cont_assign(&mut self, node: &'a Node<'a, ContAssignData<'a>>)

Called for every ContAssign node after visiting its children.

pub fn post_visit_generate_for(
    &mut self,
    node: &'a Node<'a, GenerateForData<'a>>
)

Called for every GenerateFor node after visiting its children.

pub fn post_visit_generate_if(&mut self, node: &'a Node<'a, GenerateIfData<'a>>)

Called for every GenerateIf node after visiting its children.

pub fn post_visit_generate_case(&mut self, node: &'a Node<'a, GenerateCaseData>)

Called for every GenerateCase node after visiting its children.

pub fn post_visit_generate_block(
    &mut self,
    node: &'a Node<'a, GenerateBlockData<'a>>
)

Called for every GenerateBlock node after visiting its children.

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

Called for every ParamAssignment node after visiting its children.

pub fn post_visit_port_conn(&mut self, node: &'a Node<'a, PortConnData<'a>>)

Called for every PortConn node after visiting its children.

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

Called for every PortConnMode node after visiting its children.

pub fn post_visit_dpi_decl(&mut self, node: &'a Node<'a, DpiDeclData<'a>>)

Called for every DpiDecl node after visiting its children.

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

Called for every DpiProperty node after visiting its children.

pub fn post_visit_data_type(&mut self, node: &'a Node<'a, DataTypeData<'a>>)

Called for every DataType node after visiting its children.

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

Called for every IntType node after visiting its children.

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

Called for every RealType node after visiting its children.

pub fn post_visit_implicit_data_type(
    &mut self,
    node: &'a Node<'a, ImplicitDataTypeData<'a>>
)

Called for every ImplicitDataType node after visiting its children.

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

Called for every DataTypeOrImplicit node after visiting its children.

pub fn post_visit_var_dim(&mut self, node: &'a Node<'a, VarDimData<'a>>)

Called for every VarDim node after visiting its children.

pub fn post_visit_packed_dim(&mut self, node: &'a Node<'a, PackedDimData<'a>>)

Called for every PackedDim node after visiting its children.

pub fn post_visit_unpacked_dim(
    &mut self,
    node: &'a Node<'a, UnpackedDimData<'a>>
)

Called for every UnpackedDim node after visiting its children.

pub fn post_visit_path_segment(
    &mut self,
    node: &'a Node<'a, PathSegmentData<'a>>
)

Called for every PathSegment node after visiting its children.

Loading content...

Implementors

Loading content...