Class: Prism::Dispatcher

Inherits:
Visitor show all
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

dispatcher = 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)

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from BasicVisitor

#visit, #visit_all, #visit_child_nodes

Constructor Details

#initialize ⇒ Dispatcher

Returns a new instance of Dispatcher.



44
45
46
 
# File 'lib/prism/dispatcher.rb', line 44

def initialize
  @listeners = {}
end

Instance Attribute Details

#listeners ⇒ Object (readonly)

attr_reader listeners: Hash[Symbol, Array]



42
43
44
 
# File 'lib/prism/dispatcher.rb', line 42

def listeners
  @listeners
end

Instance Method Details

#dispatch_once(node) ⇒ Object

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

def dispatch_once: (Node) -> void



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

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

#register(listener, *events) ⇒ Object

Register a listener for one or more events

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



51
52
53
 
# File 'lib/prism/dispatcher.rb', line 51

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

#visit_alias_global_variable_node(node) ⇒ Object

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



69
70
71
72
73
 
# File 'lib/prism/dispatcher.rb', line 69

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) ⇒ Object

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



77
78
79
80
81
 
# File 'lib/prism/dispatcher.rb', line 77

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) ⇒ Object

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



85
86
87
88
89
 
# File 'lib/prism/dispatcher.rb', line 85

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) ⇒ Object

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



93
94
95
96
97
 
# File 'lib/prism/dispatcher.rb', line 93

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) ⇒ Object

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



101
102
103
104
105
 
# File 'lib/prism/dispatcher.rb', line 101

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) ⇒ Object

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



109
110
111
112
113
 
# File 'lib/prism/dispatcher.rb', line 109

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) ⇒ Object

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



117
118
119
120
121
 
# File 'lib/prism/dispatcher.rb', line 117

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) ⇒ Object

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



125
126
127
128
129
 
# File 'lib/prism/dispatcher.rb', line 125

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) ⇒ Object

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



133
134
135
136
137
 
# File 'lib/prism/dispatcher.rb', line 133

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) ⇒ Object

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



141
142
143
144
145
 
# File 'lib/prism/dispatcher.rb', line 141

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) ⇒ Object

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



149
150
151
152
153
 
# File 'lib/prism/dispatcher.rb', line 149

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) ⇒ Object

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



157
158
159
160
161
 
# File 'lib/prism/dispatcher.rb', line 157

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) ⇒ Object

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



165
166
167
168
169
 
# File 'lib/prism/dispatcher.rb', line 165

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) ⇒ Object

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



173
174
175
176
177
 
# File 'lib/prism/dispatcher.rb', line 173

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) ⇒ Object

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



181
182
183
184
185
 
# File 'lib/prism/dispatcher.rb', line 181

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) ⇒ Object

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



189
190
191
192
193
 
# File 'lib/prism/dispatcher.rb', line 189

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) ⇒ Object

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



197
198
199
200
201
 
# File 'lib/prism/dispatcher.rb', line 197

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) ⇒ Object

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



205
206
207
208
209
 
# File 'lib/prism/dispatcher.rb', line 205

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) ⇒ Object

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



213
214
215
216
217
 
# File 'lib/prism/dispatcher.rb', line 213

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) ⇒ Object

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



221
222
223
224
225
 
# File 'lib/prism/dispatcher.rb', line 221

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) ⇒ Object

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



229
230
231
232
233
 
# File 'lib/prism/dispatcher.rb', line 229

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_capture_pattern_node(node) ⇒ Object

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



237
238
239
240
241
 
# File 'lib/prism/dispatcher.rb', line 237

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_node(node) ⇒ Object

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



245
246
247
248
249
 
# File 'lib/prism/dispatcher.rb', line 245

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) ⇒ Object

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



253
254
255
256
257
 
# File 'lib/prism/dispatcher.rb', line 253

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) ⇒ Object

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



261
262
263
264
265
 
# File 'lib/prism/dispatcher.rb', line 261

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) ⇒ Object

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



269
270
271
272
273
 
# File 'lib/prism/dispatcher.rb', line 269

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) ⇒ Object

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



277
278
279
280
281
 
# File 'lib/prism/dispatcher.rb', line 277

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) ⇒ Object

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



285
286
287
288
289
 
# File 'lib/prism/dispatcher.rb', line 285

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) ⇒ Object

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



293
294
295
296
297
 
# File 'lib/prism/dispatcher.rb', line 293

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) ⇒ Object

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



301
302
303
304
305
 
# File 'lib/prism/dispatcher.rb', line 301

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) ⇒ Object

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



309
310
311
312
313
 
# File 'lib/prism/dispatcher.rb', line 309

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) ⇒ Object

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



317
318
319
320
321
 
# File 'lib/prism/dispatcher.rb', line 317

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) ⇒ Object

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



325
326
327
328
329
 
# File 'lib/prism/dispatcher.rb', line 325

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) ⇒ Object

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



333
334
335
336
337
 
# File 'lib/prism/dispatcher.rb', line 333

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) ⇒ Object

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



341
342
343
344
345
 
# File 'lib/prism/dispatcher.rb', line 341

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) ⇒ Object

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



349
350
351
352
353
 
# File 'lib/prism/dispatcher.rb', line 349

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) ⇒ Object

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



357
358
359
360
361
 
# File 'lib/prism/dispatcher.rb', line 357

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) ⇒ Object

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



365
366
367
368
369
 
# File 'lib/prism/dispatcher.rb', line 365

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) ⇒ Object

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



373
374
375
376
377
 
# File 'lib/prism/dispatcher.rb', line 373

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) ⇒ Object

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



381
382
383
384
385
 
# File 'lib/prism/dispatcher.rb', line 381

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) ⇒ Object

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



389
390
391
392
393
 
# File 'lib/prism/dispatcher.rb', line 389

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) ⇒ Object

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



397
398
399
400
401
 
# File 'lib/prism/dispatcher.rb', line 397

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) ⇒ Object

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



405
406
407
408
409
 
# File 'lib/prism/dispatcher.rb', line 405

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) ⇒ Object

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



413
414
415
416
417
 
# File 'lib/prism/dispatcher.rb', line 413

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) ⇒ Object

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



421
422
423
424
425
 
# File 'lib/prism/dispatcher.rb', line 421

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) ⇒ Object

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



429
430
431
432
433
 
# File 'lib/prism/dispatcher.rb', line 429

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) ⇒ Object

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



437
438
439
440
441
 
# File 'lib/prism/dispatcher.rb', line 437

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) ⇒ Object

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



445
446
447
448
449
 
# File 'lib/prism/dispatcher.rb', line 445

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) ⇒ Object

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



453
454
455
456
457
 
# File 'lib/prism/dispatcher.rb', line 453

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) ⇒ Object

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



461
462
463
464
465
 
# File 'lib/prism/dispatcher.rb', line 461

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) ⇒ Object

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



469
470
471
472
473
 
# File 'lib/prism/dispatcher.rb', line 469

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) ⇒ Object

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



477
478
479
480
481
 
# File 'lib/prism/dispatcher.rb', line 477

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) ⇒ Object

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



485
486
487
488
489
 
# File 'lib/prism/dispatcher.rb', line 485

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) ⇒ Object

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



493
494
495
496
497
 
# File 'lib/prism/dispatcher.rb', line 493

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) ⇒ Object

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



501
502
503
504
505
 
# File 'lib/prism/dispatcher.rb', line 501

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) ⇒ Object

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



509
510
511
512
513
 
# File 'lib/prism/dispatcher.rb', line 509

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) ⇒ Object

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



517
518
519
520
521
 
# File 'lib/prism/dispatcher.rb', line 517

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) ⇒ Object

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



525
526
527
528
529
 
# File 'lib/prism/dispatcher.rb', line 525

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) ⇒ Object

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



533
534
535
536
537
 
# File 'lib/prism/dispatcher.rb', line 533

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) ⇒ Object

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



541
542
543
544
545
 
# File 'lib/prism/dispatcher.rb', line 541

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) ⇒ Object

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



549
550
551
552
553
 
# File 'lib/prism/dispatcher.rb', line 549

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) ⇒ Object

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



557
558
559
560
561
 
# File 'lib/prism/dispatcher.rb', line 557

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) ⇒ Object

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



565
566
567
568
569
 
# File 'lib/prism/dispatcher.rb', line 565

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) ⇒ Object

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



573
574
575
576
577
 
# File 'lib/prism/dispatcher.rb', line 573

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) ⇒ Object

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



581
582
583
584
585
 
# File 'lib/prism/dispatcher.rb', line 581

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) ⇒ Object

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



589
590
591
592
593
 
# File 'lib/prism/dispatcher.rb', line 589

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) ⇒ Object

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



597
598
599
600
601
 
# File 'lib/prism/dispatcher.rb', line 597

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_in_node(node) ⇒ Object

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



605
606
607
608
609
 
# File 'lib/prism/dispatcher.rb', line 605

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_instance_variable_and_write_node(node) ⇒ Object

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



613
614
615
616
617
 
# File 'lib/prism/dispatcher.rb', line 613

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) ⇒ Object

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



621
622
623
624
625
 
# File 'lib/prism/dispatcher.rb', line 621

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) ⇒ Object

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



629
630
631
632
633
 
# File 'lib/prism/dispatcher.rb', line 629

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) ⇒ Object

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



637
638
639
640
641
 
# File 'lib/prism/dispatcher.rb', line 637

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) ⇒ Object

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



645
646
647
648
649
 
# File 'lib/prism/dispatcher.rb', line 645

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) ⇒ Object

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



653
654
655
656
657
 
# File 'lib/prism/dispatcher.rb', line 653

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) ⇒ Object

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



661
662
663
664
665
 
# File 'lib/prism/dispatcher.rb', line 661

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) ⇒ Object

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



669
670
671
672
673
 
# File 'lib/prism/dispatcher.rb', line 669

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) ⇒ Object

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



677
678
679
680
681
 
# File 'lib/prism/dispatcher.rb', line 677

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) ⇒ Object

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



685
686
687
688
689
 
# File 'lib/prism/dispatcher.rb', line 685

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) ⇒ Object

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



693
694
695
696
697
 
# File 'lib/prism/dispatcher.rb', line 693

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) ⇒ Object

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



701
702
703
704
705
 
# File 'lib/prism/dispatcher.rb', line 701

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_keyword_hash_node(node) ⇒ Object

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



709
710
711
712
713
 
# File 'lib/prism/dispatcher.rb', line 709

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_parameter_node(node) ⇒ Object

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



717
718
719
720
721
 
# File 'lib/prism/dispatcher.rb', line 717

def visit_keyword_parameter_node(node)
  listeners[:on_keyword_parameter_node_enter]&.each { |listener| listener.on_keyword_parameter_node_enter(node) }
  super
  listeners[:on_keyword_parameter_node_leave]&.each { |listener| listener.on_keyword_parameter_node_leave(node) }
end

#visit_keyword_rest_parameter_node(node) ⇒ Object

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



725
726
727
728
729
 
# File 'lib/prism/dispatcher.rb', line 725

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) ⇒ Object

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



733
734
735
736
737
 
# File 'lib/prism/dispatcher.rb', line 733

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) ⇒ Object

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



741
742
743
744
745
 
# File 'lib/prism/dispatcher.rb', line 741

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) ⇒ Object

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



749
750
751
752
753
 
# File 'lib/prism/dispatcher.rb', line 749

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) ⇒ Object

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



757
758
759
760
761
 
# File 'lib/prism/dispatcher.rb', line 757

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) ⇒ Object

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



765
766
767
768
769
 
# File 'lib/prism/dispatcher.rb', line 765

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) ⇒ Object

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



773
774
775
776
777
 
# File 'lib/prism/dispatcher.rb', line 773

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) ⇒ Object

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



781
782
783
784
785
 
# File 'lib/prism/dispatcher.rb', line 781

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) ⇒ Object

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



789
790
791
792
793
 
# File 'lib/prism/dispatcher.rb', line 789

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) ⇒ Object

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



797
798
799
800
801
 
# File 'lib/prism/dispatcher.rb', line 797

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) ⇒ Object

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



805
806
807
808
809
 
# File 'lib/prism/dispatcher.rb', line 805

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) ⇒ Object

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



813
814
815
816
817
 
# File 'lib/prism/dispatcher.rb', line 813

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) ⇒ Object

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



821
822
823
824
825
 
# File 'lib/prism/dispatcher.rb', line 821

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) ⇒ Object

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



829
830
831
832
833
 
# File 'lib/prism/dispatcher.rb', line 829

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) ⇒ Object

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



837
838
839
840
841
 
# File 'lib/prism/dispatcher.rb', line 837

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) ⇒ Object

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



845
846
847
848
849
 
# File 'lib/prism/dispatcher.rb', line 845

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) ⇒ Object

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



853
854
855
856
857
 
# File 'lib/prism/dispatcher.rb', line 853

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) ⇒ Object

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



861
862
863
864
865
 
# File 'lib/prism/dispatcher.rb', line 861

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) ⇒ Object

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



869
870
871
872
873
 
# File 'lib/prism/dispatcher.rb', line 869

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_reference_read_node(node) ⇒ Object

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



877
878
879
880
881
 
# File 'lib/prism/dispatcher.rb', line 877

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_parameter_node(node) ⇒ Object

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



885
886
887
888
889
 
# File 'lib/prism/dispatcher.rb', line 885

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) ⇒ Object

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



893
894
895
896
897
 
# File 'lib/prism/dispatcher.rb', line 893

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) ⇒ Object

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



901
902
903
904
905
 
# File 'lib/prism/dispatcher.rb', line 901

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) ⇒ Object

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



909
910
911
912
913
 
# File 'lib/prism/dispatcher.rb', line 909

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) ⇒ Object

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



917
918
919
920
921
 
# File 'lib/prism/dispatcher.rb', line 917

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) ⇒ Object

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



925
926
927
928
929
 
# File 'lib/prism/dispatcher.rb', line 925

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) ⇒ Object

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



933
934
935
936
937
 
# File 'lib/prism/dispatcher.rb', line 933

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) ⇒ Object

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



941
942
943
944
945
 
# File 'lib/prism/dispatcher.rb', line 941

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) ⇒ Object

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



949
950
951
952
953
 
# File 'lib/prism/dispatcher.rb', line 949

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) ⇒ Object

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



957
958
959
960
961
 
# File 'lib/prism/dispatcher.rb', line 957

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) ⇒ Object

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



965
966
967
968
969
 
# File 'lib/prism/dispatcher.rb', line 965

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) ⇒ Object

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



973
974
975
976
977
 
# File 'lib/prism/dispatcher.rb', line 973

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) ⇒ Object

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



981
982
983
984
985
 
# File 'lib/prism/dispatcher.rb', line 981

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_destructured_parameter_node(node) ⇒ Object

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



989
990
991
992
993
 
# File 'lib/prism/dispatcher.rb', line 989

def visit_required_destructured_parameter_node(node)
  listeners[:on_required_destructured_parameter_node_enter]&.each { |listener| listener.on_required_destructured_parameter_node_enter(node) }
  super
  listeners[:on_required_destructured_parameter_node_leave]&.each { |listener| listener.on_required_destructured_parameter_node_leave(node) }
end

#visit_required_parameter_node(node) ⇒ Object

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



997
998
999
1000
1001
 
# File 'lib/prism/dispatcher.rb', line 997

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) ⇒ Object

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



1005
1006
1007
1008
1009
 
# File 'lib/prism/dispatcher.rb', line 1005

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) ⇒ Object

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



1013
1014
1015
1016
1017
 
# File 'lib/prism/dispatcher.rb', line 1013

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) ⇒ Object

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



1021
1022
1023
1024
1025
 
# File 'lib/prism/dispatcher.rb', line 1021

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) ⇒ Object

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



1029
1030
1031
1032
1033
 
# File 'lib/prism/dispatcher.rb', line 1029

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) ⇒ Object

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



1037
1038
1039
1040
1041
 
# File 'lib/prism/dispatcher.rb', line 1037

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) ⇒ Object

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



1045
1046
1047
1048
1049
 
# File 'lib/prism/dispatcher.rb', line 1045

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_singleton_class_node(node) ⇒ Object

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



1053
1054
1055
1056
1057
 
# File 'lib/prism/dispatcher.rb', line 1053

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) ⇒ Object

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



1061
1062
1063
1064
1065
 
# File 'lib/prism/dispatcher.rb', line 1061

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) ⇒ Object

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



1069
1070
1071
1072
1073
 
# File 'lib/prism/dispatcher.rb', line 1069

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) ⇒ Object

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



1077
1078
1079
1080
1081
 
# File 'lib/prism/dispatcher.rb', line 1077

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) ⇒ Object

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



1085
1086
1087
1088
1089
 
# File 'lib/prism/dispatcher.rb', line 1085

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) ⇒ Object

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



1093
1094
1095
1096
1097
 
# File 'lib/prism/dispatcher.rb', line 1093

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_concat_node(node) ⇒ Object

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



1101
1102
1103
1104
1105
 
# File 'lib/prism/dispatcher.rb', line 1101

def visit_string_concat_node(node)
  listeners[:on_string_concat_node_enter]&.each { |listener| listener.on_string_concat_node_enter(node) }
  super
  listeners[:on_string_concat_node_leave]&.each { |listener| listener.on_string_concat_node_leave(node) }
end

#visit_string_node(node) ⇒ Object

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



1109
1110
1111
1112
1113
 
# File 'lib/prism/dispatcher.rb', line 1109

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) ⇒ Object

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



1117
1118
1119
1120
1121
 
# File 'lib/prism/dispatcher.rb', line 1117

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) ⇒ Object

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



1125
1126
1127
1128
1129
 
# File 'lib/prism/dispatcher.rb', line 1125

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) ⇒ Object

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



1133
1134
1135
1136
1137
 
# File 'lib/prism/dispatcher.rb', line 1133

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) ⇒ Object

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



1141
1142
1143
1144
1145
 
# File 'lib/prism/dispatcher.rb', line 1141

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) ⇒ Object

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



1149
1150
1151
1152
1153
 
# File 'lib/prism/dispatcher.rb', line 1149

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) ⇒ Object

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



1157
1158
1159
1160
1161
 
# File 'lib/prism/dispatcher.rb', line 1157

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) ⇒ Object

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



1165
1166
1167
1168
1169
 
# File 'lib/prism/dispatcher.rb', line 1165

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) ⇒ Object

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



1173
1174
1175
1176
1177
 
# File 'lib/prism/dispatcher.rb', line 1173

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) ⇒ Object

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



1181
1182
1183
1184
1185
 
# File 'lib/prism/dispatcher.rb', line 1181

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) ⇒ Object

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



1189
1190
1191
1192
1193
 
# File 'lib/prism/dispatcher.rb', line 1189

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