Class: SyntaxTree::Translator::Parser

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

Direct Known Subclasses

RuboCop

Defined Under Namespace

Classes: HeredocSegments

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(buffer) ⇒ Parser

Returns a new instance of Parser.



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

def initialize(buffer)
  @buffer = buffer
  @stack = []
end

Instance Attribute Details

#buffer ⇒ Object (readonly)

Returns the value of attribute buffer.



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

def buffer
  @buffer
end

#stack ⇒ Object (readonly)

Returns the value of attribute stack.



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

def stack
  @stack
end

Instance Method Details

#visit(node) ⇒ Object 



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

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

#visit___end__(node) ⇒ Object 



1237
1238
1239
 
# File 'lib/syntax_tree/translator/parser.rb', line 1237

def visit___end__(node)
  raise
end

#visit_alias(node) ⇒ Object 



20
21
22
 
# File 'lib/syntax_tree/translator/parser.rb', line 20

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

#visit_aref(node) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/syntax_tree/translator/parser.rb', line 42

def visit_aref(node)
  if ::Parser::Builders::Default.emit_index
    case node
    in { index: Args[parts:] }
      s(:index, [visit(node.collection), *visit_all(parts)])
    in { index: nil }
      s(:index, [visit(node.collection)])
    end
  else
    case node
    in { index: Args[parts:] }
      s(:send, [visit(node.collection), :[], *visit_all(parts)])
    in { index: nil }
      s(:send, [visit(node.collection), :[], nil])
    end
  end
end

#visit_aref_field(node) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/syntax_tree/translator/parser.rb', line 24

def visit_aref_field(node)
  if ::Parser::Builders::Default.emit_index
    case node
    in { index: Args[parts:] }
      s(:indexasgn, [visit(node.collection), *visit_all(parts)])
    in { index: nil }
      s(:indexasgn, [visit(node.collection), nil])
    end
  else
    case node
    in { index: Args[parts:] }
      s(:send, [visit(node.collection), :[]=, *visit_all(parts)])
    in { index: nil }
      s(:send, [visit(node.collection), :[]=, nil])
    end
  end
end

#visit_arg_block(node) ⇒ Object 



60
61
62
 
# File 'lib/syntax_tree/translator/parser.rb', line 60

def visit_arg_block(node)
  s(:block_pass, [visit(node.value)])
end

#visit_arg_paren(node) ⇒ Object 



64
65
66
 
# File 'lib/syntax_tree/translator/parser.rb', line 64

def visit_arg_paren(node)
  raise
end

#visit_arg_star(node) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/syntax_tree/translator/parser.rb', line 68

def visit_arg_star(node)
  if stack[-3] in MLHSParen[contents: MLHS]
    case node
    in { value: nil }
      s(:restarg)
    in { value: VarField[value: { value: }]}
      s(:restarg, [value.to_sym])
    in { value: Ident[value:] }
      s(:restarg, [value.to_sym])
    end
  else
    case node
    in { value: nil }
      s(:splat)
    else
      s(:splat, [visit(node.value)])
    end
  end
end

#visit_args(node) ⇒ Object 



88
89
90
 
# File 'lib/syntax_tree/translator/parser.rb', line 88

def visit_args(node)
  raise
end

#visit_args_forward(node) ⇒ Object 



92
93
94
 
# File 'lib/syntax_tree/translator/parser.rb', line 92

def visit_args_forward(node)
  s(:forwarded_args)
end

#visit_array(node) ⇒ Object 



96
97
98
99
100
101
102
103
 
# File 'lib/syntax_tree/translator/parser.rb', line 96

def visit_array(node)
  case node
  in { contents: nil }
    s(:array)
  in { contents: Args[parts:] }
    s(:array, visit_all(parts))
  end
end

#visit_aryptn(node) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/syntax_tree/translator/parser.rb', line 105

def visit_aryptn(node)
  type = :array_pattern
  children = visit_all(node.requireds)

  case node.rest
  in VarField[value: nil, location: { start_char:, end_char: ^(start_char) }] if node.posts.empty?
    # Here we have an implicit rest, as in [foo,]. parser has a specific
    # type for these patterns.
    type = :array_pattern_with_tail
  in VarField[value: nil]
    children << s(:match_rest)
  in VarField
    children << s(:match_rest, [visit(node.rest)])
  else
  end

  inner = s(type, children + visit_all(node.posts))
  node.constant ? s(:const_pattern, [visit(node.constant), inner]) : inner
end

#visit_assign(node) ⇒ Object 



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

def visit_assign(node)
  target = visit(node.target)
  s(target.type, target.children + [visit(node.value)])
end

#visit_assoc(node) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
 
# File 'lib/syntax_tree/translator/parser.rb', line 130

def visit_assoc(node)
  case node
  in { key:, value: nil } if key.value.start_with?(/[a-z]/)
    s(:pair, [visit(key), s(:send, [nil, key.value.chomp(":").to_sym])])
  in { key:, value: nil } if key.value.start_with?(/[A-Z]/)
    s(:pair, [visit(key), s(:const, [nil, key.value.chomp(":").to_sym])])
  in { key:, value: }
    s(:pair, [visit(key), visit(value)])
  end
end

#visit_assoc_splat(node) ⇒ Object 



141
142
143
 
# File 'lib/syntax_tree/translator/parser.rb', line 141

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

#visit_backref(node) ⇒ Object 



145
146
147
148
149
150
151
 
# File 'lib/syntax_tree/translator/parser.rb', line 145

def visit_backref(node)
  if node.value.match?(/^\$\d+$/)
    s(:nth_ref, [node.value[1..-1].to_i])
  else
    s(:back_ref, [node.value.to_sym])
  end
end

#visit_backtick(node) ⇒ Object 



153
154
155
 
# File 'lib/syntax_tree/translator/parser.rb', line 153

def visit_backtick(node)
  raise
end

#visit_bare_assoc_hash(node) ⇒ Object 



157
158
159
160
161
162
163
164
165
166
 
# File 'lib/syntax_tree/translator/parser.rb', line 157

def visit_bare_assoc_hash(node)
  type =
    if ::Parser::Builders::Default.emit_kwargs && !(stack[-2] in ArrayLiteral)
      :kwargs
    else
      :hash
    end

  s(type, visit_all(node.assocs))
end

#visit_BEGIN(node) ⇒ Object 



168
169
170
 
# File 'lib/syntax_tree/translator/parser.rb', line 168

def visit_BEGIN(node)
  s(:preexe, [visit(node.statements)])
end

#visit_begin(node) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
 
# File 'lib/syntax_tree/translator/parser.rb', line 172

def visit_begin(node)
  if node.bodystmt.empty?
    s(:kwbegin)
  elsif node.bodystmt in { statements:, rescue_clause: nil, ensure_clause: nil, else_clause: nil }
    visited = visit(statements)
    s(:kwbegin, visited.type == :begin ? visited.children : [visited])
  else
    s(:kwbegin, [visit(node.bodystmt)])
  end
end

#visit_binary(node) ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/syntax_tree/translator/parser.rb', line 183

def visit_binary(node)
  case node
  in { operator: :| }
    current = -2
    current -= 1 while (stack[current] in Binary[operator: :|])

    if stack[current] in In
      s(:match_alt, [visit(node.left), visit(node.right)])
    else
      s(:send, [visit(node.left), node.operator, visit(node.right)])
    end
  in { operator: :"=>" }
    s(:match_as, [visit(node.left), visit(node.right)])
  in { operator: :"&&" | :and }
    s(:and, [visit(node.left), visit(node.right)])
  in { operator: :"||" | :or }
    s(:or, [visit(node.left), visit(node.right)])
  in { left: RegexpLiteral[parts: [TStringContent]], operator: :=~ }
    s(:match_with_lvasgn, [visit(node.left), visit(node.right)])
  else
    s(:send, [visit(node.left), node.operator, visit(node.right)])
  end
end

#visit_block_var(node) ⇒ Object 



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

def visit_block_var(node)
  shadowargs = node.locals.map { |local| s(:shadowarg, [local.value.to_sym]) }

  case node
  in { params: { requireds: [(Ident | MLHSParen) => required], optionals: [], rest: nil, posts: [], keywords: [], keyword_rest: nil, block: nil } } if ::Parser::Builders::Default.emit_procarg0
    procarg0 =
      if ::Parser::Builders::Default.emit_arg_inside_procarg0 && required in Ident
        s(:procarg0, [s(:arg, [required.value.to_sym])])
      else
        s(:procarg0, visit(required).children)
      end

    s(:args, [procarg0] + shadowargs)
  else
    s(:args, visit(node.params).children + shadowargs)
  end
end

#visit_blockarg(node) ⇒ Object 



207
208
209
210
211
212
213
214
 
# File 'lib/syntax_tree/translator/parser.rb', line 207

def visit_blockarg(node)
  case node
  in { name: nil }
    s(:blockarg, [nil])
  else
    s(:blockarg, [node.name.value.to_sym])
  end
end

#visit_bodystmt(node) ⇒ Object 



234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/syntax_tree/translator/parser.rb', line 234

def visit_bodystmt(node)
  inner = visit(node.statements)

  if node.rescue_clause
    children = [inner] + visit(node.rescue_clause).children

    if node.else_clause
      children.pop
      children << visit(node.else_clause)
    end

    inner = s(:rescue, children)
  end

  if node.ensure_clause
    inner = s(:ensure, [inner] + visit(node.ensure_clause).children)
  end

  inner
end

#visit_brace_block(node) ⇒ Object 



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

def visit_brace_block(node)
  raise
end

#visit_break(node) ⇒ Object 



259
260
261
 
# File 'lib/syntax_tree/translator/parser.rb', line 259

def visit_break(node)
  s(:break, visit_all(node.arguments.parts))
end

#visit_call(node) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'lib/syntax_tree/translator/parser.rb', line 263

def visit_call(node)
  type = send_type(node.operator)

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

#visit_case(node) ⇒ Object 



280
281
282
283
284
285
286
 
# File 'lib/syntax_tree/translator/parser.rb', line 280

def visit_case(node)
  clauses = [node.consequent]
  clauses << clauses.last.consequent while clauses.last && !(clauses.last in Else)

  type = (node.consequent in In) ? :case_match : :case
  s(type, [visit(node.value)] + clauses.map { |clause| visit(clause) })
end

#visit_CHAR(node) ⇒ Object 



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

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

#visit_class(node) ⇒ Object 



292
293
294
 
# File 'lib/syntax_tree/translator/parser.rb', line 292

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

#visit_comma(node) ⇒ Object 



296
297
298
 
# File 'lib/syntax_tree/translator/parser.rb', line 296

def visit_comma(node)
  raise
end

#visit_command(node) ⇒ Object 



300
301
302
 
# File 'lib/syntax_tree/translator/parser.rb', line 300

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

#visit_command_call(node) ⇒ Object 



304
305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/syntax_tree/translator/parser.rb', line 304

def visit_command_call(node)
  children = [visit(node.receiver), node.message.value.to_sym]

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

  s(send_type(node.operator), children)
end

#visit_comment(node) ⇒ Object 



319
320
321
 
# File 'lib/syntax_tree/translator/parser.rb', line 319

def visit_comment(node)
  raise
end

#visit_const(node) ⇒ Object 



323
324
325
 
# File 'lib/syntax_tree/translator/parser.rb', line 323

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

#visit_const_path_field(node) ⇒ Object 



327
328
329
330
331
332
333
 
# File 'lib/syntax_tree/translator/parser.rb', line 327

def visit_const_path_field(node)
  if node in { parent: VarRef[value: Kw[value: "self"]] => parent, constant: Ident[value:] }
    s(:send, [visit(parent), :"#{value}="])
  else
    s(:casgn, [visit(node.parent), node.constant.value.to_sym])
  end
end

#visit_const_path_ref(node) ⇒ Object 



335
336
337
 
# File 'lib/syntax_tree/translator/parser.rb', line 335

def visit_const_path_ref(node)
  s(:const, [visit(node.parent), node.constant.value.to_sym])
end

#visit_const_ref(node) ⇒ Object 



339
340
341
 
# File 'lib/syntax_tree/translator/parser.rb', line 339

def visit_const_ref(node)
  s(:const, [nil, node.constant.value.to_sym])
end

#visit_cvar(node) ⇒ Object 



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

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

#visit_def(node) ⇒ Object 



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

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

#visit_def_endless(node) ⇒ Object 



352
353
354
355
356
357
358
359
360
 
# File 'lib/syntax_tree/translator/parser.rb', line 352

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 : :def, children)
end

#visit_defined(node) ⇒ Object 



362
363
364
 
# File 'lib/syntax_tree/translator/parser.rb', line 362

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

#visit_defs(node) ⇒ Object 



366
367
368
369
 
# File 'lib/syntax_tree/translator/parser.rb', line 366

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

#visit_do_block(node) ⇒ Object 



371
372
373
 
# File 'lib/syntax_tree/translator/parser.rb', line 371

def visit_do_block(node)
  raise
end

#visit_dot2(node) ⇒ Object 



375
376
377
 
# File 'lib/syntax_tree/translator/parser.rb', line 375

def visit_dot2(node)
  s(:irange, [visit(node.left), visit(node.right)])
end

#visit_dot3(node) ⇒ Object 



379
380
381
 
# File 'lib/syntax_tree/translator/parser.rb', line 379

def visit_dot3(node)
  s(:erange, [visit(node.left), visit(node.right)])
end

#visit_dyna_symbol(node) ⇒ Object 



383
384
385
386
387
388
389
390
 
# File 'lib/syntax_tree/translator/parser.rb', line 383

def visit_dyna_symbol(node)
  case node
  in { parts: [TStringContent[value:]] }
    s(:sym, ["\"#{value}\"".undump.to_sym])
  else
    s(:dsym, visit_all(node.parts))
  end
end

#visit_else(node) ⇒ Object 



392
393
394
395
396
397
398
 
# File 'lib/syntax_tree/translator/parser.rb', line 392

def visit_else(node)
  if node.statements.empty? && (stack[-2] in Case)
    s(:empty_else)
  else
    visit(node.statements)
  end
end

#visit_elsif(node) ⇒ Object 



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

def visit_elsif(node)
  s(:if, [visit(node.predicate), visit(node.statements), visit(node.consequent)])
end

#visit_embdoc(node) ⇒ Object 



404
405
406
 
# File 'lib/syntax_tree/translator/parser.rb', line 404

def visit_embdoc(node)
  raise
end

#visit_embexpr_beg(node) ⇒ Object 



408
409
410
 
# File 'lib/syntax_tree/translator/parser.rb', line 408

def visit_embexpr_beg(node)
  raise
end

#visit_embexpr_end(node) ⇒ Object 



412
413
414
 
# File 'lib/syntax_tree/translator/parser.rb', line 412

def visit_embexpr_end(node)
  raise
end

#visit_embvar(node) ⇒ Object 



416
417
418
 
# File 'lib/syntax_tree/translator/parser.rb', line 416

def visit_embvar(node)
  raise
end

#visit_END(node) ⇒ Object 



420
421
422
 
# File 'lib/syntax_tree/translator/parser.rb', line 420

def visit_END(node)
  s(:postexe, [visit(node.statements)])
end

#visit_ensure(node) ⇒ Object 



424
425
426
 
# File 'lib/syntax_tree/translator/parser.rb', line 424

def visit_ensure(node)
  s(:ensure, [visit(node.statements)])
end

#visit_excessed_comma(node) ⇒ Object 



428
429
430
 
# File 'lib/syntax_tree/translator/parser.rb', line 428

def visit_excessed_comma(node)
  raise
end

#visit_fcall(node) ⇒ Object 



432
433
434
435
436
437
438
439
440
441
 
# File 'lib/syntax_tree/translator/parser.rb', line 432

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

#visit_field(node) ⇒ Object 



443
444
445
446
447
448
449
 
# File 'lib/syntax_tree/translator/parser.rb', line 443

def visit_field(node)
  if stack[-2] in Assign | MLHS
    s(send_type(node.operator), [visit(node.parent), :"#{node.name.value}="])
  else
    s(send_type(node.operator), [visit(node.parent), node.name.value.to_sym])
  end
end

#visit_float(node) ⇒ Object 



451
452
453
 
# File 'lib/syntax_tree/translator/parser.rb', line 451

def visit_float(node)
  s(:float, [node.value.to_f])
end

#visit_fndptn(node) ⇒ Object 



455
456
457
458
459
460
461
462
463
464
 
# File 'lib/syntax_tree/translator/parser.rb', line 455

def visit_fndptn(node)
  children = [
    s(:match_rest, (node.left in VarField[value: nil]) ? [] : [visit(node.left)]),
    *visit_all(node.values),
    s(:match_rest, (node.right in VarField[value: nil]) ? [] : [visit(node.right)])
  ]

  inner = s(:find_pattern, children)
  node.constant ? s(:const_pattern, [visit(node.constant), inner]) : inner
end

#visit_for(node) ⇒ Object 



466
467
468
 
# File 'lib/syntax_tree/translator/parser.rb', line 466

def visit_for(node)
  s(:for, [visit(node.index), visit(node.collection), visit(node.statements)])
end

#visit_gvar(node) ⇒ Object 



470
471
472
 
# File 'lib/syntax_tree/translator/parser.rb', line 470

def visit_gvar(node)
  s(:gvar, [node.value.to_sym])
end

#visit_hash(node) ⇒ Object 



474
475
476
 
# File 'lib/syntax_tree/translator/parser.rb', line 474

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

#visit_heredoc(node) ⇒ Object 



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
 
# File 'lib/syntax_tree/translator/parser.rb', line 541

def visit_heredoc(node)
  heredoc_segments = HeredocSegments.new(node)

  node.parts.each do |part|
    if (part in TStringContent[value:]) && value.count("\n") > 1
      part.value.split("\n").each do |line|
        heredoc_segments << s(:str, ["#{line}\n"])
      end
    else
      heredoc_segments << visit(part)
    end
  end

  heredoc_segments.trim!

  if node.beginning.value.match?(/`\w+`\z/)
    s(:xstr, heredoc_segments.segments)
  elsif heredoc_segments.segments.length > 1
    s(:dstr, heredoc_segments.segments)
  elsif heredoc_segments.segments.empty?
    s(:dstr)
  else
    heredoc_segments.segments.first
  end
end

#visit_heredoc_beg(node) ⇒ Object 



567
568
569
 
# File 'lib/syntax_tree/translator/parser.rb', line 567

def visit_heredoc_beg(node)
  raise
end

#visit_hshptn(node) ⇒ Object 



571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
 
# File 'lib/syntax_tree/translator/parser.rb', line 571

def visit_hshptn(node)
  children =
    node.keywords.map do |(keyword, value)|
      next s(:pair, [visit(keyword), visit(value)]) if value

      case keyword
      in Label
        s(:match_var, [keyword.value.chomp(":").to_sym])
      in StringContent[parts: [TStringContent[value:]]]
        s(:match_var, [value.to_sym])
      end
    end

  case node.keyword_rest
  in VarField[value: nil]
    children << s(:match_rest)
  in VarField[value: :nil]
    children << s(:match_nil_pattern)
  in VarField
    children << s(:match_rest, [visit(node.keyword_rest)])
  else
  end

  inner = s(:hash_pattern, children)
  node.constant ? s(:const_pattern, [visit(node.constant), inner]) : inner
end

#visit_ident(node) ⇒ Object 



598
599
600
 
# File 'lib/syntax_tree/translator/parser.rb', line 598

def visit_ident(node)
  s(:lvar, [node.value.to_sym])
end

#visit_if(node) ⇒ Object 



602
603
604
605
606
607
608
609
610
611
612
613
614
 
# File 'lib/syntax_tree/translator/parser.rb', line 602

def visit_if(node)
  predicate =
    case node.predicate
    in Dot2
      s(:iflipflop, visit(node.predicate).children)
    in Dot3
      s(:eflipflop, visit(node.predicate).children)
    else
      visit(node.predicate)
    end

  s(:if, [predicate, visit(node.statements), visit(node.consequent)])
end

#visit_if_mod(node) ⇒ Object 



616
617
618
 
# File 'lib/syntax_tree/translator/parser.rb', line 616

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

#visit_if_op(node) ⇒ Object 



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

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

#visit_imaginary(node) ⇒ Object 



624
625
626
627
628
629
 
# File 'lib/syntax_tree/translator/parser.rb', line 624

def visit_imaginary(node)
  # We have to do an eval here in order to get the value in case it's
  # something like 42ri. to_c will not give the right value in that case.
  # Maybe there's an API for this but I can't find it.
  s(:complex, [eval(node.value)])
end

#visit_in(node) ⇒ Object 



631
632
633
634
635
636
637
638
639
640
 
# File 'lib/syntax_tree/translator/parser.rb', line 631

def visit_in(node)
  case node
  in { pattern: IfMod[predicate:, statement:], statements: }
    s(:in_pattern, [visit(statement), s(:if_guard, [visit(predicate)]), visit(statements)])
  in { pattern: UnlessMod[predicate:, statement:], statements: }
    s(:in_pattern, [visit(statement), s(:unless_guard, [visit(predicate)]), visit(statements)])
  else
    s(:in_pattern, [visit(node.pattern), nil, visit(node.statements)])
  end
end

#visit_int(node) ⇒ Object 



642
643
644
 
# File 'lib/syntax_tree/translator/parser.rb', line 642

def visit_int(node)
  s(:int, [node.value.to_i])
end

#visit_ivar(node) ⇒ Object 



646
647
648
 
# File 'lib/syntax_tree/translator/parser.rb', line 646

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

#visit_kw(node) ⇒ Object 



650
651
652
653
654
655
656
657
658
659
660
661
 
# File 'lib/syntax_tree/translator/parser.rb', line 650

def visit_kw(node)
  case node.value
  in "__FILE__"
    s(:str, [buffer.name])
  in "__LINE__"
    s(:int, [node.location.start_line + buffer.first_line - 1])
  in "__ENCODING__" unless ::Parser::Builders::Default.emit_encoding
    s(:const, [s(:const, [nil, :Encoding]), :UTF_8])
  else
    s(node.value.to_sym)
  end
end

#visit_kwrest_param(node) ⇒ Object 



663
664
665
666
667
668
669
670
 
# File 'lib/syntax_tree/translator/parser.rb', line 663

def visit_kwrest_param(node)
  case node
  in { name: nil }
    s(:kwrestarg)
  else
    s(:kwrestarg, [node.name.value.to_sym])
  end
end

#visit_label(node) ⇒ Object 



672
673
674
 
# File 'lib/syntax_tree/translator/parser.rb', line 672

def visit_label(node)
  s(:sym, [node.value.chomp(":").to_sym])
end

#visit_label_end(node) ⇒ Object 



676
677
678
 
# File 'lib/syntax_tree/translator/parser.rb', line 676

def visit_label_end(node)
  raise
end

#visit_lambda(node) ⇒ Object 



680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
 
# File 'lib/syntax_tree/translator/parser.rb', line 680

def visit_lambda(node)
  args = (node.params in Params) ? node.params : node.params.contents

  arguments = visit(args)
  child =
    if ::Parser::Builders::Default.emit_lambda
      s(:lambda)
    else
      s(:send, [nil, :lambda])
    end

  type = :block
  if args.empty? && (maximum = num_block_type(node.statements))
    type = :numblock
    arguments = maximum
  end

  s(type, [child, arguments, visit(node.statements)])
end

#visit_lbrace(node) ⇒ Object 



700
701
702
 
# File 'lib/syntax_tree/translator/parser.rb', line 700

def visit_lbrace(node)
  raise
end

#visit_lbracket(node) ⇒ Object 



704
705
706
 
# File 'lib/syntax_tree/translator/parser.rb', line 704

def visit_lbracket(node)
  raise
end

#visit_lparen(node) ⇒ Object 



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

def visit_lparen(node)
  raise
end

#visit_massign(node) ⇒ Object 



712
713
714
 
# File 'lib/syntax_tree/translator/parser.rb', line 712

def visit_massign(node)
  s(:masgn, [visit(node.target), visit(node.value)])
end

#visit_method_add_block(node) ⇒ Object 



716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
 
# File 'lib/syntax_tree/translator/parser.rb', line 716

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

  arguments =
    if node.block.block_var
      visit(node.block.block_var)
    else
      s(:args)
    end

  type = :block
  if !node.block.block_var && (maximum = num_block_type(statements))
    type = :numblock
    arguments = maximum
  end

  if node.call in Break | Next | Return
    call = visit(node.call)
    s(call.type, [s(type, [*call.children, arguments, visit(statements)])])
  else
    s(type, [visit(node.call), arguments, visit(statements)])
  end
end

#visit_mlhs(node) ⇒ Object 



745
746
747
 
# File 'lib/syntax_tree/translator/parser.rb', line 745

def visit_mlhs(node)
  s(:mlhs, node.parts.map { |part| (part in Ident[value:]) ? s(:arg, [value.to_sym]) : visit(part) })
end

#visit_mlhs_paren(node) ⇒ Object 



749
750
751
 
# File 'lib/syntax_tree/translator/parser.rb', line 749

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

#visit_module(node) ⇒ Object 



753
754
755
 
# File 'lib/syntax_tree/translator/parser.rb', line 753

def visit_module(node)
  s(:module, [visit(node.constant), visit(node.bodystmt)])
end

#visit_mrhs(node) ⇒ Object 



757
758
759
 
# File 'lib/syntax_tree/translator/parser.rb', line 757

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

#visit_next(node) ⇒ Object 



761
762
763
 
# File 'lib/syntax_tree/translator/parser.rb', line 761

def visit_next(node)
  s(:next, visit_all(node.arguments.parts))
end

#visit_not(node) ⇒ Object 



765
766
767
768
769
770
771
772
 
# File 'lib/syntax_tree/translator/parser.rb', line 765

def visit_not(node)
  case node
  in { statement: nil }
    s(:send, [s(:begin), :"!"])
  else
    s(:send, [visit(node.statement), :"!"])
  end
end

#visit_op(node) ⇒ Object 



774
775
776
 
# File 'lib/syntax_tree/translator/parser.rb', line 774

def visit_op(node)
  raise
end

#visit_opassign(node) ⇒ Object 



778
779
780
781
782
783
784
785
786
787
 
# File 'lib/syntax_tree/translator/parser.rb', line 778

def visit_opassign(node)
  case node.operator
  in { value: "||=" }
    s(:or_asgn, [visit(node.target), visit(node.value)])
  in { value: "&&=" }
    s(:and_asgn, [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 



789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
 
# File 'lib/syntax_tree/translator/parser.rb', line 789

def visit_params(node)
  children = []

  children +=
    node.requireds.map do |required|
      case required
      in MLHSParen
        visit(required)
      else
        s(:arg, [required.value.to_sym])
      end
    end

  children += node.optionals.map { |(name, value)| s(:optarg, [name.value.to_sym, visit(value)]) }
  children << visit(node.rest) if node.rest && !(node.rest in ExcessedComma)
  children += node.posts.map { |post| s(:arg, [post.value.to_sym]) }
  children +=
    node.keywords.map do |(name, value)|
      key = name.value.chomp(":").to_sym
      value ? s(:kwoptarg, [key, visit(value)]) : s(:kwarg, [key])
    end

  case node.keyword_rest
  in nil | ArgsForward
    # do nothing
  in :nil
    children << s(:kwnilarg)
  else
    children << visit(node.keyword_rest)
  end

  children << visit(node.block) if node.block
  
  if (node.keyword_rest in ArgsForward)
    if children.empty? && !::Parser::Builders::Default.emit_forward_arg
      return s(:forward_args)
    end

    children.insert(node.requireds.length + node.optionals.length + node.keywords.length, s(:forward_arg))
  end

  s(:args, children)
end

#visit_paren(node) ⇒ Object 



833
834
835
836
837
838
839
840
841
842
 
# File 'lib/syntax_tree/translator/parser.rb', line 833

def visit_paren(node)
  if node in { contents: nil | Statements[body: [VoidStmt]] }
    s(:begin)
  elsif stack[-2] in Defs[target: ^(node)]
    visit(node.contents)
  else
    visited = visit(node.contents)
    visited.type == :begin ? visited : s(:begin, [visited])
  end
end

#visit_period(node) ⇒ Object 



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

def visit_period(node)
  raise
end

#visit_pinned_begin(node) ⇒ Object 



848
849
850
 
# File 'lib/syntax_tree/translator/parser.rb', line 848

def visit_pinned_begin(node)
  s(:pin, [s(:begin, [visit(node.statement)])])
end

#visit_pinned_var_ref(node) ⇒ Object 



852
853
854
 
# File 'lib/syntax_tree/translator/parser.rb', line 852

def visit_pinned_var_ref(node)
  s(:pin, [visit(node.value)])
end

#visit_program(node) ⇒ Object 



856
857
858
 
# File 'lib/syntax_tree/translator/parser.rb', line 856

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

#visit_qsymbols(node) ⇒ Object 



860
861
862
 
# File 'lib/syntax_tree/translator/parser.rb', line 860

def visit_qsymbols(node)
  s(:array, node.elements.map { |element| s(:sym, [element.value.to_sym]) })
end

#visit_qsymbols_beg(node) ⇒ Object 



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

def visit_qsymbols_beg(node)
  raise
end

#visit_qwords(node) ⇒ Object 



868
869
870
 
# File 'lib/syntax_tree/translator/parser.rb', line 868

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

#visit_qwords_beg(node) ⇒ Object 



872
873
874
 
# File 'lib/syntax_tree/translator/parser.rb', line 872

def visit_qwords_beg(node)
  raise
end

#visit_rassign(node) ⇒ Object 



876
877
878
879
 
# File 'lib/syntax_tree/translator/parser.rb', line 876

def visit_rassign(node)
  type = (node.operator in Op[value: "=>"]) ? :match_pattern : :match_pattern_p
  s(type, [visit(node.value), visit(node.pattern)])
end

#visit_rational(node) ⇒ Object 



881
882
883
 
# File 'lib/syntax_tree/translator/parser.rb', line 881

def visit_rational(node)
  s(:rational, [node.value.to_r])
end

#visit_rbrace(node) ⇒ Object 



885
886
887
 
# File 'lib/syntax_tree/translator/parser.rb', line 885

def visit_rbrace(node)
  raise
end

#visit_rbracket(node) ⇒ Object 



889
890
891
 
# File 'lib/syntax_tree/translator/parser.rb', line 889

def visit_rbracket(node)
  raise
end

#visit_redo(node) ⇒ Object 



893
894
895
 
# File 'lib/syntax_tree/translator/parser.rb', line 893

def visit_redo(node)
  s(:redo)
end

#visit_regexp_beg(node) ⇒ Object 



897
898
899
 
# File 'lib/syntax_tree/translator/parser.rb', line 897

def visit_regexp_beg(node)
  raise
end

#visit_regexp_content(node) ⇒ Object 



901
902
903
 
# File 'lib/syntax_tree/translator/parser.rb', line 901

def visit_regexp_content(node)
  raise
end

#visit_regexp_end(node) ⇒ Object 



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

def visit_regexp_end(node)
  raise
end

#visit_regexp_literal(node) ⇒ Object 



909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
 
# File 'lib/syntax_tree/translator/parser.rb', line 909

def visit_regexp_literal(node)
  children = visit_all(node.parts)
  children << s(:regopt, node.ending.scan(/[a-z]/).sort.map(&:to_sym))
  regexp = s(:regexp, children)

  if stack[-2] in If[predicate: ^(node)] | Unless[predicate: ^(node)]
    s(:match_current_line, [regexp])
  elsif stack[-3] in If[predicate: Unary[statement: ^(node), operator: "!"]] | Unless[predicate: Unary[statement: ^(node), operator: "!"]]
    s(:match_current_line, [regexp])
  elsif stack[-4] in Program[statements: { body: [*, Unary[statement: ^(node), operator: "!"]] }]
    s(:match_current_line, [regexp])
  else
    regexp
  end
end

#visit_rescue(node) ⇒ Object 



925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
 
# File 'lib/syntax_tree/translator/parser.rb', line 925

def visit_rescue(node)
  exceptions =
    case node.exception
    in nil | { exceptions: nil }
      nil
    in { exceptions: VarRef => part }
      s(:array, [visit(part)])
    in { exceptions: MRHS[parts:] }
      s(:array, visit_all(parts))
    else
      s(:array, [visit(node.exception.exceptions)])
    end

  resbody =
    case node.exception
    in nil
      s(:resbody, [nil, nil, visit(node.statements)])
    in { variable: nil }
      s(:resbody, [exceptions, nil, visit(node.statements)])
    in { variable: VarField => variable }
      s(:resbody, [exceptions, visit(variable), visit(node.statements)])
    end

  children = [resbody]
  if node.consequent
    children += visit(node.consequent).children
  else
    children << nil
  end

  s(:rescue, children)
end

#visit_rescue_ex(node) ⇒ Object 



958
959
960
 
# File 'lib/syntax_tree/translator/parser.rb', line 958

def visit_rescue_ex(node)
  raise
end

#visit_rescue_mod(node) ⇒ Object 



962
963
964
 
# File 'lib/syntax_tree/translator/parser.rb', line 962

def visit_rescue_mod(node)
  s(:rescue, [visit(node.statement), s(:resbody, [nil, nil, visit(node.value)]), nil])
end

#visit_rest_param(node) ⇒ Object 



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

def visit_rest_param(node)
  s(:restarg, node.name ? [node.name.value.to_sym] : [])
end

#visit_retry(node) ⇒ Object 



970
971
972
 
# File 'lib/syntax_tree/translator/parser.rb', line 970

def visit_retry(node)
  s(:retry)
end

#visit_return(node) ⇒ Object 



974
975
976
 
# File 'lib/syntax_tree/translator/parser.rb', line 974

def visit_return(node)
  s(:return, visit_all(node.arguments.parts))
end

#visit_return0(node) ⇒ Object 



978
979
980
 
# File 'lib/syntax_tree/translator/parser.rb', line 978

def visit_return0(node)
  s(:return)
end

#visit_rparen(node) ⇒ Object 



982
983
984
 
# File 'lib/syntax_tree/translator/parser.rb', line 982

def visit_rparen(node)
  raise
end

#visit_sclass(node) ⇒ Object 



986
987
988
 
# File 'lib/syntax_tree/translator/parser.rb', line 986

def visit_sclass(node)
  s(:sclass, [visit(node.target), visit(node.bodystmt)])
end

#visit_statements(node) ⇒ Object 



990
991
992
993
994
995
996
997
998
999
1000
1001
 
# File 'lib/syntax_tree/translator/parser.rb', line 990

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

  case children
  in []
    nil
  in [statement]
    visit(statement)
  else
    s(:begin, visit_all(children))
  end
end

#visit_string_concat(node) ⇒ Object 



1003
1004
1005
 
# File 'lib/syntax_tree/translator/parser.rb', line 1003

def visit_string_concat(node)
  s(:dstr, [visit(node.left), visit(node.right)])
end

#visit_string_content(node) ⇒ Object 



1007
1008
1009
1010
 
# File 'lib/syntax_tree/translator/parser.rb', line 1007

def visit_string_content(node)
  # Can get here if you're inside a hash pattern, e.g., in "a": 1
  s(:sym, [node.parts.first.value.to_sym])
end

#visit_string_dvar(node) ⇒ Object 



1012
1013
1014
 
# File 'lib/syntax_tree/translator/parser.rb', line 1012

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

#visit_string_embexpr(node) ⇒ Object 



1016
1017
1018
1019
 
# File 'lib/syntax_tree/translator/parser.rb', line 1016

def visit_string_embexpr(node)
  child = visit(node.statements)
  s(:begin, child ? [child] : [])
end

#visit_string_literal(node) ⇒ Object 



1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
 
# File 'lib/syntax_tree/translator/parser.rb', line 1021

def visit_string_literal(node)
  case node
  in { parts: [] }
    s(:str, [""])
  in { parts: [TStringContent => part] }
    visit(part)
  else
    s(:dstr, visit_all(node.parts))
  end
end

#visit_super(node) ⇒ Object 



1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
 
# File 'lib/syntax_tree/translator/parser.rb', line 1032

def visit_super(node)
  case node.arguments
  in ArgParen[arguments: nil]
    s(:super)
  in ArgParen[arguments: ArgsForward => arguments]
    s(:super, [visit(arguments)])
  in ArgParen[arguments: { parts: }]
    s(:super, visit_all(parts))
  in Args[parts:]
    s(:super, visit_all(parts))
  end
end

#visit_symbeg(node) ⇒ Object 



1045
1046
1047
 
# File 'lib/syntax_tree/translator/parser.rb', line 1045

def visit_symbeg(node)
  raise
end

#visit_symbol_content(node) ⇒ Object 



1049
1050
1051
 
# File 'lib/syntax_tree/translator/parser.rb', line 1049

def visit_symbol_content(node)
  raise
end

#visit_symbol_literal(node) ⇒ Object 



1053
1054
1055
 
# File 'lib/syntax_tree/translator/parser.rb', line 1053

def visit_symbol_literal(node)
  s(:sym, [node.value.value.to_sym])
end

#visit_symbols(node) ⇒ Object 



1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
 
# File 'lib/syntax_tree/translator/parser.rb', line 1057

def visit_symbols(node)
  children =
    node.elements.map do |element|
      if element.parts.length > 1 || !(element.parts.first in TStringContent)
        s(:dsym, visit_all(element.parts))
      else
        s(:sym, [element.parts.first.value.to_sym])
      end
    end

  s(:array, children)
end

#visit_symbols_beg(node) ⇒ Object 



1070
1071
1072
 
# File 'lib/syntax_tree/translator/parser.rb', line 1070

def visit_symbols_beg(node)
  raise
end

#visit_tlambda(node) ⇒ Object 



1074
1075
1076
 
# File 'lib/syntax_tree/translator/parser.rb', line 1074

def visit_tlambda(node)
  raise
end

#visit_tlambeg(node) ⇒ Object 



1078
1079
1080
 
# File 'lib/syntax_tree/translator/parser.rb', line 1078

def visit_tlambeg(node)
  raise
end

#visit_top_const_field(node) ⇒ Object 



1082
1083
1084
 
# File 'lib/syntax_tree/translator/parser.rb', line 1082

def visit_top_const_field(node)
  s(:casgn, [s(:cbase), node.constant.value.to_sym])
end

#visit_top_const_ref(node) ⇒ Object 



1086
1087
1088
 
# File 'lib/syntax_tree/translator/parser.rb', line 1086

def visit_top_const_ref(node)
  s(:const, [s(:cbase), node.constant.value.to_sym])
end

#visit_tstring_beg(node) ⇒ Object 



1090
1091
1092
 
# File 'lib/syntax_tree/translator/parser.rb', line 1090

def visit_tstring_beg(node)
  raise
end

#visit_tstring_content(node) ⇒ Object 



1094
1095
1096
1097
 
# File 'lib/syntax_tree/translator/parser.rb', line 1094

def visit_tstring_content(node)
  value = node.value.gsub(/([^[:ascii:]])/) { $1.dump[1...-1] }
  s(:str, ["\"#{value}\"".undump])
end

#visit_tstring_end(node) ⇒ Object 



1099
1100
1101
 
# File 'lib/syntax_tree/translator/parser.rb', line 1099

def visit_tstring_end(node)
  raise
end

#visit_unary(node) ⇒ Object 



1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
 
# File 'lib/syntax_tree/translator/parser.rb', line 1103

def visit_unary(node)
  case node
  in { statement: Paren[contents: Statements[body: [Dot2 => contents]]], operator: "!" }
    s(:send, [s(:begin, [s(:iflipflop, visit(contents).children)]), :"!"])
  in { statement: Paren[contents: Statements[body: [Dot3 => contents]]], operator: "!" }
    s(:send, [s(:begin, [s(:eflipflop, visit(contents).children)]), :"!"])
  in { statement: Int[value:], operator: "+" }
    s(:int, [value.to_i])
  in { statement: Int[value:], operator: "-" }
    s(:int, [-value.to_i])
  in { statement: FloatLiteral[value:], operator: "+" }
    s(:float, [value.to_f])
  in { statement: FloatLiteral[value:], operator: "-" }
    s(:float, [-value.to_f])
  in { statement:, operator: "+" }
    s(:send, [visit(statement), :"+@"])
  in { statement:, operator: "-" }
    s(:send, [visit(statement), :"-@"])
  else
    s(:send, [visit(node.statement), node.operator.to_sym])
  end
end

#visit_undef(node) ⇒ Object 



1126
1127
1128
 
# File 'lib/syntax_tree/translator/parser.rb', line 1126

def visit_undef(node)
  s(:undef, visit_all(node.symbols))
end

#visit_unless(node) ⇒ Object 



1130
1131
1132
 
# File 'lib/syntax_tree/translator/parser.rb', line 1130

def visit_unless(node)
  s(:if, [visit(node.predicate), visit(node.consequent), visit(node.statements)])
end

#visit_unless_mod(node) ⇒ Object 



1134
1135
1136
 
# File 'lib/syntax_tree/translator/parser.rb', line 1134

def visit_unless_mod(node)
  s(:if, [visit(node.predicate), nil, visit(node.statement)])
end

#visit_until(node) ⇒ Object 



1138
1139
1140
 
# File 'lib/syntax_tree/translator/parser.rb', line 1138

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

#visit_until_mod(node) ⇒ Object 



1142
1143
1144
1145
 
# File 'lib/syntax_tree/translator/parser.rb', line 1142

def visit_until_mod(node)
  children = [visit(node.predicate), visit(node.statement)]
  s((node.statement in Begin) ? :until_post : :until, children)
end

#visit_var_alias(node) ⇒ Object 



1147
1148
1149
 
# File 'lib/syntax_tree/translator/parser.rb', line 1147

def visit_var_alias(node)
  s(:alias, [visit(node.left), visit(node.right)])
end

#visit_var_field(node) ⇒ Object 



1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
 
# File 'lib/syntax_tree/translator/parser.rb', line 1151

def visit_var_field(node)
  if stack[-2] in AryPtn | Binary[operator: :"=>"] | FndPtn | HshPtn | In | RAssign
    return s(:match_var, [node.value.value.to_sym])
  end

  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(:lvasgn, [value.to_sym])
  in IVar[value:] then s(:ivasgn, [value.to_sym])
  in VarRef[value:] then s(:lvasgn, [value.to_sym])
  in nil then s(:match_rest)
  end
end

#visit_var_ref(node) ⇒ Object 



1167
1168
1169
 
# File 'lib/syntax_tree/translator/parser.rb', line 1167

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

#visit_vcall(node) ⇒ Object 



1171
1172
1173
1174
1175
1176
 
# File 'lib/syntax_tree/translator/parser.rb', line 1171

def visit_vcall(node)
  range = ::Parser::Source::Range.new(buffer, node.location.start_char, node.location.end_char)
  location = ::Parser::Source::Map::Send.new(nil, range, nil, nil, range)

  s(:send, [nil, node.value.value.to_sym], location: location)
end

#visit_void_stmt(node) ⇒ Object 



1178
1179
1180
 
# File 'lib/syntax_tree/translator/parser.rb', line 1178

def visit_void_stmt(node)
  raise
end

#visit_when(node) ⇒ Object 



1182
1183
1184
 
# File 'lib/syntax_tree/translator/parser.rb', line 1182

def visit_when(node)
  s(:when, visit_all(node.arguments.parts) + [visit(node.statements)])
end

#visit_while(node) ⇒ Object 



1186
1187
1188
 
# File 'lib/syntax_tree/translator/parser.rb', line 1186

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

#visit_while_mod(node) ⇒ Object 



1190
1191
1192
1193
 
# File 'lib/syntax_tree/translator/parser.rb', line 1190

def visit_while_mod(node)
  children = [visit(node.predicate), visit(node.statement)]
  s((node.statement in Begin) ? :while_post : :while, children)
end

#visit_word(node) ⇒ Object 



1195
1196
1197
1198
1199
1200
1201
1202
 
# File 'lib/syntax_tree/translator/parser.rb', line 1195

def visit_word(node)
  case node
  in { parts: [TStringContent => part] }
    visit(part)
  else
    s(:dstr, visit_all(node.parts))
  end
end

#visit_words(node) ⇒ Object 



1204
1205
1206
 
# File 'lib/syntax_tree/translator/parser.rb', line 1204

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

#visit_words_beg(node) ⇒ Object 



1208
1209
1210
 
# File 'lib/syntax_tree/translator/parser.rb', line 1208

def visit_words_beg(node)
  raise
end

#visit_xstring(node) ⇒ Object 



1212
1213
1214
 
# File 'lib/syntax_tree/translator/parser.rb', line 1212

def visit_xstring(node)
  raise
end

#visit_xstring_literal(node) ⇒ Object 



1216
1217
1218
 
# File 'lib/syntax_tree/translator/parser.rb', line 1216

def visit_xstring_literal(node)
  s(:xstr, visit_all(node.parts))
end

#visit_yield(node) ⇒ Object 



1220
1221
1222
1223
1224
1225
1226
1227
 
# File 'lib/syntax_tree/translator/parser.rb', line 1220

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

#visit_yield0(node) ⇒ Object 



1229
1230
1231
 
# File 'lib/syntax_tree/translator/parser.rb', line 1229

def visit_yield0(node)
  s(:yield)
end

#visit_zsuper(node) ⇒ Object 



1233
1234
1235
 
# File 'lib/syntax_tree/translator/parser.rb', line 1233

def visit_zsuper(node)
  s(:zsuper)
end