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_arguments_node
#visit_array_node
#visit_array_pattern_node
#visit_assoc_node
#visit_assoc_splat_node
#visit_back_reference_read_node
#visit_begin_node
#visit_block_argument_node
#visit_block_local_variable_node
#visit_block_node
#visit_block_parameter_node
#visit_block_parameters_node
#visit_break_node
#visit_call_and_write_node
#visit_call_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_class_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_defined_node
#visit_else_node
#visit_embedded_statements_node
#visit_embedded_variable_node
#visit_ensure_node
#visit_false_node
#visit_find_pattern_node
#visit_flip_flop_node
#visit_float_node
#visit_for_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_hash_pattern_node
#visit_if_node
#visit_imaginary_node
#visit_implicit_node
#visit_implicit_rest_node
#visit_in_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_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_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_module_node
#visit_multi_target_node
#visit_multi_write_node
#visit_next_node
#visit_nil_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_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_range_node
#visit_rational_node
#visit_redo_node
#visit_regular_expression_node
#visit_required_keyword_parameter_node
#visit_required_parameter_node
#visit_rescue_modifier_node
#visit_rescue_node
#visit_rest_parameter_node
#visit_retry_node
#visit_return_node
#visit_self_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_statements_node
#visit_string_node
#visit_super_node
#visit_symbol_node
#visit_true_node
#visit_undef_node
#visit_unless_node
#visit_until_node
#visit_when_node
#visit_while_node
#visit_x_string_node
#visit_yield_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 1281

def initialize(listeners)
  @listeners = listeners
end

Instance Attribute Details

#listeners (readonly)

[ GitHub ]

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

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 1286

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 1292

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 1298

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 1304

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 1310

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 1316

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 1322

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 1328

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 1334

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 1340

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 1346

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 1352

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 1358

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 1364

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 1370

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 1376

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 1382

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 1388

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 1394

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 1400

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 1406

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 1412

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 1418

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 1424

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 1430

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 1436

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 1442

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 1448

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 1454

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 1460

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 1466

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 1472

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 1478

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 1484

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 1490

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 1496

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 1502

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 1508

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 1514

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 1520

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 1526

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 1532

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 1538

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 1544

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 1550

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 1556

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 1562

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 1568

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 1574

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 1580

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 1586

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 1592

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 1598

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 1604

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 1610

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 1616

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 1622

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 1628

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 1634

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 1640

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 1646

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 1652

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 1658

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 1664

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 1670

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 1676

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 1682

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 1688

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 1694

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 1700

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 1706

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 1712

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 1718

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 1724

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 1730

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 1736

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 1742

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 1748

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 1754

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 1760

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 1766

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 1772

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 1778

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 1784

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 1790

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 1796

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 1802

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 1808

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 1814

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 1820

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 1826

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 1832

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 1838

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 1844

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 1850

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 1856

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 1862

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 1868

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 1874

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 1880

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 1886

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 1892

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 1898

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 1904

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 1910

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 1916

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 1922

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 1928

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 1934

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 1940

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 1946

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 1952

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 1958

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 1964

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 1970

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 1976

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 1982

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 1988

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 1994

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 2000

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 2006

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 2012

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 2018

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 2024

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 2030

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 2036

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 2042

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 2048

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 2054

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 2060

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 2066

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 2072

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 2078

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 2084

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 2090

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 2096

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 2102

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 2108

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 2114

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 2120

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 2126

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 2132

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 2138

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 2144

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 2150

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 2156

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 2162

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 2168

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 2174

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 2180

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 2186

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