Class: SyntaxTree::Translator::RubyParser

Inherits:
Visitor
  • Object
show all
Defined in:
lib/syntax_tree/translator/ruby_parser.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ RubyParser

Returns a new instance of RubyParser.



8
9
10
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 8

def initialize
  @stack = []
end

Instance Attribute Details

#stack ⇒ Object (readonly)

Returns the value of attribute stack.



6
7
8
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 6

def stack
  @stack
end

Instance Method Details

#visit(node) ⇒ Object 



12
13
14
15
16
17
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 12

def visit(node)
  stack << node
  result = super
  stack.pop
  result
end

#visit___end__(node) ⇒ Object

Visit an EndContent node.



1040
1041
1042
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1040

def visit___end__(node)
  raise
end

#visit_alias(node) ⇒ Object

Visit an Alias node.



40
41
42
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 40

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

#visit_aref(node) ⇒ Object

Visit an ARef node.



20
21
22
23
24
25
26
27
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 20

def visit_aref(node)
  case node
  in { index: Args[parts: [part]] }
    s(:call, visit(node.collection), :[], visit(part))
  in { index: nil }
    s(:call, visit(node.collection), :[])
  end
end

#visit_aref_field(node) ⇒ Object

Visit an ARefField node.



30
31
32
33
34
35
36
37
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 30

def visit_aref_field(node)
  case node
  in { index: Args[parts: [part]] }
    s(:attrasgn, visit(node.collection), :[]=, visit(part))
  in { index: nil }
    s(:attrasgn, visit(node.collection), :[]=)
  end
end

#visit_arg_block(node) ⇒ Object

Visit an ArgBlock node.



45
46
47
48
49
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 45

def visit_arg_block(node)
  children = []
  children << visit(node.value) if node.value
  s(:block_pass, *children)
end

#visit_arg_paren(node) ⇒ Object

Visit an ArgParen node.



52
53
54
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 52

def visit_arg_paren(node)
  raise
end

#visit_arg_star(node) ⇒ Object

Visit an ArgStar node.



57
58
59
60
61
62
63
64
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 57

def visit_arg_star(node)
  case node
  in { value: nil | Ident }
    :"*#{visit(node.value)}"
  else
    s(:splat, visit(node.value))
  end
end

#visit_args(node) ⇒ Object

Visit an Args node.



67
68
69
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 67

def visit_args(node)
  s(:args, *visit_all(node.parts))
end

#visit_args_forward(node) ⇒ Object

Visit an ArgsForward node.



72
73
74
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 72

def visit_args_forward(node)
  raise
end

#visit_array(node) ⇒ Object

Visit an ArrayLiteral node.



77
78
79
80
81
82
83
84
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 77

def visit_array(node)
  case node
  in { contents: nil }
    s(:array)
  in { contents: }
    s(:array, *visit(contents)[1..])
  end
end

#visit_aryptn(node) ⇒ Object

Visit an AryPtn node.



87
88
89
90
91
92
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 87

def visit_aryptn(node)
  children = [visit(node.constant)] + visit_all(node.requireds)
  children << visit(node.rest) if node.rest
  children += visit_all(node.posts)
  s(:array_pat, *children)
end

#visit_assign(node) ⇒ Object

Visit an Assign node.



95
96
97
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 95

def visit_assign(node)
  s(*visit(node.target), visit(node.value))
end

#visit_assoc(node) ⇒ Object

Visit an Assoc node.



100
101
102
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 100

def visit_assoc(node)
  [visit(node.key), visit(node.value)]
end

#visit_assoc_splat(node) ⇒ Object

Visit an AssocSplat node.



105
106
107
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 105

def visit_assoc_splat(node)
  [s(:kwsplat, visit(node.value))]
end

#visit_backref(node) ⇒ Object

Visit a Backref node.



110
111
112
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 110

def visit_backref(node)
  node.value.to_sym
end

#visit_backtick(node) ⇒ Object

Visit a Backtick node.



115
116
117
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 115

def visit_backtick(node)
  raise
end

#visit_bare_assoc_hash(node) ⇒ Object

Visit a BareAssocHash node.



120
121
122
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 120

def visit_bare_assoc_hash(node)
  s(:hash, *visit_all(node.assocs).flatten(1))
end

#visit_BEGIN(node) ⇒ Object

Visit a BEGINBlock node.



125
126
127
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 125

def visit_BEGIN(node)
  s(:iter, s(:preexe), 0, visit(node.statements))
end

#visit_begin(node) ⇒ Object

Visit a Begin node.



130
131
132
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 130

def visit_begin(node)
  raise
end

#visit_binary(node) ⇒ Object

Visit a Binary node.



135
136
137
138
139
140
141
142
143
144
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 135

def visit_binary(node)
  case node
  in { operator: :and }
    s(:and, visit(node.left), visit(node.right))
  in { operator: :"!~" }
    s(:not, s(:call, visit(node.left), :=~, visit(node.right)))
  else
    s(:call, visit(node.left), node.operator, visit(node.right))
  end
end

#visit_block_var(node) ⇒ Object

Visit a BlockVar node.



152
153
154
155
156
157
158
159
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 152

def visit_block_var(node)
  case node
  in { locals: [] }
    s(*visit(node.params))
  else
    s(*visit(node.params), s(:shadow, *node.locals.map { |local| visit(local) }))
  end
end

#visit_blockarg(node) ⇒ Object

Visit a BlockArg node.



147
148
149
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 147

def visit_blockarg(node)
  :"&#{visit(node.name)}"
end

#visit_bodystmt(node) ⇒ Object

Visit a BodyStmt node.



162
163
164
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 162

def visit_bodystmt(node)
  visit(node.statements)
end

#visit_brace_block(node) ⇒ Object

Visit a BraceBlock node.



167
168
169
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 167

def visit_brace_block(node)
  raise
end

#visit_break(node) ⇒ Object

Visit a Break node.



172
173
174
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 172

def visit_break(node)
  s(:break, *visit(node.arguments)[1..])
end

#visit_call(node) ⇒ Object

Visit a Call node.



177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 177

def visit_call(node)
  case node
  in { message: :call, arguments: ArgParen[arguments: nil] }
    s(call_type(node.operator), visit(node.receiver), :call)
  in { message: :call, arguments: ArgParen[arguments: { parts: }] }
    s(call_type(node.operator), visit(node.receiver), :call, *visit_all(parts))
  in { arguments: nil | ArgParen[arguments: nil] }
    s(call_type(node.operator), visit(node.receiver), node.message.value.to_sym)
  in { arguments: Args[parts:] }
    s(call_type(node.operator), visit(node.receiver), node.message.value.to_sym, *visit_all(parts))
  in { arguments: ArgParen[arguments: { parts: }] }
    s(call_type(node.operator), visit(node.receiver), node.message.value.to_sym, *visit_all(parts))
  end
end

#visit_case(node) ⇒ Object

Visit a Case node.



193
194
195
196
197
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 193

def visit_case(node)
  clauses = [node.consequent]
  clauses << clauses.last.consequent while clauses.last && !(clauses.last in Else)
  s(:case, visit(node.value), *visit_all(clauses))
end

#visit_CHAR(node) ⇒ Object

Visit a CHAR node.



200
201
202
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 200

def visit_CHAR(node)
  s(:str, node.value[1..])
end

#visit_class(node) ⇒ Object

Visit a ClassDeclaration node.



205
206
207
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 205

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

#visit_comma(node) ⇒ Object

Visit a Comma node.



210
211
212
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 210

def visit_comma(node)
  raise
end

#visit_command(node) ⇒ Object

Visit a Command node.



215
216
217
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 215

def visit_command(node)
  s(:call, nil, node.message.value.to_sym, *visit_all(node.arguments.parts))
end

#visit_command_call(node) ⇒ Object

Visit a CommandCall node.



220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 220

def visit_command_call(node)
  arguments =
    case node
    in { arguments: nil }
      # do nothing
    in { arguments: Args[parts:] }
      visit_all(parts)
    in { arguments: ArgParen[arguments: { parts: }] }
      visit_all(parts)
    end

  s(call_type(node.operator), visit(node.receiver), visit(node.message), *arguments)
end

#visit_comment(node) ⇒ Object

Visit a Comment node.



235
236
237
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 235

def visit_comment(node)
  raise
end

#visit_const(node) ⇒ Object

Visit a Const node.



240
241
242
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 240

def visit_const(node)
  s(:const, node.value.to_sym)
end

#visit_const_path_field(node) ⇒ Object

Visit a ConstPathField node.



245
246
247
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 245

def visit_const_path_field(node)
  s(:colon2, visit(node.parent), node.constant.value.to_sym)
end

#visit_const_path_ref(node) ⇒ Object

Visit a ConstPathRef node.



250
251
252
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 250

def visit_const_path_ref(node)
  raise
end

#visit_const_ref(node) ⇒ Object

Visit a ConstRef node.



255
256
257
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 255

def visit_const_ref(node)
  node.constant.value.to_sym
end

#visit_cvar(node) ⇒ Object

Visit a CVar node.



260
261
262
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 260

def visit_cvar(node)
  s(:cvar, node.value.to_sym)
end

#visit_def(node) ⇒ Object

Visit a Def node.



265
266
267
268
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 265

def visit_def(node)
  args = (node.params in Params) ? node.params : node.params.contents
  s(:defn, node.name.value.to_sym, visit(args), visit(node.bodystmt))
end

#visit_def_endless(node) ⇒ Object

Visit a DefEndless node.



271
272
273
274
275
276
277
278
279
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 271

def visit_def_endless(node)
  children = []
  children << visit(node.target) if node.target

  args = (node.paren in Params) ? node.paren : node.paren.contents
  children += [node.name.value.to_sym, visit(args), visit(node.statement)]

  s(node.target ? :defs : :defn, *children)
end

#visit_defined(node) ⇒ Object

Visit a Defined node.



282
283
284
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 282

def visit_defined(node)
  s(:defined, visit(node.value))
end

#visit_defs(node) ⇒ Object

Visit a Defs node.



287
288
289
290
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 287

def visit_defs(node)
  args = (node.params in Params) ? node.params : node.params.contents
  s(:defs, visit(node.target), visit(node.name), visit(args), visit(node.bodystmt))
end

#visit_do_block(node) ⇒ Object

Visit a DoBlock node.



293
294
295
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 293

def visit_do_block(node)
  raise
end

#visit_dot2(node) ⇒ Object

Visit a Dot2 node.



298
299
300
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 298

def visit_dot2(node)
  s(:dot2, visit(node.left), visit(node.right))
end

#visit_dot3(node) ⇒ Object

Visit a Dot3 node.



303
304
305
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 303

def visit_dot3(node)
  s(:dot3, visit(node.left), visit(node.right))
end

#visit_dyna_symbol(node) ⇒ Object

Visit a DynaSymbol node.



308
309
310
311
312
313
314
315
316
317
318
319
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 308

def visit_dyna_symbol(node)
  case node
  in { parts: [] }
    s(:lit, :"")
  in { parts: [TStringContent => part] }
    s(:lit, part.value.to_sym)
  in { parts: [StringEmbExpr => part, *parts] }
    s(:dsym, "", visit(part), *visit_all(parts))
  else
    s(:dsym, *visit_all(node.parts))
  end
end

#visit_else(node) ⇒ Object

Visit an Else node.



327
328
329
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 327

def visit_else(node)
  visit(node.statements)
end

#visit_elsif(node) ⇒ Object

Visit an Elsif node.



332
333
334
335
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 332

def visit_elsif(node)
  statements = node.statements.empty? ? nil : visit(node.statements)
  s(:if, visit(node.predicate), statements, visit(node.consequent))
end

#visit_embdoc(node) ⇒ Object

Visit an EmbDoc node.



338
339
340
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 338

def visit_embdoc(node)
  raise
end

#visit_embexpr_beg(node) ⇒ Object

Visit an EmbExprBeg node.



343
344
345
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 343

def visit_embexpr_beg(node)
  raise
end

#visit_embexpr_end(node) ⇒ Object

Visit an EmbExprEnd node.



348
349
350
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 348

def visit_embexpr_end(node)
  raise
end

#visit_embvar(node) ⇒ Object

Visit an EmbVar node.



353
354
355
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 353

def visit_embvar(node)
  raise
end

#visit_END(node) ⇒ Object

Visit an ENDBlock node.



322
323
324
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 322

def visit_END(node)
  s(:iter, s(:postexe), 0, visit(node.statements))
end

#visit_ensure(node) ⇒ Object

Visit an Ensure node.



358
359
360
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 358

def visit_ensure(node)
  raise
end

#visit_excessed_comma(node) ⇒ Object

Visit an ExcessedComma node.



363
364
365
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 363

def visit_excessed_comma(node)
  raise
end

#visit_fcall(node) ⇒ Object

Visit a FCall node.



368
369
370
371
372
373
374
375
376
377
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 368

def visit_fcall(node)
  case node
  in { arguments: Args[parts: []] | ArgParen[arguments: nil] }
    s(:call, nil, node.value.value.to_sym)
  in { arguments: ArgParen[arguments: { parts: }] }
    s(:call, nil, node.value.value.to_sym, *visit_all(parts))
  in { arguments: ArgParen[arguments: ArgsForward] }
    s(:call, nil, node.value.value.to_sym, s(:forwarded_args))
  end
end

#visit_field(node) ⇒ Object

Visit a Field node.



380
381
382
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 380

def visit_field(node)
  s(:attrasgn, visit(node.parent), :"#{node.name.value}=")
end

#visit_float(node) ⇒ Object

Visit a FloatLiteral node.



385
386
387
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 385

def visit_float(node)
  s(:lit, node.value.to_f)
end

#visit_fndptn(node) ⇒ Object

Visit a FndPtn node.



390
391
392
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 390

def visit_fndptn(node)
  raise
end

#visit_for(node) ⇒ Object

Visit a For node.



395
396
397
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 395

def visit_for(node)
  raise
end

#visit_gvar(node) ⇒ Object

Visit a GVar node.



400
401
402
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 400

def visit_gvar(node)
  node.value.to_sym
end

#visit_hash(node) ⇒ Object

Visit a HashLiteral node.



405
406
407
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 405

def visit_hash(node)
  s(:hash, *visit_all(node.assocs).flatten(1))
end

#visit_heredoc(node) ⇒ Object

Visit a Heredoc node.



410
411
412
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 410

def visit_heredoc(node)
  raise
end

#visit_heredoc_beg(node) ⇒ Object

Visit a HeredocBeg node.



415
416
417
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 415

def visit_heredoc_beg(node)
  raise
end

#visit_hshptn(node) ⇒ Object

Visit a HshPtn node.



420
421
422
423
424
425
426
427
428
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 420

def visit_hshptn(node)
  children = [
    visit(node.constant),
    *node.keywords.flat_map { |(keyword, value)| [visit(keyword), visit(value)] }
  ]

  children << visit(node.keyword_rest) if node.keyword_rest
  s(:hash_pat, *children)
end

#visit_ident(node) ⇒ Object

Visit an Ident node.



431
432
433
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 431

def visit_ident(node)
  node.value.to_sym
end

#visit_if(node) ⇒ Object

Visit an If node.



436
437
438
439
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 436

def visit_if(node)
  statements = node.statements.empty? ? nil : visit(node.statements)
  s(:if, visit(node.predicate), statements, visit(node.consequent))
end

#visit_if_mod(node) ⇒ Object

Visit an IfMod node.



442
443
444
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 442

def visit_if_mod(node)
  s(:if, visit(node.predicate), visit(node.statement), nil)
end

#visit_if_op(node) ⇒ Object

Visit an IfOp node.



447
448
449
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 447

def visit_if_op(node)
  s(:if, visit(node.predicate), visit(node.truthy), visit(node.falsy))
end

#visit_imaginary(node) ⇒ Object

Visit an Imaginary node.



452
453
454
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 452

def visit_imaginary(node)
  s(:lit, eval(node.value))
end

#visit_in(node) ⇒ Object

Visit an In node.



457
458
459
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 457

def visit_in(node)
  s(:in, visit(node.pattern), visit(node.statements))
end

#visit_int(node) ⇒ Object

Visit an Int node.



462
463
464
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 462

def visit_int(node)
  s(:lit, node.value.to_i)
end

#visit_ivar(node) ⇒ Object

Visit an IVar node.



467
468
469
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 467

def visit_ivar(node)
  s(:ivar, node.value.to_sym)
end

#visit_kw(node) ⇒ Object

Visit a Kw node.



472
473
474
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 472

def visit_kw(node)
  s(node.value.to_sym)
end

#visit_kwrest_param(node) ⇒ Object

Visit a KwRestParam node.



477
478
479
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 477

def visit_kwrest_param(node)
  :"**#{visit(node.name)}"
end

#visit_label(node) ⇒ Object

Visit a Label node.



482
483
484
485
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 482

def visit_label(node)
  value = node.value.chomp(":").to_sym
  (stack[-2] in Params) ? value : s(:lit, value)
end

#visit_label_end(node) ⇒ Object

Visit a LabelEnd node.



488
489
490
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 488

def visit_label_end(node)
  raise
end

#visit_lambda(node) ⇒ Object

Visit a Lambda node.



493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 493

def visit_lambda(node)
  children = [s(:lambda)]

  case node
  in { params: Paren[contents: Params => params] } if params.empty?
    children << s(:args)
  in { params: Params => params } if params.empty?
    children << 0
  else
    children << visit(node.params)
  end

  children << visit(node.statements) unless node.statements.empty?

  s(:iter, *children)
end

#visit_lbrace(node) ⇒ Object

Visit a LBrace node.



511
512
513
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 511

def visit_lbrace(node)
  raise
end

#visit_lbracket(node) ⇒ Object

Visit a LBracket node.



516
517
518
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 516

def visit_lbracket(node)
  raise
end

#visit_lparen(node) ⇒ Object

Visit a LParen node.



521
522
523
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 521

def visit_lparen(node)
  raise
end

#visit_massign(node) ⇒ Object

Visit a MAssign node.



526
527
528
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 526

def visit_massign(node)
  s(:masgn, s(:array, visit(node.target)), s(:to_ary, visit(node.value)))
end

#visit_method_add_block(node) ⇒ Object

Visit a MethodAddBlock node.



531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 531

def visit_method_add_block(node)
  statements =
    if node.block in BraceBlock
      node.block.statements
    else
      node.block.bodystmt
    end

  block = statements.empty? ? nil : visit(statements)

  if node.call in Break | Next | Return | Yield
    type, *children = visit(node.call)
    s(type, s(:iter, *children, visit(node.block.block_var), *block))
  else
    s(:iter, visit(node.call), visit(node.block.block_var), *block)
  end
end

#visit_mlhs(node) ⇒ Object

Visit a MLHS node.



550
551
552
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 550

def visit_mlhs(node)
  s(:masgn, *visit_all(node.parts))
end

#visit_mlhs_paren(node) ⇒ Object

Visit a MLHSParen node.



555
556
557
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 555

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

#visit_module(node) ⇒ Object

Visit a ModuleDeclaration node.



560
561
562
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 560

def visit_module(node)
  raise
end

#visit_mrhs(node) ⇒ Object

Visit a MRHS node.



565
566
567
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 565

def visit_mrhs(node)
  s(:svalue, s(:array, *visit_all(node.parts)))
end

#visit_next(node) ⇒ Object

Visit a Next node.



570
571
572
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 570

def visit_next(node)
  s(:next, *visit(node.arguments)[1..])
end

#visit_not(node) ⇒ Object

Visit a Not node.



575
576
577
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 575

def visit_not(node)
  s(:call, visit(node.statement), :"!")
end

#visit_op(node) ⇒ Object

Visit an Op node.



580
581
582
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 580

def visit_op(node)
  node.value.to_sym
end

#visit_opassign(node) ⇒ Object

Visit an OpAssign node.



585
586
587
588
589
590
591
592
593
594
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 585

def visit_opassign(node)
  case node.operator
  in { value: "||=" }
    s(:op_asgn_or, visit(node.target), visit(node.value))
  in { value: "&&=" }
    s(:op_asgn_and, visit(node.target), visit(node.value))
  else
    s(:op_asgn, visit(node.target), node.operator.value.chomp("=").to_sym, visit(node.value))
  end
end

#visit_params(node) ⇒ Object

Visit a Params node.



597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 597

def visit_params(node)
  s(
    :args,
    *node.requireds.map { |required| visit(required) },
    *node.optionals.map { |(name, value)| s(:lasgn, visit(name), visit(value)) },
    *visit(node.rest),
    *node.posts.map { |post| visit(post) },
    *node.keywords.map do |(name, value)|
      children = [visit(name)]
      children << visit(value) if value
      s(:kwarg, *children)
    end,
    *visit(node.keyword_rest),
    *visit(node.block)
  )
end

#visit_paren(node) ⇒ Object

Visit a Paren node.



615
616
617
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 615

def visit_paren(node)
  visit(node.contents)
end

#visit_period(node) ⇒ Object

Visit a Period node.



620
621
622
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 620

def visit_period(node)
  raise
end

#visit_pinned_begin(node) ⇒ Object

Visit a PinnedBegin node.



625
626
627
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 625

def visit_pinned_begin(node)
  raise
end

#visit_pinned_var_ref(node) ⇒ Object

Visit a PinnedVarRef node.



630
631
632
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 630

def visit_pinned_var_ref(node)
  raise
end

#visit_program(node) ⇒ Object

Visit a Program node.



635
636
637
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 635

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

#visit_qsymbols(node) ⇒ Object

Visit a QSymbols node.



640
641
642
643
644
645
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 640

def visit_qsymbols(node)
  s(
    :array,
    *node.elements.map { |element| s(:lit, element.value.to_sym) }
  )
end

#visit_qsymbols_beg(node) ⇒ Object

Visit a QSymbolsBeg node.



648
649
650
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 648

def visit_qsymbols_beg(node)
  raise
end

#visit_qwords(node) ⇒ Object

Visit a QWords node.



653
654
655
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 653

def visit_qwords(node)
  s(:array, *visit_all(node.elements))
end

#visit_qwords_beg(node) ⇒ Object

Visit a QWordsBeg node.



658
659
660
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 658

def visit_qwords_beg(node)
  raise
end

#visit_rassign(node) ⇒ Object

Visit a RAssign node.



663
664
665
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 663

def visit_rassign(node)
  s(:case, visit(node.value), s(:in, visit(node.pattern), nil), nil)
end

#visit_rational(node) ⇒ Object

Visit a RationalLiteral node.



668
669
670
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 668

def visit_rational(node)
  s(:lit, node.value.to_r)
end

#visit_rbrace(node) ⇒ Object

Visit a RBrace node.



673
674
675
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 673

def visit_rbrace(node)
  raise
end

#visit_rbracket(node) ⇒ Object

Visit a RBracket node.



678
679
680
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 678

def visit_rbracket(node)
  raise
end

#visit_redo(node) ⇒ Object

Visit a Redo node.



683
684
685
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 683

def visit_redo(node)
  s(:redo)
end

#visit_regexp_beg(node) ⇒ Object

Visit a RegexpBeg node.



688
689
690
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 688

def visit_regexp_beg(node)
  raise
end

#visit_regexp_content(node) ⇒ Object

Visit a RegexpContent node.



693
694
695
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 693

def visit_regexp_content(node)
  raise
end

#visit_regexp_end(node) ⇒ Object

Visit a RegexpEnd node.



698
699
700
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 698

def visit_regexp_end(node)
  raise
end

#visit_regexp_literal(node) ⇒ Object

Visit a RegexpLiteral node.



703
704
705
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 703

def visit_regexp_literal(node)
  raise
end

#visit_rescue(node) ⇒ Object

Visit a Rescue node.



708
709
710
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 708

def visit_rescue(node)
  raise
end

#visit_rescue_ex(node) ⇒ Object

Visit a RescueEx node.



713
714
715
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 713

def visit_rescue_ex(node)
  raise
end

#visit_rescue_mod(node) ⇒ Object

Visit a RescueMod node.



718
719
720
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 718

def visit_rescue_mod(node)
  s(:rescue, visit(node.statement), s(:resbody, s(:array), visit(node.value)))
end

#visit_rest_param(node) ⇒ Object

Visit a RestParam node.



723
724
725
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 723

def visit_rest_param(node)
  :"*#{visit(node.name)}"
end

#visit_retry(node) ⇒ Object

Visit a Retry node.



728
729
730
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 728

def visit_retry(node)
  s(:retry)
end

#visit_return(node) ⇒ Object

Visit a Return node.



733
734
735
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 733

def visit_return(node)
  s(:return, *visit(node.arguments)[1..])
end

#visit_return0(node) ⇒ Object

Visit a Return0 node.



738
739
740
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 738

def visit_return0(node)
  s(:return)
end

#visit_rparen(node) ⇒ Object

Visit a RParen node.



743
744
745
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 743

def visit_rparen(node)
  raise
end

#visit_sclass(node) ⇒ Object

Visit a SClass node.



748
749
750
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 748

def visit_sclass(node)
  raise
end

#visit_statements(node) ⇒ Object

Visit a Statements node.



753
754
755
756
757
758
759
760
761
762
763
764
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 753

def visit_statements(node)
  children = node.body.reject { |child| child in Comment | EmbDoc | EndContent | VoidStmt }

  case children
  in []
    s(:nil)
  in [child]
    visit(child)
  else
    s(:block, *visit_all(children))
  end
end

#visit_string_concat(node) ⇒ Object

Visit a StringConcat node.



767
768
769
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 767

def visit_string_concat(node)
  raise
end

#visit_string_content(node) ⇒ Object

Visit a StringContent node.



772
773
774
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 772

def visit_string_content(node)
  raise
end

#visit_string_dvar(node) ⇒ Object

Visit a StringDVar node.



777
778
779
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 777

def visit_string_dvar(node)
  raise
end

#visit_string_embexpr(node) ⇒ Object

Visit a StringEmbExpr node.



782
783
784
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 782

def visit_string_embexpr(node)
  s(:evstr, visit(node.statements))
end

#visit_string_literal(node) ⇒ Object

Visit a StringLiteral node.



787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 787

def visit_string_literal(node)
  children = [+""]

  node.parts.each_with_index do |part, index|
    if children.last in String
      case part
      in StringEmbExpr[statements: { body: [StringLiteral[parts: [TStringContent => tstring]]] }]
        children.last << visit(tstring)
      in TStringContent
        children.last << visit(part)
      else
        children << visit(part)
      end
    else
      children << visit(part)
    end
  end

  case children
  in [String => child]
    s(:str, child)
  else
    s(:dstr, *children)
  end
end

#visit_super(node) ⇒ Object

Visit a Super node.



814
815
816
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 814

def visit_super(node)
  raise
end

#visit_symbeg(node) ⇒ Object

Visit a SymBeg node.



819
820
821
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 819

def visit_symbeg(node)
  raise
end

#visit_symbol_content(node) ⇒ Object

Visit a SymbolContent node.



824
825
826
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 824

def visit_symbol_content(node)
  raise
end

#visit_symbol_literal(node) ⇒ Object

Visit a SymbolLiteral node.



829
830
831
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 829

def visit_symbol_literal(node)
  s(:lit, node.value.value.to_sym)
end

#visit_symbols(node) ⇒ Object

Visit a Symbols node.



834
835
836
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 834

def visit_symbols(node)
  s(:array, *visit_all(node.elements))
end

#visit_symbols_beg(node) ⇒ Object

Visit a SymbolsBeg node.



839
840
841
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 839

def visit_symbols_beg(node)
  raise
end

#visit_tlambda(node) ⇒ Object

Visit a TLambda node.



844
845
846
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 844

def visit_tlambda(node)
  raise
end

#visit_tlambeg(node) ⇒ Object

Visit a TLamBeg node.



849
850
851
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 849

def visit_tlambeg(node)
  raise
end

#visit_top_const_field(node) ⇒ Object

Visit a TopConstField node.



854
855
856
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 854

def visit_top_const_field(node)
  s(:colon3, node.constant.value.to_sym)
end

#visit_top_const_ref(node) ⇒ Object

Visit a TopConstRef node.



859
860
861
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 859

def visit_top_const_ref(node)
  s(:colon3, node.constant.value.to_sym)
end

#visit_tstring_beg(node) ⇒ Object

Visit a TStringBeg node.



864
865
866
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 864

def visit_tstring_beg(node)
  raise
end

#visit_tstring_content(node) ⇒ Object

Visit a TStringContent node.



869
870
871
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 869

def visit_tstring_content(node)
  node.value
end

#visit_tstring_end(node) ⇒ Object

Visit a TStringEnd node.



874
875
876
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 874

def visit_tstring_end(node)
  raise
end

#visit_unary(node) ⇒ Object

Visit an Unary node.



879
880
881
882
883
884
885
886
887
888
889
890
891
892
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 879

def visit_unary(node)
  case node
  in { operator: "+" }
    s(:call, visit(node.statement), :+@)
  in { statement: FloatLiteral[value:], operator: "-" }
    s(:lit, -value.to_f)
  in { statement: Int[value:], operator: "-" }
    s(:lit, -value.to_i)
  in { operator: "-" }
    s(:call, visit(node.statement), :-@)
  else
    s(:call, visit(node.statement), node.operator.to_sym)
  end
end

#visit_undef(node) ⇒ Object

Visit an Undef node.



895
896
897
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 895

def visit_undef(node)
  raise
end

#visit_unless(node) ⇒ Object

Visit an Unless node.



900
901
902
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 900

def visit_unless(node)
  raise
end

#visit_unless_mod(node) ⇒ Object

Visit an UnlessMod node.



905
906
907
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 905

def visit_unless_mod(node)
  s(:unless, visit(node.predicate), visit(node.statement), nil)
end

#visit_until(node) ⇒ Object

Visit an Until node.



910
911
912
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 910

def visit_until(node)
  s(:until, visit(node.predicate), visit(node.statements), true)
end

#visit_until_mod(node) ⇒ Object

Visit an UntilMod node.



915
916
917
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 915

def visit_until_mod(node)
  s(:until, visit(node.predicate), visit(node.statement), true)
end

#visit_var_alias(node) ⇒ Object

Visit a VarAlias node.



920
921
922
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 920

def visit_var_alias(node)
  s(:valias, visit(node.left), visit(node.right))
end

#visit_var_field(node) ⇒ Object

Visit a VarField node.



925
926
927
928
929
930
931
932
933
934
935
936
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 925

def visit_var_field(node)
  case node.value
  in Const[value:] then s(:casgn, nil, value.to_sym)
  in CVar[value:] then s(:cvasgn, value.to_sym)
  in GVar[value:] then s(:gvasgn, value.to_sym)
  in Ident[value:] then s(:lasgn, value.to_sym)
  in IVar[value:] then s(:ivasgn, value.to_sym)
  in VarRef[value:] then s(:lasgn, value.to_sym)
  in :nil then s(:kwrest, :"**nil")
  in nil then :*
  end
end

#visit_var_ref(node) ⇒ Object

Visit a VarRef node.



939
940
941
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 939

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

#visit_vcall(node) ⇒ Object

Visit a VCall node.



944
945
946
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 944

def visit_vcall(node)
  s(:call, nil, node.value.value.to_sym)
end

#visit_void_stmt(node) ⇒ Object

Visit a VoidStmt node.



949
950
951
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 949

def visit_void_stmt(node)
  raise
end

#visit_when(node) ⇒ Object

Visit a When node.



954
955
956
957
958
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 954

def visit_when(node)
  cases = s(:array, *visit_all(node.arguments.parts))
  statements = node.statements.empty? ? nil : visit(node.statements)
  s(:when, cases, statements)
end

#visit_while(node) ⇒ Object

Visit a While node.



961
962
963
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 961

def visit_while(node)
  s(:while, visit(node.predicate), visit(node.statements), true)
end

#visit_while_mod(node) ⇒ Object

Visit a WhileMod node.



966
967
968
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 966

def visit_while_mod(node)
  s(:while, visit(node.predicate), visit(node.statement), true)
end

#visit_word(node) ⇒ Object

Visit a Word node.



971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 971

def visit_word(node)
  case stack[-2]
  in Symbols
    case node
    in { parts: [TStringContent => part] }
      s(:lit, part.value.to_sym)
    in { parts: [StringEmbExpr => part, *parts] }
      s(:dsym, "", visit(part), *visit_all(parts))
    else
      s(:dsym, *visit_all(parts))
    end
  in Words
    case node
    in { parts: [TStringContent => part] }
      s(:str, visit(part))
    in { parts: [StringEmbExpr => part, *parts] }
      s(:dstr, "", visit(part), *visit_all(parts))
    else
      s(:dstr, *visit_all(parts))
    end
  end
end

#visit_words(node) ⇒ Object

Visit a Words node.



995
996
997
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 995

def visit_words(node)
  s(:array, *visit_all(node.elements))
end

#visit_words_beg(node) ⇒ Object

Visit a WordsBeg node.



1000
1001
1002
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1000

def visit_words_beg(node)
  raise
end

#visit_xstring(node) ⇒ Object

Visit a XString node.



1005
1006
1007
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1005

def visit_xstring(node)
  raise
end

#visit_xstring_literal(node) ⇒ Object

Visit a XStringLiteral node.



1010
1011
1012
1013
1014
1015
1016
1017
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1010

def visit_xstring_literal(node)
  case node
  in { parts: [StringEmbExpr => part, *parts] }
    s(:dxstr, "", visit(part), *visit_all(parts))
  else
    s(:dxstr, *visit_all(node.parts))
  end
end

#visit_yield(node) ⇒ Object

Visit a Yield node.



1020
1021
1022
1023
1024
1025
1026
1027
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1020

def visit_yield(node)
  case node
  in { arguments: Args[parts:] }
    s(:yield, *visit_all(parts))
  in { arguments: Paren[contents: Args[parts:]] }
    s(:yield, *visit_all(parts))
  end
end

#visit_yield0(node) ⇒ Object

Visit a Yield0 node.



1030
1031
1032
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1030

def visit_yield0(node)
  s(:yield)
end

#visit_zsuper(node) ⇒ Object

Visit a ZSuper node.



1035
1036
1037
 
# File 'lib/syntax_tree/translator/ruby_parser.rb', line 1035

def visit_zsuper(node)
  s(:zsuper)
end