Class: Prism::Visitor

Inherits:
BasicVisitor show all
Defined in:
lib/prism/visitor.rb

Overview

A visitor is a class that provides a default implementation for every accept method defined on the nodes. This means it can walk a tree without the caller needing to define any special handling. This allows you to handle a subset of the tree, while still walking the whole tree.

For example, to find all of the method calls that call the ‘foo` method, you could write:

class FooCalls < Prism::Visitor
  def visit_call_node(node)
    if node.name == :foo
      # Do something with the node
    end

    # Call super so that the visitor continues walking the tree
    super
  end
end

Direct Known Subclasses

Dispatcher, DotVisitor, InspectVisitor

Instance Method Summary collapse

Methods inherited from BasicVisitor

#visit, #visit_all, #visit_child_nodes

Instance Method Details

#visit_alias_global_variable_node(node) ⇒ Object

Visit a AliasGlobalVariableNode node



59
60
61
 
# File 'lib/prism/visitor.rb', line 59

def visit_alias_global_variable_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_alias_method_node(node) ⇒ Object

Visit a AliasMethodNode node



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

def visit_alias_method_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_alternation_pattern_node(node) ⇒ Object

Visit a AlternationPatternNode node



69
70
71
 
# File 'lib/prism/visitor.rb', line 69

def visit_alternation_pattern_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_and_node(node) ⇒ Object

Visit a AndNode node



74
75
76
 
# File 'lib/prism/visitor.rb', line 74

def visit_and_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_arguments_node(node) ⇒ Object

Visit a ArgumentsNode node



79
80
81
 
# File 'lib/prism/visitor.rb', line 79

def visit_arguments_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_array_node(node) ⇒ Object

Visit a ArrayNode node



84
85
86
 
# File 'lib/prism/visitor.rb', line 84

def visit_array_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_array_pattern_node(node) ⇒ Object

Visit a ArrayPatternNode node



89
90
91
 
# File 'lib/prism/visitor.rb', line 89

def visit_array_pattern_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_assoc_node(node) ⇒ Object

Visit a AssocNode node



94
95
96
 
# File 'lib/prism/visitor.rb', line 94

def visit_assoc_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_assoc_splat_node(node) ⇒ Object

Visit a AssocSplatNode node



99
100
101
 
# File 'lib/prism/visitor.rb', line 99

def visit_assoc_splat_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_back_reference_read_node(node) ⇒ Object

Visit a BackReferenceReadNode node



104
105
106
 
# File 'lib/prism/visitor.rb', line 104

def visit_back_reference_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_begin_node(node) ⇒ Object

Visit a BeginNode node



109
110
111
 
# File 'lib/prism/visitor.rb', line 109

def visit_begin_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_block_argument_node(node) ⇒ Object

Visit a BlockArgumentNode node



114
115
116
 
# File 'lib/prism/visitor.rb', line 114

def visit_block_argument_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_block_local_variable_node(node) ⇒ Object

Visit a BlockLocalVariableNode node



119
120
121
 
# File 'lib/prism/visitor.rb', line 119

def visit_block_local_variable_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_block_node(node) ⇒ Object

Visit a BlockNode node



124
125
126
 
# File 'lib/prism/visitor.rb', line 124

def visit_block_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_block_parameter_node(node) ⇒ Object

Visit a BlockParameterNode node



129
130
131
 
# File 'lib/prism/visitor.rb', line 129

def visit_block_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_block_parameters_node(node) ⇒ Object

Visit a BlockParametersNode node



134
135
136
 
# File 'lib/prism/visitor.rb', line 134

def visit_block_parameters_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_break_node(node) ⇒ Object

Visit a BreakNode node



139
140
141
 
# File 'lib/prism/visitor.rb', line 139

def visit_break_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_call_and_write_node(node) ⇒ Object

Visit a CallAndWriteNode node



144
145
146
 
# File 'lib/prism/visitor.rb', line 144

def visit_call_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_call_node(node) ⇒ Object

Visit a CallNode node



149
150
151
 
# File 'lib/prism/visitor.rb', line 149

def visit_call_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_call_operator_write_node(node) ⇒ Object

Visit a CallOperatorWriteNode node



154
155
156
 
# File 'lib/prism/visitor.rb', line 154

def visit_call_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_call_or_write_node(node) ⇒ Object

Visit a CallOrWriteNode node



159
160
161
 
# File 'lib/prism/visitor.rb', line 159

def visit_call_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_call_target_node(node) ⇒ Object

Visit a CallTargetNode node



164
165
166
 
# File 'lib/prism/visitor.rb', line 164

def visit_call_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_capture_pattern_node(node) ⇒ Object

Visit a CapturePatternNode node



169
170
171
 
# File 'lib/prism/visitor.rb', line 169

def visit_capture_pattern_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_case_match_node(node) ⇒ Object

Visit a CaseMatchNode node



174
175
176
 
# File 'lib/prism/visitor.rb', line 174

def visit_case_match_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_case_node(node) ⇒ Object

Visit a CaseNode node



179
180
181
 
# File 'lib/prism/visitor.rb', line 179

def visit_case_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_node(node) ⇒ Object

Visit a ClassNode node



184
185
186
 
# File 'lib/prism/visitor.rb', line 184

def visit_class_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_variable_and_write_node(node) ⇒ Object

Visit a ClassVariableAndWriteNode node



189
190
191
 
# File 'lib/prism/visitor.rb', line 189

def visit_class_variable_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_variable_operator_write_node(node) ⇒ Object

Visit a ClassVariableOperatorWriteNode node



194
195
196
 
# File 'lib/prism/visitor.rb', line 194

def visit_class_variable_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_variable_or_write_node(node) ⇒ Object

Visit a ClassVariableOrWriteNode node



199
200
201
 
# File 'lib/prism/visitor.rb', line 199

def visit_class_variable_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_variable_read_node(node) ⇒ Object

Visit a ClassVariableReadNode node



204
205
206
 
# File 'lib/prism/visitor.rb', line 204

def visit_class_variable_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_variable_target_node(node) ⇒ Object

Visit a ClassVariableTargetNode node



209
210
211
 
# File 'lib/prism/visitor.rb', line 209

def visit_class_variable_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_class_variable_write_node(node) ⇒ Object

Visit a ClassVariableWriteNode node



214
215
216
 
# File 'lib/prism/visitor.rb', line 214

def visit_class_variable_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_and_write_node(node) ⇒ Object

Visit a ConstantAndWriteNode node



219
220
221
 
# File 'lib/prism/visitor.rb', line 219

def visit_constant_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_operator_write_node(node) ⇒ Object

Visit a ConstantOperatorWriteNode node



224
225
226
 
# File 'lib/prism/visitor.rb', line 224

def visit_constant_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_or_write_node(node) ⇒ Object

Visit a ConstantOrWriteNode node



229
230
231
 
# File 'lib/prism/visitor.rb', line 229

def visit_constant_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_path_and_write_node(node) ⇒ Object

Visit a ConstantPathAndWriteNode node



234
235
236
 
# File 'lib/prism/visitor.rb', line 234

def visit_constant_path_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_path_node(node) ⇒ Object

Visit a ConstantPathNode node



239
240
241
 
# File 'lib/prism/visitor.rb', line 239

def visit_constant_path_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_path_operator_write_node(node) ⇒ Object

Visit a ConstantPathOperatorWriteNode node



244
245
246
 
# File 'lib/prism/visitor.rb', line 244

def visit_constant_path_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_path_or_write_node(node) ⇒ Object

Visit a ConstantPathOrWriteNode node



249
250
251
 
# File 'lib/prism/visitor.rb', line 249

def visit_constant_path_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_path_target_node(node) ⇒ Object

Visit a ConstantPathTargetNode node



254
255
256
 
# File 'lib/prism/visitor.rb', line 254

def visit_constant_path_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_path_write_node(node) ⇒ Object

Visit a ConstantPathWriteNode node



259
260
261
 
# File 'lib/prism/visitor.rb', line 259

def visit_constant_path_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_read_node(node) ⇒ Object

Visit a ConstantReadNode node



264
265
266
 
# File 'lib/prism/visitor.rb', line 264

def visit_constant_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_target_node(node) ⇒ Object

Visit a ConstantTargetNode node



269
270
271
 
# File 'lib/prism/visitor.rb', line 269

def visit_constant_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_constant_write_node(node) ⇒ Object

Visit a ConstantWriteNode node



274
275
276
 
# File 'lib/prism/visitor.rb', line 274

def visit_constant_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_def_node(node) ⇒ Object

Visit a DefNode node



279
280
281
 
# File 'lib/prism/visitor.rb', line 279

def visit_def_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_defined_node(node) ⇒ Object

Visit a DefinedNode node



284
285
286
 
# File 'lib/prism/visitor.rb', line 284

def visit_defined_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_else_node(node) ⇒ Object

Visit a ElseNode node



289
290
291
 
# File 'lib/prism/visitor.rb', line 289

def visit_else_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_embedded_statements_node(node) ⇒ Object

Visit a EmbeddedStatementsNode node



294
295
296
 
# File 'lib/prism/visitor.rb', line 294

def visit_embedded_statements_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_embedded_variable_node(node) ⇒ Object

Visit a EmbeddedVariableNode node



299
300
301
 
# File 'lib/prism/visitor.rb', line 299

def visit_embedded_variable_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_ensure_node(node) ⇒ Object

Visit a EnsureNode node



304
305
306
 
# File 'lib/prism/visitor.rb', line 304

def visit_ensure_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_false_node(node) ⇒ Object

Visit a FalseNode node



309
310
311
 
# File 'lib/prism/visitor.rb', line 309

def visit_false_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_find_pattern_node(node) ⇒ Object

Visit a FindPatternNode node



314
315
316
 
# File 'lib/prism/visitor.rb', line 314

def visit_find_pattern_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_flip_flop_node(node) ⇒ Object

Visit a FlipFlopNode node



319
320
321
 
# File 'lib/prism/visitor.rb', line 319

def visit_flip_flop_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_float_node(node) ⇒ Object

Visit a FloatNode node



324
325
326
 
# File 'lib/prism/visitor.rb', line 324

def visit_float_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_for_node(node) ⇒ Object

Visit a ForNode node



329
330
331
 
# File 'lib/prism/visitor.rb', line 329

def visit_for_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_forwarding_arguments_node(node) ⇒ Object

Visit a ForwardingArgumentsNode node



334
335
336
 
# File 'lib/prism/visitor.rb', line 334

def visit_forwarding_arguments_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_forwarding_parameter_node(node) ⇒ Object

Visit a ForwardingParameterNode node



339
340
341
 
# File 'lib/prism/visitor.rb', line 339

def visit_forwarding_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_forwarding_super_node(node) ⇒ Object

Visit a ForwardingSuperNode node



344
345
346
 
# File 'lib/prism/visitor.rb', line 344

def visit_forwarding_super_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_global_variable_and_write_node(node) ⇒ Object

Visit a GlobalVariableAndWriteNode node



349
350
351
 
# File 'lib/prism/visitor.rb', line 349

def visit_global_variable_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_global_variable_operator_write_node(node) ⇒ Object

Visit a GlobalVariableOperatorWriteNode node



354
355
356
 
# File 'lib/prism/visitor.rb', line 354

def visit_global_variable_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_global_variable_or_write_node(node) ⇒ Object

Visit a GlobalVariableOrWriteNode node



359
360
361
 
# File 'lib/prism/visitor.rb', line 359

def visit_global_variable_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_global_variable_read_node(node) ⇒ Object

Visit a GlobalVariableReadNode node



364
365
366
 
# File 'lib/prism/visitor.rb', line 364

def visit_global_variable_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_global_variable_target_node(node) ⇒ Object

Visit a GlobalVariableTargetNode node



369
370
371
 
# File 'lib/prism/visitor.rb', line 369

def visit_global_variable_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_global_variable_write_node(node) ⇒ Object

Visit a GlobalVariableWriteNode node



374
375
376
 
# File 'lib/prism/visitor.rb', line 374

def visit_global_variable_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_hash_node(node) ⇒ Object

Visit a HashNode node



379
380
381
 
# File 'lib/prism/visitor.rb', line 379

def visit_hash_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_hash_pattern_node(node) ⇒ Object

Visit a HashPatternNode node



384
385
386
 
# File 'lib/prism/visitor.rb', line 384

def visit_hash_pattern_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_if_node(node) ⇒ Object

Visit a IfNode node



389
390
391
 
# File 'lib/prism/visitor.rb', line 389

def visit_if_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_imaginary_node(node) ⇒ Object

Visit a ImaginaryNode node



394
395
396
 
# File 'lib/prism/visitor.rb', line 394

def visit_imaginary_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_implicit_node(node) ⇒ Object

Visit a ImplicitNode node



399
400
401
 
# File 'lib/prism/visitor.rb', line 399

def visit_implicit_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_implicit_rest_node(node) ⇒ Object

Visit a ImplicitRestNode node



404
405
406
 
# File 'lib/prism/visitor.rb', line 404

def visit_implicit_rest_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_in_node(node) ⇒ Object

Visit a InNode node



409
410
411
 
# File 'lib/prism/visitor.rb', line 409

def visit_in_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_index_and_write_node(node) ⇒ Object

Visit a IndexAndWriteNode node



414
415
416
 
# File 'lib/prism/visitor.rb', line 414

def visit_index_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_index_operator_write_node(node) ⇒ Object

Visit a IndexOperatorWriteNode node



419
420
421
 
# File 'lib/prism/visitor.rb', line 419

def visit_index_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_index_or_write_node(node) ⇒ Object

Visit a IndexOrWriteNode node



424
425
426
 
# File 'lib/prism/visitor.rb', line 424

def visit_index_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_index_target_node(node) ⇒ Object

Visit a IndexTargetNode node



429
430
431
 
# File 'lib/prism/visitor.rb', line 429

def visit_index_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_instance_variable_and_write_node(node) ⇒ Object

Visit a InstanceVariableAndWriteNode node



434
435
436
 
# File 'lib/prism/visitor.rb', line 434

def visit_instance_variable_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_instance_variable_operator_write_node(node) ⇒ Object

Visit a InstanceVariableOperatorWriteNode node



439
440
441
 
# File 'lib/prism/visitor.rb', line 439

def visit_instance_variable_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_instance_variable_or_write_node(node) ⇒ Object

Visit a InstanceVariableOrWriteNode node



444
445
446
 
# File 'lib/prism/visitor.rb', line 444

def visit_instance_variable_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_instance_variable_read_node(node) ⇒ Object

Visit a InstanceVariableReadNode node



449
450
451
 
# File 'lib/prism/visitor.rb', line 449

def visit_instance_variable_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_instance_variable_target_node(node) ⇒ Object

Visit a InstanceVariableTargetNode node



454
455
456
 
# File 'lib/prism/visitor.rb', line 454

def visit_instance_variable_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_instance_variable_write_node(node) ⇒ Object

Visit a InstanceVariableWriteNode node



459
460
461
 
# File 'lib/prism/visitor.rb', line 459

def visit_instance_variable_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_integer_node(node) ⇒ Object

Visit a IntegerNode node



464
465
466
 
# File 'lib/prism/visitor.rb', line 464

def visit_integer_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_interpolated_match_last_line_node(node) ⇒ Object

Visit a InterpolatedMatchLastLineNode node



469
470
471
 
# File 'lib/prism/visitor.rb', line 469

def visit_interpolated_match_last_line_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_interpolated_regular_expression_node(node) ⇒ Object

Visit a InterpolatedRegularExpressionNode node



474
475
476
 
# File 'lib/prism/visitor.rb', line 474

def visit_interpolated_regular_expression_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_interpolated_string_node(node) ⇒ Object

Visit a InterpolatedStringNode node



479
480
481
 
# File 'lib/prism/visitor.rb', line 479

def visit_interpolated_string_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_interpolated_symbol_node(node) ⇒ Object

Visit a InterpolatedSymbolNode node



484
485
486
 
# File 'lib/prism/visitor.rb', line 484

def visit_interpolated_symbol_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_interpolated_x_string_node(node) ⇒ Object

Visit a InterpolatedXStringNode node



489
490
491
 
# File 'lib/prism/visitor.rb', line 489

def visit_interpolated_x_string_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_it_local_variable_read_node(node) ⇒ Object

Visit a ItLocalVariableReadNode node



494
495
496
 
# File 'lib/prism/visitor.rb', line 494

def visit_it_local_variable_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_it_parameters_node(node) ⇒ Object

Visit a ItParametersNode node



499
500
501
 
# File 'lib/prism/visitor.rb', line 499

def visit_it_parameters_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_keyword_hash_node(node) ⇒ Object

Visit a KeywordHashNode node



504
505
506
 
# File 'lib/prism/visitor.rb', line 504

def visit_keyword_hash_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_keyword_rest_parameter_node(node) ⇒ Object

Visit a KeywordRestParameterNode node



509
510
511
 
# File 'lib/prism/visitor.rb', line 509

def visit_keyword_rest_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_lambda_node(node) ⇒ Object

Visit a LambdaNode node



514
515
516
 
# File 'lib/prism/visitor.rb', line 514

def visit_lambda_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_local_variable_and_write_node(node) ⇒ Object

Visit a LocalVariableAndWriteNode node



519
520
521
 
# File 'lib/prism/visitor.rb', line 519

def visit_local_variable_and_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_local_variable_operator_write_node(node) ⇒ Object

Visit a LocalVariableOperatorWriteNode node



524
525
526
 
# File 'lib/prism/visitor.rb', line 524

def visit_local_variable_operator_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_local_variable_or_write_node(node) ⇒ Object

Visit a LocalVariableOrWriteNode node



529
530
531
 
# File 'lib/prism/visitor.rb', line 529

def visit_local_variable_or_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_local_variable_read_node(node) ⇒ Object

Visit a LocalVariableReadNode node



534
535
536
 
# File 'lib/prism/visitor.rb', line 534

def visit_local_variable_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_local_variable_target_node(node) ⇒ Object

Visit a LocalVariableTargetNode node



539
540
541
 
# File 'lib/prism/visitor.rb', line 539

def visit_local_variable_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_local_variable_write_node(node) ⇒ Object

Visit a LocalVariableWriteNode node



544
545
546
 
# File 'lib/prism/visitor.rb', line 544

def visit_local_variable_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_match_last_line_node(node) ⇒ Object

Visit a MatchLastLineNode node



549
550
551
 
# File 'lib/prism/visitor.rb', line 549

def visit_match_last_line_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_match_predicate_node(node) ⇒ Object

Visit a MatchPredicateNode node



554
555
556
 
# File 'lib/prism/visitor.rb', line 554

def visit_match_predicate_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_match_required_node(node) ⇒ Object

Visit a MatchRequiredNode node



559
560
561
 
# File 'lib/prism/visitor.rb', line 559

def visit_match_required_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_match_write_node(node) ⇒ Object

Visit a MatchWriteNode node



564
565
566
 
# File 'lib/prism/visitor.rb', line 564

def visit_match_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_missing_node(node) ⇒ Object

Visit a MissingNode node



569
570
571
 
# File 'lib/prism/visitor.rb', line 569

def visit_missing_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_module_node(node) ⇒ Object

Visit a ModuleNode node



574
575
576
 
# File 'lib/prism/visitor.rb', line 574

def visit_module_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_multi_target_node(node) ⇒ Object

Visit a MultiTargetNode node



579
580
581
 
# File 'lib/prism/visitor.rb', line 579

def visit_multi_target_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_multi_write_node(node) ⇒ Object

Visit a MultiWriteNode node



584
585
586
 
# File 'lib/prism/visitor.rb', line 584

def visit_multi_write_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_next_node(node) ⇒ Object

Visit a NextNode node



589
590
591
 
# File 'lib/prism/visitor.rb', line 589

def visit_next_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_nil_node(node) ⇒ Object

Visit a NilNode node



594
595
596
 
# File 'lib/prism/visitor.rb', line 594

def visit_nil_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_no_keywords_parameter_node(node) ⇒ Object

Visit a NoKeywordsParameterNode node



599
600
601
 
# File 'lib/prism/visitor.rb', line 599

def visit_no_keywords_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_numbered_parameters_node(node) ⇒ Object

Visit a NumberedParametersNode node



604
605
606
 
# File 'lib/prism/visitor.rb', line 604

def visit_numbered_parameters_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_numbered_reference_read_node(node) ⇒ Object

Visit a NumberedReferenceReadNode node



609
610
611
 
# File 'lib/prism/visitor.rb', line 609

def visit_numbered_reference_read_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_optional_keyword_parameter_node(node) ⇒ Object

Visit a OptionalKeywordParameterNode node



614
615
616
 
# File 'lib/prism/visitor.rb', line 614

def visit_optional_keyword_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_optional_parameter_node(node) ⇒ Object

Visit a OptionalParameterNode node



619
620
621
 
# File 'lib/prism/visitor.rb', line 619

def visit_optional_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_or_node(node) ⇒ Object

Visit a OrNode node



624
625
626
 
# File 'lib/prism/visitor.rb', line 624

def visit_or_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_parameters_node(node) ⇒ Object

Visit a ParametersNode node



629
630
631
 
# File 'lib/prism/visitor.rb', line 629

def visit_parameters_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_parentheses_node(node) ⇒ Object

Visit a ParenthesesNode node



634
635
636
 
# File 'lib/prism/visitor.rb', line 634

def visit_parentheses_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_pinned_expression_node(node) ⇒ Object

Visit a PinnedExpressionNode node



639
640
641
 
# File 'lib/prism/visitor.rb', line 639

def visit_pinned_expression_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_pinned_variable_node(node) ⇒ Object

Visit a PinnedVariableNode node



644
645
646
 
# File 'lib/prism/visitor.rb', line 644

def visit_pinned_variable_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_post_execution_node(node) ⇒ Object

Visit a PostExecutionNode node



649
650
651
 
# File 'lib/prism/visitor.rb', line 649

def visit_post_execution_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_pre_execution_node(node) ⇒ Object

Visit a PreExecutionNode node



654
655
656
 
# File 'lib/prism/visitor.rb', line 654

def visit_pre_execution_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_program_node(node) ⇒ Object

Visit a ProgramNode node



659
660
661
 
# File 'lib/prism/visitor.rb', line 659

def visit_program_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_range_node(node) ⇒ Object

Visit a RangeNode node



664
665
666
 
# File 'lib/prism/visitor.rb', line 664

def visit_range_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_rational_node(node) ⇒ Object

Visit a RationalNode node



669
670
671
 
# File 'lib/prism/visitor.rb', line 669

def visit_rational_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_redo_node(node) ⇒ Object

Visit a RedoNode node



674
675
676
 
# File 'lib/prism/visitor.rb', line 674

def visit_redo_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_regular_expression_node(node) ⇒ Object

Visit a RegularExpressionNode node



679
680
681
 
# File 'lib/prism/visitor.rb', line 679

def visit_regular_expression_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_required_keyword_parameter_node(node) ⇒ Object

Visit a RequiredKeywordParameterNode node



684
685
686
 
# File 'lib/prism/visitor.rb', line 684

def visit_required_keyword_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_required_parameter_node(node) ⇒ Object

Visit a RequiredParameterNode node



689
690
691
 
# File 'lib/prism/visitor.rb', line 689

def visit_required_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_rescue_modifier_node(node) ⇒ Object

Visit a RescueModifierNode node



694
695
696
 
# File 'lib/prism/visitor.rb', line 694

def visit_rescue_modifier_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_rescue_node(node) ⇒ Object

Visit a RescueNode node



699
700
701
 
# File 'lib/prism/visitor.rb', line 699

def visit_rescue_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_rest_parameter_node(node) ⇒ Object

Visit a RestParameterNode node



704
705
706
 
# File 'lib/prism/visitor.rb', line 704

def visit_rest_parameter_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_retry_node(node) ⇒ Object

Visit a RetryNode node



709
710
711
 
# File 'lib/prism/visitor.rb', line 709

def visit_retry_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_return_node(node) ⇒ Object

Visit a ReturnNode node



714
715
716
 
# File 'lib/prism/visitor.rb', line 714

def visit_return_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_self_node(node) ⇒ Object

Visit a SelfNode node



719
720
721
 
# File 'lib/prism/visitor.rb', line 719

def visit_self_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_shareable_constant_node(node) ⇒ Object

Visit a ShareableConstantNode node



724
725
726
 
# File 'lib/prism/visitor.rb', line 724

def visit_shareable_constant_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_singleton_class_node(node) ⇒ Object

Visit a SingletonClassNode node



729
730
731
 
# File 'lib/prism/visitor.rb', line 729

def visit_singleton_class_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_source_encoding_node(node) ⇒ Object

Visit a SourceEncodingNode node



734
735
736
 
# File 'lib/prism/visitor.rb', line 734

def visit_source_encoding_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_source_file_node(node) ⇒ Object

Visit a SourceFileNode node



739
740
741
 
# File 'lib/prism/visitor.rb', line 739

def visit_source_file_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_source_line_node(node) ⇒ Object

Visit a SourceLineNode node



744
745
746
 
# File 'lib/prism/visitor.rb', line 744

def visit_source_line_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_splat_node(node) ⇒ Object

Visit a SplatNode node



749
750
751
 
# File 'lib/prism/visitor.rb', line 749

def visit_splat_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_statements_node(node) ⇒ Object

Visit a StatementsNode node



754
755
756
 
# File 'lib/prism/visitor.rb', line 754

def visit_statements_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_string_node(node) ⇒ Object

Visit a StringNode node



759
760
761
 
# File 'lib/prism/visitor.rb', line 759

def visit_string_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_super_node(node) ⇒ Object

Visit a SuperNode node



764
765
766
 
# File 'lib/prism/visitor.rb', line 764

def visit_super_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_symbol_node(node) ⇒ Object

Visit a SymbolNode node



769
770
771
 
# File 'lib/prism/visitor.rb', line 769

def visit_symbol_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_true_node(node) ⇒ Object

Visit a TrueNode node



774
775
776
 
# File 'lib/prism/visitor.rb', line 774

def visit_true_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_undef_node(node) ⇒ Object

Visit a UndefNode node



779
780
781
 
# File 'lib/prism/visitor.rb', line 779

def visit_undef_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_unless_node(node) ⇒ Object

Visit a UnlessNode node



784
785
786
 
# File 'lib/prism/visitor.rb', line 784

def visit_unless_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_until_node(node) ⇒ Object

Visit a UntilNode node



789
790
791
 
# File 'lib/prism/visitor.rb', line 789

def visit_until_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_when_node(node) ⇒ Object

Visit a WhenNode node



794
795
796
 
# File 'lib/prism/visitor.rb', line 794

def visit_when_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_while_node(node) ⇒ Object

Visit a WhileNode node



799
800
801
 
# File 'lib/prism/visitor.rb', line 799

def visit_while_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_x_string_node(node) ⇒ Object

Visit a XStringNode node



804
805
806
 
# File 'lib/prism/visitor.rb', line 804

def visit_x_string_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end

#visit_yield_node(node) ⇒ Object

Visit a YieldNode node



809
810
811
 
# File 'lib/prism/visitor.rb', line 809

def visit_yield_node(node)
  node.compact_child_nodes.each { |node| node.accept(self) }
end