Class: SyntaxTree::Visitor::MutationVisitor

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

Overview

This visitor walks through the tree and copies each node as it is being visited. This is useful for mutating the tree before it is formatted.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from BasicVisitor

#visit_all, #visit_child_nodes, visit_method, visit_methods

Constructor Details

#initialize ⇒ MutationVisitor

Returns a new instance of MutationVisitor.



10
11
12
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 10

def initialize
  @mutations = []
end

Instance Attribute Details

#mutations ⇒ Object (readonly)

Returns the value of attribute mutations.



8
9
10
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 8

def mutations
  @mutations
end

Instance Method Details

#mutate(query, &block) ⇒ Object

Create a new mutation based on the given query that will mutate the node using the given block. The block should return a new node that will take the place of the given node in the tree. These blocks frequently make use of the ‘copy` method on nodes to create a new node with the same properties as the original node.



19
20
21
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 19

def mutate(query, &block)
  mutations << [Pattern.new(query).compile, block]
end

#visit(node) ⇒ Object

This is the base visit method for each node in the tree. It first creates a copy of the node using the visit_* methods defined below. Then it checks each mutation in sequence and calls it if it finds a match.



26
27
28
29
30
31
32
33
34
35
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 26

def visit(node)
  return unless node
  result = node.accept(self)

  mutations.each do |(pattern, mutation)|
    result = mutation.call(result) if pattern.call(result)
  end

  result
end

#visit___end__(node) ⇒ Object

Visit a EndContent node.



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

def visit___end__(node)
  node.copy
end

#visit_alias(node) ⇒ Object

Visit a AliasNode node.



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

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

#visit_aref(node) ⇒ Object

Visit a ARef node.



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

def visit_aref(node)
  node.copy(index: visit(node.index))
end

#visit_aref_field(node) ⇒ Object

Visit a ARefField node.



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

def visit_aref_field(node)
  node.copy(index: visit(node.index))
end

#visit_arg_block(node) ⇒ Object

Visit a ArgBlock node.



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

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

#visit_arg_paren(node) ⇒ Object

Visit a ArgParen node.



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

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

#visit_arg_star(node) ⇒ Object

Visit a ArgStar node.



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

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

#visit_args(node) ⇒ Object

Visit a Args node.



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

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

#visit_args_forward(node) ⇒ Object

Visit a ArgsForward node.



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

def visit_args_forward(node)
  node.copy
end

#visit_array(node) ⇒ Object

Visit a ArrayLiteral node.



104
105
106
107
108
109
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 104

def visit_array(node)
  node.copy(
    lbracket: visit(node.lbracket),
    contents: visit(node.contents)
  )
end

#visit_aryptn(node) ⇒ Object

Visit a AryPtn node.



112
113
114
115
116
117
118
119
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 112

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

#visit_assign(node) ⇒ Object

Visit a Assign node.



122
123
124
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 122

def visit_assign(node)
  node.copy(target: visit(node.target))
end

#visit_assoc(node) ⇒ Object

Visit a Assoc node.



127
128
129
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 127

def visit_assoc(node)
  node.copy
end

#visit_assoc_splat(node) ⇒ Object

Visit a AssocSplat node.



132
133
134
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 132

def visit_assoc_splat(node)
  node.copy
end

#visit_backref(node) ⇒ Object

Visit a Backref node.



137
138
139
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 137

def visit_backref(node)
  node.copy
end

#visit_backtick(node) ⇒ Object

Visit a Backtick node.



142
143
144
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 142

def visit_backtick(node)
  node.copy
end

#visit_bare_assoc_hash(node) ⇒ Object

Visit a BareAssocHash node.



147
148
149
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 147

def visit_bare_assoc_hash(node)
  node.copy(assocs: visit_all(node.assocs))
end

#visit_BEGIN(node) ⇒ Object

Visit a BEGINBlock node.



38
39
40
41
42
43
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 38

def visit_BEGIN(node)
  node.copy(
    lbrace: visit(node.lbrace),
    statements: visit(node.statements)
  )
end

#visit_begin(node) ⇒ Object

Visit a Begin node.



152
153
154
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 152

def visit_begin(node)
  node.copy(bodystmt: visit(node.bodystmt))
end

#visit_binary(node) ⇒ Object

Visit a Binary node.



162
163
164
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 162

def visit_binary(node)
  node.copy
end

#visit_block(node) ⇒ Object

Visit a Block node.



295
296
297
298
299
300
301
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 295

def visit_block(node)
  node.copy(
    opening: visit(node.opening),
    block_var: visit(node.block_var),
    bodystmt: visit(node.bodystmt)
  )
end

#visit_block_var(node) ⇒ Object

Visit a BlockVar node.



167
168
169
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 167

def visit_block_var(node)
  node.copy(params: visit(node.params), locals: visit_all(node.locals))
end

#visit_blockarg(node) ⇒ Object

Visit a BlockArg node.



172
173
174
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 172

def visit_blockarg(node)
  node.copy(name: visit(node.name))
end

#visit_bodystmt(node) ⇒ Object

Visit a BodyStmt node.



177
178
179
180
181
182
183
184
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 177

def visit_bodystmt(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_break(node) ⇒ Object

Visit a Break node.



187
188
189
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 187

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

#visit_call(node) ⇒ Object

Visit a Call node.



192
193
194
195
196
197
198
199
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 192

def visit_call(node)
  node.copy(
    receiver: visit(node.receiver),
    operator: node.operator == :"::" ? :"::" : visit(node.operator),
    message: node.message == :call ? :call : visit(node.message),
    arguments: visit(node.arguments)
  )
end

#visit_case(node) ⇒ Object

Visit a Case node.



202
203
204
205
206
207
208
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 202

def visit_case(node)
  node.copy(
    keyword: visit(node.keyword),
    value: visit(node.value),
    consequent: visit(node.consequent)
  )
end

#visit_CHAR(node) ⇒ Object

Visit a CHAR node.



46
47
48
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 46

def visit_CHAR(node)
  node.copy
end

#visit_class(node) ⇒ Object

Visit a ClassDeclaration node.



216
217
218
219
220
221
222
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 216

def visit_class(node)
  node.copy(
    constant: visit(node.constant),
    superclass: visit(node.superclass),
    bodystmt: visit(node.bodystmt)
  )
end

#visit_comma(node) ⇒ Object

Visit a Comma node.



225
226
227
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 225

def visit_comma(node)
  node.copy
end

#visit_command(node) ⇒ Object

Visit a Command node.



230
231
232
233
234
235
236
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 230

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

#visit_command_call(node) ⇒ Object

Visit a CommandCall node.



239
240
241
242
243
244
245
246
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 239

def visit_command_call(node)
  node.copy(
    operator: node.operator == :"::" ? :"::" : visit(node.operator),
    message: visit(node.message),
    arguments: visit(node.arguments),
    block: visit(node.block)
  )
end

#visit_comment(node) ⇒ Object

Visit a Comment node.



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

def visit_comment(node)
  node.copy
end

#visit_const(node) ⇒ Object

Visit a Const node.



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

def visit_const(node)
  node.copy
end

#visit_const_path_field(node) ⇒ Object

Visit a ConstPathField node.



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

def visit_const_path_field(node)
  node.copy(constant: visit(node.constant))
end

#visit_const_path_ref(node) ⇒ Object

Visit a ConstPathRef node.



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

def visit_const_path_ref(node)
  node.copy(constant: visit(node.constant))
end

#visit_const_ref(node) ⇒ Object

Visit a ConstRef node.



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

def visit_const_ref(node)
  node.copy(constant: visit(node.constant))
end

#visit_cvar(node) ⇒ Object

Visit a CVar node.



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

def visit_cvar(node)
  node.copy
end

#visit_def(node) ⇒ Object

Visit a Def node.



279
280
281
282
283
284
285
286
287
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 279

def visit_def(node)
  node.copy(
    target: visit(node.target),
    operator: visit(node.operator),
    name: visit(node.name),
    params: visit(node.params),
    bodystmt: visit(node.bodystmt)
  )
end

#visit_defined(node) ⇒ Object

Visit a Defined node.



290
291
292
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 290

def visit_defined(node)
  node.copy
end

#visit_dyna_symbol(node) ⇒ Object

Visit a DynaSymbol node.



313
314
315
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 313

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

#visit_else(node) ⇒ Object

Visit a Else node.



318
319
320
321
322
323
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 318

def visit_else(node)
  node.copy(
    keyword: visit(node.keyword),
    statements: visit(node.statements)
  )
end

#visit_elsif(node) ⇒ Object

Visit a Elsif node.



326
327
328
329
330
331
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 326

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

#visit_embdoc(node) ⇒ Object

Visit a EmbDoc node.



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

def visit_embdoc(node)
  node.copy
end

#visit_embexpr_beg(node) ⇒ Object

Visit a EmbExprBeg node.



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

def visit_embexpr_beg(node)
  node.copy
end

#visit_embexpr_end(node) ⇒ Object

Visit a EmbExprEnd node.



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

def visit_embexpr_end(node)
  node.copy
end

#visit_embvar(node) ⇒ Object

Visit a EmbVar node.



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

def visit_embvar(node)
  node.copy
end

#visit_END(node) ⇒ Object

Visit a ENDBlock node.



51
52
53
54
55
56
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 51

def visit_END(node)
  node.copy(
    lbrace: visit(node.lbrace),
    statements: visit(node.statements)
  )
end

#visit_ensure(node) ⇒ Object

Visit a Ensure node.



354
355
356
357
358
359
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 354

def visit_ensure(node)
  node.copy(
    keyword: visit(node.keyword),
    statements: visit(node.statements)
  )
end

#visit_excessed_comma(node) ⇒ Object

Visit a ExcessedComma node.



362
363
364
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 362

def visit_excessed_comma(node)
  node.copy
end

#visit_field(node) ⇒ Object

Visit a Field node.



367
368
369
370
371
372
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 367

def visit_field(node)
  node.copy(
    operator: node.operator == :"::" ? :"::" : visit(node.operator),
    name: visit(node.name)
  )
end

#visit_float(node) ⇒ Object

Visit a FloatLiteral node.



375
376
377
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 375

def visit_float(node)
  node.copy
end

#visit_fndptn(node) ⇒ Object

Visit a FndPtn node.



380
381
382
383
384
385
386
387
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 380

def visit_fndptn(node)
  node.copy(
    constant: visit(node.constant),
    left: visit(node.left),
    values: visit_all(node.values),
    right: visit(node.right)
  )
end

#visit_for(node) ⇒ Object

Visit a For node.



390
391
392
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 390

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

#visit_gvar(node) ⇒ Object

Visit a GVar node.



395
396
397
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 395

def visit_gvar(node)
  node.copy
end

#visit_hash(node) ⇒ Object

Visit a HashLiteral node.



400
401
402
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 400

def visit_hash(node)
  node.copy(lbrace: visit(node.lbrace), assocs: visit_all(node.assocs))
end

#visit_heredoc(node) ⇒ Object

Visit a Heredoc node.



405
406
407
408
409
410
411
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 405

def visit_heredoc(node)
  node.copy(
    beginning: visit(node.beginning),
    ending: visit(node.ending),
    parts: visit_all(node.parts)
  )
end

#visit_heredoc_beg(node) ⇒ Object

Visit a HeredocBeg node.



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

def visit_heredoc_beg(node)
  node.copy
end

#visit_heredoc_end(node) ⇒ Object

Visit a HeredocEnd node.



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

def visit_heredoc_end(node)
  node.copy
end

#visit_hshptn(node) ⇒ Object

Visit a HshPtn node.



424
425
426
427
428
429
430
431
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 424

def visit_hshptn(node)
  node.copy(
    constant: visit(node.constant),
    keywords:
      node.keywords.map { |label, value| [visit(label), visit(value)] },
    keyword_rest: visit(node.keyword_rest)
  )
end

#visit_ident(node) ⇒ Object

Visit a Ident node.



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

def visit_ident(node)
  node.copy
end

#visit_if(node) ⇒ Object

Visit a IfNode node.



439
440
441
442
443
444
445
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 439

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

#visit_if_op(node) ⇒ Object

Visit a IfOp node.



448
449
450
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 448

def visit_if_op(node)
  node.copy
end

#visit_imaginary(node) ⇒ Object

Visit a Imaginary node.



453
454
455
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 453

def visit_imaginary(node)
  node.copy
end

#visit_in(node) ⇒ Object

Visit a In node.



458
459
460
461
462
463
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 458

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

#visit_int(node) ⇒ Object

Visit a Int node.



466
467
468
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 466

def visit_int(node)
  node.copy
end

#visit_ivar(node) ⇒ Object

Visit a IVar node.



471
472
473
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 471

def visit_ivar(node)
  node.copy
end

#visit_kw(node) ⇒ Object

Visit a Kw node.



476
477
478
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 476

def visit_kw(node)
  node.copy
end

#visit_kwrest_param(node) ⇒ Object

Visit a KwRestParam node.



481
482
483
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 481

def visit_kwrest_param(node)
  node.copy(name: visit(node.name))
end

#visit_label(node) ⇒ Object

Visit a Label node.



486
487
488
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 486

def visit_label(node)
  node.copy
end

#visit_label_end(node) ⇒ Object

Visit a LabelEnd node.



491
492
493
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 491

def visit_label_end(node)
  node.copy
end

#visit_lambda(node) ⇒ Object

Visit a Lambda node.



496
497
498
499
500
501
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 496

def visit_lambda(node)
  node.copy(
    params: visit(node.params),
    statements: visit(node.statements)
  )
end

#visit_lambda_var(node) ⇒ Object

Visit a LambdaVar node.



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

def visit_lambda_var(node)
  node.copy(params: visit(node.params), locals: visit_all(node.locals))
end

#visit_lbrace(node) ⇒ Object

Visit a LBrace node.



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

def visit_lbrace(node)
  node.copy
end

#visit_lbracket(node) ⇒ Object

Visit a LBracket node.



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

def visit_lbracket(node)
  node.copy
end

#visit_lparen(node) ⇒ Object

Visit a LParen node.



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

def visit_lparen(node)
  node.copy
end

#visit_massign(node) ⇒ Object

Visit a MAssign node.



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

def visit_massign(node)
  node.copy(target: visit(node.target))
end

#visit_method_add_block(node) ⇒ Object

Visit a MethodAddBlock node.



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

def visit_method_add_block(node)
  node.copy(call: visit(node.call), block: visit(node.block))
end

#visit_mlhs(node) ⇒ Object

Visit a MLHS node.



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

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

#visit_mlhs_paren(node) ⇒ Object

Visit a MLHSParen node.



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

def visit_mlhs_paren(node)
  node.copy(contents: visit(node.contents))
end

#visit_module(node) ⇒ Object

Visit a ModuleDeclaration node.



544
545
546
547
548
549
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 544

def visit_module(node)
  node.copy(
    constant: visit(node.constant),
    bodystmt: visit(node.bodystmt)
  )
end

#visit_mrhs(node) ⇒ Object

Visit a MRHS node.



552
553
554
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 552

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

#visit_next(node) ⇒ Object

Visit a Next node.



557
558
559
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 557

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

#visit_not(node) ⇒ Object

Visit a Not node.



812
813
814
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 812

def visit_not(node)
  node.copy(statement: visit(node.statement))
end

#visit_op(node) ⇒ Object

Visit a Op node.



562
563
564
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 562

def visit_op(node)
  node.copy
end

#visit_opassign(node) ⇒ Object

Visit a OpAssign node.



567
568
569
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 567

def visit_opassign(node)
  node.copy(target: visit(node.target), operator: visit(node.operator))
end

#visit_params(node) ⇒ Object

Visit a Params node.



572
573
574
575
576
577
578
579
580
581
582
583
584
585
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 572

def visit_params(node)
  node.copy(
    requireds: visit_all(node.requireds),
    optionals:
      node.optionals.map { |ident, value| [visit(ident), visit(value)] },
    rest: visit(node.rest),
    posts: visit_all(node.posts),
    keywords:
      node.keywords.map { |ident, value| [visit(ident), visit(value)] },
    keyword_rest:
      node.keyword_rest == :nil ? :nil : visit(node.keyword_rest),
    block: visit(node.block)
  )
end

#visit_paren(node) ⇒ Object

Visit a Paren node.



588
589
590
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 588

def visit_paren(node)
  node.copy(lparen: visit(node.lparen), contents: visit(node.contents))
end

#visit_period(node) ⇒ Object

Visit a Period node.



593
594
595
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 593

def visit_period(node)
  node.copy
end

#visit_pinned_begin(node) ⇒ Object

Visit a PinnedBegin node.



157
158
159
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 157

def visit_pinned_begin(node)
  node.copy
end

#visit_pinned_var_ref(node) ⇒ Object

Visit a PinnedVarRef node.



854
855
856
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 854

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

#visit_program(node) ⇒ Object

Visit a Program node.



598
599
600
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 598

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

#visit_qsymbols(node) ⇒ Object

Visit a QSymbols node.



603
604
605
606
607
608
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 603

def visit_qsymbols(node)
  node.copy(
    beginning: visit(node.beginning),
    elements: visit_all(node.elements)
  )
end

#visit_qsymbols_beg(node) ⇒ Object

Visit a QSymbolsBeg node.



611
612
613
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 611

def visit_qsymbols_beg(node)
  node.copy
end

#visit_qwords(node) ⇒ Object

Visit a QWords node.



616
617
618
619
620
621
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 616

def visit_qwords(node)
  node.copy(
    beginning: visit(node.beginning),
    elements: visit_all(node.elements)
  )
end

#visit_qwords_beg(node) ⇒ Object

Visit a QWordsBeg node.



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

def visit_qwords_beg(node)
  node.copy
end

#visit_range(node) ⇒ Object

Visit a RangeNode node.



304
305
306
307
308
309
310
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 304

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

#visit_rassign(node) ⇒ Object

Visit a RAssign node.



211
212
213
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 211

def visit_rassign(node)
  node.copy(operator: visit(node.operator))
end

#visit_rational(node) ⇒ Object

Visit a RationalLiteral node.



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

def visit_rational(node)
  node.copy
end

#visit_rbrace(node) ⇒ Object

Visit a RBrace node.



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

def visit_rbrace(node)
  node.copy
end

#visit_rbracket(node) ⇒ Object

Visit a RBracket node.



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

def visit_rbracket(node)
  node.copy
end

#visit_redo(node) ⇒ Object

Visit a Redo node.



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

def visit_redo(node)
  node.copy
end

#visit_regexp_beg(node) ⇒ Object

Visit a RegexpBeg node.



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

def visit_regexp_beg(node)
  node.copy
end

#visit_regexp_content(node) ⇒ Object

Visit a RegexpContent node.



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

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

#visit_regexp_end(node) ⇒ Object

Visit a RegexpEnd node.



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

def visit_regexp_end(node)
  node.copy
end

#visit_regexp_literal(node) ⇒ Object

Visit a RegexpLiteral node.



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

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

#visit_rescue(node) ⇒ Object

Visit a Rescue node.



674
675
676
677
678
679
680
681
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 674

def visit_rescue(node)
  node.copy(
    keyword: visit(node.keyword),
    exception: visit(node.exception),
    statements: visit(node.statements),
    consequent: visit(node.consequent)
  )
end

#visit_rescue_ex(node) ⇒ Object

Visit a RescueEx node.



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

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

#visit_rescue_mod(node) ⇒ Object

Visit a RescueMod node.



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

def visit_rescue_mod(node)
  node.copy
end

#visit_rest_param(node) ⇒ Object

Visit a RestParam node.



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

def visit_rest_param(node)
  node.copy(name: visit(node.name))
end

#visit_retry(node) ⇒ Object

Visit a Retry node.



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

def visit_retry(node)
  node.copy
end

#visit_return(node) ⇒ Object

Visit a Return node.



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

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

#visit_rparen(node) ⇒ Object

Visit a RParen node.



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

def visit_rparen(node)
  node.copy
end

#visit_sclass(node) ⇒ Object

Visit a SClass node.



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

def visit_sclass(node)
  node.copy(bodystmt: visit(node.bodystmt))
end

#visit_statements(node) ⇒ Object

Visit a Statements node.



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

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

#visit_string_concat(node) ⇒ Object

Visit a StringConcat node.



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

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

#visit_string_content(node) ⇒ Object

Visit a StringContent node.



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

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

#visit_string_dvar(node) ⇒ Object

Visit a StringDVar node.



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

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

#visit_string_embexpr(node) ⇒ Object

Visit a StringEmbExpr node.



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

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

#visit_string_literal(node) ⇒ Object

Visit a StringLiteral node.



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

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

#visit_super(node) ⇒ Object

Visit a Super node.



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

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

#visit_symbeg(node) ⇒ Object

Visit a SymBeg node.



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

def visit_symbeg(node)
  node.copy
end

#visit_symbol_content(node) ⇒ Object

Visit a SymbolContent node.



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

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

#visit_symbol_literal(node) ⇒ Object

Visit a SymbolLiteral node.



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

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

#visit_symbols(node) ⇒ Object

Visit a Symbols node.



764
765
766
767
768
769
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 764

def visit_symbols(node)
  node.copy(
    beginning: visit(node.beginning),
    elements: visit_all(node.elements)
  )
end

#visit_symbols_beg(node) ⇒ Object

Visit a SymbolsBeg node.



772
773
774
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 772

def visit_symbols_beg(node)
  node.copy
end

#visit_tlambda(node) ⇒ Object

Visit a TLambda node.



777
778
779
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 777

def visit_tlambda(node)
  node.copy
end

#visit_tlambeg(node) ⇒ Object

Visit a TLamBeg node.



782
783
784
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 782

def visit_tlambeg(node)
  node.copy
end

#visit_top_const_field(node) ⇒ Object

Visit a TopConstField node.



787
788
789
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 787

def visit_top_const_field(node)
  node.copy(constant: visit(node.constant))
end

#visit_top_const_ref(node) ⇒ Object

Visit a TopConstRef node.



792
793
794
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 792

def visit_top_const_ref(node)
  node.copy(constant: visit(node.constant))
end

#visit_tstring_beg(node) ⇒ Object

Visit a TStringBeg node.



797
798
799
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 797

def visit_tstring_beg(node)
  node.copy
end

#visit_tstring_content(node) ⇒ Object

Visit a TStringContent node.



802
803
804
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 802

def visit_tstring_content(node)
  node.copy
end

#visit_tstring_end(node) ⇒ Object

Visit a TStringEnd node.



807
808
809
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 807

def visit_tstring_end(node)
  node.copy
end

#visit_unary(node) ⇒ Object

Visit a Unary node.



817
818
819
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 817

def visit_unary(node)
  node.copy
end

#visit_undef(node) ⇒ Object

Visit a Undef node.



822
823
824
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 822

def visit_undef(node)
  node.copy(symbols: visit_all(node.symbols))
end

#visit_unless(node) ⇒ Object

Visit a UnlessNode node.



827
828
829
830
831
832
833
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 827

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

#visit_until(node) ⇒ Object

Visit a UntilNode node.



836
837
838
839
840
841
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 836

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

#visit_var_field(node) ⇒ Object

Visit a VarField node.



844
845
846
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 844

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

#visit_var_ref(node) ⇒ Object

Visit a VarRef node.



849
850
851
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 849

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

#visit_vcall(node) ⇒ Object

Visit a VCall node.



859
860
861
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 859

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

#visit_void_stmt(node) ⇒ Object

Visit a VoidStmt node.



864
865
866
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 864

def visit_void_stmt(node)
  node.copy
end

#visit_when(node) ⇒ Object

Visit a When node.



869
870
871
872
873
874
875
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 869

def visit_when(node)
  node.copy(
    arguments: visit(node.arguments),
    statements: visit(node.statements),
    consequent: visit(node.consequent)
  )
end

#visit_while(node) ⇒ Object

Visit a WhileNode node.



878
879
880
881
882
883
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 878

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

#visit_word(node) ⇒ Object

Visit a Word node.



886
887
888
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 886

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

#visit_words(node) ⇒ Object

Visit a Words node.



891
892
893
894
895
896
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 891

def visit_words(node)
  node.copy(
    beginning: visit(node.beginning),
    elements: visit_all(node.elements)
  )
end

#visit_words_beg(node) ⇒ Object

Visit a WordsBeg node.



899
900
901
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 899

def visit_words_beg(node)
  node.copy
end

#visit_xstring(node) ⇒ Object

Visit a XString node.



904
905
906
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 904

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

#visit_xstring_literal(node) ⇒ Object

Visit a XStringLiteral node.



909
910
911
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 909

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

#visit_yield(node) ⇒ Object

Visit a YieldNode node.



914
915
916
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 914

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

#visit_zsuper(node) ⇒ Object

Visit a ZSuper node.



919
920
921
 
# File 'lib/syntax_tree/visitor/mutation_visitor.rb', line 919

def visit_zsuper(node)
  node.copy
end