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

Initialize a new dispatcher.



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

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



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

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



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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

#visit_call_target_node(node) ⇒ Object

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



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

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

#visit_capture_pattern_node(node) ⇒ Object

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



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

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

#visit_case_match_node(node) ⇒ Object

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



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

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

#visit_case_node(node) ⇒ Object

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



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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

#visit_implicit_rest_node(node) ⇒ Object

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



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

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

#visit_in_node(node) ⇒ Object

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



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

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

#visit_index_and_write_node(node) ⇒ Object

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



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

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

#visit_index_operator_write_node(node) ⇒ Object

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



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

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

#visit_index_or_write_node(node) ⇒ Object

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



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

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

#visit_index_target_node(node) ⇒ Object

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



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

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

#visit_instance_variable_and_write_node(node) ⇒ Object

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



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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

#visit_keyword_rest_parameter_node(node) ⇒ Object

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



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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

#visit_numbered_parameters_node(node) ⇒ Object

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



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

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

#visit_numbered_reference_read_node(node) ⇒ Object

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



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

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

#visit_optional_keyword_parameter_node(node) ⇒ Object

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



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

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

#visit_optional_parameter_node(node) ⇒ Object

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



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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

#visit_required_keyword_parameter_node(node) ⇒ Object

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



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

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

#visit_required_parameter_node(node) ⇒ Object

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



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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

#visit_string_node(node) ⇒ Object

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



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

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.



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

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.



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

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.



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

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.



1198
1199
1200
1201
1202
 
# File 'lib/prism/dispatcher.rb', line 1198

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.



1206
1207
1208
1209
1210
 
# File 'lib/prism/dispatcher.rb', line 1206

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.



1214
1215
1216
1217
1218
 
# File 'lib/prism/dispatcher.rb', line 1214

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.



1222
1223
1224
1225
1226
 
# File 'lib/prism/dispatcher.rb', line 1222

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.



1230
1231
1232
1233
1234
 
# File 'lib/prism/dispatcher.rb', line 1230

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.



1238
1239
1240
1241
1242
 
# File 'lib/prism/dispatcher.rb', line 1238

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.



1246
1247
1248
1249
1250
 
# File 'lib/prism/dispatcher.rb', line 1246

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