123456789_123456789_123456789_123456789_123456789_

Class: Prism::Dispatcher::DispatchOnce

Do not use. This class is for internal use only.
Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
Instance Chain:
Inherits: Prism::Visitor
Defined in: lib/prism/dispatcher.rb

Class Method Summary

Instance Attribute Summary

Instance Method Summary

::Prism::Visitor - Inherited

#visit_alias_global_variable_node
#visit_alias_method_node
#visit_alternation_pattern_node
#visit_and_node

Visit a ::Prism::AndNode node.

#visit_arguments_node
#visit_array_node

Visit a ::Prism::ArrayNode node.

#visit_array_pattern_node
#visit_assoc_node

Visit a ::Prism::AssocNode node.

#visit_assoc_splat_node
#visit_back_reference_read_node
#visit_begin_node

Visit a ::Prism::BeginNode node.

#visit_block_argument_node
#visit_block_local_variable_node
#visit_block_node

Visit a ::Prism::BlockNode node.

#visit_block_parameter_node
#visit_block_parameters_node
#visit_break_node

Visit a ::Prism::BreakNode node.

#visit_call_and_write_node
#visit_call_node

Visit a ::Prism::CallNode node.

#visit_call_operator_write_node
#visit_call_or_write_node
#visit_call_target_node
#visit_capture_pattern_node
#visit_case_match_node
#visit_case_node

Visit a ::Prism::CaseNode node.

#visit_class_node

Visit a ::Prism::ClassNode node.

#visit_class_variable_and_write_node
#visit_class_variable_operator_write_node
#visit_class_variable_or_write_node
#visit_class_variable_read_node
#visit_class_variable_target_node
#visit_class_variable_write_node
#visit_constant_and_write_node
#visit_constant_operator_write_node
#visit_constant_or_write_node
#visit_constant_path_and_write_node
#visit_constant_path_node
#visit_constant_path_operator_write_node
#visit_constant_path_or_write_node
#visit_constant_path_target_node
#visit_constant_path_write_node
#visit_constant_read_node
#visit_constant_target_node
#visit_constant_write_node
#visit_def_node

Visit a ::Prism::DefNode node.

#visit_defined_node

Visit a ::Prism::DefinedNode node.

#visit_else_node

Visit a ::Prism::ElseNode node.

#visit_embedded_statements_node
#visit_embedded_variable_node
#visit_ensure_node

Visit a ::Prism::EnsureNode node.

#visit_false_node

Visit a ::Prism::FalseNode node.

#visit_find_pattern_node
#visit_flip_flop_node

Visit a ::Prism::FlipFlopNode node.

#visit_float_node

Visit a ::Prism::FloatNode node.

#visit_for_node

Visit a ::Prism::ForNode node.

#visit_forwarding_arguments_node
#visit_forwarding_parameter_node
#visit_forwarding_super_node
#visit_global_variable_and_write_node
#visit_global_variable_operator_write_node
#visit_global_variable_or_write_node
#visit_global_variable_read_node
#visit_global_variable_target_node
#visit_global_variable_write_node
#visit_hash_node

Visit a ::Prism::HashNode node.

#visit_hash_pattern_node
#visit_if_node

Visit a ::Prism::IfNode node.

#visit_imaginary_node
#visit_implicit_node

Visit a ::Prism::ImplicitNode node.

#visit_implicit_rest_node
#visit_in_node

Visit a ::Prism::InNode node.

#visit_index_and_write_node
#visit_index_operator_write_node
#visit_index_or_write_node
#visit_index_target_node
#visit_instance_variable_and_write_node
#visit_instance_variable_operator_write_node
#visit_instance_variable_or_write_node
#visit_instance_variable_read_node
#visit_instance_variable_target_node
#visit_instance_variable_write_node
#visit_integer_node

Visit a ::Prism::IntegerNode node.

#visit_interpolated_match_last_line_node
#visit_interpolated_regular_expression_node
#visit_interpolated_string_node
#visit_interpolated_symbol_node
#visit_interpolated_x_string_node
#visit_it_local_variable_read_node
#visit_it_parameters_node
#visit_keyword_hash_node
#visit_keyword_rest_parameter_node
#visit_lambda_node

Visit a ::Prism::LambdaNode node.

#visit_local_variable_and_write_node
#visit_local_variable_operator_write_node
#visit_local_variable_or_write_node
#visit_local_variable_read_node
#visit_local_variable_target_node
#visit_local_variable_write_node
#visit_match_last_line_node
#visit_match_predicate_node
#visit_match_required_node
#visit_match_write_node
#visit_missing_node

Visit a ::Prism::MissingNode node.

#visit_module_node

Visit a ::Prism::ModuleNode node.

#visit_multi_target_node
#visit_multi_write_node
#visit_next_node

Visit a ::Prism::NextNode node.

#visit_nil_node

Visit a ::Prism::NilNode node.

#visit_no_keywords_parameter_node
#visit_numbered_parameters_node
#visit_numbered_reference_read_node
#visit_optional_keyword_parameter_node
#visit_optional_parameter_node
#visit_or_node

Visit a ::Prism::OrNode node.

#visit_parameters_node
#visit_parentheses_node
#visit_pinned_expression_node
#visit_pinned_variable_node
#visit_post_execution_node
#visit_pre_execution_node
#visit_program_node

Visit a ::Prism::ProgramNode node.

#visit_range_node

Visit a ::Prism::RangeNode node.

#visit_rational_node

Visit a ::Prism::RationalNode node.

#visit_redo_node

Visit a ::Prism::RedoNode node.

#visit_regular_expression_node
#visit_required_keyword_parameter_node
#visit_required_parameter_node
#visit_rescue_modifier_node
#visit_rescue_node

Visit a ::Prism::RescueNode node.

#visit_rest_parameter_node
#visit_retry_node

Visit a ::Prism::RetryNode node.

#visit_return_node

Visit a ::Prism::ReturnNode node.

#visit_self_node

Visit a ::Prism::SelfNode node.

#visit_shareable_constant_node
#visit_singleton_class_node
#visit_source_encoding_node
#visit_source_file_node
#visit_source_line_node
#visit_splat_node

Visit a ::Prism::SplatNode node.

#visit_statements_node
#visit_string_node

Visit a ::Prism::StringNode node.

#visit_super_node

Visit a ::Prism::SuperNode node.

#visit_symbol_node

Visit a ::Prism::SymbolNode node.

#visit_true_node

Visit a ::Prism::TrueNode node.

#visit_undef_node

Visit a ::Prism::UndefNode node.

#visit_unless_node

Visit a ::Prism::UnlessNode node.

#visit_until_node

Visit a ::Prism::UntilNode node.

#visit_when_node

Visit a ::Prism::WhenNode node.

#visit_while_node

Visit a ::Prism::WhileNode node.

#visit_x_string_node

Visit a ::Prism::XStringNode node.

#visit_yield_node

Visit a ::Prism::YieldNode node.

::Prism::BasicVisitor - Inherited

#visit

Calls accept on the given node if it is not nil, which in turn should call back into this visitor by calling the appropriate visit_* method.

#visit_all

Visits each node in nodes by calling accept on each one.

#visit_child_nodes

Visits the child nodes of node by calling accept on each one.

Constructor Details

.new(listeners) ⇒ DispatchOnce

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1297

def initialize(listeners)
  @listeners = listeners
end

Instance Attribute Details

#listeners (readonly)

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1295

attr_reader :listeners

Instance Method Details

#visit_alias_global_variable_node(node)

Dispatch enter and leave events for ::Prism::AliasGlobalVariableNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1302

def visit_alias_global_variable_node(node)
  listeners[:on_alias_global_variable_node_enter]&.each { |listener| listener.on_alias_global_variable_node_enter(node) }
  listeners[:on_alias_global_variable_node_leave]&.each { |listener| listener.on_alias_global_variable_node_leave(node) }
end

#visit_alias_method_node(node)

Dispatch enter and leave events for ::Prism::AliasMethodNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1308

def visit_alias_method_node(node)
  listeners[:on_alias_method_node_enter]&.each { |listener| listener.on_alias_method_node_enter(node) }
  listeners[:on_alias_method_node_leave]&.each { |listener| listener.on_alias_method_node_leave(node) }
end

#visit_alternation_pattern_node(node)

Dispatch enter and leave events for ::Prism::AlternationPatternNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1314

def visit_alternation_pattern_node(node)
  listeners[:on_alternation_pattern_node_enter]&.each { |listener| listener.on_alternation_pattern_node_enter(node) }
  listeners[:on_alternation_pattern_node_leave]&.each { |listener| listener.on_alternation_pattern_node_leave(node) }
end

#visit_and_node(node)

Dispatch enter and leave events for ::Prism::AndNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1320

def visit_and_node(node)
  listeners[:on_and_node_enter]&.each { |listener| listener.on_and_node_enter(node) }
  listeners[:on_and_node_leave]&.each { |listener| listener.on_and_node_leave(node) }
end

#visit_arguments_node(node)

Dispatch enter and leave events for ::Prism::ArgumentsNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1326

def visit_arguments_node(node)
  listeners[:on_arguments_node_enter]&.each { |listener| listener.on_arguments_node_enter(node) }
  listeners[:on_arguments_node_leave]&.each { |listener| listener.on_arguments_node_leave(node) }
end

#visit_array_node(node)

Dispatch enter and leave events for ::Prism::ArrayNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1332

def visit_array_node(node)
  listeners[:on_array_node_enter]&.each { |listener| listener.on_array_node_enter(node) }
  listeners[:on_array_node_leave]&.each { |listener| listener.on_array_node_leave(node) }
end

#visit_array_pattern_node(node)

Dispatch enter and leave events for ::Prism::ArrayPatternNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1338

def visit_array_pattern_node(node)
  listeners[:on_array_pattern_node_enter]&.each { |listener| listener.on_array_pattern_node_enter(node) }
  listeners[:on_array_pattern_node_leave]&.each { |listener| listener.on_array_pattern_node_leave(node) }
end

#visit_assoc_node(node)

Dispatch enter and leave events for ::Prism::AssocNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1344

def visit_assoc_node(node)
  listeners[:on_assoc_node_enter]&.each { |listener| listener.on_assoc_node_enter(node) }
  listeners[:on_assoc_node_leave]&.each { |listener| listener.on_assoc_node_leave(node) }
end

#visit_assoc_splat_node(node)

Dispatch enter and leave events for ::Prism::AssocSplatNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1350

def visit_assoc_splat_node(node)
  listeners[:on_assoc_splat_node_enter]&.each { |listener| listener.on_assoc_splat_node_enter(node) }
  listeners[:on_assoc_splat_node_leave]&.each { |listener| listener.on_assoc_splat_node_leave(node) }
end

#visit_back_reference_read_node(node)

Dispatch enter and leave events for ::Prism::BackReferenceReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1356

def visit_back_reference_read_node(node)
  listeners[:on_back_reference_read_node_enter]&.each { |listener| listener.on_back_reference_read_node_enter(node) }
  listeners[:on_back_reference_read_node_leave]&.each { |listener| listener.on_back_reference_read_node_leave(node) }
end

#visit_begin_node(node)

Dispatch enter and leave events for ::Prism::BeginNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1362

def visit_begin_node(node)
  listeners[:on_begin_node_enter]&.each { |listener| listener.on_begin_node_enter(node) }
  listeners[:on_begin_node_leave]&.each { |listener| listener.on_begin_node_leave(node) }
end

#visit_block_argument_node(node)

Dispatch enter and leave events for ::Prism::BlockArgumentNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1368

def visit_block_argument_node(node)
  listeners[:on_block_argument_node_enter]&.each { |listener| listener.on_block_argument_node_enter(node) }
  listeners[:on_block_argument_node_leave]&.each { |listener| listener.on_block_argument_node_leave(node) }
end

#visit_block_local_variable_node(node)

Dispatch enter and leave events for ::Prism::BlockLocalVariableNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1374

def visit_block_local_variable_node(node)
  listeners[:on_block_local_variable_node_enter]&.each { |listener| listener.on_block_local_variable_node_enter(node) }
  listeners[:on_block_local_variable_node_leave]&.each { |listener| listener.on_block_local_variable_node_leave(node) }
end

#visit_block_node(node)

Dispatch enter and leave events for ::Prism::BlockNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1380

def visit_block_node(node)
  listeners[:on_block_node_enter]&.each { |listener| listener.on_block_node_enter(node) }
  listeners[:on_block_node_leave]&.each { |listener| listener.on_block_node_leave(node) }
end

#visit_block_parameter_node(node)

Dispatch enter and leave events for ::Prism::BlockParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1386

def visit_block_parameter_node(node)
  listeners[:on_block_parameter_node_enter]&.each { |listener| listener.on_block_parameter_node_enter(node) }
  listeners[:on_block_parameter_node_leave]&.each { |listener| listener.on_block_parameter_node_leave(node) }
end

#visit_block_parameters_node(node)

Dispatch enter and leave events for ::Prism::BlockParametersNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1392

def visit_block_parameters_node(node)
  listeners[:on_block_parameters_node_enter]&.each { |listener| listener.on_block_parameters_node_enter(node) }
  listeners[:on_block_parameters_node_leave]&.each { |listener| listener.on_block_parameters_node_leave(node) }
end

#visit_break_node(node)

Dispatch enter and leave events for ::Prism::BreakNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1398

def visit_break_node(node)
  listeners[:on_break_node_enter]&.each { |listener| listener.on_break_node_enter(node) }
  listeners[:on_break_node_leave]&.each { |listener| listener.on_break_node_leave(node) }
end

#visit_call_and_write_node(node)

Dispatch enter and leave events for ::Prism::CallAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1404

def visit_call_and_write_node(node)
  listeners[:on_call_and_write_node_enter]&.each { |listener| listener.on_call_and_write_node_enter(node) }
  listeners[:on_call_and_write_node_leave]&.each { |listener| listener.on_call_and_write_node_leave(node) }
end

#visit_call_node(node)

Dispatch enter and leave events for ::Prism::CallNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1410

def visit_call_node(node)
  listeners[:on_call_node_enter]&.each { |listener| listener.on_call_node_enter(node) }
  listeners[:on_call_node_leave]&.each { |listener| listener.on_call_node_leave(node) }
end

#visit_call_operator_write_node(node)

Dispatch enter and leave events for ::Prism::CallOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1416

def visit_call_operator_write_node(node)
  listeners[:on_call_operator_write_node_enter]&.each { |listener| listener.on_call_operator_write_node_enter(node) }
  listeners[:on_call_operator_write_node_leave]&.each { |listener| listener.on_call_operator_write_node_leave(node) }
end

#visit_call_or_write_node(node)

Dispatch enter and leave events for ::Prism::CallOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1422

def visit_call_or_write_node(node)
  listeners[:on_call_or_write_node_enter]&.each { |listener| listener.on_call_or_write_node_enter(node) }
  listeners[:on_call_or_write_node_leave]&.each { |listener| listener.on_call_or_write_node_leave(node) }
end

#visit_call_target_node(node)

Dispatch enter and leave events for ::Prism::CallTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1428

def visit_call_target_node(node)
  listeners[:on_call_target_node_enter]&.each { |listener| listener.on_call_target_node_enter(node) }
  listeners[:on_call_target_node_leave]&.each { |listener| listener.on_call_target_node_leave(node) }
end

#visit_capture_pattern_node(node)

Dispatch enter and leave events for ::Prism::CapturePatternNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1434

def visit_capture_pattern_node(node)
  listeners[:on_capture_pattern_node_enter]&.each { |listener| listener.on_capture_pattern_node_enter(node) }
  listeners[:on_capture_pattern_node_leave]&.each { |listener| listener.on_capture_pattern_node_leave(node) }
end

#visit_case_match_node(node)

Dispatch enter and leave events for ::Prism::CaseMatchNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1440

def visit_case_match_node(node)
  listeners[:on_case_match_node_enter]&.each { |listener| listener.on_case_match_node_enter(node) }
  listeners[:on_case_match_node_leave]&.each { |listener| listener.on_case_match_node_leave(node) }
end

#visit_case_node(node)

Dispatch enter and leave events for ::Prism::CaseNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1446

def visit_case_node(node)
  listeners[:on_case_node_enter]&.each { |listener| listener.on_case_node_enter(node) }
  listeners[:on_case_node_leave]&.each { |listener| listener.on_case_node_leave(node) }
end

#visit_class_node(node)

Dispatch enter and leave events for ::Prism::ClassNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1452

def visit_class_node(node)
  listeners[:on_class_node_enter]&.each { |listener| listener.on_class_node_enter(node) }
  listeners[:on_class_node_leave]&.each { |listener| listener.on_class_node_leave(node) }
end

#visit_class_variable_and_write_node(node)

Dispatch enter and leave events for ::Prism::ClassVariableAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1458

def visit_class_variable_and_write_node(node)
  listeners[:on_class_variable_and_write_node_enter]&.each { |listener| listener.on_class_variable_and_write_node_enter(node) }
  listeners[:on_class_variable_and_write_node_leave]&.each { |listener| listener.on_class_variable_and_write_node_leave(node) }
end

#visit_class_variable_operator_write_node(node)

Dispatch enter and leave events for ::Prism::ClassVariableOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1464

def visit_class_variable_operator_write_node(node)
  listeners[:on_class_variable_operator_write_node_enter]&.each { |listener| listener.on_class_variable_operator_write_node_enter(node) }
  listeners[:on_class_variable_operator_write_node_leave]&.each { |listener| listener.on_class_variable_operator_write_node_leave(node) }
end

#visit_class_variable_or_write_node(node)

Dispatch enter and leave events for ::Prism::ClassVariableOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1470

def visit_class_variable_or_write_node(node)
  listeners[:on_class_variable_or_write_node_enter]&.each { |listener| listener.on_class_variable_or_write_node_enter(node) }
  listeners[:on_class_variable_or_write_node_leave]&.each { |listener| listener.on_class_variable_or_write_node_leave(node) }
end

#visit_class_variable_read_node(node)

Dispatch enter and leave events for ::Prism::ClassVariableReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1476

def visit_class_variable_read_node(node)
  listeners[:on_class_variable_read_node_enter]&.each { |listener| listener.on_class_variable_read_node_enter(node) }
  listeners[:on_class_variable_read_node_leave]&.each { |listener| listener.on_class_variable_read_node_leave(node) }
end

#visit_class_variable_target_node(node)

Dispatch enter and leave events for ::Prism::ClassVariableTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1482

def visit_class_variable_target_node(node)
  listeners[:on_class_variable_target_node_enter]&.each { |listener| listener.on_class_variable_target_node_enter(node) }
  listeners[:on_class_variable_target_node_leave]&.each { |listener| listener.on_class_variable_target_node_leave(node) }
end

#visit_class_variable_write_node(node)

Dispatch enter and leave events for ::Prism::ClassVariableWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1488

def visit_class_variable_write_node(node)
  listeners[:on_class_variable_write_node_enter]&.each { |listener| listener.on_class_variable_write_node_enter(node) }
  listeners[:on_class_variable_write_node_leave]&.each { |listener| listener.on_class_variable_write_node_leave(node) }
end

#visit_constant_and_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1494

def visit_constant_and_write_node(node)
  listeners[:on_constant_and_write_node_enter]&.each { |listener| listener.on_constant_and_write_node_enter(node) }
  listeners[:on_constant_and_write_node_leave]&.each { |listener| listener.on_constant_and_write_node_leave(node) }
end

#visit_constant_operator_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1500

def visit_constant_operator_write_node(node)
  listeners[:on_constant_operator_write_node_enter]&.each { |listener| listener.on_constant_operator_write_node_enter(node) }
  listeners[:on_constant_operator_write_node_leave]&.each { |listener| listener.on_constant_operator_write_node_leave(node) }
end

#visit_constant_or_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1506

def visit_constant_or_write_node(node)
  listeners[:on_constant_or_write_node_enter]&.each { |listener| listener.on_constant_or_write_node_enter(node) }
  listeners[:on_constant_or_write_node_leave]&.each { |listener| listener.on_constant_or_write_node_leave(node) }
end

#visit_constant_path_and_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantPathAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1512

def visit_constant_path_and_write_node(node)
  listeners[:on_constant_path_and_write_node_enter]&.each { |listener| listener.on_constant_path_and_write_node_enter(node) }
  listeners[:on_constant_path_and_write_node_leave]&.each { |listener| listener.on_constant_path_and_write_node_leave(node) }
end

#visit_constant_path_node(node)

Dispatch enter and leave events for ::Prism::ConstantPathNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1518

def visit_constant_path_node(node)
  listeners[:on_constant_path_node_enter]&.each { |listener| listener.on_constant_path_node_enter(node) }
  listeners[:on_constant_path_node_leave]&.each { |listener| listener.on_constant_path_node_leave(node) }
end

#visit_constant_path_operator_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantPathOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1524

def visit_constant_path_operator_write_node(node)
  listeners[:on_constant_path_operator_write_node_enter]&.each { |listener| listener.on_constant_path_operator_write_node_enter(node) }
  listeners[:on_constant_path_operator_write_node_leave]&.each { |listener| listener.on_constant_path_operator_write_node_leave(node) }
end

#visit_constant_path_or_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantPathOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1530

def visit_constant_path_or_write_node(node)
  listeners[:on_constant_path_or_write_node_enter]&.each { |listener| listener.on_constant_path_or_write_node_enter(node) }
  listeners[:on_constant_path_or_write_node_leave]&.each { |listener| listener.on_constant_path_or_write_node_leave(node) }
end

#visit_constant_path_target_node(node)

Dispatch enter and leave events for ::Prism::ConstantPathTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1536

def visit_constant_path_target_node(node)
  listeners[:on_constant_path_target_node_enter]&.each { |listener| listener.on_constant_path_target_node_enter(node) }
  listeners[:on_constant_path_target_node_leave]&.each { |listener| listener.on_constant_path_target_node_leave(node) }
end

#visit_constant_path_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantPathWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1542

def visit_constant_path_write_node(node)
  listeners[:on_constant_path_write_node_enter]&.each { |listener| listener.on_constant_path_write_node_enter(node) }
  listeners[:on_constant_path_write_node_leave]&.each { |listener| listener.on_constant_path_write_node_leave(node) }
end

#visit_constant_read_node(node)

Dispatch enter and leave events for ::Prism::ConstantReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1548

def visit_constant_read_node(node)
  listeners[:on_constant_read_node_enter]&.each { |listener| listener.on_constant_read_node_enter(node) }
  listeners[:on_constant_read_node_leave]&.each { |listener| listener.on_constant_read_node_leave(node) }
end

#visit_constant_target_node(node)

Dispatch enter and leave events for ::Prism::ConstantTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1554

def visit_constant_target_node(node)
  listeners[:on_constant_target_node_enter]&.each { |listener| listener.on_constant_target_node_enter(node) }
  listeners[:on_constant_target_node_leave]&.each { |listener| listener.on_constant_target_node_leave(node) }
end

#visit_constant_write_node(node)

Dispatch enter and leave events for ::Prism::ConstantWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1560

def visit_constant_write_node(node)
  listeners[:on_constant_write_node_enter]&.each { |listener| listener.on_constant_write_node_enter(node) }
  listeners[:on_constant_write_node_leave]&.each { |listener| listener.on_constant_write_node_leave(node) }
end

#visit_def_node(node)

Dispatch enter and leave events for ::Prism::DefNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1566

def visit_def_node(node)
  listeners[:on_def_node_enter]&.each { |listener| listener.on_def_node_enter(node) }
  listeners[:on_def_node_leave]&.each { |listener| listener.on_def_node_leave(node) }
end

#visit_defined_node(node)

Dispatch enter and leave events for ::Prism::DefinedNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1572

def visit_defined_node(node)
  listeners[:on_defined_node_enter]&.each { |listener| listener.on_defined_node_enter(node) }
  listeners[:on_defined_node_leave]&.each { |listener| listener.on_defined_node_leave(node) }
end

#visit_else_node(node)

Dispatch enter and leave events for ::Prism::ElseNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1578

def visit_else_node(node)
  listeners[:on_else_node_enter]&.each { |listener| listener.on_else_node_enter(node) }
  listeners[:on_else_node_leave]&.each { |listener| listener.on_else_node_leave(node) }
end

#visit_embedded_statements_node(node)

Dispatch enter and leave events for ::Prism::EmbeddedStatementsNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1584

def visit_embedded_statements_node(node)
  listeners[:on_embedded_statements_node_enter]&.each { |listener| listener.on_embedded_statements_node_enter(node) }
  listeners[:on_embedded_statements_node_leave]&.each { |listener| listener.on_embedded_statements_node_leave(node) }
end

#visit_embedded_variable_node(node)

Dispatch enter and leave events for ::Prism::EmbeddedVariableNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1590

def visit_embedded_variable_node(node)
  listeners[:on_embedded_variable_node_enter]&.each { |listener| listener.on_embedded_variable_node_enter(node) }
  listeners[:on_embedded_variable_node_leave]&.each { |listener| listener.on_embedded_variable_node_leave(node) }
end

#visit_ensure_node(node)

Dispatch enter and leave events for ::Prism::EnsureNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1596

def visit_ensure_node(node)
  listeners[:on_ensure_node_enter]&.each { |listener| listener.on_ensure_node_enter(node) }
  listeners[:on_ensure_node_leave]&.each { |listener| listener.on_ensure_node_leave(node) }
end

#visit_false_node(node)

Dispatch enter and leave events for ::Prism::FalseNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1602

def visit_false_node(node)
  listeners[:on_false_node_enter]&.each { |listener| listener.on_false_node_enter(node) }
  listeners[:on_false_node_leave]&.each { |listener| listener.on_false_node_leave(node) }
end

#visit_find_pattern_node(node)

Dispatch enter and leave events for ::Prism::FindPatternNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1608

def visit_find_pattern_node(node)
  listeners[:on_find_pattern_node_enter]&.each { |listener| listener.on_find_pattern_node_enter(node) }
  listeners[:on_find_pattern_node_leave]&.each { |listener| listener.on_find_pattern_node_leave(node) }
end

#visit_flip_flop_node(node)

Dispatch enter and leave events for ::Prism::FlipFlopNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1614

def visit_flip_flop_node(node)
  listeners[:on_flip_flop_node_enter]&.each { |listener| listener.on_flip_flop_node_enter(node) }
  listeners[:on_flip_flop_node_leave]&.each { |listener| listener.on_flip_flop_node_leave(node) }
end

#visit_float_node(node)

Dispatch enter and leave events for ::Prism::FloatNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1620

def visit_float_node(node)
  listeners[:on_float_node_enter]&.each { |listener| listener.on_float_node_enter(node) }
  listeners[:on_float_node_leave]&.each { |listener| listener.on_float_node_leave(node) }
end

#visit_for_node(node)

Dispatch enter and leave events for ::Prism::ForNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1626

def visit_for_node(node)
  listeners[:on_for_node_enter]&.each { |listener| listener.on_for_node_enter(node) }
  listeners[:on_for_node_leave]&.each { |listener| listener.on_for_node_leave(node) }
end

#visit_forwarding_arguments_node(node)

Dispatch enter and leave events for ::Prism::ForwardingArgumentsNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1632

def visit_forwarding_arguments_node(node)
  listeners[:on_forwarding_arguments_node_enter]&.each { |listener| listener.on_forwarding_arguments_node_enter(node) }
  listeners[:on_forwarding_arguments_node_leave]&.each { |listener| listener.on_forwarding_arguments_node_leave(node) }
end

#visit_forwarding_parameter_node(node)

Dispatch enter and leave events for ::Prism::ForwardingParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1638

def visit_forwarding_parameter_node(node)
  listeners[:on_forwarding_parameter_node_enter]&.each { |listener| listener.on_forwarding_parameter_node_enter(node) }
  listeners[:on_forwarding_parameter_node_leave]&.each { |listener| listener.on_forwarding_parameter_node_leave(node) }
end

#visit_forwarding_super_node(node)

Dispatch enter and leave events for ::Prism::ForwardingSuperNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1644

def visit_forwarding_super_node(node)
  listeners[:on_forwarding_super_node_enter]&.each { |listener| listener.on_forwarding_super_node_enter(node) }
  listeners[:on_forwarding_super_node_leave]&.each { |listener| listener.on_forwarding_super_node_leave(node) }
end

#visit_global_variable_and_write_node(node)

Dispatch enter and leave events for ::Prism::GlobalVariableAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1650

def visit_global_variable_and_write_node(node)
  listeners[:on_global_variable_and_write_node_enter]&.each { |listener| listener.on_global_variable_and_write_node_enter(node) }
  listeners[:on_global_variable_and_write_node_leave]&.each { |listener| listener.on_global_variable_and_write_node_leave(node) }
end

#visit_global_variable_operator_write_node(node)

Dispatch enter and leave events for ::Prism::GlobalVariableOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1656

def visit_global_variable_operator_write_node(node)
  listeners[:on_global_variable_operator_write_node_enter]&.each { |listener| listener.on_global_variable_operator_write_node_enter(node) }
  listeners[:on_global_variable_operator_write_node_leave]&.each { |listener| listener.on_global_variable_operator_write_node_leave(node) }
end

#visit_global_variable_or_write_node(node)

Dispatch enter and leave events for ::Prism::GlobalVariableOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1662

def visit_global_variable_or_write_node(node)
  listeners[:on_global_variable_or_write_node_enter]&.each { |listener| listener.on_global_variable_or_write_node_enter(node) }
  listeners[:on_global_variable_or_write_node_leave]&.each { |listener| listener.on_global_variable_or_write_node_leave(node) }
end

#visit_global_variable_read_node(node)

Dispatch enter and leave events for ::Prism::GlobalVariableReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1668

def visit_global_variable_read_node(node)
  listeners[:on_global_variable_read_node_enter]&.each { |listener| listener.on_global_variable_read_node_enter(node) }
  listeners[:on_global_variable_read_node_leave]&.each { |listener| listener.on_global_variable_read_node_leave(node) }
end

#visit_global_variable_target_node(node)

Dispatch enter and leave events for ::Prism::GlobalVariableTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1674

def visit_global_variable_target_node(node)
  listeners[:on_global_variable_target_node_enter]&.each { |listener| listener.on_global_variable_target_node_enter(node) }
  listeners[:on_global_variable_target_node_leave]&.each { |listener| listener.on_global_variable_target_node_leave(node) }
end

#visit_global_variable_write_node(node)

Dispatch enter and leave events for ::Prism::GlobalVariableWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1680

def visit_global_variable_write_node(node)
  listeners[:on_global_variable_write_node_enter]&.each { |listener| listener.on_global_variable_write_node_enter(node) }
  listeners[:on_global_variable_write_node_leave]&.each { |listener| listener.on_global_variable_write_node_leave(node) }
end

#visit_hash_node(node)

Dispatch enter and leave events for ::Prism::HashNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1686

def visit_hash_node(node)
  listeners[:on_hash_node_enter]&.each { |listener| listener.on_hash_node_enter(node) }
  listeners[:on_hash_node_leave]&.each { |listener| listener.on_hash_node_leave(node) }
end

#visit_hash_pattern_node(node)

Dispatch enter and leave events for ::Prism::HashPatternNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1692

def visit_hash_pattern_node(node)
  listeners[:on_hash_pattern_node_enter]&.each { |listener| listener.on_hash_pattern_node_enter(node) }
  listeners[:on_hash_pattern_node_leave]&.each { |listener| listener.on_hash_pattern_node_leave(node) }
end

#visit_if_node(node)

Dispatch enter and leave events for ::Prism::IfNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1698

def visit_if_node(node)
  listeners[:on_if_node_enter]&.each { |listener| listener.on_if_node_enter(node) }
  listeners[:on_if_node_leave]&.each { |listener| listener.on_if_node_leave(node) }
end

#visit_imaginary_node(node)

Dispatch enter and leave events for ::Prism::ImaginaryNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1704

def visit_imaginary_node(node)
  listeners[:on_imaginary_node_enter]&.each { |listener| listener.on_imaginary_node_enter(node) }
  listeners[:on_imaginary_node_leave]&.each { |listener| listener.on_imaginary_node_leave(node) }
end

#visit_implicit_node(node)

Dispatch enter and leave events for ::Prism::ImplicitNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1710

def visit_implicit_node(node)
  listeners[:on_implicit_node_enter]&.each { |listener| listener.on_implicit_node_enter(node) }
  listeners[:on_implicit_node_leave]&.each { |listener| listener.on_implicit_node_leave(node) }
end

#visit_implicit_rest_node(node)

Dispatch enter and leave events for ::Prism::ImplicitRestNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1716

def visit_implicit_rest_node(node)
  listeners[:on_implicit_rest_node_enter]&.each { |listener| listener.on_implicit_rest_node_enter(node) }
  listeners[:on_implicit_rest_node_leave]&.each { |listener| listener.on_implicit_rest_node_leave(node) }
end

#visit_in_node(node)

Dispatch enter and leave events for ::Prism::InNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1722

def visit_in_node(node)
  listeners[:on_in_node_enter]&.each { |listener| listener.on_in_node_enter(node) }
  listeners[:on_in_node_leave]&.each { |listener| listener.on_in_node_leave(node) }
end

#visit_index_and_write_node(node)

Dispatch enter and leave events for ::Prism::IndexAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1728

def visit_index_and_write_node(node)
  listeners[:on_index_and_write_node_enter]&.each { |listener| listener.on_index_and_write_node_enter(node) }
  listeners[:on_index_and_write_node_leave]&.each { |listener| listener.on_index_and_write_node_leave(node) }
end

#visit_index_operator_write_node(node)

Dispatch enter and leave events for ::Prism::IndexOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1734

def visit_index_operator_write_node(node)
  listeners[:on_index_operator_write_node_enter]&.each { |listener| listener.on_index_operator_write_node_enter(node) }
  listeners[:on_index_operator_write_node_leave]&.each { |listener| listener.on_index_operator_write_node_leave(node) }
end

#visit_index_or_write_node(node)

Dispatch enter and leave events for ::Prism::IndexOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1740

def visit_index_or_write_node(node)
  listeners[:on_index_or_write_node_enter]&.each { |listener| listener.on_index_or_write_node_enter(node) }
  listeners[:on_index_or_write_node_leave]&.each { |listener| listener.on_index_or_write_node_leave(node) }
end

#visit_index_target_node(node)

Dispatch enter and leave events for ::Prism::IndexTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1746

def visit_index_target_node(node)
  listeners[:on_index_target_node_enter]&.each { |listener| listener.on_index_target_node_enter(node) }
  listeners[:on_index_target_node_leave]&.each { |listener| listener.on_index_target_node_leave(node) }
end

#visit_instance_variable_and_write_node(node)

Dispatch enter and leave events for ::Prism::InstanceVariableAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1752

def visit_instance_variable_and_write_node(node)
  listeners[:on_instance_variable_and_write_node_enter]&.each { |listener| listener.on_instance_variable_and_write_node_enter(node) }
  listeners[:on_instance_variable_and_write_node_leave]&.each { |listener| listener.on_instance_variable_and_write_node_leave(node) }
end

#visit_instance_variable_operator_write_node(node)

Dispatch enter and leave events for ::Prism::InstanceVariableOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1758

def visit_instance_variable_operator_write_node(node)
  listeners[:on_instance_variable_operator_write_node_enter]&.each { |listener| listener.on_instance_variable_operator_write_node_enter(node) }
  listeners[:on_instance_variable_operator_write_node_leave]&.each { |listener| listener.on_instance_variable_operator_write_node_leave(node) }
end

#visit_instance_variable_or_write_node(node)

Dispatch enter and leave events for ::Prism::InstanceVariableOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1764

def visit_instance_variable_or_write_node(node)
  listeners[:on_instance_variable_or_write_node_enter]&.each { |listener| listener.on_instance_variable_or_write_node_enter(node) }
  listeners[:on_instance_variable_or_write_node_leave]&.each { |listener| listener.on_instance_variable_or_write_node_leave(node) }
end

#visit_instance_variable_read_node(node)

Dispatch enter and leave events for ::Prism::InstanceVariableReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1770

def visit_instance_variable_read_node(node)
  listeners[:on_instance_variable_read_node_enter]&.each { |listener| listener.on_instance_variable_read_node_enter(node) }
  listeners[:on_instance_variable_read_node_leave]&.each { |listener| listener.on_instance_variable_read_node_leave(node) }
end

#visit_instance_variable_target_node(node)

Dispatch enter and leave events for ::Prism::InstanceVariableTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1776

def visit_instance_variable_target_node(node)
  listeners[:on_instance_variable_target_node_enter]&.each { |listener| listener.on_instance_variable_target_node_enter(node) }
  listeners[:on_instance_variable_target_node_leave]&.each { |listener| listener.on_instance_variable_target_node_leave(node) }
end

#visit_instance_variable_write_node(node)

Dispatch enter and leave events for ::Prism::InstanceVariableWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1782

def visit_instance_variable_write_node(node)
  listeners[:on_instance_variable_write_node_enter]&.each { |listener| listener.on_instance_variable_write_node_enter(node) }
  listeners[:on_instance_variable_write_node_leave]&.each { |listener| listener.on_instance_variable_write_node_leave(node) }
end

#visit_integer_node(node)

Dispatch enter and leave events for ::Prism::IntegerNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1788

def visit_integer_node(node)
  listeners[:on_integer_node_enter]&.each { |listener| listener.on_integer_node_enter(node) }
  listeners[:on_integer_node_leave]&.each { |listener| listener.on_integer_node_leave(node) }
end

#visit_interpolated_match_last_line_node(node)

Dispatch enter and leave events for ::Prism::InterpolatedMatchLastLineNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1794

def visit_interpolated_match_last_line_node(node)
  listeners[:on_interpolated_match_last_line_node_enter]&.each { |listener| listener.on_interpolated_match_last_line_node_enter(node) }
  listeners[:on_interpolated_match_last_line_node_leave]&.each { |listener| listener.on_interpolated_match_last_line_node_leave(node) }
end

#visit_interpolated_regular_expression_node(node)

Dispatch enter and leave events for ::Prism::InterpolatedRegularExpressionNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1800

def visit_interpolated_regular_expression_node(node)
  listeners[:on_interpolated_regular_expression_node_enter]&.each { |listener| listener.on_interpolated_regular_expression_node_enter(node) }
  listeners[:on_interpolated_regular_expression_node_leave]&.each { |listener| listener.on_interpolated_regular_expression_node_leave(node) }
end

#visit_interpolated_string_node(node)

Dispatch enter and leave events for ::Prism::InterpolatedStringNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1806

def visit_interpolated_string_node(node)
  listeners[:on_interpolated_string_node_enter]&.each { |listener| listener.on_interpolated_string_node_enter(node) }
  listeners[:on_interpolated_string_node_leave]&.each { |listener| listener.on_interpolated_string_node_leave(node) }
end

#visit_interpolated_symbol_node(node)

Dispatch enter and leave events for ::Prism::InterpolatedSymbolNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1812

def visit_interpolated_symbol_node(node)
  listeners[:on_interpolated_symbol_node_enter]&.each { |listener| listener.on_interpolated_symbol_node_enter(node) }
  listeners[:on_interpolated_symbol_node_leave]&.each { |listener| listener.on_interpolated_symbol_node_leave(node) }
end

#visit_interpolated_x_string_node(node)

Dispatch enter and leave events for ::Prism::InterpolatedXStringNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1818

def visit_interpolated_x_string_node(node)
  listeners[:on_interpolated_x_string_node_enter]&.each { |listener| listener.on_interpolated_x_string_node_enter(node) }
  listeners[:on_interpolated_x_string_node_leave]&.each { |listener| listener.on_interpolated_x_string_node_leave(node) }
end

#visit_it_local_variable_read_node(node)

Dispatch enter and leave events for ::Prism::ItLocalVariableReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1824

def visit_it_local_variable_read_node(node)
  listeners[:on_it_local_variable_read_node_enter]&.each { |listener| listener.on_it_local_variable_read_node_enter(node) }
  listeners[:on_it_local_variable_read_node_leave]&.each { |listener| listener.on_it_local_variable_read_node_leave(node) }
end

#visit_it_parameters_node(node)

Dispatch enter and leave events for ::Prism::ItParametersNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1830

def visit_it_parameters_node(node)
  listeners[:on_it_parameters_node_enter]&.each { |listener| listener.on_it_parameters_node_enter(node) }
  listeners[:on_it_parameters_node_leave]&.each { |listener| listener.on_it_parameters_node_leave(node) }
end

#visit_keyword_hash_node(node)

Dispatch enter and leave events for ::Prism::KeywordHashNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1836

def visit_keyword_hash_node(node)
  listeners[:on_keyword_hash_node_enter]&.each { |listener| listener.on_keyword_hash_node_enter(node) }
  listeners[:on_keyword_hash_node_leave]&.each { |listener| listener.on_keyword_hash_node_leave(node) }
end

#visit_keyword_rest_parameter_node(node)

Dispatch enter and leave events for ::Prism::KeywordRestParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1842

def visit_keyword_rest_parameter_node(node)
  listeners[:on_keyword_rest_parameter_node_enter]&.each { |listener| listener.on_keyword_rest_parameter_node_enter(node) }
  listeners[:on_keyword_rest_parameter_node_leave]&.each { |listener| listener.on_keyword_rest_parameter_node_leave(node) }
end

#visit_lambda_node(node)

Dispatch enter and leave events for ::Prism::LambdaNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1848

def visit_lambda_node(node)
  listeners[:on_lambda_node_enter]&.each { |listener| listener.on_lambda_node_enter(node) }
  listeners[:on_lambda_node_leave]&.each { |listener| listener.on_lambda_node_leave(node) }
end

#visit_local_variable_and_write_node(node)

Dispatch enter and leave events for ::Prism::LocalVariableAndWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1854

def visit_local_variable_and_write_node(node)
  listeners[:on_local_variable_and_write_node_enter]&.each { |listener| listener.on_local_variable_and_write_node_enter(node) }
  listeners[:on_local_variable_and_write_node_leave]&.each { |listener| listener.on_local_variable_and_write_node_leave(node) }
end

#visit_local_variable_operator_write_node(node)

Dispatch enter and leave events for ::Prism::LocalVariableOperatorWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1860

def visit_local_variable_operator_write_node(node)
  listeners[:on_local_variable_operator_write_node_enter]&.each { |listener| listener.on_local_variable_operator_write_node_enter(node) }
  listeners[:on_local_variable_operator_write_node_leave]&.each { |listener| listener.on_local_variable_operator_write_node_leave(node) }
end

#visit_local_variable_or_write_node(node)

Dispatch enter and leave events for ::Prism::LocalVariableOrWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1866

def visit_local_variable_or_write_node(node)
  listeners[:on_local_variable_or_write_node_enter]&.each { |listener| listener.on_local_variable_or_write_node_enter(node) }
  listeners[:on_local_variable_or_write_node_leave]&.each { |listener| listener.on_local_variable_or_write_node_leave(node) }
end

#visit_local_variable_read_node(node)

Dispatch enter and leave events for ::Prism::LocalVariableReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1872

def visit_local_variable_read_node(node)
  listeners[:on_local_variable_read_node_enter]&.each { |listener| listener.on_local_variable_read_node_enter(node) }
  listeners[:on_local_variable_read_node_leave]&.each { |listener| listener.on_local_variable_read_node_leave(node) }
end

#visit_local_variable_target_node(node)

Dispatch enter and leave events for ::Prism::LocalVariableTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1878

def visit_local_variable_target_node(node)
  listeners[:on_local_variable_target_node_enter]&.each { |listener| listener.on_local_variable_target_node_enter(node) }
  listeners[:on_local_variable_target_node_leave]&.each { |listener| listener.on_local_variable_target_node_leave(node) }
end

#visit_local_variable_write_node(node)

Dispatch enter and leave events for ::Prism::LocalVariableWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1884

def visit_local_variable_write_node(node)
  listeners[:on_local_variable_write_node_enter]&.each { |listener| listener.on_local_variable_write_node_enter(node) }
  listeners[:on_local_variable_write_node_leave]&.each { |listener| listener.on_local_variable_write_node_leave(node) }
end

#visit_match_last_line_node(node)

Dispatch enter and leave events for ::Prism::MatchLastLineNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1890

def visit_match_last_line_node(node)
  listeners[:on_match_last_line_node_enter]&.each { |listener| listener.on_match_last_line_node_enter(node) }
  listeners[:on_match_last_line_node_leave]&.each { |listener| listener.on_match_last_line_node_leave(node) }
end

#visit_match_predicate_node(node)

Dispatch enter and leave events for ::Prism::MatchPredicateNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1896

def visit_match_predicate_node(node)
  listeners[:on_match_predicate_node_enter]&.each { |listener| listener.on_match_predicate_node_enter(node) }
  listeners[:on_match_predicate_node_leave]&.each { |listener| listener.on_match_predicate_node_leave(node) }
end

#visit_match_required_node(node)

Dispatch enter and leave events for ::Prism::MatchRequiredNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1902

def visit_match_required_node(node)
  listeners[:on_match_required_node_enter]&.each { |listener| listener.on_match_required_node_enter(node) }
  listeners[:on_match_required_node_leave]&.each { |listener| listener.on_match_required_node_leave(node) }
end

#visit_match_write_node(node)

Dispatch enter and leave events for ::Prism::MatchWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1908

def visit_match_write_node(node)
  listeners[:on_match_write_node_enter]&.each { |listener| listener.on_match_write_node_enter(node) }
  listeners[:on_match_write_node_leave]&.each { |listener| listener.on_match_write_node_leave(node) }
end

#visit_missing_node(node)

Dispatch enter and leave events for ::Prism::MissingNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1914

def visit_missing_node(node)
  listeners[:on_missing_node_enter]&.each { |listener| listener.on_missing_node_enter(node) }
  listeners[:on_missing_node_leave]&.each { |listener| listener.on_missing_node_leave(node) }
end

#visit_module_node(node)

Dispatch enter and leave events for ::Prism::ModuleNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1920

def visit_module_node(node)
  listeners[:on_module_node_enter]&.each { |listener| listener.on_module_node_enter(node) }
  listeners[:on_module_node_leave]&.each { |listener| listener.on_module_node_leave(node) }
end

#visit_multi_target_node(node)

Dispatch enter and leave events for ::Prism::MultiTargetNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1926

def visit_multi_target_node(node)
  listeners[:on_multi_target_node_enter]&.each { |listener| listener.on_multi_target_node_enter(node) }
  listeners[:on_multi_target_node_leave]&.each { |listener| listener.on_multi_target_node_leave(node) }
end

#visit_multi_write_node(node)

Dispatch enter and leave events for ::Prism::MultiWriteNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1932

def visit_multi_write_node(node)
  listeners[:on_multi_write_node_enter]&.each { |listener| listener.on_multi_write_node_enter(node) }
  listeners[:on_multi_write_node_leave]&.each { |listener| listener.on_multi_write_node_leave(node) }
end

#visit_next_node(node)

Dispatch enter and leave events for ::Prism::NextNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1938

def visit_next_node(node)
  listeners[:on_next_node_enter]&.each { |listener| listener.on_next_node_enter(node) }
  listeners[:on_next_node_leave]&.each { |listener| listener.on_next_node_leave(node) }
end

#visit_nil_node(node)

Dispatch enter and leave events for ::Prism::NilNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1944

def visit_nil_node(node)
  listeners[:on_nil_node_enter]&.each { |listener| listener.on_nil_node_enter(node) }
  listeners[:on_nil_node_leave]&.each { |listener| listener.on_nil_node_leave(node) }
end

#visit_no_keywords_parameter_node(node)

Dispatch enter and leave events for ::Prism::NoKeywordsParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1950

def visit_no_keywords_parameter_node(node)
  listeners[:on_no_keywords_parameter_node_enter]&.each { |listener| listener.on_no_keywords_parameter_node_enter(node) }
  listeners[:on_no_keywords_parameter_node_leave]&.each { |listener| listener.on_no_keywords_parameter_node_leave(node) }
end

#visit_numbered_parameters_node(node)

Dispatch enter and leave events for ::Prism::NumberedParametersNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1956

def visit_numbered_parameters_node(node)
  listeners[:on_numbered_parameters_node_enter]&.each { |listener| listener.on_numbered_parameters_node_enter(node) }
  listeners[:on_numbered_parameters_node_leave]&.each { |listener| listener.on_numbered_parameters_node_leave(node) }
end

#visit_numbered_reference_read_node(node)

Dispatch enter and leave events for ::Prism::NumberedReferenceReadNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1962

def visit_numbered_reference_read_node(node)
  listeners[:on_numbered_reference_read_node_enter]&.each { |listener| listener.on_numbered_reference_read_node_enter(node) }
  listeners[:on_numbered_reference_read_node_leave]&.each { |listener| listener.on_numbered_reference_read_node_leave(node) }
end

#visit_optional_keyword_parameter_node(node)

Dispatch enter and leave events for ::Prism::OptionalKeywordParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1968

def visit_optional_keyword_parameter_node(node)
  listeners[:on_optional_keyword_parameter_node_enter]&.each { |listener| listener.on_optional_keyword_parameter_node_enter(node) }
  listeners[:on_optional_keyword_parameter_node_leave]&.each { |listener| listener.on_optional_keyword_parameter_node_leave(node) }
end

#visit_optional_parameter_node(node)

Dispatch enter and leave events for ::Prism::OptionalParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1974

def visit_optional_parameter_node(node)
  listeners[:on_optional_parameter_node_enter]&.each { |listener| listener.on_optional_parameter_node_enter(node) }
  listeners[:on_optional_parameter_node_leave]&.each { |listener| listener.on_optional_parameter_node_leave(node) }
end

#visit_or_node(node)

Dispatch enter and leave events for ::Prism::OrNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1980

def visit_or_node(node)
  listeners[:on_or_node_enter]&.each { |listener| listener.on_or_node_enter(node) }
  listeners[:on_or_node_leave]&.each { |listener| listener.on_or_node_leave(node) }
end

#visit_parameters_node(node)

Dispatch enter and leave events for ::Prism::ParametersNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1986

def visit_parameters_node(node)
  listeners[:on_parameters_node_enter]&.each { |listener| listener.on_parameters_node_enter(node) }
  listeners[:on_parameters_node_leave]&.each { |listener| listener.on_parameters_node_leave(node) }
end

#visit_parentheses_node(node)

Dispatch enter and leave events for ::Prism::ParenthesesNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1992

def visit_parentheses_node(node)
  listeners[:on_parentheses_node_enter]&.each { |listener| listener.on_parentheses_node_enter(node) }
  listeners[:on_parentheses_node_leave]&.each { |listener| listener.on_parentheses_node_leave(node) }
end

#visit_pinned_expression_node(node)

Dispatch enter and leave events for ::Prism::PinnedExpressionNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 1998

def visit_pinned_expression_node(node)
  listeners[:on_pinned_expression_node_enter]&.each { |listener| listener.on_pinned_expression_node_enter(node) }
  listeners[:on_pinned_expression_node_leave]&.each { |listener| listener.on_pinned_expression_node_leave(node) }
end

#visit_pinned_variable_node(node)

Dispatch enter and leave events for ::Prism::PinnedVariableNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2004

def visit_pinned_variable_node(node)
  listeners[:on_pinned_variable_node_enter]&.each { |listener| listener.on_pinned_variable_node_enter(node) }
  listeners[:on_pinned_variable_node_leave]&.each { |listener| listener.on_pinned_variable_node_leave(node) }
end

#visit_post_execution_node(node)

Dispatch enter and leave events for ::Prism::PostExecutionNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2010

def visit_post_execution_node(node)
  listeners[:on_post_execution_node_enter]&.each { |listener| listener.on_post_execution_node_enter(node) }
  listeners[:on_post_execution_node_leave]&.each { |listener| listener.on_post_execution_node_leave(node) }
end

#visit_pre_execution_node(node)

Dispatch enter and leave events for ::Prism::PreExecutionNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2016

def visit_pre_execution_node(node)
  listeners[:on_pre_execution_node_enter]&.each { |listener| listener.on_pre_execution_node_enter(node) }
  listeners[:on_pre_execution_node_leave]&.each { |listener| listener.on_pre_execution_node_leave(node) }
end

#visit_program_node(node)

Dispatch enter and leave events for ::Prism::ProgramNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2022

def visit_program_node(node)
  listeners[:on_program_node_enter]&.each { |listener| listener.on_program_node_enter(node) }
  listeners[:on_program_node_leave]&.each { |listener| listener.on_program_node_leave(node) }
end

#visit_range_node(node)

Dispatch enter and leave events for ::Prism::RangeNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2028

def visit_range_node(node)
  listeners[:on_range_node_enter]&.each { |listener| listener.on_range_node_enter(node) }
  listeners[:on_range_node_leave]&.each { |listener| listener.on_range_node_leave(node) }
end

#visit_rational_node(node)

Dispatch enter and leave events for ::Prism::RationalNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2034

def visit_rational_node(node)
  listeners[:on_rational_node_enter]&.each { |listener| listener.on_rational_node_enter(node) }
  listeners[:on_rational_node_leave]&.each { |listener| listener.on_rational_node_leave(node) }
end

#visit_redo_node(node)

Dispatch enter and leave events for ::Prism::RedoNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2040

def visit_redo_node(node)
  listeners[:on_redo_node_enter]&.each { |listener| listener.on_redo_node_enter(node) }
  listeners[:on_redo_node_leave]&.each { |listener| listener.on_redo_node_leave(node) }
end

#visit_regular_expression_node(node)

Dispatch enter and leave events for ::Prism::RegularExpressionNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2046

def visit_regular_expression_node(node)
  listeners[:on_regular_expression_node_enter]&.each { |listener| listener.on_regular_expression_node_enter(node) }
  listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
end

#visit_required_keyword_parameter_node(node)

Dispatch enter and leave events for ::Prism::RequiredKeywordParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2052

def visit_required_keyword_parameter_node(node)
  listeners[:on_required_keyword_parameter_node_enter]&.each { |listener| listener.on_required_keyword_parameter_node_enter(node) }
  listeners[:on_required_keyword_parameter_node_leave]&.each { |listener| listener.on_required_keyword_parameter_node_leave(node) }
end

#visit_required_parameter_node(node)

Dispatch enter and leave events for ::Prism::RequiredParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2058

def visit_required_parameter_node(node)
  listeners[:on_required_parameter_node_enter]&.each { |listener| listener.on_required_parameter_node_enter(node) }
  listeners[:on_required_parameter_node_leave]&.each { |listener| listener.on_required_parameter_node_leave(node) }
end

#visit_rescue_modifier_node(node)

Dispatch enter and leave events for ::Prism::RescueModifierNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2064

def visit_rescue_modifier_node(node)
  listeners[:on_rescue_modifier_node_enter]&.each { |listener| listener.on_rescue_modifier_node_enter(node) }
  listeners[:on_rescue_modifier_node_leave]&.each { |listener| listener.on_rescue_modifier_node_leave(node) }
end

#visit_rescue_node(node)

Dispatch enter and leave events for ::Prism::RescueNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2070

def visit_rescue_node(node)
  listeners[:on_rescue_node_enter]&.each { |listener| listener.on_rescue_node_enter(node) }
  listeners[:on_rescue_node_leave]&.each { |listener| listener.on_rescue_node_leave(node) }
end

#visit_rest_parameter_node(node)

Dispatch enter and leave events for ::Prism::RestParameterNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2076

def visit_rest_parameter_node(node)
  listeners[:on_rest_parameter_node_enter]&.each { |listener| listener.on_rest_parameter_node_enter(node) }
  listeners[:on_rest_parameter_node_leave]&.each { |listener| listener.on_rest_parameter_node_leave(node) }
end

#visit_retry_node(node)

Dispatch enter and leave events for ::Prism::RetryNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2082

def visit_retry_node(node)
  listeners[:on_retry_node_enter]&.each { |listener| listener.on_retry_node_enter(node) }
  listeners[:on_retry_node_leave]&.each { |listener| listener.on_retry_node_leave(node) }
end

#visit_return_node(node)

Dispatch enter and leave events for ::Prism::ReturnNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2088

def visit_return_node(node)
  listeners[:on_return_node_enter]&.each { |listener| listener.on_return_node_enter(node) }
  listeners[:on_return_node_leave]&.each { |listener| listener.on_return_node_leave(node) }
end

#visit_self_node(node)

Dispatch enter and leave events for ::Prism::SelfNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2094

def visit_self_node(node)
  listeners[:on_self_node_enter]&.each { |listener| listener.on_self_node_enter(node) }
  listeners[:on_self_node_leave]&.each { |listener| listener.on_self_node_leave(node) }
end

#visit_shareable_constant_node(node)

Dispatch enter and leave events for ::Prism::ShareableConstantNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2100

def visit_shareable_constant_node(node)
  listeners[:on_shareable_constant_node_enter]&.each { |listener| listener.on_shareable_constant_node_enter(node) }
  listeners[:on_shareable_constant_node_leave]&.each { |listener| listener.on_shareable_constant_node_leave(node) }
end

#visit_singleton_class_node(node)

Dispatch enter and leave events for ::Prism::SingletonClassNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2106

def visit_singleton_class_node(node)
  listeners[:on_singleton_class_node_enter]&.each { |listener| listener.on_singleton_class_node_enter(node) }
  listeners[:on_singleton_class_node_leave]&.each { |listener| listener.on_singleton_class_node_leave(node) }
end

#visit_source_encoding_node(node)

Dispatch enter and leave events for ::Prism::SourceEncodingNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2112

def visit_source_encoding_node(node)
  listeners[:on_source_encoding_node_enter]&.each { |listener| listener.on_source_encoding_node_enter(node) }
  listeners[:on_source_encoding_node_leave]&.each { |listener| listener.on_source_encoding_node_leave(node) }
end

#visit_source_file_node(node)

Dispatch enter and leave events for ::Prism::SourceFileNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2118

def visit_source_file_node(node)
  listeners[:on_source_file_node_enter]&.each { |listener| listener.on_source_file_node_enter(node) }
  listeners[:on_source_file_node_leave]&.each { |listener| listener.on_source_file_node_leave(node) }
end

#visit_source_line_node(node)

Dispatch enter and leave events for ::Prism::SourceLineNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2124

def visit_source_line_node(node)
  listeners[:on_source_line_node_enter]&.each { |listener| listener.on_source_line_node_enter(node) }
  listeners[:on_source_line_node_leave]&.each { |listener| listener.on_source_line_node_leave(node) }
end

#visit_splat_node(node)

Dispatch enter and leave events for ::Prism::SplatNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2130

def visit_splat_node(node)
  listeners[:on_splat_node_enter]&.each { |listener| listener.on_splat_node_enter(node) }
  listeners[:on_splat_node_leave]&.each { |listener| listener.on_splat_node_leave(node) }
end

#visit_statements_node(node)

Dispatch enter and leave events for ::Prism::StatementsNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2136

def visit_statements_node(node)
  listeners[:on_statements_node_enter]&.each { |listener| listener.on_statements_node_enter(node) }
  listeners[:on_statements_node_leave]&.each { |listener| listener.on_statements_node_leave(node) }
end

#visit_string_node(node)

Dispatch enter and leave events for ::Prism::StringNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2142

def visit_string_node(node)
  listeners[:on_string_node_enter]&.each { |listener| listener.on_string_node_enter(node) }
  listeners[:on_string_node_leave]&.each { |listener| listener.on_string_node_leave(node) }
end

#visit_super_node(node)

Dispatch enter and leave events for ::Prism::SuperNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2148

def visit_super_node(node)
  listeners[:on_super_node_enter]&.each { |listener| listener.on_super_node_enter(node) }
  listeners[:on_super_node_leave]&.each { |listener| listener.on_super_node_leave(node) }
end

#visit_symbol_node(node)

Dispatch enter and leave events for ::Prism::SymbolNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2154

def visit_symbol_node(node)
  listeners[:on_symbol_node_enter]&.each { |listener| listener.on_symbol_node_enter(node) }
  listeners[:on_symbol_node_leave]&.each { |listener| listener.on_symbol_node_leave(node) }
end

#visit_true_node(node)

Dispatch enter and leave events for ::Prism::TrueNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2160

def visit_true_node(node)
  listeners[:on_true_node_enter]&.each { |listener| listener.on_true_node_enter(node) }
  listeners[:on_true_node_leave]&.each { |listener| listener.on_true_node_leave(node) }
end

#visit_undef_node(node)

Dispatch enter and leave events for ::Prism::UndefNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2166

def visit_undef_node(node)
  listeners[:on_undef_node_enter]&.each { |listener| listener.on_undef_node_enter(node) }
  listeners[:on_undef_node_leave]&.each { |listener| listener.on_undef_node_leave(node) }
end

#visit_unless_node(node)

Dispatch enter and leave events for ::Prism::UnlessNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2172

def visit_unless_node(node)
  listeners[:on_unless_node_enter]&.each { |listener| listener.on_unless_node_enter(node) }
  listeners[:on_unless_node_leave]&.each { |listener| listener.on_unless_node_leave(node) }
end

#visit_until_node(node)

Dispatch enter and leave events for ::Prism::UntilNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2178

def visit_until_node(node)
  listeners[:on_until_node_enter]&.each { |listener| listener.on_until_node_enter(node) }
  listeners[:on_until_node_leave]&.each { |listener| listener.on_until_node_leave(node) }
end

#visit_when_node(node)

Dispatch enter and leave events for ::Prism::WhenNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2184

def visit_when_node(node)
  listeners[:on_when_node_enter]&.each { |listener| listener.on_when_node_enter(node) }
  listeners[:on_when_node_leave]&.each { |listener| listener.on_when_node_leave(node) }
end

#visit_while_node(node)

Dispatch enter and leave events for ::Prism::WhileNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2190

def visit_while_node(node)
  listeners[:on_while_node_enter]&.each { |listener| listener.on_while_node_enter(node) }
  listeners[:on_while_node_leave]&.each { |listener| listener.on_while_node_leave(node) }
end

#visit_x_string_node(node)

Dispatch enter and leave events for ::Prism::XStringNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2196

def visit_x_string_node(node)
  listeners[:on_x_string_node_enter]&.each { |listener| listener.on_x_string_node_enter(node) }
  listeners[:on_x_string_node_leave]&.each { |listener| listener.on_x_string_node_leave(node) }
end

#visit_yield_node(node)

Dispatch enter and leave events for ::Prism::YieldNode nodes.

[ GitHub ]

  
# File 'lib/prism/dispatcher.rb', line 2202

def visit_yield_node(node)
  listeners[:on_yield_node_enter]&.each { |listener| listener.on_yield_node_enter(node) }
  listeners[:on_yield_node_leave]&.each { |listener| listener.on_yield_node_leave(node) }
end