123456789_123456789_123456789_123456789_123456789_

Class: Prism::Dispatcher

Relationships & Source Files
Namespace Children
Classes:
DispatchOnce
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Visitor, BasicVisitor
Instance Chain:
self, Visitor, BasicVisitor
Inherits: Prism::Visitor
Defined in: lib/prism/dispatcher.rb

Overview

The dispatcher class fires events for nodes that are found while walking an AST to all registered listeners. It’s useful for performing different types of analysis on the AST while only having to walk the tree once.

To use the dispatcher, you would first instantiate it and register listeners for the events you’re interested in:

class OctalListener
  def on_integer_node_enter(node)
    if node.octal? && !node.slice.start_with?("0o")
      warn("Octal integers should be written with the 0o prefix")
    end
  end
end

listener = OctalListener.new
dispatcher = Prism::Dispatcher.new
dispatcher.register(listener, :on_integer_node_enter)

Then, you can walk any number of trees and dispatch events to the listeners:

result = Prism.parse("001 + 002 + 003")
dispatcher.dispatch(result.value)

Optionally, you can also use #dispatch_once to dispatch enter and leave events for a single node without recursing further down the tree. This can be useful in circumstances where you want to reuse the listeners you already have registers but want to stop walking the tree at a certain point.

integer = result.value.statements.body.first.receiver.receiver
dispatcher.dispatch_once(integer)

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Visitor - Inherited

#visit_alias_global_variable_node

Visit a AliasGlobalVariableNode node.
#visit_alias_method_node

Visit a AliasMethodNode node.
#visit_alternation_pattern_node

Visit a AlternationPatternNode node.
#visit_and_node

Visit a AndNode node.
#visit_arguments_node

Visit a ArgumentsNode node.
#visit_array_node

Visit a ArrayNode node.
#visit_array_pattern_node

Visit a ArrayPatternNode node.
#visit_assoc_node

Visit a AssocNode node.
#visit_assoc_splat_node

Visit a AssocSplatNode node.
#visit_back_reference_read_node

Visit a BackReferenceReadNode node.
#visit_begin_node

Visit a BeginNode node.
#visit_block_argument_node

Visit a BlockArgumentNode node.
#visit_block_local_variable_node

Visit a BlockLocalVariableNode node.
#visit_block_node

Visit a BlockNode node.
#visit_block_parameter_node

Visit a BlockParameterNode node.
#visit_block_parameters_node

Visit a BlockParametersNode node.
#visit_break_node

Visit a BreakNode node.
#visit_call_and_write_node

Visit a CallAndWriteNode node.
#visit_call_node

Visit a CallNode node.
#visit_call_operator_write_node

Visit a CallOperatorWriteNode node.
#visit_call_or_write_node

Visit a CallOrWriteNode node.
#visit_call_target_node

Visit a CallTargetNode node.
#visit_capture_pattern_node

Visit a CapturePatternNode node.
#visit_case_match_node

Visit a CaseMatchNode node.
#visit_case_node

Visit a CaseNode node.
#visit_class_node

Visit a ClassNode node.
#visit_class_variable_and_write_node

Visit a ClassVariableAndWriteNode node.
#visit_class_variable_operator_write_node

Visit a ClassVariableOperatorWriteNode node.
#visit_class_variable_or_write_node

Visit a ClassVariableOrWriteNode node.
#visit_class_variable_read_node

Visit a ClassVariableReadNode node.
#visit_class_variable_target_node

Visit a ClassVariableTargetNode node.
#visit_class_variable_write_node

Visit a ClassVariableWriteNode node.
#visit_constant_and_write_node

Visit a ConstantAndWriteNode node.
#visit_constant_operator_write_node

Visit a ConstantOperatorWriteNode node.
#visit_constant_or_write_node

Visit a ConstantOrWriteNode node.
#visit_constant_path_and_write_node

Visit a ConstantPathAndWriteNode node.
#visit_constant_path_node

Visit a ConstantPathNode node.
#visit_constant_path_operator_write_node

Visit a ConstantPathOperatorWriteNode node.
#visit_constant_path_or_write_node

Visit a ConstantPathOrWriteNode node.
#visit_constant_path_target_node

Visit a ConstantPathTargetNode node.
#visit_constant_path_write_node

Visit a ConstantPathWriteNode node.
#visit_constant_read_node

Visit a ConstantReadNode node.
#visit_constant_target_node

Visit a ConstantTargetNode node.
#visit_constant_write_node

Visit a ConstantWriteNode node.
#visit_def_node

Visit a DefNode node.
#visit_defined_node

Visit a DefinedNode node.
#visit_else_node

Visit a ElseNode node.
#visit_embedded_statements_node

Visit a EmbeddedStatementsNode node.
#visit_embedded_variable_node

Visit a EmbeddedVariableNode node.
#visit_ensure_node

Visit a EnsureNode node.
#visit_false_node

Visit a FalseNode node.
#visit_find_pattern_node

Visit a FindPatternNode node.
#visit_flip_flop_node

Visit a FlipFlopNode node.
#visit_float_node

Visit a FloatNode node.
#visit_for_node

Visit a ForNode node.
#visit_forwarding_arguments_node

Visit a ForwardingArgumentsNode node.
#visit_forwarding_parameter_node

Visit a ForwardingParameterNode node.
#visit_forwarding_super_node

Visit a ForwardingSuperNode node.
#visit_global_variable_and_write_node

Visit a GlobalVariableAndWriteNode node.
#visit_global_variable_operator_write_node

Visit a GlobalVariableOperatorWriteNode node.
#visit_global_variable_or_write_node

Visit a GlobalVariableOrWriteNode node.
#visit_global_variable_read_node

Visit a GlobalVariableReadNode node.
#visit_global_variable_target_node

Visit a GlobalVariableTargetNode node.
#visit_global_variable_write_node

Visit a GlobalVariableWriteNode node.
#visit_hash_node

Visit a HashNode node.
#visit_hash_pattern_node

Visit a HashPatternNode node.
#visit_if_node

Visit a IfNode node.
#visit_imaginary_node

Visit a ImaginaryNode node.
#visit_implicit_node

Visit a ImplicitNode node.
#visit_implicit_rest_node

Visit a ImplicitRestNode node.
#visit_in_node

Visit a InNode node.
#visit_index_and_write_node

Visit a IndexAndWriteNode node.
#visit_index_operator_write_node

Visit a IndexOperatorWriteNode node.
#visit_index_or_write_node

Visit a IndexOrWriteNode node.
#visit_index_target_node

Visit a IndexTargetNode node.
#visit_instance_variable_and_write_node

Visit a InstanceVariableAndWriteNode node.
#visit_instance_variable_operator_write_node

Visit a InstanceVariableOperatorWriteNode node.
#visit_instance_variable_or_write_node

Visit a InstanceVariableOrWriteNode node.
#visit_instance_variable_read_node

Visit a InstanceVariableReadNode node.
#visit_instance_variable_target_node

Visit a InstanceVariableTargetNode node.
#visit_instance_variable_write_node

Visit a InstanceVariableWriteNode node.
#visit_integer_node

Visit a IntegerNode node.
#visit_interpolated_match_last_line_node

Visit a InterpolatedMatchLastLineNode node.
#visit_interpolated_regular_expression_node

Visit a InterpolatedRegularExpressionNode node.
#visit_interpolated_string_node

Visit a InterpolatedStringNode node.
#visit_interpolated_symbol_node

Visit a InterpolatedSymbolNode node.
#visit_interpolated_x_string_node

Visit a InterpolatedXStringNode node.
#visit_it_local_variable_read_node

Visit a ItLocalVariableReadNode node.
#visit_it_parameters_node

Visit a ItParametersNode node.
#visit_keyword_hash_node

Visit a KeywordHashNode node.
#visit_keyword_rest_parameter_node

Visit a KeywordRestParameterNode node.
#visit_lambda_node

Visit a LambdaNode node.
#visit_local_variable_and_write_node

Visit a LocalVariableAndWriteNode node.
#visit_local_variable_operator_write_node

Visit a LocalVariableOperatorWriteNode node.
#visit_local_variable_or_write_node

Visit a LocalVariableOrWriteNode node.
#visit_local_variable_read_node

Visit a LocalVariableReadNode node.
#visit_local_variable_target_node

Visit a LocalVariableTargetNode node.
#visit_local_variable_write_node

Visit a LocalVariableWriteNode node.
#visit_match_last_line_node

Visit a MatchLastLineNode node.
#visit_match_predicate_node

Visit a MatchPredicateNode node.
#visit_match_required_node

Visit a MatchRequiredNode node.
#visit_match_write_node

Visit a MatchWriteNode node.
#visit_missing_node

Visit a MissingNode node.
#visit_module_node

Visit a ModuleNode node.
#visit_multi_target_node

Visit a MultiTargetNode node.
#visit_multi_write_node

Visit a MultiWriteNode node.
#visit_next_node

Visit a NextNode node.
#visit_nil_node

Visit a NilNode node.
#visit_no_keywords_parameter_node

Visit a NoKeywordsParameterNode node.
#visit_numbered_parameters_node

Visit a NumberedParametersNode node.
#visit_numbered_reference_read_node

Visit a NumberedReferenceReadNode node.
#visit_optional_keyword_parameter_node

Visit a OptionalKeywordParameterNode node.
#visit_optional_parameter_node

Visit a OptionalParameterNode node.
#visit_or_node

Visit a OrNode node.
#visit_parameters_node

Visit a ParametersNode node.
#visit_parentheses_node

Visit a ParenthesesNode node.
#visit_pinned_expression_node

Visit a PinnedExpressionNode node.
#visit_pinned_variable_node

Visit a PinnedVariableNode node.
#visit_post_execution_node

Visit a PostExecutionNode node.
#visit_pre_execution_node

Visit a PreExecutionNode node.
#visit_program_node

Visit a ProgramNode node.
#visit_range_node

Visit a RangeNode node.
#visit_rational_node

Visit a RationalNode node.
#visit_redo_node

Visit a RedoNode node.
#visit_regular_expression_node

Visit a RegularExpressionNode node.
#visit_required_keyword_parameter_node

Visit a RequiredKeywordParameterNode node.
#visit_required_parameter_node

Visit a RequiredParameterNode node.
#visit_rescue_modifier_node

Visit a RescueModifierNode node.
#visit_rescue_node

Visit a RescueNode node.
#visit_rest_parameter_node

Visit a RestParameterNode node.
#visit_retry_node

Visit a RetryNode node.
#visit_return_node

Visit a ReturnNode node.
#visit_self_node

Visit a SelfNode node.
#visit_shareable_constant_node

Visit a ShareableConstantNode node.
#visit_singleton_class_node

Visit a SingletonClassNode node.
#visit_source_encoding_node

Visit a SourceEncodingNode node.
#visit_source_file_node

Visit a SourceFileNode node.
#visit_source_line_node

Visit a SourceLineNode node.
#visit_splat_node

Visit a SplatNode node.
#visit_statements_node

Visit a StatementsNode node.
#visit_string_node

Visit a StringNode node.
#visit_super_node

Visit a SuperNode node.
#visit_symbol_node

Visit a SymbolNode node.
#visit_true_node

Visit a TrueNode node.
#visit_undef_node

Visit a UndefNode node.
#visit_unless_node

Visit a UnlessNode node.
#visit_until_node

Visit a UntilNode node.
#visit_when_node

Visit a WhenNode node.
#visit_while_node

Visit a WhileNode node.
#visit_x_string_node

Visit a XStringNode node.
#visit_yield_node

Visit a YieldNode node.

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 ⇒ Dispatcher

Initialize a new dispatcher.

[ GitHub ] 

  


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



def initialize
  @listeners = {}
end


  







Instance Attribute Details



  

    #listeners   (readonly)
  



  

    

attr_reader listeners: Hash[Symbol, Array]


  



  [ GitHub ]


  

  


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



attr_reader :listeners


  







Instance Method Details



  

    #dispatch(node)  
  



  

    

Alias for BasicVisitor#visit.


  



  [ GitHub ]


  

  


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



alias dispatch visit


  








  

    #dispatch_once(node)  
  



  

    

Dispatches a single event for node to all registered listeners.



def dispatch_once: (Node) -> void


  



  [ GitHub ]


  

  


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



def dispatch_once(node)
  node.accept(DispatchOnce.new(listeners))
end


  








  

    #register(listener, *events)  
  



  

    

Register a listener for one or more events.



def register: (Listener, *Symbol) -> void


  



  [ GitHub ]


  

  


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



def register(listener, *events)
  register_events(listener, events)
end


  








  

    #register_events(listener, events)   (private)
  



  

    

Register a listener for the given events.


  



  [ GitHub ]


  

  


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



private def register_events(listener, events)
  events.each { |event| (listeners[event] ||= []) << listener }
end


  








  

    #register_public_methods(listener)  
  



  

    

Register all public methods of a listener that match the pattern on_<node_name>_(enter|leave).



def register_public_methods: (Listener) -> void


  



  [ GitHub ]


  

  


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



def register_public_methods(listener)
  register_events(listener, listener.public_methods(false).grep(/\Aon_.+_(?:enter|leave)\z/))
end


  








  

    #visit_alias_global_variable_node(node)  
  



  

    

Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_alias_global_variable_node(node)
  listeners[:on_alias_global_variable_node_enter]&.each { |listener| listener.on_alias_global_variable_node_enter(node) }
  super
  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 AliasMethodNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_alias_method_node(node)
  listeners[:on_alias_method_node_enter]&.each { |listener| listener.on_alias_method_node_enter(node) }
  super
  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 AlternationPatternNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_alternation_pattern_node(node)
  listeners[:on_alternation_pattern_node_enter]&.each { |listener| listener.on_alternation_pattern_node_enter(node) }
  super
  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 AndNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_arguments_node(node)  
  



  

    

Dispatch enter and leave events for ArgumentsNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_array_node(node)  
  



  

    

Dispatch enter and leave events for ArrayNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_array_node(node)
  listeners[:on_array_node_enter]&.each { |listener| listener.on_array_node_enter(node) }
  super
  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 ArrayPatternNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_array_pattern_node(node)
  listeners[:on_array_pattern_node_enter]&.each { |listener| listener.on_array_pattern_node_enter(node) }
  super
  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 AssocNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_assoc_node(node)
  listeners[:on_assoc_node_enter]&.each { |listener| listener.on_assoc_node_enter(node) }
  super
  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 AssocSplatNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_assoc_splat_node(node)
  listeners[:on_assoc_splat_node_enter]&.each { |listener| listener.on_assoc_splat_node_enter(node) }
  super
  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 BackReferenceReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_back_reference_read_node(node)
  listeners[:on_back_reference_read_node_enter]&.each { |listener| listener.on_back_reference_read_node_enter(node) }
  super
  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 BeginNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_begin_node(node)
  listeners[:on_begin_node_enter]&.each { |listener| listener.on_begin_node_enter(node) }
  super
  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 BlockArgumentNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_block_argument_node(node)
  listeners[:on_block_argument_node_enter]&.each { |listener| listener.on_block_argument_node_enter(node) }
  super
  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 BlockLocalVariableNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_block_local_variable_node(node)
  listeners[:on_block_local_variable_node_enter]&.each { |listener| listener.on_block_local_variable_node_enter(node) }
  super
  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 BlockNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_block_node(node)
  listeners[:on_block_node_enter]&.each { |listener| listener.on_block_node_enter(node) }
  super
  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 BlockParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_block_parameter_node(node)
  listeners[:on_block_parameter_node_enter]&.each { |listener| listener.on_block_parameter_node_enter(node) }
  super
  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 BlockParametersNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_block_parameters_node(node)
  listeners[:on_block_parameters_node_enter]&.each { |listener| listener.on_block_parameters_node_enter(node) }
  super
  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 BreakNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_break_node(node)
  listeners[:on_break_node_enter]&.each { |listener| listener.on_break_node_enter(node) }
  super
  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 CallAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_call_and_write_node(node)
  listeners[:on_call_and_write_node_enter]&.each { |listener| listener.on_call_and_write_node_enter(node) }
  super
  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 CallNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_call_node(node)
  listeners[:on_call_node_enter]&.each { |listener| listener.on_call_node_enter(node) }
  super
  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 CallOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_call_operator_write_node(node)
  listeners[:on_call_operator_write_node_enter]&.each { |listener| listener.on_call_operator_write_node_enter(node) }
  super
  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 CallOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_call_or_write_node(node)
  listeners[:on_call_or_write_node_enter]&.each { |listener| listener.on_call_or_write_node_enter(node) }
  super
  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 CallTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_call_target_node(node)
  listeners[:on_call_target_node_enter]&.each { |listener| listener.on_call_target_node_enter(node) }
  super
  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 CapturePatternNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_capture_pattern_node(node)
  listeners[:on_capture_pattern_node_enter]&.each { |listener| listener.on_capture_pattern_node_enter(node) }
  super
  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 CaseMatchNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_case_match_node(node)
  listeners[:on_case_match_node_enter]&.each { |listener| listener.on_case_match_node_enter(node) }
  super
  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 CaseNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_class_node(node)  
  



  

    

Dispatch enter and leave events for ClassNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_class_node(node)
  listeners[:on_class_node_enter]&.each { |listener| listener.on_class_node_enter(node) }
  super
  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 ClassVariableAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ClassVariableOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ClassVariableOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ClassVariableReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_class_variable_read_node(node)
  listeners[:on_class_variable_read_node_enter]&.each { |listener| listener.on_class_variable_read_node_enter(node) }
  super
  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 ClassVariableTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_class_variable_target_node(node)
  listeners[:on_class_variable_target_node_enter]&.each { |listener| listener.on_class_variable_target_node_enter(node) }
  super
  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 ClassVariableWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_class_variable_write_node(node)
  listeners[:on_class_variable_write_node_enter]&.each { |listener| listener.on_class_variable_write_node_enter(node) }
  super
  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 ConstantAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_and_write_node(node)
  listeners[:on_constant_and_write_node_enter]&.each { |listener| listener.on_constant_and_write_node_enter(node) }
  super
  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 ConstantOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_operator_write_node(node)
  listeners[:on_constant_operator_write_node_enter]&.each { |listener| listener.on_constant_operator_write_node_enter(node) }
  super
  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 ConstantOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_or_write_node(node)
  listeners[:on_constant_or_write_node_enter]&.each { |listener| listener.on_constant_or_write_node_enter(node) }
  super
  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 ConstantPathAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ConstantPathNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_path_node(node)
  listeners[:on_constant_path_node_enter]&.each { |listener| listener.on_constant_path_node_enter(node) }
  super
  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 ConstantPathOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ConstantPathOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ConstantPathTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_path_target_node(node)
  listeners[:on_constant_path_target_node_enter]&.each { |listener| listener.on_constant_path_target_node_enter(node) }
  super
  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 ConstantPathWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_path_write_node(node)
  listeners[:on_constant_path_write_node_enter]&.each { |listener| listener.on_constant_path_write_node_enter(node) }
  super
  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 ConstantReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_read_node(node)
  listeners[:on_constant_read_node_enter]&.each { |listener| listener.on_constant_read_node_enter(node) }
  super
  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 ConstantTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_target_node(node)
  listeners[:on_constant_target_node_enter]&.each { |listener| listener.on_constant_target_node_enter(node) }
  super
  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 ConstantWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_constant_write_node(node)
  listeners[:on_constant_write_node_enter]&.each { |listener| listener.on_constant_write_node_enter(node) }
  super
  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 DefNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_defined_node(node)  
  



  

    

Dispatch enter and leave events for DefinedNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_else_node(node)  
  



  

    

Dispatch enter and leave events for ElseNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_else_node(node)
  listeners[:on_else_node_enter]&.each { |listener| listener.on_else_node_enter(node) }
  super
  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 EmbeddedStatementsNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_embedded_statements_node(node)
  listeners[:on_embedded_statements_node_enter]&.each { |listener| listener.on_embedded_statements_node_enter(node) }
  super
  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 EmbeddedVariableNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_embedded_variable_node(node)
  listeners[:on_embedded_variable_node_enter]&.each { |listener| listener.on_embedded_variable_node_enter(node) }
  super
  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 EnsureNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_false_node(node)  
  



  

    

Dispatch enter and leave events for FalseNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_false_node(node)
  listeners[:on_false_node_enter]&.each { |listener| listener.on_false_node_enter(node) }
  super
  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 FindPatternNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_find_pattern_node(node)
  listeners[:on_find_pattern_node_enter]&.each { |listener| listener.on_find_pattern_node_enter(node) }
  super
  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 FlipFlopNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_flip_flop_node(node)
  listeners[:on_flip_flop_node_enter]&.each { |listener| listener.on_flip_flop_node_enter(node) }
  super
  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 FloatNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_for_node(node)  
  



  

    

Dispatch enter and leave events for ForNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_for_node(node)
  listeners[:on_for_node_enter]&.each { |listener| listener.on_for_node_enter(node) }
  super
  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 ForwardingArgumentsNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_forwarding_arguments_node(node)
  listeners[:on_forwarding_arguments_node_enter]&.each { |listener| listener.on_forwarding_arguments_node_enter(node) }
  super
  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 ForwardingParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_forwarding_parameter_node(node)
  listeners[:on_forwarding_parameter_node_enter]&.each { |listener| listener.on_forwarding_parameter_node_enter(node) }
  super
  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 ForwardingSuperNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_forwarding_super_node(node)
  listeners[:on_forwarding_super_node_enter]&.each { |listener| listener.on_forwarding_super_node_enter(node) }
  super
  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 GlobalVariableAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 GlobalVariableOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 GlobalVariableOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 GlobalVariableReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_global_variable_read_node(node)
  listeners[:on_global_variable_read_node_enter]&.each { |listener| listener.on_global_variable_read_node_enter(node) }
  super
  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 GlobalVariableTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_global_variable_target_node(node)
  listeners[:on_global_variable_target_node_enter]&.each { |listener| listener.on_global_variable_target_node_enter(node) }
  super
  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 GlobalVariableWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_global_variable_write_node(node)
  listeners[:on_global_variable_write_node_enter]&.each { |listener| listener.on_global_variable_write_node_enter(node) }
  super
  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 HashNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_hash_node(node)
  listeners[:on_hash_node_enter]&.each { |listener| listener.on_hash_node_enter(node) }
  super
  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 HashPatternNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_hash_pattern_node(node)
  listeners[:on_hash_pattern_node_enter]&.each { |listener| listener.on_hash_pattern_node_enter(node) }
  super
  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 IfNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_imaginary_node(node)  
  



  

    

Dispatch enter and leave events for ImaginaryNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_implicit_node(node)  
  



  

    

Dispatch enter and leave events for ImplicitNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_implicit_node(node)
  listeners[:on_implicit_node_enter]&.each { |listener| listener.on_implicit_node_enter(node) }
  super
  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 ImplicitRestNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_implicit_rest_node(node)
  listeners[:on_implicit_rest_node_enter]&.each { |listener| listener.on_implicit_rest_node_enter(node) }
  super
  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 InNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_in_node(node)
  listeners[:on_in_node_enter]&.each { |listener| listener.on_in_node_enter(node) }
  super
  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 IndexAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_index_and_write_node(node)
  listeners[:on_index_and_write_node_enter]&.each { |listener| listener.on_index_and_write_node_enter(node) }
  super
  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 IndexOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_index_operator_write_node(node)
  listeners[:on_index_operator_write_node_enter]&.each { |listener| listener.on_index_operator_write_node_enter(node) }
  super
  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 IndexOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_index_or_write_node(node)
  listeners[:on_index_or_write_node_enter]&.each { |listener| listener.on_index_or_write_node_enter(node) }
  super
  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 IndexTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_index_target_node(node)
  listeners[:on_index_target_node_enter]&.each { |listener| listener.on_index_target_node_enter(node) }
  super
  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 InstanceVariableAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 InstanceVariableOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 InstanceVariableOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 InstanceVariableReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_instance_variable_read_node(node)
  listeners[:on_instance_variable_read_node_enter]&.each { |listener| listener.on_instance_variable_read_node_enter(node) }
  super
  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 InstanceVariableTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_instance_variable_target_node(node)
  listeners[:on_instance_variable_target_node_enter]&.each { |listener| listener.on_instance_variable_target_node_enter(node) }
  super
  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 InstanceVariableWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_instance_variable_write_node(node)
  listeners[:on_instance_variable_write_node_enter]&.each { |listener| listener.on_instance_variable_write_node_enter(node) }
  super
  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 IntegerNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_integer_node(node)
  listeners[:on_integer_node_enter]&.each { |listener| listener.on_integer_node_enter(node) }
  super
  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 InterpolatedMatchLastLineNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 InterpolatedRegularExpressionNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_interpolated_regular_expression_node(node)
  listeners[:on_interpolated_regular_expression_node_enter]&.each { |listener| listener.on_interpolated_regular_expression_node_enter(node) }
  super
  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 InterpolatedStringNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_interpolated_string_node(node)
  listeners[:on_interpolated_string_node_enter]&.each { |listener| listener.on_interpolated_string_node_enter(node) }
  super
  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 InterpolatedSymbolNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_interpolated_symbol_node(node)
  listeners[:on_interpolated_symbol_node_enter]&.each { |listener| listener.on_interpolated_symbol_node_enter(node) }
  super
  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 InterpolatedXStringNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_interpolated_x_string_node(node)
  listeners[:on_interpolated_x_string_node_enter]&.each { |listener| listener.on_interpolated_x_string_node_enter(node) }
  super
  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 ItLocalVariableReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 ItParametersNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_it_parameters_node(node)
  listeners[:on_it_parameters_node_enter]&.each { |listener| listener.on_it_parameters_node_enter(node) }
  super
  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 KeywordHashNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_keyword_hash_node(node)
  listeners[:on_keyword_hash_node_enter]&.each { |listener| listener.on_keyword_hash_node_enter(node) }
  super
  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 KeywordRestParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_keyword_rest_parameter_node(node)
  listeners[:on_keyword_rest_parameter_node_enter]&.each { |listener| listener.on_keyword_rest_parameter_node_enter(node) }
  super
  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 LambdaNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_lambda_node(node)
  listeners[:on_lambda_node_enter]&.each { |listener| listener.on_lambda_node_enter(node) }
  super
  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 LocalVariableAndWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 LocalVariableOperatorWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 LocalVariableOrWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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) }
  super
  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 LocalVariableReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_local_variable_read_node(node)
  listeners[:on_local_variable_read_node_enter]&.each { |listener| listener.on_local_variable_read_node_enter(node) }
  super
  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 LocalVariableTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_local_variable_target_node(node)
  listeners[:on_local_variable_target_node_enter]&.each { |listener| listener.on_local_variable_target_node_enter(node) }
  super
  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 LocalVariableWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_local_variable_write_node(node)
  listeners[:on_local_variable_write_node_enter]&.each { |listener| listener.on_local_variable_write_node_enter(node) }
  super
  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 MatchLastLineNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_match_last_line_node(node)
  listeners[:on_match_last_line_node_enter]&.each { |listener| listener.on_match_last_line_node_enter(node) }
  super
  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 MatchPredicateNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_match_predicate_node(node)
  listeners[:on_match_predicate_node_enter]&.each { |listener| listener.on_match_predicate_node_enter(node) }
  super
  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 MatchRequiredNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_match_required_node(node)
  listeners[:on_match_required_node_enter]&.each { |listener| listener.on_match_required_node_enter(node) }
  super
  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 MatchWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_match_write_node(node)
  listeners[:on_match_write_node_enter]&.each { |listener| listener.on_match_write_node_enter(node) }
  super
  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 MissingNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_module_node(node)  
  



  

    

Dispatch enter and leave events for ModuleNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_module_node(node)
  listeners[:on_module_node_enter]&.each { |listener| listener.on_module_node_enter(node) }
  super
  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 MultiTargetNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_multi_target_node(node)
  listeners[:on_multi_target_node_enter]&.each { |listener| listener.on_multi_target_node_enter(node) }
  super
  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 MultiWriteNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_multi_write_node(node)
  listeners[:on_multi_write_node_enter]&.each { |listener| listener.on_multi_write_node_enter(node) }
  super
  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 NextNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_nil_node(node)  
  



  

    

Dispatch enter and leave events for NilNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_nil_node(node)
  listeners[:on_nil_node_enter]&.each { |listener| listener.on_nil_node_enter(node) }
  super
  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 NoKeywordsParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_no_keywords_parameter_node(node)
  listeners[:on_no_keywords_parameter_node_enter]&.each { |listener| listener.on_no_keywords_parameter_node_enter(node) }
  super
  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 NumberedParametersNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_numbered_parameters_node(node)
  listeners[:on_numbered_parameters_node_enter]&.each { |listener| listener.on_numbered_parameters_node_enter(node) }
  super
  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 NumberedReferenceReadNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_numbered_reference_read_node(node)
  listeners[:on_numbered_reference_read_node_enter]&.each { |listener| listener.on_numbered_reference_read_node_enter(node) }
  super
  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 OptionalKeywordParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_optional_keyword_parameter_node(node)
  listeners[:on_optional_keyword_parameter_node_enter]&.each { |listener| listener.on_optional_keyword_parameter_node_enter(node) }
  super
  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 OptionalParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_optional_parameter_node(node)
  listeners[:on_optional_parameter_node_enter]&.each { |listener| listener.on_optional_parameter_node_enter(node) }
  super
  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 OrNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_parameters_node(node)  
  



  

    

Dispatch enter and leave events for ParametersNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_parentheses_node(node)  
  



  

    

Dispatch enter and leave events for ParenthesesNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_parentheses_node(node)
  listeners[:on_parentheses_node_enter]&.each { |listener| listener.on_parentheses_node_enter(node) }
  super
  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 PinnedExpressionNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_pinned_expression_node(node)
  listeners[:on_pinned_expression_node_enter]&.each { |listener| listener.on_pinned_expression_node_enter(node) }
  super
  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 PinnedVariableNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_pinned_variable_node(node)
  listeners[:on_pinned_variable_node_enter]&.each { |listener| listener.on_pinned_variable_node_enter(node) }
  super
  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 PostExecutionNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_post_execution_node(node)
  listeners[:on_post_execution_node_enter]&.each { |listener| listener.on_post_execution_node_enter(node) }
  super
  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 PreExecutionNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_pre_execution_node(node)
  listeners[:on_pre_execution_node_enter]&.each { |listener| listener.on_pre_execution_node_enter(node) }
  super
  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 ProgramNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_range_node(node)  
  



  

    

Dispatch enter and leave events for RangeNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_rational_node(node)  
  



  

    

Dispatch enter and leave events for RationalNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_redo_node(node)  
  



  

    

Dispatch enter and leave events for RedoNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_redo_node(node)
  listeners[:on_redo_node_enter]&.each { |listener| listener.on_redo_node_enter(node) }
  super
  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 RegularExpressionNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_regular_expression_node(node)
  listeners[:on_regular_expression_node_enter]&.each { |listener| listener.on_regular_expression_node_enter(node) }
  super
  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 RequiredKeywordParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_required_keyword_parameter_node(node)
  listeners[:on_required_keyword_parameter_node_enter]&.each { |listener| listener.on_required_keyword_parameter_node_enter(node) }
  super
  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 RequiredParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_required_parameter_node(node)
  listeners[:on_required_parameter_node_enter]&.each { |listener| listener.on_required_parameter_node_enter(node) }
  super
  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 RescueModifierNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_rescue_modifier_node(node)
  listeners[:on_rescue_modifier_node_enter]&.each { |listener| listener.on_rescue_modifier_node_enter(node) }
  super
  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 RescueNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_rescue_node(node)
  listeners[:on_rescue_node_enter]&.each { |listener| listener.on_rescue_node_enter(node) }
  super
  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 RestParameterNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_rest_parameter_node(node)
  listeners[:on_rest_parameter_node_enter]&.each { |listener| listener.on_rest_parameter_node_enter(node) }
  super
  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 RetryNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_return_node(node)  
  



  

    

Dispatch enter and leave events for ReturnNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_self_node(node)  
  



  

    

Dispatch enter and leave events for SelfNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_self_node(node)
  listeners[:on_self_node_enter]&.each { |listener| listener.on_self_node_enter(node) }
  super
  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 ShareableConstantNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_shareable_constant_node(node)
  listeners[:on_shareable_constant_node_enter]&.each { |listener| listener.on_shareable_constant_node_enter(node) }
  super
  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 SingletonClassNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_singleton_class_node(node)
  listeners[:on_singleton_class_node_enter]&.each { |listener| listener.on_singleton_class_node_enter(node) }
  super
  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 SourceEncodingNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_source_encoding_node(node)
  listeners[:on_source_encoding_node_enter]&.each { |listener| listener.on_source_encoding_node_enter(node) }
  super
  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 SourceFileNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_source_file_node(node)
  listeners[:on_source_file_node_enter]&.each { |listener| listener.on_source_file_node_enter(node) }
  super
  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 SourceLineNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_source_line_node(node)
  listeners[:on_source_line_node_enter]&.each { |listener| listener.on_source_line_node_enter(node) }
  super
  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 SplatNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_statements_node(node)  
  



  

    

Dispatch enter and leave events for StatementsNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_string_node(node)  
  



  

    

Dispatch enter and leave events for StringNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_super_node(node)  
  



  

    

Dispatch enter and leave events for SuperNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_symbol_node(node)  
  



  

    

Dispatch enter and leave events for SymbolNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_true_node(node)  
  



  

    

Dispatch enter and leave events for TrueNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_undef_node(node)  
  



  

    

Dispatch enter and leave events for UndefNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_unless_node(node)  
  



  

    

Dispatch enter and leave events for UnlessNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_until_node(node)  
  



  

    

Dispatch enter and leave events for UntilNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_when_node(node)  
  



  

    

Dispatch enter and leave events for WhenNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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


  








  

    #visit_while_node(node)  
  



  

    

Dispatch enter and leave events for WhileNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_while_node(node)
  listeners[:on_while_node_enter]&.each { |listener| listener.on_while_node_enter(node) }
  super
  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 XStringNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



def visit_x_string_node(node)
  listeners[:on_x_string_node_enter]&.each { |listener| listener.on_x_string_node_enter(node) }
  super
  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 YieldNode nodes and continue walking the tree.


  



  [ GitHub ]


  

  


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



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