Class: Prism::MutationCompiler

Inherits:
Compiler show all
Defined in:
lib/prism/mutation_compiler.rb

Overview

This visitor walks through the tree and copies each node as it is being visited. This is useful for consumers that want to mutate the tree, as you can change subtrees in place without effecting the rest of the tree.

Direct Known Subclasses

DesugarCompiler

Instance Method Summary collapse

Methods inherited from BasicVisitor

#visit, #visit_all, #visit_child_nodes

Instance Method Details

#visit_alias_global_variable_node(node) ⇒ Object

Copy a AliasGlobalVariableNode node



18
19
20
 
# File 'lib/prism/mutation_compiler.rb', line 18

def visit_alias_global_variable_node(node)
  node.copy(new_name: visit(node.new_name), old_name: visit(node.old_name))
end

#visit_alias_method_node(node) ⇒ Object

Copy a AliasMethodNode node



23
24
25
 
# File 'lib/prism/mutation_compiler.rb', line 23

def visit_alias_method_node(node)
  node.copy(new_name: visit(node.new_name), old_name: visit(node.old_name))
end

#visit_alternation_pattern_node(node) ⇒ Object

Copy a AlternationPatternNode node



28
29
30
 
# File 'lib/prism/mutation_compiler.rb', line 28

def visit_alternation_pattern_node(node)
  node.copy(left: visit(node.left), right: visit(node.right))
end

#visit_and_node(node) ⇒ Object

Copy a AndNode node



33
34
35
 
# File 'lib/prism/mutation_compiler.rb', line 33

def visit_and_node(node)
  node.copy(left: visit(node.left), right: visit(node.right))
end

#visit_arguments_node(node) ⇒ Object

Copy a ArgumentsNode node



38
39
40
 
# File 'lib/prism/mutation_compiler.rb', line 38

def visit_arguments_node(node)
  node.copy(arguments: visit_all(node.arguments))
end

#visit_array_node(node) ⇒ Object

Copy a ArrayNode node



43
44
45
 
# File 'lib/prism/mutation_compiler.rb', line 43

def visit_array_node(node)
  node.copy(elements: visit_all(node.elements))
end

#visit_array_pattern_node(node) ⇒ Object

Copy a ArrayPatternNode node



48
49
50
 
# File 'lib/prism/mutation_compiler.rb', line 48

def visit_array_pattern_node(node)
  node.copy(constant: visit(node.constant), requireds: visit_all(node.requireds), rest: visit(node.rest), posts: visit_all(node.posts))
end

#visit_assoc_node(node) ⇒ Object

Copy a AssocNode node



53
54
55
 
# File 'lib/prism/mutation_compiler.rb', line 53

def visit_assoc_node(node)
  node.copy(key: visit(node.key), value: visit(node.value))
end

#visit_assoc_splat_node(node) ⇒ Object

Copy a AssocSplatNode node



58
59
60
 
# File 'lib/prism/mutation_compiler.rb', line 58

def visit_assoc_splat_node(node)
  node.copy(value: visit(node.value))
end

#visit_back_reference_read_node(node) ⇒ Object

Copy a BackReferenceReadNode node



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

def visit_back_reference_read_node(node)
  node.copy
end

#visit_begin_node(node) ⇒ Object

Copy a BeginNode node



68
69
70
 
# File 'lib/prism/mutation_compiler.rb', line 68

def visit_begin_node(node)
  node.copy(statements: visit(node.statements), rescue_clause: visit(node.rescue_clause), else_clause: visit(node.else_clause), ensure_clause: visit(node.ensure_clause))
end

#visit_block_argument_node(node) ⇒ Object

Copy a BlockArgumentNode node



73
74
75
 
# File 'lib/prism/mutation_compiler.rb', line 73

def visit_block_argument_node(node)
  node.copy(expression: visit(node.expression))
end

#visit_block_local_variable_node(node) ⇒ Object

Copy a BlockLocalVariableNode node



78
79
80
 
# File 'lib/prism/mutation_compiler.rb', line 78

def visit_block_local_variable_node(node)
  node.copy
end

#visit_block_node(node) ⇒ Object

Copy a BlockNode node



83
84
85
 
# File 'lib/prism/mutation_compiler.rb', line 83

def visit_block_node(node)
  node.copy(parameters: visit(node.parameters), body: visit(node.body))
end

#visit_block_parameter_node(node) ⇒ Object

Copy a BlockParameterNode node



88
89
90
 
# File 'lib/prism/mutation_compiler.rb', line 88

def visit_block_parameter_node(node)
  node.copy
end

#visit_block_parameters_node(node) ⇒ Object

Copy a BlockParametersNode node



93
94
95
 
# File 'lib/prism/mutation_compiler.rb', line 93

def visit_block_parameters_node(node)
  node.copy(parameters: visit(node.parameters), locals: visit_all(node.locals))
end

#visit_break_node(node) ⇒ Object

Copy a BreakNode node



98
99
100
 
# File 'lib/prism/mutation_compiler.rb', line 98

def visit_break_node(node)
  node.copy(arguments: visit(node.arguments))
end

#visit_call_and_write_node(node) ⇒ Object

Copy a CallAndWriteNode node



103
104
105
 
# File 'lib/prism/mutation_compiler.rb', line 103

def visit_call_and_write_node(node)
  node.copy(receiver: visit(node.receiver), value: visit(node.value))
end

#visit_call_node(node) ⇒ Object

Copy a CallNode node



108
109
110
 
# File 'lib/prism/mutation_compiler.rb', line 108

def visit_call_node(node)
  node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), block: visit(node.block))
end

#visit_call_operator_write_node(node) ⇒ Object

Copy a CallOperatorWriteNode node



113
114
115
 
# File 'lib/prism/mutation_compiler.rb', line 113

def visit_call_operator_write_node(node)
  node.copy(receiver: visit(node.receiver), value: visit(node.value))
end

#visit_call_or_write_node(node) ⇒ Object

Copy a CallOrWriteNode node



118
119
120
 
# File 'lib/prism/mutation_compiler.rb', line 118

def visit_call_or_write_node(node)
  node.copy(receiver: visit(node.receiver), value: visit(node.value))
end

#visit_call_target_node(node) ⇒ Object

Copy a CallTargetNode node



123
124
125
 
# File 'lib/prism/mutation_compiler.rb', line 123

def visit_call_target_node(node)
  node.copy(receiver: visit(node.receiver))
end

#visit_capture_pattern_node(node) ⇒ Object

Copy a CapturePatternNode node



128
129
130
 
# File 'lib/prism/mutation_compiler.rb', line 128

def visit_capture_pattern_node(node)
  node.copy(value: visit(node.value), target: visit(node.target))
end

#visit_case_match_node(node) ⇒ Object

Copy a CaseMatchNode node



133
134
135
 
# File 'lib/prism/mutation_compiler.rb', line 133

def visit_case_match_node(node)
  node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), else_clause: visit(node.else_clause))
end

#visit_case_node(node) ⇒ Object

Copy a CaseNode node



138
139
140
 
# File 'lib/prism/mutation_compiler.rb', line 138

def visit_case_node(node)
  node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), else_clause: visit(node.else_clause))
end

#visit_class_node(node) ⇒ Object

Copy a ClassNode node



143
144
145
 
# File 'lib/prism/mutation_compiler.rb', line 143

def visit_class_node(node)
  node.copy(constant_path: visit(node.constant_path), superclass: visit(node.superclass), body: visit(node.body))
end

#visit_class_variable_and_write_node(node) ⇒ Object

Copy a ClassVariableAndWriteNode node



148
149
150
 
# File 'lib/prism/mutation_compiler.rb', line 148

def visit_class_variable_and_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_class_variable_operator_write_node(node) ⇒ Object

Copy a ClassVariableOperatorWriteNode node



153
154
155
 
# File 'lib/prism/mutation_compiler.rb', line 153

def visit_class_variable_operator_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_class_variable_or_write_node(node) ⇒ Object

Copy a ClassVariableOrWriteNode node



158
159
160
 
# File 'lib/prism/mutation_compiler.rb', line 158

def visit_class_variable_or_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_class_variable_read_node(node) ⇒ Object

Copy a ClassVariableReadNode node



163
164
165
 
# File 'lib/prism/mutation_compiler.rb', line 163

def visit_class_variable_read_node(node)
  node.copy
end

#visit_class_variable_target_node(node) ⇒ Object

Copy a ClassVariableTargetNode node



168
169
170
 
# File 'lib/prism/mutation_compiler.rb', line 168

def visit_class_variable_target_node(node)
  node.copy
end

#visit_class_variable_write_node(node) ⇒ Object

Copy a ClassVariableWriteNode node



173
174
175
 
# File 'lib/prism/mutation_compiler.rb', line 173

def visit_class_variable_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_constant_and_write_node(node) ⇒ Object

Copy a ConstantAndWriteNode node



178
179
180
 
# File 'lib/prism/mutation_compiler.rb', line 178

def visit_constant_and_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_constant_operator_write_node(node) ⇒ Object

Copy a ConstantOperatorWriteNode node



183
184
185
 
# File 'lib/prism/mutation_compiler.rb', line 183

def visit_constant_operator_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_constant_or_write_node(node) ⇒ Object

Copy a ConstantOrWriteNode node



188
189
190
 
# File 'lib/prism/mutation_compiler.rb', line 188

def visit_constant_or_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_constant_path_and_write_node(node) ⇒ Object

Copy a ConstantPathAndWriteNode node



193
194
195
 
# File 'lib/prism/mutation_compiler.rb', line 193

def visit_constant_path_and_write_node(node)
  node.copy(target: visit(node.target), value: visit(node.value))
end

#visit_constant_path_node(node) ⇒ Object

Copy a ConstantPathNode node



198
199
200
 
# File 'lib/prism/mutation_compiler.rb', line 198

def visit_constant_path_node(node)
  node.copy(parent: visit(node.parent))
end

#visit_constant_path_operator_write_node(node) ⇒ Object

Copy a ConstantPathOperatorWriteNode node



203
204
205
 
# File 'lib/prism/mutation_compiler.rb', line 203

def visit_constant_path_operator_write_node(node)
  node.copy(target: visit(node.target), value: visit(node.value))
end

#visit_constant_path_or_write_node(node) ⇒ Object

Copy a ConstantPathOrWriteNode node



208
209
210
 
# File 'lib/prism/mutation_compiler.rb', line 208

def visit_constant_path_or_write_node(node)
  node.copy(target: visit(node.target), value: visit(node.value))
end

#visit_constant_path_target_node(node) ⇒ Object

Copy a ConstantPathTargetNode node



213
214
215
 
# File 'lib/prism/mutation_compiler.rb', line 213

def visit_constant_path_target_node(node)
  node.copy(parent: visit(node.parent))
end

#visit_constant_path_write_node(node) ⇒ Object

Copy a ConstantPathWriteNode node



218
219
220
 
# File 'lib/prism/mutation_compiler.rb', line 218

def visit_constant_path_write_node(node)
  node.copy(target: visit(node.target), value: visit(node.value))
end

#visit_constant_read_node(node) ⇒ Object

Copy a ConstantReadNode node



223
224
225
 
# File 'lib/prism/mutation_compiler.rb', line 223

def visit_constant_read_node(node)
  node.copy
end

#visit_constant_target_node(node) ⇒ Object

Copy a ConstantTargetNode node



228
229
230
 
# File 'lib/prism/mutation_compiler.rb', line 228

def visit_constant_target_node(node)
  node.copy
end

#visit_constant_write_node(node) ⇒ Object

Copy a ConstantWriteNode node



233
234
235
 
# File 'lib/prism/mutation_compiler.rb', line 233

def visit_constant_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_def_node(node) ⇒ Object

Copy a DefNode node



238
239
240
 
# File 'lib/prism/mutation_compiler.rb', line 238

def visit_def_node(node)
  node.copy(receiver: visit(node.receiver), parameters: visit(node.parameters), body: visit(node.body))
end

#visit_defined_node(node) ⇒ Object

Copy a DefinedNode node



243
244
245
 
# File 'lib/prism/mutation_compiler.rb', line 243

def visit_defined_node(node)
  node.copy(value: visit(node.value))
end

#visit_else_node(node) ⇒ Object

Copy a ElseNode node



248
249
250
 
# File 'lib/prism/mutation_compiler.rb', line 248

def visit_else_node(node)
  node.copy(statements: visit(node.statements))
end

#visit_embedded_statements_node(node) ⇒ Object

Copy a EmbeddedStatementsNode node



253
254
255
 
# File 'lib/prism/mutation_compiler.rb', line 253

def visit_embedded_statements_node(node)
  node.copy(statements: visit(node.statements))
end

#visit_embedded_variable_node(node) ⇒ Object

Copy a EmbeddedVariableNode node



258
259
260
 
# File 'lib/prism/mutation_compiler.rb', line 258

def visit_embedded_variable_node(node)
  node.copy(variable: visit(node.variable))
end

#visit_ensure_node(node) ⇒ Object

Copy a EnsureNode node



263
264
265
 
# File 'lib/prism/mutation_compiler.rb', line 263

def visit_ensure_node(node)
  node.copy(statements: visit(node.statements))
end

#visit_false_node(node) ⇒ Object

Copy a FalseNode node



268
269
270
 
# File 'lib/prism/mutation_compiler.rb', line 268

def visit_false_node(node)
  node.copy
end

#visit_find_pattern_node(node) ⇒ Object

Copy a FindPatternNode node



273
274
275
 
# File 'lib/prism/mutation_compiler.rb', line 273

def visit_find_pattern_node(node)
  node.copy(constant: visit(node.constant), left: visit(node.left), requireds: visit_all(node.requireds), right: visit(node.right))
end

#visit_flip_flop_node(node) ⇒ Object

Copy a FlipFlopNode node



278
279
280
 
# File 'lib/prism/mutation_compiler.rb', line 278

def visit_flip_flop_node(node)
  node.copy(left: visit(node.left), right: visit(node.right))
end

#visit_float_node(node) ⇒ Object

Copy a FloatNode node



283
284
285
 
# File 'lib/prism/mutation_compiler.rb', line 283

def visit_float_node(node)
  node.copy
end

#visit_for_node(node) ⇒ Object

Copy a ForNode node



288
289
290
 
# File 'lib/prism/mutation_compiler.rb', line 288

def visit_for_node(node)
  node.copy(index: visit(node.index), collection: visit(node.collection), statements: visit(node.statements))
end

#visit_forwarding_arguments_node(node) ⇒ Object

Copy a ForwardingArgumentsNode node



293
294
295
 
# File 'lib/prism/mutation_compiler.rb', line 293

def visit_forwarding_arguments_node(node)
  node.copy
end

#visit_forwarding_parameter_node(node) ⇒ Object

Copy a ForwardingParameterNode node



298
299
300
 
# File 'lib/prism/mutation_compiler.rb', line 298

def visit_forwarding_parameter_node(node)
  node.copy
end

#visit_forwarding_super_node(node) ⇒ Object

Copy a ForwardingSuperNode node



303
304
305
 
# File 'lib/prism/mutation_compiler.rb', line 303

def visit_forwarding_super_node(node)
  node.copy(block: visit(node.block))
end

#visit_global_variable_and_write_node(node) ⇒ Object

Copy a GlobalVariableAndWriteNode node



308
309
310
 
# File 'lib/prism/mutation_compiler.rb', line 308

def visit_global_variable_and_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_global_variable_operator_write_node(node) ⇒ Object

Copy a GlobalVariableOperatorWriteNode node



313
314
315
 
# File 'lib/prism/mutation_compiler.rb', line 313

def visit_global_variable_operator_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_global_variable_or_write_node(node) ⇒ Object

Copy a GlobalVariableOrWriteNode node



318
319
320
 
# File 'lib/prism/mutation_compiler.rb', line 318

def visit_global_variable_or_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_global_variable_read_node(node) ⇒ Object

Copy a GlobalVariableReadNode node



323
324
325
 
# File 'lib/prism/mutation_compiler.rb', line 323

def visit_global_variable_read_node(node)
  node.copy
end

#visit_global_variable_target_node(node) ⇒ Object

Copy a GlobalVariableTargetNode node



328
329
330
 
# File 'lib/prism/mutation_compiler.rb', line 328

def visit_global_variable_target_node(node)
  node.copy
end

#visit_global_variable_write_node(node) ⇒ Object

Copy a GlobalVariableWriteNode node



333
334
335
 
# File 'lib/prism/mutation_compiler.rb', line 333

def visit_global_variable_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_hash_node(node) ⇒ Object

Copy a HashNode node



338
339
340
 
# File 'lib/prism/mutation_compiler.rb', line 338

def visit_hash_node(node)
  node.copy(elements: visit_all(node.elements))
end

#visit_hash_pattern_node(node) ⇒ Object

Copy a HashPatternNode node



343
344
345
 
# File 'lib/prism/mutation_compiler.rb', line 343

def visit_hash_pattern_node(node)
  node.copy(constant: visit(node.constant), elements: visit_all(node.elements), rest: visit(node.rest))
end

#visit_if_node(node) ⇒ Object

Copy a IfNode node



348
349
350
 
# File 'lib/prism/mutation_compiler.rb', line 348

def visit_if_node(node)
  node.copy(predicate: visit(node.predicate), statements: visit(node.statements), subsequent: visit(node.subsequent))
end

#visit_imaginary_node(node) ⇒ Object

Copy a ImaginaryNode node



353
354
355
 
# File 'lib/prism/mutation_compiler.rb', line 353

def visit_imaginary_node(node)
  node.copy(numeric: visit(node.numeric))
end

#visit_implicit_node(node) ⇒ Object

Copy a ImplicitNode node



358
359
360
 
# File 'lib/prism/mutation_compiler.rb', line 358

def visit_implicit_node(node)
  node.copy(value: visit(node.value))
end

#visit_implicit_rest_node(node) ⇒ Object

Copy a ImplicitRestNode node



363
364
365
 
# File 'lib/prism/mutation_compiler.rb', line 363

def visit_implicit_rest_node(node)
  node.copy
end

#visit_in_node(node) ⇒ Object

Copy a InNode node



368
369
370
 
# File 'lib/prism/mutation_compiler.rb', line 368

def visit_in_node(node)
  node.copy(pattern: visit(node.pattern), statements: visit(node.statements))
end

#visit_index_and_write_node(node) ⇒ Object

Copy a IndexAndWriteNode node



373
374
375
 
# File 'lib/prism/mutation_compiler.rb', line 373

def visit_index_and_write_node(node)
  node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), block: visit(node.block), value: visit(node.value))
end

#visit_index_operator_write_node(node) ⇒ Object

Copy a IndexOperatorWriteNode node



378
379
380
 
# File 'lib/prism/mutation_compiler.rb', line 378

def visit_index_operator_write_node(node)
  node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), block: visit(node.block), value: visit(node.value))
end

#visit_index_or_write_node(node) ⇒ Object

Copy a IndexOrWriteNode node



383
384
385
 
# File 'lib/prism/mutation_compiler.rb', line 383

def visit_index_or_write_node(node)
  node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), block: visit(node.block), value: visit(node.value))
end

#visit_index_target_node(node) ⇒ Object

Copy a IndexTargetNode node



388
389
390
 
# File 'lib/prism/mutation_compiler.rb', line 388

def visit_index_target_node(node)
  node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), block: visit(node.block))
end

#visit_instance_variable_and_write_node(node) ⇒ Object

Copy a InstanceVariableAndWriteNode node



393
394
395
 
# File 'lib/prism/mutation_compiler.rb', line 393

def visit_instance_variable_and_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_instance_variable_operator_write_node(node) ⇒ Object

Copy a InstanceVariableOperatorWriteNode node



398
399
400
 
# File 'lib/prism/mutation_compiler.rb', line 398

def visit_instance_variable_operator_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_instance_variable_or_write_node(node) ⇒ Object

Copy a InstanceVariableOrWriteNode node



403
404
405
 
# File 'lib/prism/mutation_compiler.rb', line 403

def visit_instance_variable_or_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_instance_variable_read_node(node) ⇒ Object

Copy a InstanceVariableReadNode node



408
409
410
 
# File 'lib/prism/mutation_compiler.rb', line 408

def visit_instance_variable_read_node(node)
  node.copy
end

#visit_instance_variable_target_node(node) ⇒ Object

Copy a InstanceVariableTargetNode node



413
414
415
 
# File 'lib/prism/mutation_compiler.rb', line 413

def visit_instance_variable_target_node(node)
  node.copy
end

#visit_instance_variable_write_node(node) ⇒ Object

Copy a InstanceVariableWriteNode node



418
419
420
 
# File 'lib/prism/mutation_compiler.rb', line 418

def visit_instance_variable_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_integer_node(node) ⇒ Object

Copy a IntegerNode node



423
424
425
 
# File 'lib/prism/mutation_compiler.rb', line 423

def visit_integer_node(node)
  node.copy
end

#visit_interpolated_match_last_line_node(node) ⇒ Object

Copy a InterpolatedMatchLastLineNode node



428
429
430
 
# File 'lib/prism/mutation_compiler.rb', line 428

def visit_interpolated_match_last_line_node(node)
  node.copy(parts: visit_all(node.parts))
end

#visit_interpolated_regular_expression_node(node) ⇒ Object

Copy a InterpolatedRegularExpressionNode node



433
434
435
 
# File 'lib/prism/mutation_compiler.rb', line 433

def visit_interpolated_regular_expression_node(node)
  node.copy(parts: visit_all(node.parts))
end

#visit_interpolated_string_node(node) ⇒ Object

Copy a InterpolatedStringNode node



438
439
440
 
# File 'lib/prism/mutation_compiler.rb', line 438

def visit_interpolated_string_node(node)
  node.copy(parts: visit_all(node.parts))
end

#visit_interpolated_symbol_node(node) ⇒ Object

Copy a InterpolatedSymbolNode node



443
444
445
 
# File 'lib/prism/mutation_compiler.rb', line 443

def visit_interpolated_symbol_node(node)
  node.copy(parts: visit_all(node.parts))
end

#visit_interpolated_x_string_node(node) ⇒ Object

Copy a InterpolatedXStringNode node



448
449
450
 
# File 'lib/prism/mutation_compiler.rb', line 448

def visit_interpolated_x_string_node(node)
  node.copy(parts: visit_all(node.parts))
end

#visit_it_local_variable_read_node(node) ⇒ Object

Copy a ItLocalVariableReadNode node



453
454
455
 
# File 'lib/prism/mutation_compiler.rb', line 453

def visit_it_local_variable_read_node(node)
  node.copy
end

#visit_it_parameters_node(node) ⇒ Object

Copy a ItParametersNode node



458
459
460
 
# File 'lib/prism/mutation_compiler.rb', line 458

def visit_it_parameters_node(node)
  node.copy
end

#visit_keyword_hash_node(node) ⇒ Object

Copy a KeywordHashNode node



463
464
465
 
# File 'lib/prism/mutation_compiler.rb', line 463

def visit_keyword_hash_node(node)
  node.copy(elements: visit_all(node.elements))
end

#visit_keyword_rest_parameter_node(node) ⇒ Object

Copy a KeywordRestParameterNode node



468
469
470
 
# File 'lib/prism/mutation_compiler.rb', line 468

def visit_keyword_rest_parameter_node(node)
  node.copy
end

#visit_lambda_node(node) ⇒ Object

Copy a LambdaNode node



473
474
475
 
# File 'lib/prism/mutation_compiler.rb', line 473

def visit_lambda_node(node)
  node.copy(parameters: visit(node.parameters), body: visit(node.body))
end

#visit_local_variable_and_write_node(node) ⇒ Object

Copy a LocalVariableAndWriteNode node



478
479
480
 
# File 'lib/prism/mutation_compiler.rb', line 478

def visit_local_variable_and_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_local_variable_operator_write_node(node) ⇒ Object

Copy a LocalVariableOperatorWriteNode node



483
484
485
 
# File 'lib/prism/mutation_compiler.rb', line 483

def visit_local_variable_operator_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_local_variable_or_write_node(node) ⇒ Object

Copy a LocalVariableOrWriteNode node



488
489
490
 
# File 'lib/prism/mutation_compiler.rb', line 488

def visit_local_variable_or_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_local_variable_read_node(node) ⇒ Object

Copy a LocalVariableReadNode node



493
494
495
 
# File 'lib/prism/mutation_compiler.rb', line 493

def visit_local_variable_read_node(node)
  node.copy
end

#visit_local_variable_target_node(node) ⇒ Object

Copy a LocalVariableTargetNode node



498
499
500
 
# File 'lib/prism/mutation_compiler.rb', line 498

def visit_local_variable_target_node(node)
  node.copy
end

#visit_local_variable_write_node(node) ⇒ Object

Copy a LocalVariableWriteNode node



503
504
505
 
# File 'lib/prism/mutation_compiler.rb', line 503

def visit_local_variable_write_node(node)
  node.copy(value: visit(node.value))
end

#visit_match_last_line_node(node) ⇒ Object

Copy a MatchLastLineNode node



508
509
510
 
# File 'lib/prism/mutation_compiler.rb', line 508

def visit_match_last_line_node(node)
  node.copy
end

#visit_match_predicate_node(node) ⇒ Object

Copy a MatchPredicateNode node



513
514
515
 
# File 'lib/prism/mutation_compiler.rb', line 513

def visit_match_predicate_node(node)
  node.copy(value: visit(node.value), pattern: visit(node.pattern))
end

#visit_match_required_node(node) ⇒ Object

Copy a MatchRequiredNode node



518
519
520
 
# File 'lib/prism/mutation_compiler.rb', line 518

def visit_match_required_node(node)
  node.copy(value: visit(node.value), pattern: visit(node.pattern))
end

#visit_match_write_node(node) ⇒ Object

Copy a MatchWriteNode node



523
524
525
 
# File 'lib/prism/mutation_compiler.rb', line 523

def visit_match_write_node(node)
  node.copy(call: visit(node.call), targets: visit_all(node.targets))
end

#visit_missing_node(node) ⇒ Object

Copy a MissingNode node



528
529
530
 
# File 'lib/prism/mutation_compiler.rb', line 528

def visit_missing_node(node)
  node.copy
end

#visit_module_node(node) ⇒ Object

Copy a ModuleNode node



533
534
535
 
# File 'lib/prism/mutation_compiler.rb', line 533

def visit_module_node(node)
  node.copy(constant_path: visit(node.constant_path), body: visit(node.body))
end

#visit_multi_target_node(node) ⇒ Object

Copy a MultiTargetNode node



538
539
540
 
# File 'lib/prism/mutation_compiler.rb', line 538

def visit_multi_target_node(node)
  node.copy(lefts: visit_all(node.lefts), rest: visit(node.rest), rights: visit_all(node.rights))
end

#visit_multi_write_node(node) ⇒ Object

Copy a MultiWriteNode node



543
544
545
 
# File 'lib/prism/mutation_compiler.rb', line 543

def visit_multi_write_node(node)
  node.copy(lefts: visit_all(node.lefts), rest: visit(node.rest), rights: visit_all(node.rights), value: visit(node.value))
end

#visit_next_node(node) ⇒ Object

Copy a NextNode node



548
549
550
 
# File 'lib/prism/mutation_compiler.rb', line 548

def visit_next_node(node)
  node.copy(arguments: visit(node.arguments))
end

#visit_nil_node(node) ⇒ Object

Copy a NilNode node



553
554
555
 
# File 'lib/prism/mutation_compiler.rb', line 553

def visit_nil_node(node)
  node.copy
end

#visit_no_keywords_parameter_node(node) ⇒ Object

Copy a NoKeywordsParameterNode node



558
559
560
 
# File 'lib/prism/mutation_compiler.rb', line 558

def visit_no_keywords_parameter_node(node)
  node.copy
end

#visit_numbered_parameters_node(node) ⇒ Object

Copy a NumberedParametersNode node



563
564
565
 
# File 'lib/prism/mutation_compiler.rb', line 563

def visit_numbered_parameters_node(node)
  node.copy
end

#visit_numbered_reference_read_node(node) ⇒ Object

Copy a NumberedReferenceReadNode node



568
569
570
 
# File 'lib/prism/mutation_compiler.rb', line 568

def visit_numbered_reference_read_node(node)
  node.copy
end

#visit_optional_keyword_parameter_node(node) ⇒ Object

Copy a OptionalKeywordParameterNode node



573
574
575
 
# File 'lib/prism/mutation_compiler.rb', line 573

def visit_optional_keyword_parameter_node(node)
  node.copy(value: visit(node.value))
end

#visit_optional_parameter_node(node) ⇒ Object

Copy a OptionalParameterNode node



578
579
580
 
# File 'lib/prism/mutation_compiler.rb', line 578

def visit_optional_parameter_node(node)
  node.copy(value: visit(node.value))
end

#visit_or_node(node) ⇒ Object

Copy a OrNode node



583
584
585
 
# File 'lib/prism/mutation_compiler.rb', line 583

def visit_or_node(node)
  node.copy(left: visit(node.left), right: visit(node.right))
end

#visit_parameters_node(node) ⇒ Object

Copy a ParametersNode node



588
589
590
 
# File 'lib/prism/mutation_compiler.rb', line 588

def visit_parameters_node(node)
  node.copy(requireds: visit_all(node.requireds), optionals: visit_all(node.optionals), rest: visit(node.rest), posts: visit_all(node.posts), keywords: visit_all(node.keywords), keyword_rest: visit(node.keyword_rest), block: visit(node.block))
end

#visit_parentheses_node(node) ⇒ Object

Copy a ParenthesesNode node



593
594
595
 
# File 'lib/prism/mutation_compiler.rb', line 593

def visit_parentheses_node(node)
  node.copy(body: visit(node.body))
end

#visit_pinned_expression_node(node) ⇒ Object

Copy a PinnedExpressionNode node



598
599
600
 
# File 'lib/prism/mutation_compiler.rb', line 598

def visit_pinned_expression_node(node)
  node.copy(expression: visit(node.expression))
end

#visit_pinned_variable_node(node) ⇒ Object

Copy a PinnedVariableNode node



603
604
605
 
# File 'lib/prism/mutation_compiler.rb', line 603

def visit_pinned_variable_node(node)
  node.copy(variable: visit(node.variable))
end

#visit_post_execution_node(node) ⇒ Object

Copy a PostExecutionNode node



608
609
610
 
# File 'lib/prism/mutation_compiler.rb', line 608

def visit_post_execution_node(node)
  node.copy(statements: visit(node.statements))
end

#visit_pre_execution_node(node) ⇒ Object

Copy a PreExecutionNode node



613
614
615
 
# File 'lib/prism/mutation_compiler.rb', line 613

def visit_pre_execution_node(node)
  node.copy(statements: visit(node.statements))
end

#visit_program_node(node) ⇒ Object

Copy a ProgramNode node



618
619
620
 
# File 'lib/prism/mutation_compiler.rb', line 618

def visit_program_node(node)
  node.copy(statements: visit(node.statements))
end

#visit_range_node(node) ⇒ Object

Copy a RangeNode node



623
624
625
 
# File 'lib/prism/mutation_compiler.rb', line 623

def visit_range_node(node)
  node.copy(left: visit(node.left), right: visit(node.right))
end

#visit_rational_node(node) ⇒ Object

Copy a RationalNode node



628
629
630
 
# File 'lib/prism/mutation_compiler.rb', line 628

def visit_rational_node(node)
  node.copy
end

#visit_redo_node(node) ⇒ Object

Copy a RedoNode node



633
634
635
 
# File 'lib/prism/mutation_compiler.rb', line 633

def visit_redo_node(node)
  node.copy
end

#visit_regular_expression_node(node) ⇒ Object

Copy a RegularExpressionNode node



638
639
640
 
# File 'lib/prism/mutation_compiler.rb', line 638

def visit_regular_expression_node(node)
  node.copy
end

#visit_required_keyword_parameter_node(node) ⇒ Object

Copy a RequiredKeywordParameterNode node



643
644
645
 
# File 'lib/prism/mutation_compiler.rb', line 643

def visit_required_keyword_parameter_node(node)
  node.copy
end

#visit_required_parameter_node(node) ⇒ Object

Copy a RequiredParameterNode node



648
649
650
 
# File 'lib/prism/mutation_compiler.rb', line 648

def visit_required_parameter_node(node)
  node.copy
end

#visit_rescue_modifier_node(node) ⇒ Object

Copy a RescueModifierNode node



653
654
655
 
# File 'lib/prism/mutation_compiler.rb', line 653

def visit_rescue_modifier_node(node)
  node.copy(expression: visit(node.expression), rescue_expression: visit(node.rescue_expression))
end

#visit_rescue_node(node) ⇒ Object

Copy a RescueNode node



658
659
660
 
# File 'lib/prism/mutation_compiler.rb', line 658

def visit_rescue_node(node)
  node.copy(exceptions: visit_all(node.exceptions), reference: visit(node.reference), statements: visit(node.statements), subsequent: visit(node.subsequent))
end

#visit_rest_parameter_node(node) ⇒ Object

Copy a RestParameterNode node



663
664
665
 
# File 'lib/prism/mutation_compiler.rb', line 663

def visit_rest_parameter_node(node)
  node.copy
end

#visit_retry_node(node) ⇒ Object

Copy a RetryNode node



668
669
670
 
# File 'lib/prism/mutation_compiler.rb', line 668

def visit_retry_node(node)
  node.copy
end

#visit_return_node(node) ⇒ Object

Copy a ReturnNode node



673
674
675
 
# File 'lib/prism/mutation_compiler.rb', line 673

def visit_return_node(node)
  node.copy(arguments: visit(node.arguments))
end

#visit_self_node(node) ⇒ Object

Copy a SelfNode node



678
679
680
 
# File 'lib/prism/mutation_compiler.rb', line 678

def visit_self_node(node)
  node.copy
end

#visit_shareable_constant_node(node) ⇒ Object

Copy a ShareableConstantNode node



683
684
685
 
# File 'lib/prism/mutation_compiler.rb', line 683

def visit_shareable_constant_node(node)
  node.copy(write: visit(node.write))
end

#visit_singleton_class_node(node) ⇒ Object

Copy a SingletonClassNode node



688
689
690
 
# File 'lib/prism/mutation_compiler.rb', line 688

def visit_singleton_class_node(node)
  node.copy(expression: visit(node.expression), body: visit(node.body))
end

#visit_source_encoding_node(node) ⇒ Object

Copy a SourceEncodingNode node



693
694
695
 
# File 'lib/prism/mutation_compiler.rb', line 693

def visit_source_encoding_node(node)
  node.copy
end

#visit_source_file_node(node) ⇒ Object

Copy a SourceFileNode node



698
699
700
 
# File 'lib/prism/mutation_compiler.rb', line 698

def visit_source_file_node(node)
  node.copy
end

#visit_source_line_node(node) ⇒ Object

Copy a SourceLineNode node



703
704
705
 
# File 'lib/prism/mutation_compiler.rb', line 703

def visit_source_line_node(node)
  node.copy
end

#visit_splat_node(node) ⇒ Object

Copy a SplatNode node



708
709
710
 
# File 'lib/prism/mutation_compiler.rb', line 708

def visit_splat_node(node)
  node.copy(expression: visit(node.expression))
end

#visit_statements_node(node) ⇒ Object

Copy a StatementsNode node



713
714
715
 
# File 'lib/prism/mutation_compiler.rb', line 713

def visit_statements_node(node)
  node.copy(body: visit_all(node.body))
end

#visit_string_node(node) ⇒ Object

Copy a StringNode node



718
719
720
 
# File 'lib/prism/mutation_compiler.rb', line 718

def visit_string_node(node)
  node.copy
end

#visit_super_node(node) ⇒ Object

Copy a SuperNode node



723
724
725
 
# File 'lib/prism/mutation_compiler.rb', line 723

def visit_super_node(node)
  node.copy(arguments: visit(node.arguments), block: visit(node.block))
end

#visit_symbol_node(node) ⇒ Object

Copy a SymbolNode node



728
729
730
 
# File 'lib/prism/mutation_compiler.rb', line 728

def visit_symbol_node(node)
  node.copy
end

#visit_true_node(node) ⇒ Object

Copy a TrueNode node



733
734
735
 
# File 'lib/prism/mutation_compiler.rb', line 733

def visit_true_node(node)
  node.copy
end

#visit_undef_node(node) ⇒ Object

Copy a UndefNode node



738
739
740
 
# File 'lib/prism/mutation_compiler.rb', line 738

def visit_undef_node(node)
  node.copy(names: visit_all(node.names))
end

#visit_unless_node(node) ⇒ Object

Copy a UnlessNode node



743
744
745
 
# File 'lib/prism/mutation_compiler.rb', line 743

def visit_unless_node(node)
  node.copy(predicate: visit(node.predicate), statements: visit(node.statements), else_clause: visit(node.else_clause))
end

#visit_until_node(node) ⇒ Object

Copy a UntilNode node



748
749
750
 
# File 'lib/prism/mutation_compiler.rb', line 748

def visit_until_node(node)
  node.copy(predicate: visit(node.predicate), statements: visit(node.statements))
end

#visit_when_node(node) ⇒ Object

Copy a WhenNode node



753
754
755
 
# File 'lib/prism/mutation_compiler.rb', line 753

def visit_when_node(node)
  node.copy(conditions: visit_all(node.conditions), statements: visit(node.statements))
end

#visit_while_node(node) ⇒ Object

Copy a WhileNode node



758
759
760
 
# File 'lib/prism/mutation_compiler.rb', line 758

def visit_while_node(node)
  node.copy(predicate: visit(node.predicate), statements: visit(node.statements))
end

#visit_x_string_node(node) ⇒ Object

Copy a XStringNode node



763
764
765
 
# File 'lib/prism/mutation_compiler.rb', line 763

def visit_x_string_node(node)
  node.copy
end

#visit_yield_node(node) ⇒ Object

Copy a YieldNode node



768
769
770
 
# File 'lib/prism/mutation_compiler.rb', line 768

def visit_yield_node(node)
  node.copy(arguments: visit(node.arguments))
end