class Prism::Dispatcher - Documentation for Ruby 4.0
Description: class Prism::Dispatcher: The dispatcher class fires events for nodes that are found while walking an AST to all registered listeners. It's useful for performing different type
Keywords: ruby,class,Prism::Dispatcher

🔍

No recent searches

# class Prism::Dispatcher

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)

### Attributes

listeners [R]

attr_reader listeners: Hash[Symbol, Array]

### Public Class Methods

new ()
Source

    # File lib/prism/dispatcher.rb, line 50
    def initialize
      @listeners = {}
    end

Initialize a new dispatcher.

### Public Instance Methods

dispatch_once (node)
Source

    # File lib/prism/dispatcher.rb, line 82
    def dispatch_once(node)
      node.accept(DispatchOnce.new(listeners))
    end

Dispatches a single event for `node` to all registered listeners.

def `dispatch_once`: (`Node`) -> void

register (listener, *events)
Source

    # File lib/prism/dispatcher.rb, line 57
    def register(listener, *events)
      register_events(listener, events)
    end

Register a listener for one or more events.

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

register_public_methods (listener)
Source

    # 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

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

def `register_public_methods`: (Listener) -> void

visit_alias_global_variable_node (node)
Source

    # 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

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

Calls superclass method
visit_alias_method_node (node)
Source

    # 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

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

Calls superclass method
visit_alternation_pattern_node (node)
Source

    # 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

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

Calls superclass method
visit_and_node (node)
Source

    # 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

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

Calls superclass method
visit_arguments_node (node)
Source

    # 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

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

Calls superclass method
visit_array_node (node)
Source

    # 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

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

Calls superclass method
visit_array_pattern_node (node)
Source

    # 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

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

Calls superclass method
visit_assoc_node (node)
Source

    # 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

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

Calls superclass method
visit_assoc_splat_node (node)
Source

    # 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

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

Calls superclass method
visit_back_reference_read_node (node)
Source

    # 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

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

Calls superclass method
visit_begin_node (node)
Source

    # 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

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

Calls superclass method
visit_block_argument_node (node)
Source

    # 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

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

Calls superclass method
visit_block_local_variable_node (node)
Source

    # 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

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

Calls superclass method
visit_block_node (node)
Source

    # 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

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

Calls superclass method
visit_block_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_block_parameters_node (node)
Source

    # 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

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

Calls superclass method
visit_break_node (node)
Source

    # 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

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

Calls superclass method
visit_call_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_call_node (node)
Source

    # 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

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

Calls superclass method
visit_call_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_call_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_call_target_node (node)
Source

    # 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

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

Calls superclass method
visit_capture_pattern_node (node)
Source

    # 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

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

Calls superclass method
visit_case_match_node (node)
Source

    # 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

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

Calls superclass method
visit_case_node (node)
Source

    # 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

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

Calls superclass method
visit_class_node (node)
Source

    # 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

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

Calls superclass method
visit_class_variable_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_class_variable_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_class_variable_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_class_variable_read_node (node)
Source

    # 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

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

Calls superclass method
visit_class_variable_target_node (node)
Source

    # 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

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

Calls superclass method
visit_class_variable_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_path_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_path_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_path_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_path_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_path_target_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_path_write_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_read_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_target_node (node)
Source

    # 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

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

Calls superclass method
visit_constant_write_node (node)
Source

    # 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

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

Calls superclass method
visit_def_node (node)
Source

    # 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

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

Calls superclass method
visit_defined_node (node)
Source

    # 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

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

Calls superclass method
visit_else_node (node)
Source

    # 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

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

Calls superclass method
visit_embedded_statements_node (node)
Source

    # 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

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

Calls superclass method
visit_embedded_variable_node (node)
Source

    # 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

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

Calls superclass method
visit_ensure_node (node)
Source

    # 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

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

Calls superclass method
visit_false_node (node)
Source

    # 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

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

Calls superclass method
visit_find_pattern_node (node)
Source

    # 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

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

Calls superclass method
visit_flip_flop_node (node)
Source

    # 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

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

Calls superclass method
visit_float_node (node)
Source

    # 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

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

Calls superclass method
visit_for_node (node)
Source

    # 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

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

Calls superclass method
visit_forwarding_arguments_node (node)
Source

    # 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

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

Calls superclass method
visit_forwarding_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_forwarding_super_node (node)
Source

    # 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

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

Calls superclass method
visit_global_variable_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_global_variable_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_global_variable_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_global_variable_read_node (node)
Source

    # 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

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

Calls superclass method
visit_global_variable_target_node (node)
Source

    # 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

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

Calls superclass method
visit_global_variable_write_node (node)
Source

    # 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

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

Calls superclass method
visit_hash_node (node)
Source

    # 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

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

Calls superclass method
visit_hash_pattern_node (node)
Source

    # 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

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

Calls superclass method
visit_if_node (node)
Source

    # 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

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

Calls superclass method
visit_imaginary_node (node)
Source

    # 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

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

Calls superclass method
visit_implicit_node (node)
Source

    # 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

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

Calls superclass method
visit_implicit_rest_node (node)
Source

    # 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

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

Calls superclass method
visit_in_node (node)
Source

    # 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

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

Calls superclass method
visit_index_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_index_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_index_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_index_target_node (node)
Source

    # 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

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

Calls superclass method
visit_instance_variable_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_instance_variable_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_instance_variable_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_instance_variable_read_node (node)
Source

    # 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

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

Calls superclass method
visit_instance_variable_target_node (node)
Source

    # 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

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

Calls superclass method
visit_instance_variable_write_node (node)
Source

    # 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

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

Calls superclass method
visit_integer_node (node)
Source

    # 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

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

Calls superclass method
visit_interpolated_match_last_line_node (node)
Source

    # 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

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

Calls superclass method
visit_interpolated_regular_expression_node (node)
Source

    # 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

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

Calls superclass method
visit_interpolated_string_node (node)
Source

    # 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

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

Calls superclass method
visit_interpolated_symbol_node (node)
Source

    # 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

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

Calls superclass method
visit_interpolated_x_string_node (node)
Source

    # 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

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

Calls superclass method
visit_it_local_variable_read_node (node)
Source

    # 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

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

Calls superclass method
visit_it_parameters_node (node)
Source

    # 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

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

Calls superclass method
visit_keyword_hash_node (node)
Source

    # 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

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

Calls superclass method
visit_keyword_rest_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_lambda_node (node)
Source

    # 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

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

Calls superclass method
visit_local_variable_and_write_node (node)
Source

    # 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

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

Calls superclass method
visit_local_variable_operator_write_node (node)
Source

    # 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

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

Calls superclass method
visit_local_variable_or_write_node (node)
Source

    # 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

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

Calls superclass method
visit_local_variable_read_node (node)
Source

    # 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

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

Calls superclass method
visit_local_variable_target_node (node)
Source

    # 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

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

Calls superclass method
visit_local_variable_write_node (node)
Source

    # 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

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

Calls superclass method
visit_match_last_line_node (node)
Source

    # 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

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

Calls superclass method
visit_match_predicate_node (node)
Source

    # 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

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

Calls superclass method
visit_match_required_node (node)
Source

    # 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

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

Calls superclass method
visit_match_write_node (node)
Source

    # 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

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

Calls superclass method
visit_missing_node (node)
Source

    # 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

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

Calls superclass method
visit_module_node (node)
Source

    # 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

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

Calls superclass method
visit_multi_target_node (node)
Source

    # 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

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

Calls superclass method
visit_multi_write_node (node)
Source

    # 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

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

Calls superclass method
visit_next_node (node)
Source

    # 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

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

Calls superclass method
visit_nil_node (node)
Source

    # 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

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

Calls superclass method
visit_no_keywords_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_numbered_parameters_node (node)
Source

    # 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

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

Calls superclass method
visit_numbered_reference_read_node (node)
Source

    # 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

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

Calls superclass method
visit_optional_keyword_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_optional_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_or_node (node)
Source

    # 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

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

Calls superclass method
visit_parameters_node (node)
Source

    # 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

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

Calls superclass method
visit_parentheses_node (node)
Source

    # 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

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

Calls superclass method
visit_pinned_expression_node (node)
Source

    # 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

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

Calls superclass method
visit_pinned_variable_node (node)
Source

    # 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

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

Calls superclass method
visit_post_execution_node (node)
Source

    # 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

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

Calls superclass method
visit_pre_execution_node (node)
Source

    # 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

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

Calls superclass method
visit_program_node (node)
Source

    # 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

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

Calls superclass method
visit_range_node (node)
Source

    # 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

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

Calls superclass method
visit_rational_node (node)
Source

    # 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

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

Calls superclass method
visit_redo_node (node)
Source

    # 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

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

Calls superclass method
visit_regular_expression_node (node)
Source

    # 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

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

Calls superclass method
visit_required_keyword_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_required_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_rescue_modifier_node (node)
Source

    # 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

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

Calls superclass method
visit_rescue_node (node)
Source

    # 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

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

Calls superclass method
visit_rest_parameter_node (node)
Source

    # 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

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

Calls superclass method
visit_retry_node (node)
Source

    # 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

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

Calls superclass method
visit_return_node (node)
Source

    # 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

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

Calls superclass method
visit_self_node (node)
Source

    # 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

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

Calls superclass method
visit_shareable_constant_node (node)
Source

    # 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

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

Calls superclass method
visit_singleton_class_node (node)
Source

    # 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

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

Calls superclass method
visit_source_encoding_node (node)
Source

    # 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

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

Calls superclass method
visit_source_file_node (node)
Source

    # 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

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

Calls superclass method
visit_source_line_node (node)
Source

    # 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

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

Calls superclass method
visit_splat_node (node)
Source

    # 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

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

Calls superclass method
visit_statements_node (node)
Source

    # 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

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

Calls superclass method
visit_string_node (node)
Source

    # 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

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

Calls superclass method
visit_super_node (node)
Source

    # 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

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

Calls superclass method
visit_symbol_node (node)
Source

    # 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

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

Calls superclass method
visit_true_node (node)
Source

    # 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

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

Calls superclass method
visit_undef_node (node)
Source

    # 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

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

Calls superclass method
visit_unless_node (node)
Source

    # 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

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

Calls superclass method
visit_until_node (node)
Source

    # 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

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

Calls superclass method
visit_when_node (node)
Source

    # 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

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

Calls superclass method
visit_while_node (node)
Source

    # 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

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

Calls superclass method
visit_x_string_node (node)
Source

    # 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

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

Calls superclass method
visit_yield_node (node)
Source

    # 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

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

Calls superclass method

### Private Instance Methods

register_events (listener, events)
Source

    # File lib/prism/dispatcher.rb, line 70
            def register_events(listener, events)
      events.each { |event| (listeners[event] ||= []) << listener }
    end

Register a listener for the given events.