Class: Prism::MutationCompiler

Inherits:
Compiler
  • Object
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 Compiler

#visit, #visit_all, #visit_child_nodes

Instance Method Details

#visit_alias_global_variable_node(node) ⇒ Object

Copy a AliasGlobalVariableNode node



14
15
16
 
# File 'lib/prism/mutation_compiler.rb', line 14

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



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

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



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

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



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

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



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

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

#visit_array_node(node) ⇒ Object

Copy a ArrayNode node



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

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

#visit_array_pattern_node(node) ⇒ Object

Copy a ArrayPatternNode node



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

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



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

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



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

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

#visit_back_reference_read_node(node) ⇒ Object

Copy a BackReferenceReadNode node



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

def visit_back_reference_read_node(node)
  node.copy
end

#visit_begin_node(node) ⇒ Object

Copy a BeginNode node



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

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



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

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

#visit_block_local_variable_node(node) ⇒ Object

Copy a BlockLocalVariableNode node



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

def visit_block_local_variable_node(node)
  node.copy
end

#visit_block_node(node) ⇒ Object

Copy a BlockNode node



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

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



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

def visit_block_parameter_node(node)
  node.copy
end

#visit_block_parameters_node(node) ⇒ Object

Copy a BlockParametersNode node



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

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



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

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

#visit_call_and_write_node(node) ⇒ Object

Copy a CallAndWriteNode node



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

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



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

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



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

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



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

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



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

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

#visit_capture_pattern_node(node) ⇒ Object

Copy a CapturePatternNode node



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

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



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

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

#visit_case_node(node) ⇒ Object

Copy a CaseNode node



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

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

#visit_class_node(node) ⇒ Object

Copy a ClassNode node



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

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



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

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



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

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



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

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



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

def visit_class_variable_read_node(node)
  node.copy
end

#visit_class_variable_target_node(node) ⇒ Object

Copy a ClassVariableTargetNode node



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

def visit_class_variable_target_node(node)
  node.copy
end

#visit_class_variable_write_node(node) ⇒ Object

Copy a ClassVariableWriteNode node



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

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



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

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



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

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



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

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



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

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



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

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

#visit_constant_path_operator_write_node(node) ⇒ Object

Copy a ConstantPathOperatorWriteNode node



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

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



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

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



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

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

#visit_constant_path_write_node(node) ⇒ Object

Copy a ConstantPathWriteNode node



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

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



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

def visit_constant_read_node(node)
  node.copy
end

#visit_constant_target_node(node) ⇒ Object

Copy a ConstantTargetNode node



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

def visit_constant_target_node(node)
  node.copy
end

#visit_constant_write_node(node) ⇒ Object

Copy a ConstantWriteNode node



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

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

#visit_def_node(node) ⇒ Object

Copy a DefNode node



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

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



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

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

#visit_else_node(node) ⇒ Object

Copy a ElseNode node



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

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

#visit_embedded_statements_node(node) ⇒ Object

Copy a EmbeddedStatementsNode node



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

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

#visit_embedded_variable_node(node) ⇒ Object

Copy a EmbeddedVariableNode node



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

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

#visit_ensure_node(node) ⇒ Object

Copy a EnsureNode node



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

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

#visit_false_node(node) ⇒ Object

Copy a FalseNode node



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

def visit_false_node(node)
  node.copy
end

#visit_find_pattern_node(node) ⇒ Object

Copy a FindPatternNode node



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

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



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

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



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

def visit_float_node(node)
  node.copy
end

#visit_for_node(node) ⇒ Object

Copy a ForNode node



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

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



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

def visit_forwarding_arguments_node(node)
  node.copy
end

#visit_forwarding_parameter_node(node) ⇒ Object

Copy a ForwardingParameterNode node



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

def visit_forwarding_parameter_node(node)
  node.copy
end

#visit_forwarding_super_node(node) ⇒ Object

Copy a ForwardingSuperNode node



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

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



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

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



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

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



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

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



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

def visit_global_variable_read_node(node)
  node.copy
end

#visit_global_variable_target_node(node) ⇒ Object

Copy a GlobalVariableTargetNode node



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

def visit_global_variable_target_node(node)
  node.copy
end

#visit_global_variable_write_node(node) ⇒ Object

Copy a GlobalVariableWriteNode node



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

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

#visit_hash_node(node) ⇒ Object

Copy a HashNode node



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

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

#visit_hash_pattern_node(node) ⇒ Object

Copy a HashPatternNode node



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

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



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

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

#visit_imaginary_node(node) ⇒ Object

Copy a ImaginaryNode node



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

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

#visit_implicit_node(node) ⇒ Object

Copy a ImplicitNode node



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

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

#visit_implicit_rest_node(node) ⇒ Object

Copy a ImplicitRestNode node



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

def visit_implicit_rest_node(node)
  node.copy
end

#visit_in_node(node) ⇒ Object

Copy a InNode node



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

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



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

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



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

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



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

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



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

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



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

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



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

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



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

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



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

def visit_instance_variable_read_node(node)
  node.copy
end

#visit_instance_variable_target_node(node) ⇒ Object

Copy a InstanceVariableTargetNode node



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

def visit_instance_variable_target_node(node)
  node.copy
end

#visit_instance_variable_write_node(node) ⇒ Object

Copy a InstanceVariableWriteNode node



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

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

#visit_integer_node(node) ⇒ Object

Copy a IntegerNode node



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

def visit_integer_node(node)
  node.copy
end

#visit_interpolated_match_last_line_node(node) ⇒ Object

Copy a InterpolatedMatchLastLineNode node



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

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



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

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



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

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

#visit_interpolated_symbol_node(node) ⇒ Object

Copy a InterpolatedSymbolNode node



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

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



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

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

#visit_keyword_hash_node(node) ⇒ Object

Copy a KeywordHashNode node



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

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



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

def visit_keyword_rest_parameter_node(node)
  node.copy
end

#visit_lambda_node(node) ⇒ Object

Copy a LambdaNode node



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

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



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

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



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

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



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

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



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

def visit_local_variable_read_node(node)
  node.copy
end

#visit_local_variable_target_node(node) ⇒ Object

Copy a LocalVariableTargetNode node



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

def visit_local_variable_target_node(node)
  node.copy
end

#visit_local_variable_write_node(node) ⇒ Object

Copy a LocalVariableWriteNode node



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

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



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

def visit_match_last_line_node(node)
  node.copy
end

#visit_match_predicate_node(node) ⇒ Object

Copy a MatchPredicateNode node



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

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



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

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



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

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



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

def visit_missing_node(node)
  node.copy
end

#visit_module_node(node) ⇒ Object

Copy a ModuleNode node



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

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



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

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



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

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



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

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

#visit_nil_node(node) ⇒ Object

Copy a NilNode node



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

def visit_nil_node(node)
  node.copy
end

#visit_no_keywords_parameter_node(node) ⇒ Object

Copy a NoKeywordsParameterNode node



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

def visit_no_keywords_parameter_node(node)
  node.copy
end

#visit_numbered_parameters_node(node) ⇒ Object

Copy a NumberedParametersNode node



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

def visit_numbered_parameters_node(node)
  node.copy
end

#visit_numbered_reference_read_node(node) ⇒ Object

Copy a NumberedReferenceReadNode node



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

def visit_numbered_reference_read_node(node)
  node.copy
end

#visit_optional_keyword_parameter_node(node) ⇒ Object

Copy a OptionalKeywordParameterNode node



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

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

#visit_optional_parameter_node(node) ⇒ Object

Copy a OptionalParameterNode node



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

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

#visit_or_node(node) ⇒ Object

Copy a OrNode node



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

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



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

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



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

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

#visit_pinned_expression_node(node) ⇒ Object

Copy a PinnedExpressionNode node



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

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

#visit_pinned_variable_node(node) ⇒ Object

Copy a PinnedVariableNode node



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

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

#visit_post_execution_node(node) ⇒ Object

Copy a PostExecutionNode node



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

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

#visit_pre_execution_node(node) ⇒ Object

Copy a PreExecutionNode node



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

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

#visit_program_node(node) ⇒ Object

Copy a ProgramNode node



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

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

#visit_range_node(node) ⇒ Object

Copy a RangeNode node



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

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



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

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

#visit_redo_node(node) ⇒ Object

Copy a RedoNode node



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

def visit_redo_node(node)
  node.copy
end

#visit_regular_expression_node(node) ⇒ Object

Copy a RegularExpressionNode node



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

def visit_regular_expression_node(node)
  node.copy
end

#visit_required_keyword_parameter_node(node) ⇒ Object

Copy a RequiredKeywordParameterNode node



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

def visit_required_keyword_parameter_node(node)
  node.copy
end

#visit_required_parameter_node(node) ⇒ Object

Copy a RequiredParameterNode node



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

def visit_required_parameter_node(node)
  node.copy
end

#visit_rescue_modifier_node(node) ⇒ Object

Copy a RescueModifierNode node



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

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



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

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

#visit_rest_parameter_node(node) ⇒ Object

Copy a RestParameterNode node



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

def visit_rest_parameter_node(node)
  node.copy
end

#visit_retry_node(node) ⇒ Object

Copy a RetryNode node



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

def visit_retry_node(node)
  node.copy
end

#visit_return_node(node) ⇒ Object

Copy a ReturnNode node



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

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

#visit_self_node(node) ⇒ Object

Copy a SelfNode node



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

def visit_self_node(node)
  node.copy
end

#visit_singleton_class_node(node) ⇒ Object

Copy a SingletonClassNode node



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

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



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

def visit_source_encoding_node(node)
  node.copy
end

#visit_source_file_node(node) ⇒ Object

Copy a SourceFileNode node



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

def visit_source_file_node(node)
  node.copy
end

#visit_source_line_node(node) ⇒ Object

Copy a SourceLineNode node



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

def visit_source_line_node(node)
  node.copy
end

#visit_splat_node(node) ⇒ Object

Copy a SplatNode node



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

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

#visit_statements_node(node) ⇒ Object

Copy a StatementsNode node



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

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

#visit_string_node(node) ⇒ Object

Copy a StringNode node



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

def visit_string_node(node)
  node.copy
end

#visit_super_node(node) ⇒ Object

Copy a SuperNode node



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

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



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

def visit_symbol_node(node)
  node.copy
end

#visit_true_node(node) ⇒ Object

Copy a TrueNode node



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

def visit_true_node(node)
  node.copy
end

#visit_undef_node(node) ⇒ Object

Copy a UndefNode node



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

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

#visit_unless_node(node) ⇒ Object

Copy a UnlessNode node



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

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

#visit_until_node(node) ⇒ Object

Copy a UntilNode node



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

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



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

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



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

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



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

def visit_x_string_node(node)
  node.copy
end

#visit_yield_node(node) ⇒ Object

Copy a YieldNode node



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

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