sexp_processor 3.2.0 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. data.tar.gz.sig +0 -0
  2. data/History.txt +14 -0
  3. data/README.txt +1 -2
  4. data/lib/pt_testcase.rb +561 -808
  5. data/lib/sexp.rb +23 -1
  6. data/lib/sexp_processor.rb +1 -1
  7. metadata +9 -9
  8. metadata.gz.sig +0 -0
data.tar.gz.sig CHANGED
Binary file
data/History.txt CHANGED
@@ -1,3 +1,17 @@
1
+ === 4.0.0 / 2012-06-07
2
+
3
+ * 5 major enhancements:
4
+
5
+ * Removed :arglist from everything except :op_asgn1.
6
+ * Removed block from resbody
7
+ * Removed block from when node
8
+ * Removed block nodes inside of scope nodes (defn/defs/class/sclass).
9
+ * Removed scope nodes in defn/defs/class/sclass nodes.
10
+
11
+ * 1 minor enhancement:
12
+
13
+ * Added Sexp#deep_each and Sexp#each_sexp. Refactored from Flay
14
+
1
15
  === 3.2.0 / 2012-04-15
2
16
 
3
17
  * 5 minor enhancements:
data/README.txt CHANGED
@@ -1,8 +1,7 @@
1
1
  = SexpProcessor
2
2
 
3
3
  home :: https://github.com/seattlerb/sexp_processor
4
- rdoc :: http://parsetree.rubyforge.org/sexp_processor
5
- * http://rubyforge.org/projects/parsetree/
4
+ rdoc :: http://docs.seattlerb.org/sexp_processor
6
5
 
7
6
  == DESCRIPTION:
8
7
 
data/lib/pt_testcase.rb CHANGED
@@ -219,46 +219,45 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
219
219
  add_tests("alias",
220
220
  "Ruby" => "class X\n alias :y :x\nend",
221
221
  "ParseTree" => s(:class, :X, nil,
222
- s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))))
222
+ s(:alias, s(:lit, :y), s(:lit, :x))))
223
223
 
224
224
  add_tests("alias_ugh",
225
225
  "Ruby" => "class X\n alias y x\nend",
226
226
  "ParseTree" => s(:class, :X, nil,
227
- s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))),
227
+ s(:alias, s(:lit, :y), s(:lit, :x))),
228
228
  "Ruby2Ruby" => "class X\n alias :y :x\nend")
229
229
 
230
230
  add_tests("and",
231
231
  "Ruby" => "a and b",
232
232
  "ParseTree" => s(:and,
233
- s(:call, nil, :a, s(:arglist)),
234
- s(:call, nil, :b, s(:arglist))))
233
+ s(:call, nil, :a),
234
+ s(:call, nil, :b)))
235
235
 
236
236
  add_tests("argscat_inside",
237
237
  "Ruby" => "a = [b, *c]",
238
238
  "ParseTree" => s(:lasgn, :a,
239
239
  s(:array,
240
- s(:call, nil, :b, s(:arglist)),
241
- s(:splat, s(:call, nil, :c, s(:arglist))))))
240
+ s(:call, nil, :b),
241
+ s(:splat, s(:call, nil, :c)))))
242
242
 
243
243
  add_tests("argscat_svalue",
244
244
  "Ruby" => "a = b, c, *d",
245
245
  "ParseTree" => s(:lasgn, :a,
246
246
  s(:svalue,
247
247
  s(:array,
248
- s(:call, nil, :b, s(:arglist)),
249
- s(:call, nil, :c, s(:arglist)),
248
+ s(:call, nil, :b),
249
+ s(:call, nil, :c),
250
250
  s(:splat,
251
- s(:call, nil, :d, s(:arglist)))))))
251
+ s(:call, nil, :d))))))
252
252
 
253
253
  add_tests("argspush",
254
254
  "Ruby" => "a[*b] = c",
255
255
  "ParseTree" => s(:attrasgn,
256
- s(:call, nil, :a, s(:arglist)),
256
+ s(:call, nil, :a),
257
257
  :[]=,
258
- s(:arglist,
259
- s(:splat,
260
- s(:call, nil, :b, s(:arglist))),
261
- s(:call, nil, :c, s(:arglist)))))
258
+ s(:splat,
259
+ s(:call, nil, :b)),
260
+ s(:call, nil, :c)))
262
261
 
263
262
  add_tests("array",
264
263
  "Ruby" => "[1, :b, \"c\"]",
@@ -296,22 +295,22 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
296
295
  "Ruby" => "y = 0\n42.method = y\n",
297
296
  "ParseTree" => s(:block,
298
297
  s(:lasgn, :y, s(:lit, 0)),
299
- s(:attrasgn, s(:lit, 42), :method=,
300
- s(:arglist, s(:lvar, :y)))))
298
+ s(:attrasgn,
299
+ s(:lit, 42), :method=, s(:lvar, :y))))
301
300
 
302
301
  add_tests("attrasgn_index_equals",
303
302
  "Ruby" => "a[42] = 24",
304
303
  "ParseTree" => s(:attrasgn,
305
- s(:call, nil, :a, s(:arglist)),
304
+ s(:call, nil, :a),
306
305
  :[]=,
307
- s(:arglist, s(:lit, 42), s(:lit, 24))))
306
+ s(:lit, 42), s(:lit, 24)))
308
307
 
309
308
  add_tests("attrasgn_index_equals_space",
310
309
  "Ruby" => "a = []; a [42] = 24",
311
310
  "ParseTree" => s(:block,
312
311
  s(:lasgn, :a, s(:array)),
313
312
  s(:attrasgn, s(:lvar, :a), :[]=,
314
- s(:arglist, s(:lit, 42), s(:lit, 24)))),
313
+ s(:lit, 42), s(:lit, 24))),
315
314
  "Ruby2Ruby" => "a = []\na[42] = 24\n")
316
315
 
317
316
  add_tests("attrset",
@@ -331,21 +330,19 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
331
330
 
332
331
  add_tests("begin",
333
332
  "Ruby" => "begin\n (1 + 1)\nend",
334
- "ParseTree" => s(:call, s(:lit, 1), :+,
335
- s(:arglist, s(:lit, 1))),
333
+ "ParseTree" => s(:call, s(:lit, 1), :+, s(:lit, 1)),
336
334
  "Ruby2Ruby" => "(1 + 1)")
337
335
 
338
336
  add_tests("begin_def",
339
337
  "Ruby" => "def m\n begin\n\n end\nend",
340
- "ParseTree" => s(:defn, :m, s(:args),
341
- s(:scope, s(:block, s(:nil)))),
338
+ "ParseTree" => s(:defn, :m, s(:args), s(:nil)),
342
339
  "Ruby2Ruby" => "def m\n # do nothing\nend")
343
340
 
344
341
  add_tests("begin_rescue_ensure",
345
342
  "Ruby" => "begin\n a\nrescue\n # do nothing\nensure\n # do nothing\nend",
346
343
  "ParseTree" => s(:ensure,
347
344
  s(:rescue,
348
- s(:call, nil, :a, s(:arglist)),
345
+ s(:call, nil, :a),
349
346
  s(:resbody, s(:array), nil)),
350
347
  s(:nil)))
351
348
 
@@ -360,12 +357,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
360
357
  "Ruby" => "begin\n a\nrescue => mes\n # do nothing\nend\nbegin\n b\nrescue => mes\n # do nothing\nend\n",
361
358
  "ParseTree" => s(:block,
362
359
  s(:rescue,
363
- s(:call, nil, :a, s(:arglist)),
360
+ s(:call, nil, :a),
364
361
  s(:resbody,
365
362
  s(:array, s(:lasgn, :mes, s(:gvar, :$!))),
366
363
  nil)),
367
364
  s(:rescue,
368
- s(:call, nil, :b, s(:arglist)),
365
+ s(:call, nil, :b),
369
366
  s(:resbody,
370
367
  s(:array,
371
368
  s(:lasgn, :mes, s(:gvar, :$!))),
@@ -378,13 +375,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
378
375
  "Ruby" => "def self.setup(ctx)\n bind = allocate\n bind.context = ctx\n return bind\nend",
379
376
  "ParseTree" => s(:defs, s(:self), :setup,
380
377
  s(:args, :ctx),
381
- s(:scope,
382
- s(:block,
383
- s(:lasgn, :bind,
384
- s(:call, nil, :allocate, s(:arglist))),
385
- s(:attrasgn, s(:lvar, :bind), :context=,
386
- s(:arglist, s(:lvar, :ctx))),
387
- s(:return, s(:lvar, :bind))))))
378
+ s(:lasgn, :bind, s(:call, nil, :allocate)),
379
+ s(:attrasgn,
380
+ s(:lvar, :bind), :context=, s(:lvar, :ctx)),
381
+ s(:return, s(:lvar, :bind))))
388
382
 
389
383
 
390
384
  add_tests("block_lasgn",
@@ -392,137 +386,109 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
392
386
  "ParseTree" => s(:lasgn, :x,
393
387
  s(:block,
394
388
  s(:lasgn, :y, s(:lit, 1)),
395
- s(:call, s(:lvar, :y), :+,
396
- s(:arglist, s(:lit, 2))))))
389
+ s(:call, s(:lvar, :y), :+, s(:lit, 2)))))
397
390
 
398
391
  add_tests("block_mystery_block",
399
392
  "Ruby" => "a(b) do\n if b then\n true\n else\n c = false\n d { |x| c = true }\n c\n end\nend",
400
393
  "ParseTree" => s(:iter,
401
- s(:call, nil, :a,
402
- s(:arglist, s(:call, nil, :b, s(:arglist)))),
394
+ s(:call, nil, :a, s(:call, nil, :b)),
403
395
  nil,
404
396
  s(:if,
405
- s(:call, nil, :b, s(:arglist)),
397
+ s(:call, nil, :b),
406
398
  s(:true),
407
399
  s(:block,
408
400
  s(:lasgn, :c, s(:false)),
409
401
  s(:iter,
410
- s(:call, nil, :d, s(:arglist)),
402
+ s(:call, nil, :d),
411
403
  s(:lasgn, :x),
412
404
  s(:lasgn, :c, s(:true))),
413
405
  s(:lvar, :c)))))
414
406
 
415
407
  add_tests("block_pass_args_and_splat",
416
408
  "Ruby" => "def blah(*args, &block)\n other(42, *args, &block)\nend",
417
- "ParseTree" => s(:defn, :blah,
418
- s(:args, :"*args", :"&block"),
419
- s(:scope,
420
- s(:block,
421
- s(:call, nil, :other,
422
- s(:arglist,
423
- s(:lit, 42),
424
- s(:splat, s(:lvar, :args)),
425
- s(:block_pass, s(:lvar, :block))))))))
409
+ "ParseTree" => s(:defn, :blah, s(:args, :"*args", :"&block"),
410
+ s(:call, nil, :other,
411
+ s(:lit, 42),
412
+ s(:splat, s(:lvar, :args)),
413
+ s(:block_pass, s(:lvar, :block)))))
426
414
 
427
415
  add_tests("block_pass_call_0",
428
416
  "Ruby" => "a.b(&c)",
429
417
  "ParseTree" => s(:call,
430
- s(:call, nil, :a, s(:arglist)),
418
+ s(:call, nil, :a),
431
419
  :b,
432
- s(:arglist,
433
- s(:block_pass,
434
- s(:call, nil, :c, s(:arglist))))))
420
+ s(:block_pass, s(:call, nil, :c))))
435
421
 
436
422
  add_tests("block_pass_call_1",
437
423
  "Ruby" => "a.b(4, &c)",
438
424
  "ParseTree" => s(:call,
439
- s(:call, nil, :a, s(:arglist)),
425
+ s(:call, nil, :a),
440
426
  :b,
441
- s(:arglist,
442
- s(:lit, 4),
443
- s(:block_pass,
444
- s(:call, nil, :c, s(:arglist))))))
427
+ s(:lit, 4),
428
+ s(:block_pass, s(:call, nil, :c))))
445
429
 
446
430
  add_tests("block_pass_call_n",
447
431
  "Ruby" => "a.b(1, 2, 3, &c)",
448
432
  "ParseTree" => s(:call,
449
- s(:call, nil, :a, s(:arglist)),
433
+ s(:call, nil, :a),
450
434
  :b,
451
- s(:arglist,
452
- s(:lit, 1), s(:lit, 2), s(:lit, 3),
453
- s(:block_pass,
454
- s(:call, nil, :c, s(:arglist))))))
435
+ s(:lit, 1), s(:lit, 2), s(:lit, 3),
436
+ s(:block_pass, s(:call, nil, :c))))
455
437
 
456
438
  add_tests("block_pass_fcall_0",
457
439
  "Ruby" => "a(&b)",
458
440
  "ParseTree" => s(:call, nil, :a,
459
- s(:arglist,
460
- s(:block_pass,
461
- s(:call, nil, :b, s(:arglist))))))
441
+ s(:block_pass, s(:call, nil, :b))))
462
442
 
463
443
  add_tests("block_pass_fcall_1",
464
444
  "Ruby" => "a(4, &b)",
465
445
  "ParseTree" => s(:call, nil, :a,
466
- s(:arglist,
467
- s(:lit, 4),
468
- s(:block_pass,
469
- s(:call, nil, :b, s(:arglist))))))
446
+ s(:lit, 4),
447
+ s(:block_pass, s(:call, nil, :b))))
470
448
 
471
449
  add_tests("block_pass_fcall_n",
472
450
  "Ruby" => "a(1, 2, 3, &b)",
473
451
  "ParseTree" => s(:call, nil, :a,
474
- s(:arglist,
475
- s(:lit, 1), s(:lit, 2), s(:lit, 3),
476
- s(:block_pass,
477
- s(:call, nil, :b, s(:arglist))))))
452
+ s(:lit, 1), s(:lit, 2), s(:lit, 3),
453
+ s(:block_pass, s(:call, nil, :b))))
478
454
 
479
455
  add_tests("block_pass_omgwtf",
480
456
  "Ruby" => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
481
457
  "ParseTree" => s(:call, nil, :define_attr_method,
482
- s(:arglist,
483
- s(:lit, :x),
484
- s(:lit, :sequence_name),
485
- s(:block_pass,
486
- s(:iter,
487
- s(:call, s(:const, :Proc), :new,
488
- s(:arglist)),
489
- s(:masgn,
490
- s(:array, s(:splat, s(:lasgn, :args)))),
491
- s(:nil))))))
458
+ s(:lit, :x),
459
+ s(:lit, :sequence_name),
460
+ s(:block_pass,
461
+ s(:iter,
462
+ s(:call, s(:const, :Proc), :new),
463
+ s(:masgn,
464
+ s(:array, s(:splat, s(:lasgn, :args)))),
465
+ s(:nil)))))
492
466
 
493
467
  add_tests("block_pass_splat",
494
468
  "Ruby" => "def blah(*args, &block)\n other(*args, &block)\nend",
495
469
  "ParseTree" => s(:defn, :blah,
496
470
  s(:args, :"*args", :"&block"),
497
- s(:scope,
498
- s(:block,
499
- s(:call, nil, :other,
500
- s(:arglist,
501
- s(:splat, s(:lvar, :args)),
502
- s(:block_pass, s(:lvar, :block))))))))
471
+ s(:call, nil, :other,
472
+ s(:splat, s(:lvar, :args)),
473
+ s(:block_pass, s(:lvar, :block)))))
503
474
 
504
475
  add_tests("block_pass_thingy",
505
476
  "Ruby" => "r.read_body(dest, &block)",
506
477
  "ParseTree" => s(:call,
507
- s(:call, nil, :r, s(:arglist)),
478
+ s(:call, nil, :r),
508
479
  :read_body,
509
- s(:arglist,
510
- s(:call, nil, :dest, s(:arglist)),
511
- s(:block_pass,
512
- s(:call, nil, :block, s(:arglist))))))
480
+ s(:call, nil, :dest),
481
+ s(:block_pass, s(:call, nil, :block))))
513
482
 
514
483
  add_tests("block_stmt_after",
515
484
  "Ruby" => "def f\n begin\n b\n rescue\n c\n end\n\n d\nend",
516
- "ParseTree" => s(:defn, :f,
517
- s(:args),
518
- s(:scope,
519
- s(:block,
520
- s(:rescue,
521
- s(:call, nil, :b, s(:arglist)),
522
- s(:resbody,
523
- s(:array),
524
- s(:call, nil, :c, s(:arglist)))),
525
- s(:call, nil, :d, s(:arglist))))),
485
+ "ParseTree" => s(:defn, :f, s(:args),
486
+ s(:rescue,
487
+ s(:call, nil, :b),
488
+ s(:resbody,
489
+ s(:array),
490
+ s(:call, nil, :c))),
491
+ s(:call, nil, :d)),
526
492
  "Ruby2Ruby" => "def f\n b rescue c\n d\nend")
527
493
 
528
494
  copy_test_case "block_stmt_after", "Ruby"
@@ -531,15 +497,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
531
497
 
532
498
  add_tests("block_stmt_before",
533
499
  "Ruby" => "def f\n a\n begin\n b\n rescue\n c\n end\nend",
534
- "ParseTree" => s(:defn, :f,
535
- s(:args),
536
- s(:scope,
537
- s(:block,
538
- s(:call, nil, :a, s(:arglist)),
539
- s(:rescue, s(:call, nil, :b, s(:arglist)),
540
- s(:resbody,
541
- s(:array),
542
- s(:call, nil, :c, s(:arglist))))))),
500
+ "ParseTree" => s(:defn, :f, s(:args),
501
+ s(:call, nil, :a),
502
+ s(:rescue, s(:call, nil, :b),
503
+ s(:resbody,
504
+ s(:array),
505
+ s(:call, nil, :c)))),
543
506
  "Ruby2Ruby" => "def f\n a\n b rescue c\nend")
544
507
 
545
508
  # oddly... this one doesn't HAVE any differences when verbose... new?
@@ -550,15 +513,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
550
513
  add_tests("block_stmt_both",
551
514
  "Ruby" => "def f\n a\n begin\n b\n rescue\n c\n end\n d\nend",
552
515
  "ParseTree" => s(:defn, :f, s(:args),
553
- s(:scope,
554
- s(:block,
555
- s(:call, nil, :a, s(:arglist)),
556
- s(:rescue,
557
- s(:call, nil, :b, s(:arglist)),
558
- s(:resbody,
559
- s(:array),
560
- s(:call, nil, :c, s(:arglist)))),
561
- s(:call, nil, :d, s(:arglist))))),
516
+ s(:call, nil, :a),
517
+ s(:rescue,
518
+ s(:call, nil, :b),
519
+ s(:resbody,
520
+ s(:array),
521
+ s(:call, nil, :c))),
522
+ s(:call, nil, :d)),
562
523
  "Ruby2Ruby" => "def f\n a\n b rescue c\n d\nend")
563
524
 
564
525
  copy_test_case "block_stmt_both", "Ruby"
@@ -567,65 +528,50 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
567
528
 
568
529
  add_tests("bmethod",
569
530
  "Ruby" => [Examples, :unsplatted],
570
- "ParseTree" => s(:defn, :unsplatted,
571
- s(:args, :x),
572
- s(:scope,
573
- s(:block,
574
- s(:call,
575
- s(:lvar, :x),
576
- :+,
577
- s(:arglist, s(:lit, 1)))))),
531
+ "ParseTree" => s(:defn, :unsplatted, s(:args, :x),
532
+ s(:call, s(:lvar, :x), :+, s(:lit, 1))),
578
533
  "Ruby2Ruby" => "def unsplatted(x)\n (x + 1)\nend")
579
534
 
580
535
  add_tests("bmethod_noargs",
581
536
  "Ruby" => [Examples, :bmethod_noargs],
582
- "ParseTree" => s(:defn, :bmethod_noargs,
583
- s(:args),
584
- s(:scope,
585
- s(:block,
586
- s(:call,
587
- s(:call, nil, :x, s(:arglist)),
588
- :"+",
589
- s(:arglist, s(:lit, 1)))))),
537
+ "ParseTree" => s(:defn, :bmethod_noargs, s(:args),
538
+ s(:call,
539
+ s(:call, nil, :x),
540
+ :"+",
541
+ s(:lit, 1))),
590
542
  "Ruby2Ruby" => "def bmethod_noargs\n (x + 1)\nend")
591
543
 
592
544
  add_tests("bmethod_splat",
593
545
  "Ruby" => [Examples, :splatted],
594
- "ParseTree" => s(:defn, :splatted,
595
- s(:args, :"*args"),
596
- s(:scope,
597
- s(:block,
598
- s(:lasgn, :y,
599
- s(:call, s(:lvar, :args), :first,
600
- s(:arglist))),
601
- s(:call, s(:lvar, :y), :+,
602
- s(:arglist, s(:lit, 42)))))),
546
+ "ParseTree" => s(:defn, :splatted, s(:args, :"*args"),
547
+ s(:lasgn, :y,
548
+ s(:call, s(:lvar, :args), :first)),
549
+ s(:call, s(:lvar, :y), :+, s(:lit, 42))),
603
550
  "Ruby2Ruby" => "def splatted(*args)\n y = args.first\n (y + 42)\nend")
604
551
 
605
552
  add_tests("break",
606
553
  "Ruby" => "loop { break if true }",
607
554
  "ParseTree" => s(:iter,
608
- s(:call, nil, :loop, s(:arglist)), nil,
555
+ s(:call, nil, :loop), nil,
609
556
  s(:if, s(:true), s(:break), nil)))
610
557
 
611
558
  add_tests("break_arg",
612
559
  "Ruby" => "loop { break 42 if true }",
613
560
  "ParseTree" => s(:iter,
614
- s(:call, nil, :loop, s(:arglist)), nil,
561
+ s(:call, nil, :loop), nil,
615
562
  s(:if, s(:true), s(:break, s(:lit, 42)), nil)))
616
563
 
617
564
  add_tests("call",
618
565
  "Ruby" => "self.method",
619
- "ParseTree" => s(:call, s(:self), :method, s(:arglist)))
566
+ "ParseTree" => s(:call, s(:self), :method))
620
567
 
621
568
  add_tests("call_arglist",
622
569
  "Ruby" => "o.puts(42)",
623
- "ParseTree" => s(:call, s(:call, nil, :o, s(:arglist)), :puts,
624
- s(:arglist, s(:lit, 42))))
570
+ "ParseTree" => s(:call, s(:call, nil, :o), :puts, s(:lit, 42)))
625
571
 
626
572
  add_tests("call_no_space_symbol",
627
573
  "Ruby" => "foo:bar",
628
- "ParseTree" => s(:call, nil, :foo, s(:arglist, s(:lit, :bar))),
574
+ "ParseTree" => s(:call, nil, :foo, s(:lit, :bar)),
629
575
  "Ruby2Ruby" => "foo(:bar)")
630
576
 
631
577
  add_tests("ternary_symbol_no_spaces",
@@ -637,13 +583,16 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
637
583
  "Ruby" => "1 ? m(a: 2) : 1",
638
584
  "ParseTree" => s(:if, s(:lit, 1),
639
585
  s(:call, nil, :m,
640
- s(:arglist,
641
- s(:hash, s(:lit, :a), s(:lit, 2)))),
586
+ s(:hash, s(:lit, :a), s(:lit, 2))),
642
587
  s(:lit, 1)))
643
588
 
644
589
  add_19tests("label_in_bare_hash_in_array_in_ternary",
645
590
  "Ruby" => "1 ? [:a, b: 2] : 1",
646
- "ParseTree" => s(:if, s(:lit, 1), s(:array, s(:lit, :a), s(:hash, s(:lit, :b), s(:lit, 2))), s(:lit, 1)))
591
+ "ParseTree" => s(:if, s(:lit, 1),
592
+ s(:array,
593
+ s(:lit, :a),
594
+ s(:hash, s(:lit, :b), s(:lit, 2))),
595
+ s(:lit, 1)))
647
596
 
648
597
  add_tests("ternary_nil_no_space",
649
598
  "Ruby" => "1 ? nil: 1",
@@ -653,38 +602,34 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
653
602
  add_tests("call_arglist_hash",
654
603
  "Ruby" => "o.m(:a => 1, :b => 2)",
655
604
  "ParseTree" => s(:call,
656
- s(:call, nil, :o, s(:arglist)), :m,
657
- s(:arglist,
658
- s(:hash,
659
- s(:lit, :a), s(:lit, 1),
660
- s(:lit, :b), s(:lit, 2)))))
605
+ s(:call, nil, :o), :m,
606
+ s(:hash,
607
+ s(:lit, :a), s(:lit, 1),
608
+ s(:lit, :b), s(:lit, 2))))
661
609
 
662
610
  add_tests("call_arglist_norm_hash",
663
611
  "Ruby" => "o.m(42, :a => 1, :b => 2)",
664
612
  "ParseTree" => s(:call,
665
- s(:call, nil, :o, s(:arglist)), :m,
666
- s(:arglist,
667
- s(:lit, 42),
668
- s(:hash,
669
- s(:lit, :a), s(:lit, 1),
670
- s(:lit, :b), s(:lit, 2)))))
613
+ s(:call, nil, :o), :m,
614
+ s(:lit, 42),
615
+ s(:hash,
616
+ s(:lit, :a), s(:lit, 1),
617
+ s(:lit, :b), s(:lit, 2))))
671
618
 
672
619
  add_tests("call_arglist_norm_hash_splat",
673
620
  "Ruby" => "o.m(42, :a => 1, :b => 2, *c)",
674
621
  "ParseTree" => s(:call,
675
- s(:call, nil, :o, s(:arglist)), :m,
676
- s(:arglist,
677
- s(:lit, 42),
678
- s(:hash,
679
- s(:lit, :a), s(:lit, 1),
680
- s(:lit, :b), s(:lit, 2)),
681
- s(:splat, s(:call, nil, :c, s(:arglist))))))
622
+ s(:call, nil, :o), :m,
623
+ s(:lit, 42),
624
+ s(:hash,
625
+ s(:lit, :a), s(:lit, 1),
626
+ s(:lit, :b), s(:lit, 2)),
627
+ s(:splat, s(:call, nil, :c))))
682
628
 
683
629
  add_tests("call_arglist_space",
684
630
  "Ruby" => "a (1,2,3)",
685
631
  "ParseTree" => s(:call, nil, :a,
686
- s(:arglist,
687
- s(:lit, 1), s(:lit, 2), s(:lit, 3))),
632
+ s(:lit, 1), s(:lit, 2), s(:lit, 3)),
688
633
  "Ruby2Ruby" => "a(1, 2, 3)")
689
634
 
690
635
  add_tests("call_command",
@@ -692,44 +637,38 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
692
637
  "ParseTree" => s(:call,
693
638
  s(:lit, 1),
694
639
  :b,
695
- s(:arglist, s(:call, nil, :c, s(:arglist)))))
640
+ s(:call, nil, :c)))
696
641
 
697
642
  add_tests("call_expr",
698
643
  "Ruby" => "(v = (1 + 1)).zero?",
699
644
  "ParseTree" => s(:call,
700
645
  s(:lasgn, :v,
701
- s(:call, s(:lit, 1), :+,
702
- s(:arglist, s(:lit, 1)))),
703
- :zero?, s(:arglist)))
646
+ s(:call, s(:lit, 1), :+, s(:lit, 1))),
647
+ :zero?))
704
648
 
705
649
  add_tests("call_index",
706
650
  "Ruby" => "a = []\na[42]\n",
707
651
  "ParseTree" => s(:block,
708
652
  s(:lasgn, :a, s(:array)),
709
- s(:call, s(:lvar, :a), :[],
710
- s(:arglist, s(:lit, 42)))))
653
+ s(:call, s(:lvar, :a), :[], s(:lit, 42))))
711
654
 
712
655
  add_tests("call_index_no_args",
713
656
  "Ruby" => "a[]",
714
- "ParseTree" => s(:call, s(:call, nil, :a, s(:arglist)),
715
- :[], s(:arglist)))
657
+ "ParseTree" => s(:call, s(:call, nil, :a),
658
+ :[]))
716
659
 
717
660
  add_tests("call_index_space",
718
661
  "Ruby" => "a = []\na [42]\n",
719
662
  "ParseTree" => s(:block,
720
663
  s(:lasgn, :a, s(:array)),
721
- s(:call, s(:lvar, :a), :[],
722
- s(:arglist, s(:lit, 42)))),
664
+ s(:call, s(:lvar, :a), :[], s(:lit, 42))),
723
665
  "Ruby2Ruby" => "a = []\na[42]\n")
724
666
 
725
667
  add_tests("call_unary_neg",
726
668
  "Ruby" => "-2**31",
727
669
  "ParseTree" => s(:call,
728
- s(:call,
729
- s(:lit, 2),
730
- :**,
731
- s(:arglist, s(:lit, 31))),
732
- :-@, s(:arglist)),
670
+ s(:call, s(:lit, 2), :**, s(:lit, 31)),
671
+ :-@),
733
672
  "Ruby2Ruby" => "-(2 ** 31)")
734
673
 
735
674
  add_tests("case",
@@ -741,10 +680,8 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
741
680
  s(:lvar, :var),
742
681
  s(:when,
743
682
  s(:array, s(:lit, 1)),
744
- s(:block,
745
- s(:call, nil, :puts,
746
- s(:arglist, s(:str, "something"))),
747
- s(:lasgn, :result, s(:str, "red")))),
683
+ s(:call, nil, :puts, s(:str, "something")),
684
+ s(:lasgn, :result, s(:str, "red"))),
748
685
  s(:when,
749
686
  s(:array, s(:lit, 2), s(:lit, 3)),
750
687
  s(:lasgn, :result, s(:str, "yellow"))),
@@ -788,16 +725,16 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
788
725
 
789
726
  add_tests("case_nested_inner_no_expr",
790
727
  "Ruby" => "case a\nwhen b then\n case\n when (d and e) then\n f\n else\n # do nothing\n end\nelse\n # do nothing\nend",
791
- "ParseTree" => s(:case, s(:call, nil, :a, s(:arglist)),
728
+ "ParseTree" => s(:case, s(:call, nil, :a),
792
729
  s(:when,
793
- s(:array, s(:call, nil, :b, s(:arglist))),
730
+ s(:array, s(:call, nil, :b)),
794
731
  s(:case, nil,
795
732
  s(:when,
796
733
  s(:array,
797
734
  s(:and,
798
- s(:call, nil, :d, s(:arglist)),
799
- s(:call, nil, :e, s(:arglist)))),
800
- s(:call, nil, :f, s(:arglist))),
735
+ s(:call, nil, :d),
736
+ s(:call, nil, :e))),
737
+ s(:call, nil, :f)),
801
738
  nil)),
802
739
  nil))
803
740
 
@@ -807,84 +744,64 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
807
744
  s(:when,
808
745
  s(:array,
809
746
  s(:call,
810
- s(:call, nil, :a, s(:arglist)),
747
+ s(:call, nil, :a),
811
748
  :==,
812
- s(:arglist, s(:lit, 1)))),
749
+ s(:lit, 1))),
813
750
  s(:lit, :a)),
814
751
  s(:when,
815
752
  s(:array,
816
753
  s(:call,
817
- s(:call, nil, :a, s(:arglist)),
754
+ s(:call, nil, :a),
818
755
  :==,
819
- s(:arglist, s(:lit, 2)))),
756
+ s(:lit, 2))),
820
757
  s(:lit, :b)),
821
758
  s(:lit, :c)))
822
759
 
823
760
  add_tests("case_splat",
824
761
  "Ruby" => "case a\nwhen :b, *c then\n d\nelse\n e\nend",
825
- "ParseTree" => s(:case, s(:call, nil, :a, s(:arglist)),
762
+ "ParseTree" => s(:case, s(:call, nil, :a),
826
763
  s(:when,
827
764
  s(:array,
828
765
  s(:lit, :b),
829
766
  s(:when,
830
- s(:call, nil, :c, s(:arglist)),
767
+ s(:call, nil, :c),
831
768
  nil)), # wtf?
832
- s(:call, nil, :d, s(:arglist))),
833
- s(:call, nil, :e, s(:arglist))))
769
+ s(:call, nil, :d)),
770
+ s(:call, nil, :e)))
834
771
 
835
772
  add_tests("cdecl",
836
773
  "Ruby" => "X = 42",
837
774
  "ParseTree" => s(:cdecl, :X, s(:lit, 42)))
838
775
 
839
776
  add_tests("class_plain",
840
- "Ruby" => "class X\n puts((1 + 1))\n def blah\n puts(\"hello\")\n end\nend",
841
- "ParseTree" => s(:class,
842
- :X,
843
- nil,
844
- s(:scope,
845
- s(:block,
846
- s(:call, nil, :puts,
847
- s(:arglist,
848
- s(:call, s(:lit, 1), :+,
849
- s(:arglist, s(:lit, 1))))),
850
- s(:defn, :blah,
851
- s(:args),
852
- s(:scope,
853
- s(:block,
854
- s(:call, nil, :puts,
855
- s(:arglist,
856
- s(:str, "hello"))))))))))
777
+ "Ruby" => "class X\n puts((1 + 1))\n \n def blah\n puts(\"hello\")\n end\nend",
778
+ "ParseTree" => s(:class, :X, nil,
779
+ s(:call, nil, :puts,
780
+ s(:call, s(:lit, 1), :+, s(:lit, 1))),
781
+ s(:defn, :blah, s(:args),
782
+ s(:call, nil, :puts, s(:str, "hello")))))
857
783
 
858
784
  add_tests("class_scoped",
859
785
  "Ruby" => "class X::Y\n c\nend",
860
786
  "ParseTree" => s(:class, s(:colon2, s(:const, :X), :Y), nil,
861
- s(:scope, s(:call, nil, :c, s(:arglist)))))
787
+ s(:call, nil, :c)))
862
788
 
863
789
  add_tests("class_scoped3",
864
790
  "Ruby" => "class ::Y\n c\nend",
865
791
  "ParseTree" => s(:class, s(:colon3, :Y), nil,
866
- s(:scope, s(:call, nil, :c, s(:arglist)))))
792
+ s(:call, nil, :c)))
867
793
 
868
794
  add_tests("class_super_array",
869
795
  "Ruby" => "class X < Array\nend",
870
- "ParseTree" => s(:class,
871
- :X,
872
- s(:const, :Array),
873
- s(:scope)))
796
+ "ParseTree" => s(:class, :X, s(:const, :Array)))
874
797
 
875
798
  add_tests("class_super_expr",
876
799
  "Ruby" => "class X < expr\nend",
877
- "ParseTree" => s(:class,
878
- :X,
879
- s(:call, nil, :expr, s(:arglist)),
880
- s(:scope)))
800
+ "ParseTree" => s(:class, :X, s(:call, nil, :expr)))
881
801
 
882
802
  add_tests("class_super_object",
883
803
  "Ruby" => "class X < Object\nend",
884
- "ParseTree" => s(:class,
885
- :X,
886
- s(:const, :Object),
887
- s(:scope)))
804
+ "ParseTree" => s(:class, :X, s(:const, :Object)))
888
805
 
889
806
  add_tests("colon2",
890
807
  "Ruby" => "X::Y",
@@ -918,84 +835,67 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
918
835
 
919
836
  add_tests("cvasgn",
920
837
  "Ruby" => "def x\n @@blah = 1\nend",
921
- "ParseTree" => s(:defn, :x,
922
- s(:args),
923
- s(:scope,
924
- s(:block,
925
- s(:cvasgn, :@@blah, s(:lit, 1))))))
838
+ "ParseTree" => s(:defn, :x, s(:args),
839
+ s(:cvasgn, :@@blah, s(:lit, 1))))
926
840
 
927
841
  add_tests("cvasgn_cls_method",
928
842
  "Ruby" => "def self.quiet_mode=(boolean)\n @@quiet_mode = boolean\nend",
929
843
  "ParseTree" => s(:defs, s(:self), :quiet_mode=,
930
844
  s(:args, :boolean),
931
- s(:scope,
932
- s(:block,
933
- s(:cvasgn, :@@quiet_mode,
934
- s(:lvar, :boolean))))))
845
+ s(:cvasgn, :@@quiet_mode,
846
+ s(:lvar, :boolean))))
935
847
 
936
848
  add_tests("cvdecl",
937
849
  "Ruby" => "class X\n @@blah = 1\nend",
938
850
  "ParseTree" => s(:class, :X, nil,
939
- s(:scope, s(:cvdecl, :@@blah, s(:lit, 1)))))
851
+ s(:cvdecl, :@@blah, s(:lit, 1))))
940
852
 
941
853
  add_tests("dasgn_0",
942
854
  "Ruby" => "a.each { |x| b.each { |y| x = (x + 1) } if true }",
943
855
  "ParseTree" => s(:iter,
944
- s(:call, s(:call, nil, :a, s(:arglist)), :each,
945
- s(:arglist)),
856
+ s(:call, s(:call, nil, :a), :each),
946
857
  s(:lasgn, :x),
947
858
  s(:if, s(:true),
948
859
  s(:iter,
949
- s(:call, s(:call, nil, :b, s(:arglist)),
950
- :each,
951
- s(:arglist)),
860
+ s(:call, s(:call, nil, :b), :each),
952
861
  s(:lasgn, :y),
953
862
  s(:lasgn, :x,
954
- s(:call, s(:lvar, :x), :+,
955
- s(:arglist, s(:lit, 1))))),
863
+ s(:call, s(:lvar, :x), :+, s(:lit, 1)))),
956
864
  nil)))
957
865
 
958
866
  add_tests("dasgn_1",
959
867
  "Ruby" => "a.each { |x| b.each { |y| c = (c + 1) } if true }",
960
868
  "ParseTree" => s(:iter,
961
- s(:call, s(:call, nil, :a, s(:arglist)), :each,
962
- s(:arglist)),
869
+ s(:call, s(:call, nil, :a), :each),
963
870
  s(:lasgn, :x),
964
871
  s(:if, s(:true),
965
872
  s(:iter,
966
- s(:call, s(:call, nil, :b, s(:arglist)),
967
- :each,
968
- s(:arglist)),
873
+ s(:call, s(:call, nil, :b), :each),
969
874
  s(:lasgn, :y),
970
875
  s(:lasgn, :c,
971
- s(:call, s(:lvar, :c), :+,
972
- s(:arglist, s(:lit, 1))))),
876
+ s(:call, s(:lvar, :c), :+, s(:lit, 1)))),
973
877
  nil)))
974
878
 
975
879
  add_tests("dasgn_2",
976
880
  "Ruby" => "a.each do |x|\n if true then\n c = 0\n b.each { |y| c = (c + 1) }\n end\nend", # FIX: hate that extra newline!
977
881
  "ParseTree" => s(:iter,
978
- s(:call, s(:call, nil, :a, s(:arglist)), :each,
979
- s(:arglist)),
882
+ s(:call, s(:call, nil, :a), :each),
980
883
  s(:lasgn, :x),
981
884
  s(:if, s(:true),
982
885
  s(:block,
983
886
  s(:lasgn, :c, s(:lit, 0)),
984
887
  s(:iter,
985
- s(:call, s(:call, nil, :b, s(:arglist)),
986
- :each,
987
- s(:arglist)),
888
+ s(:call, s(:call, nil, :b), :each),
988
889
  s(:lasgn, :y),
989
890
  s(:lasgn, :c,
990
891
  s(:call, s(:lvar, :c), :+,
991
- s(:arglist, s(:lit, 1)))))),
892
+ s(:lit, 1))))),
992
893
  nil)))
993
894
 
994
895
  add_tests("dasgn_curr",
995
896
  "Ruby" => "data.each do |x, y|\n a = 1\n b = a\n b = a = x\nend",
996
897
  "ParseTree" => s(:iter,
997
- s(:call, s(:call, nil, :data,
998
- s(:arglist)), :each, s(:arglist)),
898
+ s(:call, s(:call, nil, :data), :each),
999
899
  s(:masgn,
1000
900
  s(:array, s(:lasgn, :x), s(:lasgn, :y))),
1001
901
  s(:block,
@@ -1006,15 +906,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1006
906
  add_tests("dasgn_icky",
1007
907
  "Ruby" => "a do\n v = nil\n assert_block(full_message) do\n begin\n yield\n rescue Exception => v\n break\n end\n end\nend",
1008
908
  "ParseTree" => s(:iter,
1009
- s(:call, nil, :a, s(:arglist)),
909
+ s(:call, nil, :a),
1010
910
  nil,
1011
911
  s(:block,
1012
912
  s(:lasgn, :v, s(:nil)),
1013
913
  s(:iter,
1014
914
  s(:call, nil, :assert_block,
1015
- s(:arglist,
1016
- s(:call, nil, :full_message,
1017
- s(:arglist)))),
915
+ s(:call, nil, :full_message)),
1018
916
  nil,
1019
917
  s(:rescue,
1020
918
  s(:yield),
@@ -1029,12 +927,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1029
927
  "ParseTree" => s(:block,
1030
928
  s(:lasgn, :t, s(:lit, 0)),
1031
929
  s(:iter,
1032
- s(:call, s(:call, nil, :ns,
1033
- s(:arglist)), :each, s(:arglist)),
930
+ s(:call, s(:call, nil, :ns), :each),
1034
931
  s(:lasgn, :n),
1035
932
  s(:lasgn, :t,
1036
- s(:call, s(:lvar, :t), :+,
1037
- s(:arglist, s(:lvar, :n)))))),
933
+ s(:call, s(:lvar, :t), :+, s(:lvar, :n))))),
1038
934
  "Ruby2Ruby" => "t = 0\nns.each { |n| t = (t + n) }\n")
1039
935
 
1040
936
  add_tests("defined",
@@ -1044,21 +940,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1044
940
  # TODO: make all the defn_args* p their arglist
1045
941
  add_tests("defn_args_block",
1046
942
  "Ruby" => "def f(&block)\n # do nothing\nend",
1047
- "ParseTree" => s(:defn, :f,
1048
- s(:args, :"&block"),
1049
- s(:scope, s(:block, s(:nil)))))
943
+ "ParseTree" => s(:defn, :f, s(:args, :"&block"),
944
+ s(:nil)))
1050
945
 
1051
946
  add_tests("defn_args_mand",
1052
947
  "Ruby" => "def f(mand)\n # do nothing\nend",
1053
- "ParseTree" => s(:defn, :f,
1054
- s(:args, :mand),
1055
- s(:scope, s(:block, s(:nil)))))
948
+ "ParseTree" => s(:defn, :f, s(:args, :mand),
949
+ s(:nil)))
1056
950
 
1057
951
  add_tests("defn_args_mand_block",
1058
952
  "Ruby" => "def f(mand, &block)\n # do nothing\nend",
1059
- "ParseTree" => s(:defn, :f,
1060
- s(:args, :mand, :"&block"),
1061
- s(:scope, s(:block, s(:nil)))))
953
+ "ParseTree" => s(:defn, :f, s(:args, :mand, :"&block"),
954
+ s(:nil)))
1062
955
 
1063
956
  add_tests("defn_args_mand_opt",
1064
957
  "Ruby" => "def f(mand, opt = 42)\n # do nothing\nend",
@@ -1066,7 +959,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1066
959
  s(:args, :mand, :opt,
1067
960
  s(:block,
1068
961
  s(:lasgn, :opt, s(:lit, 42)))),
1069
- s(:scope, s(:block, s(:nil)))))
962
+ s(:nil)))
1070
963
 
1071
964
  add_tests("defn_args_mand_opt_block",
1072
965
  "Ruby" => "def f(mand, opt = 42, &block)\n # do nothing\nend",
@@ -1074,7 +967,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1074
967
  s(:args, :mand, :opt, :"&block",
1075
968
  s(:block,
1076
969
  s(:lasgn, :opt, s(:lit, 42)))),
1077
- s(:scope, s(:block, s(:nil)))))
970
+ s(:nil)))
1078
971
 
1079
972
  add_tests("defn_args_mand_opt_splat",
1080
973
  "Ruby" => "def f(mand, opt = 42, *rest)\n # do nothing\nend",
@@ -1082,7 +975,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1082
975
  s(:args, :mand, :opt, :"*rest",
1083
976
  s(:block,
1084
977
  s(:lasgn, :opt, s(:lit, 42)))),
1085
- s(:scope, s(:block, s(:nil)))))
978
+ s(:nil)))
1086
979
 
1087
980
  add_tests("defn_args_mand_opt_splat_block",
1088
981
  "Ruby" => "def f(mand, opt = 42, *rest, &block)\n # do nothing\nend",
@@ -1090,43 +983,37 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1090
983
  s(:args, :mand, :opt, :"*rest", :"&block",
1091
984
  s(:block,
1092
985
  s(:lasgn, :opt, s(:lit, 42)))),
1093
- s(:scope, s(:block, s(:nil)))))
986
+ s(:nil)))
1094
987
 
1095
988
  add_tests("defn_args_mand_opt_splat_no_name",
1096
989
  "Ruby" => "def x(a, b = 42, *)\n # do nothing\nend",
1097
990
  "ParseTree" => s(:defn, :x,
1098
991
  s(:args, :a, :b, :"*",
1099
992
  s(:block, s(:lasgn, :b, s(:lit, 42)))),
1100
- s(:scope,
1101
- s(:block,
1102
- s(:nil)))))
993
+ s(:nil)))
1103
994
 
1104
995
  add_tests("defn_args_mand_splat",
1105
996
  "Ruby" => "def f(mand, *rest)\n # do nothing\nend",
1106
997
  "ParseTree" => s(:defn, :f,
1107
998
  s(:args, :mand, :"*rest"),
1108
- s(:scope, s(:block, s(:nil)))))
1109
-
999
+ s(:nil)))
1000
+
1110
1001
  add_tests("defn_args_mand_splat_block",
1111
1002
  "Ruby" => "def f(mand, *rest, &block)\n # do nothing\nend",
1112
1003
  "ParseTree" => s(:defn, :f,
1113
1004
  s(:args, :mand, :"*rest", :"&block"),
1114
- s(:scope, s(:block, s(:nil)))))
1005
+ s(:nil)))
1115
1006
 
1116
1007
  add_tests("defn_args_mand_splat_no_name",
1117
1008
  "Ruby" => "def x(a, *args)\n p(a, args)\nend",
1118
- "ParseTree" => s(:defn, :x,
1119
- s(:args, :a, :"*args"),
1120
- s(:scope,
1121
- s(:block,
1122
- s(:call, nil, :p,
1123
- s(:arglist, s(:lvar, :a), s(:lvar, :args)))))))
1009
+ "ParseTree" => s(:defn, :x, s(:args, :a, :"*args"),
1010
+ s(:call, nil, :p,
1011
+ s(:lvar, :a), s(:lvar, :args))))
1124
1012
 
1125
1013
  add_tests("defn_args_none",
1126
1014
  "Ruby" => "def empty\n # do nothing\nend",
1127
- "ParseTree" => s(:defn, :empty,
1128
- s(:args),
1129
- s(:scope, s(:block, s(:nil)))))
1015
+ "ParseTree" => s(:defn, :empty, s(:args),
1016
+ s(:nil)))
1130
1017
 
1131
1018
  add_tests("defn_args_opt",
1132
1019
  "Ruby" => "def f(opt = 42)\n # do nothing\nend",
@@ -1134,7 +1021,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1134
1021
  s(:args, :opt,
1135
1022
  s(:block,
1136
1023
  s(:lasgn, :opt, s(:lit, 42)))),
1137
- s(:scope, s(:block, s(:nil)))))
1024
+ s(:nil)))
1138
1025
 
1139
1026
  add_tests("defn_args_opt_block",
1140
1027
  "Ruby" => "def f(opt = 42, &block)\n # do nothing\nend",
@@ -1142,7 +1029,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1142
1029
  s(:args, :opt, :"&block",
1143
1030
  s(:block,
1144
1031
  s(:lasgn, :opt, s(:lit, 42)))),
1145
- s(:scope, s(:block, s(:nil)))))
1032
+ s(:nil)))
1146
1033
 
1147
1034
  add_tests("defn_args_opt_splat",
1148
1035
  "Ruby" => "def f(opt = 42, *rest)\n # do nothing\nend",
@@ -1150,7 +1037,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1150
1037
  s(:args, :opt, :"*rest",
1151
1038
  s(:block,
1152
1039
  s(:lasgn, :opt, s(:lit, 42)))),
1153
- s(:scope, s(:block, s(:nil)))))
1040
+ s(:nil)))
1154
1041
 
1155
1042
  add_tests("defn_args_opt_splat_block",
1156
1043
  "Ruby" => "def f(opt = 42, *rest, &block)\n # do nothing\nend",
@@ -1158,152 +1045,119 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1158
1045
  s(:args, :opt, :"*rest", :"&block",
1159
1046
  s(:block,
1160
1047
  s(:lasgn, :opt, s(:lit, 42)))),
1161
- s(:scope, s(:block, s(:nil)))))
1048
+ s(:nil)))
1162
1049
 
1163
1050
  add_tests("defn_args_opt_splat_no_name",
1164
1051
  "Ruby" => "def x(b = 42, *)\n # do nothing\nend",
1165
1052
  "ParseTree" => s(:defn, :x,
1166
1053
  s(:args, :b, :"*",
1167
1054
  s(:block, s(:lasgn, :b, s(:lit, 42)))),
1168
- s(:scope,
1169
- s(:block,
1170
- s(:nil)))))
1055
+ s(:nil)))
1171
1056
 
1172
1057
  add_tests("defn_args_splat",
1173
1058
  "Ruby" => "def f(*rest)\n # do nothing\nend",
1174
- "ParseTree" => s(:defn, :f,
1175
- s(:args, :"*rest"),
1176
- s(:scope, s(:block, s(:nil)))))
1059
+ "ParseTree" => s(:defn, :f, s(:args, :"*rest"),
1060
+ s(:nil)))
1177
1061
 
1178
1062
  add_tests("defn_args_splat_no_name",
1179
1063
  "Ruby" => "def x(*)\n # do nothing\nend",
1180
- "ParseTree" => s(:defn, :x,
1181
- s(:args, :"*"),
1182
- s(:scope,
1183
- s(:block,
1184
- s(:nil)))))
1064
+ "ParseTree" => s(:defn, :x, s(:args, :"*"),
1065
+ s(:nil)))
1185
1066
 
1186
1067
  add_tests("defn_or",
1187
1068
  "Ruby" => "def |(o)\n # do nothing\nend",
1188
- "ParseTree" => s(:defn, :|,
1189
- s(:args, :o),
1190
- s(:scope, s(:block, s(:nil)))))
1069
+ "ParseTree" => s(:defn, :|, s(:args, :o),
1070
+ s(:nil)))
1191
1071
 
1192
1072
  add_tests("defn_rescue",
1193
1073
  "Ruby" => "def eql?(resource)\n (self.uuid == resource.uuid)\nrescue\n false\nend",
1194
1074
  "ParseTree" => s(:defn, :eql?,
1195
1075
  s(:args, :resource),
1196
- s(:scope,
1197
- s(:block,
1198
- s(:rescue,
1199
- s(:call,
1200
- s(:call, s(:self), :uuid, s(:arglist)),
1201
- :==,
1202
- s(:arglist,
1203
- s(:call, s(:lvar, :resource),
1204
- :uuid, s(:arglist)))),
1205
- s(:resbody, s(:array), s(:false)))))),
1076
+ s(:rescue,
1077
+ s(:call,
1078
+ s(:call, s(:self), :uuid),
1079
+ :==,
1080
+ s(:call, s(:lvar, :resource), :uuid)),
1081
+ s(:resbody, s(:array), s(:false)))),
1206
1082
  "Ruby2Ruby" => "def eql?(resource)\n (self.uuid == resource.uuid) rescue false\nend")
1207
1083
 
1208
1084
  add_tests("defn_rescue_mri_verbose_flag",
1209
1085
  "Ruby" => "def eql?(resource)\n (self.uuid == resource.uuid)\nrescue\n false\nend",
1210
1086
  "ParseTree" => s(:defn, :eql?,
1211
1087
  s(:args, :resource),
1212
- s(:scope,
1213
- s(:block,
1214
- s(:rescue,
1215
- s(:call,
1216
- s(:call, s(:self), :uuid, s(:arglist)),
1217
- :==,
1218
- s(:arglist,
1219
- s(:call, s(:lvar, :resource),
1220
- :uuid, s(:arglist)))),
1221
- s(:resbody, s(:array), s(:false)))))),
1088
+ s(:rescue,
1089
+ s(:call,
1090
+ s(:call, s(:self), :uuid),
1091
+ :==,
1092
+ s(:call, s(:lvar, :resource), :uuid)),
1093
+ s(:resbody, s(:array), s(:false)))),
1222
1094
  "Ruby2Ruby" => "def eql?(resource)\n (self.uuid == resource.uuid) rescue false\nend")
1223
1095
 
1224
1096
  add_tests("defn_something_eh",
1225
1097
  "Ruby" => "def something?\n # do nothing\nend",
1226
1098
  "ParseTree" => s(:defn, :something?,
1227
1099
  s(:args),
1228
- s(:scope, s(:block, s(:nil)))))
1100
+ s(:nil)))
1229
1101
 
1230
1102
  add_tests("defn_splat_no_name",
1231
1103
  "Ruby" => "def x(a, *)\n p(a)\nend",
1232
1104
  "ParseTree" => s(:defn, :x,
1233
1105
  s(:args, :a, :"*"),
1234
- s(:scope,
1235
- s(:block,
1236
- s(:call, nil, :p,
1237
- s(:arglist, s(:lvar, :a)))))))
1106
+ s(:call, nil, :p, s(:lvar, :a))))
1238
1107
 
1239
1108
  add_tests("defn_zarray",
1240
1109
  "Ruby" => "def zarray\n a = []\n return a\nend",
1241
1110
  "ParseTree" => s(:defn, :zarray,
1242
1111
  s(:args),
1243
- s(:scope,
1244
- s(:block,
1245
- s(:lasgn, :a, s(:array)),
1246
- s(:return, s(:lvar, :a))))))
1112
+ s(:lasgn, :a, s(:array)),
1113
+ s(:return, s(:lvar, :a))))
1247
1114
 
1248
1115
  add_tests("defs",
1249
1116
  "Ruby" => "def self.x(y)\n (y + 1)\nend",
1250
1117
  "ParseTree" => s(:defs, s(:self), :x,
1251
1118
  s(:args, :y),
1252
- s(:scope,
1253
- s(:block,
1254
- s(:call, s(:lvar, :y), :+,
1255
- s(:arglist, s(:lit, 1)))))))
1119
+ s(:call, s(:lvar, :y), :+, s(:lit, 1))))
1256
1120
 
1257
1121
  add_tests("defs_empty",
1258
1122
  "Ruby" => "def self.empty\n # do nothing\nend",
1259
- "ParseTree" => s(:defs, s(:self), :empty,
1260
- s(:args),
1261
- s(:scope, s(:block))))
1123
+ "ParseTree" => s(:defs, s(:self), :empty, s(:args)))
1262
1124
 
1263
1125
  add_tests("defs_empty_args",
1264
1126
  "Ruby" => "def self.empty(*)\n # do nothing\nend",
1265
1127
  "ParseTree" => s(:defs, s(:self), :empty,
1266
- s(:args, :*),
1267
- s(:scope, s(:block))))
1128
+ s(:args, :*)))
1268
1129
 
1269
1130
  add_tests("defs_expr_wtf",
1270
1131
  "Ruby" => "def (a.b).empty(*)\n # do nothing\nend",
1271
1132
  "ParseTree" => s(:defs,
1272
- s(:call,
1273
- s(:call, nil, :a, s(:arglist)),
1274
- :b, s(:arglist)),
1133
+ s(:call, s(:call, nil, :a), :b),
1275
1134
  :empty,
1276
- s(:args, :*),
1277
- s(:scope, s(:block))))
1135
+ s(:args, :*)))
1278
1136
 
1279
1137
  add_tests("dmethod",
1280
1138
  "Ruby" => [Examples, :dmethod_added],
1281
1139
  "ParseTree" => s(:defn, :dmethod_added,
1282
1140
  s(:args, :x),
1283
- s(:scope,
1284
- s(:block,
1285
- s(:call, s(:lvar, :x), :+,
1286
- s(:arglist, s(:lit, 1)))))),
1141
+ s(:call, s(:lvar, :x), :+, s(:lit, 1))),
1287
1142
  "Ruby2Ruby" => "def dmethod_added(x)\n (x + 1)\nend")
1288
1143
 
1289
1144
  add_tests("dot2",
1290
1145
  "Ruby" => "(a..b)",
1291
1146
  "ParseTree" => s(:dot2,
1292
- s(:call, nil, :a, s(:arglist)),
1293
- s(:call, nil, :b, s(:arglist))))
1147
+ s(:call, nil, :a),
1148
+ s(:call, nil, :b)))
1294
1149
 
1295
1150
  add_tests("dot3",
1296
1151
  "Ruby" => "(a...b)",
1297
1152
  "ParseTree" => s(:dot3,
1298
- s(:call, nil, :a, s(:arglist)),
1299
- s(:call, nil, :b, s(:arglist))))
1153
+ s(:call, nil, :a),
1154
+ s(:call, nil, :b)))
1300
1155
 
1301
1156
  add_tests("dregx",
1302
1157
  "Ruby" => "/x#\{(1 + 1)}y/",
1303
1158
  "ParseTree" => s(:dregx, "x",
1304
1159
  s(:evstr,
1305
- s(:call, s(:lit, 1), :+,
1306
- s(:arglist, s(:lit, 1)))),
1160
+ s(:call, s(:lit, 1), :+, s(:lit, 1))),
1307
1161
  s(:str, "y")))
1308
1162
 
1309
1163
  add_tests("dregx_interp",
@@ -1323,8 +1177,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1323
1177
  "Ruby" => "/x#\{(1 + 1)}y/o",
1324
1178
  "ParseTree" => s(:dregx_once, "x",
1325
1179
  s(:evstr,
1326
- s(:call, s(:lit, 1), :+,
1327
- s(:arglist, s(:lit, 1)))),
1180
+ s(:call, s(:lit, 1), :+, s(:lit, 1))),
1328
1181
  s(:str, "y")))
1329
1182
 
1330
1183
  add_tests("dregx_once_n_interp",
@@ -1348,7 +1201,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1348
1201
  "x",
1349
1202
  s(:evstr,
1350
1203
  s(:call, s(:str, "%.2f"), :%,
1351
- s(:arglist, s(:lit, 3.14159)))),
1204
+ s(:lit, 3.14159))),
1352
1205
  s(:str, "y"))))
1353
1206
 
1354
1207
  add_tests("dstr_3",
@@ -1363,7 +1216,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1363
1216
  s(:evstr, s(:lvar, :max)),
1364
1217
  s(:str, "f")),
1365
1218
  :%,
1366
- s(:arglist, s(:lit, 3.14159)))),
1219
+ s(:lit, 3.14159))),
1367
1220
  s(:str, "y"))))
1368
1221
 
1369
1222
  add_tests("dstr_concat",
@@ -1392,8 +1245,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1392
1245
  add_tests("dstr_heredoc_expand",
1393
1246
  "Ruby" => "<<EOM\n blah\n#\{1 + 1}blah\nEOM\n",
1394
1247
  "ParseTree" => s(:dstr, " blah\n",
1395
- s(:evstr, s(:call, s(:lit, 1), :+,
1396
- s(:arglist, s(:lit, 1)))),
1248
+ s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
1397
1249
  s(:str, "blah\n")),
1398
1250
  "Ruby2Ruby" => "\" blah\\n#\{(1 + 1)}blah\\n\"")
1399
1251
 
@@ -1401,7 +1253,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1401
1253
  "Ruby" => "<<-EOF\r\ndef test_#\{action}_valid_feed\r\n EOF\r\n",
1402
1254
  "ParseTree" => s(:dstr,
1403
1255
  'def test_',
1404
- s(:evstr, s(:call, nil, :action, s(:arglist))),
1256
+ s(:evstr, s(:call, nil, :action)),
1405
1257
  s(:str, "_valid_feed\n")),
1406
1258
  "Ruby2Ruby" => "\"def test_#\{action}_valid_feed\\n\"")
1407
1259
 
@@ -1417,7 +1269,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1417
1269
  add_tests("dstr_nest",
1418
1270
  "Ruby" => "%Q[before [#\{nest}] after]",
1419
1271
  "ParseTree" => s(:dstr, "before [",
1420
- s(:evstr, s(:call, nil, :nest, s(:arglist))),
1272
+ s(:evstr, s(:call, nil, :nest)),
1421
1273
  s(:str, "] after")),
1422
1274
  "Ruby2Ruby" => "\"before [#\{nest}] after\"")
1423
1275
 
@@ -1427,11 +1279,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1427
1279
  "blah(string):",
1428
1280
  s(:evstr, s(:lit, 1)),
1429
1281
  s(:str, ": warning: "),
1430
- s(:evstr, s(:call, s(:gvar, :$!), :message,
1431
- s(:arglist))),
1282
+ s(:evstr, s(:call, s(:gvar, :$!), :message)),
1432
1283
  s(:str, " ("),
1433
- s(:evstr, s(:call, s(:gvar, :$!), :class,
1434
- s(:arglist))),
1284
+ s(:evstr, s(:call, s(:gvar, :$!), :class)),
1435
1285
  s(:str, ")")),
1436
1286
  "Ruby2Ruby" => '"blah(string):#{1}: warning: #{$!.message} (#{$!.class})"')
1437
1287
 
@@ -1439,9 +1289,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1439
1289
  "Ruby" => '"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"',
1440
1290
  "ParseTree" => s(:dstr,
1441
1291
  "before ",
1442
- s(:evstr, s(:call, nil, :from, s(:arglist))),
1292
+ s(:evstr, s(:call, nil, :from)),
1443
1293
  s(:str, " middle "),
1444
- s(:evstr, s(:call, nil, :to, s(:arglist))),
1294
+ s(:evstr, s(:call, nil, :to)),
1445
1295
  s(:str, " ("),
1446
1296
  s(:str, "(string)"),
1447
1297
  s(:str, ":"),
@@ -1452,8 +1302,8 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1452
1302
  add_tests("dsym",
1453
1303
  "Ruby" => ":\"x#\{(1 + 1)}y\"",
1454
1304
  "ParseTree" => s(:dsym, "x",
1455
- s(:evstr, s(:call, s(:lit, 1), :+,
1456
- s(:arglist, s(:lit, 1)))), s(:str, "y")))
1305
+ s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
1306
+ s(:str, "y")))
1457
1307
 
1458
1308
  add_tests("dxstr",
1459
1309
  "Ruby" => "t = 5\n`touch #\{t}`\n",
@@ -1465,8 +1315,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1465
1315
  "Ruby" => "begin\n (1 + 1)\nrescue SyntaxError => e1\n 2\nrescue Exception => e2\n 3\nelse\n 4\nensure\n 5\nend",
1466
1316
  "ParseTree" => s(:ensure,
1467
1317
  s(:rescue,
1468
- s(:call, s(:lit, 1), :+,
1469
- s(:arglist, s(:lit, 1))),
1318
+ s(:call, s(:lit, 1), :+, s(:lit, 1)),
1470
1319
  s(:resbody,
1471
1320
  s(:array,
1472
1321
  s(:const, :SyntaxError),
@@ -1486,72 +1335,60 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1486
1335
 
1487
1336
  add_tests("fbody",
1488
1337
  "Ruby" => [Examples, :an_alias],
1489
- "ParseTree" => s(:defn, :an_alias,
1490
- s(:args, :x),
1491
- s(:scope,
1492
- s(:block,
1493
- s(:call, s(:lvar, :x), :+,
1494
- s(:arglist, s(:lit, 1)))))),
1338
+ "ParseTree" => s(:defn, :an_alias, s(:args, :x),
1339
+ s(:call, s(:lvar, :x), :+, s(:lit, 1))),
1495
1340
  "Ruby2Ruby" => "def an_alias(x)\n (x + 1)\nend")
1496
1341
 
1497
1342
  add_tests("fcall_arglist",
1498
1343
  "Ruby" => "m(42)",
1499
- "ParseTree" => s(:call, nil, :m, s(:arglist, s(:lit, 42))))
1344
+ "ParseTree" => s(:call, nil, :m, s(:lit, 42)))
1500
1345
 
1501
1346
  add_tests("fcall_arglist_hash",
1502
1347
  "Ruby" => "m(:a => 1, :b => 2)",
1503
1348
  "ParseTree" => s(:call, nil, :m,
1504
- s(:arglist,
1505
- s(:hash,
1506
- s(:lit, :a), s(:lit, 1),
1507
- s(:lit, :b), s(:lit, 2)))))
1349
+ s(:hash,
1350
+ s(:lit, :a), s(:lit, 1),
1351
+ s(:lit, :b), s(:lit, 2))))
1508
1352
 
1509
1353
  add_tests("fcall_arglist_norm_hash",
1510
1354
  "Ruby" => "m(42, :a => 1, :b => 2)",
1511
1355
  "ParseTree" => s(:call, nil, :m,
1512
- s(:arglist,
1513
- s(:lit, 42),
1514
- s(:hash,
1515
- s(:lit, :a), s(:lit, 1),
1516
- s(:lit, :b), s(:lit, 2)))))
1356
+ s(:lit, 42),
1357
+ s(:hash,
1358
+ s(:lit, :a), s(:lit, 1),
1359
+ s(:lit, :b), s(:lit, 2))))
1517
1360
 
1518
1361
  add_tests("fcall_arglist_norm_hash_splat",
1519
1362
  "Ruby" => "m(42, :a => 1, :b => 2, *c)",
1520
1363
  "ParseTree" => s(:call, nil, :m,
1521
- s(:arglist,
1522
- s(:lit, 42),
1523
- s(:hash,
1524
- s(:lit, :a), s(:lit, 1),
1525
- s(:lit, :b), s(:lit, 2)),
1526
- s(:splat, s(:call, nil, :c, s(:arglist))))))
1364
+ s(:lit, 42),
1365
+ s(:hash,
1366
+ s(:lit, :a), s(:lit, 1),
1367
+ s(:lit, :b), s(:lit, 2)),
1368
+ s(:splat, s(:call, nil, :c))))
1527
1369
 
1528
1370
  add_tests("fcall_block",
1529
1371
  "Ruby" => "a(:b) { :c }",
1530
1372
  "ParseTree" => s(:iter,
1531
- s(:call, nil, :a,
1532
- s(:arglist, s(:lit, :b))), nil,
1373
+ s(:call, nil, :a, s(:lit, :b)),
1374
+ nil,
1533
1375
  s(:lit, :c)))
1534
1376
 
1535
1377
  add_tests("fcall_index_space",
1536
1378
  "Ruby" => "a [42]",
1537
- "ParseTree" => s(:call, nil, :a,
1538
- s(:arglist, s(:array, s(:lit, 42)))),
1379
+ "ParseTree" => s(:call, nil, :a, s(:array, s(:lit, 42))),
1539
1380
  "Ruby2Ruby" => "a([42])")
1540
1381
 
1541
1382
  add_tests("fcall_keyword",
1542
1383
  "Ruby" => "42 if block_given?",
1543
1384
  "ParseTree" => s(:if,
1544
- s(:call, nil, :block_given?, s(:arglist)),
1385
+ s(:call, nil, :block_given?),
1545
1386
  s(:lit, 42), nil))
1546
1387
 
1547
1388
  add_tests("fcall_inside_parens",
1548
1389
  "Ruby" => "( a (b), c)",
1549
- "ParseTree" => s(:call,
1550
- nil,
1551
- :a,
1552
- s(:arglist,
1553
- s(:call, nil, :b, s(:arglist)),
1554
- s(:call, nil, :c, s(:arglist)))),
1390
+ "ParseTree" => s(:call, nil, :a,
1391
+ s(:call, nil, :b), s(:call, nil, :c)),
1555
1392
  "Ruby2Ruby" => "a(b, c)")
1556
1393
 
1557
1394
  add_tests("flip2",
@@ -1561,18 +1398,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1561
1398
  s(:if,
1562
1399
  s(:flip2,
1563
1400
  s(:call,
1564
- s(:call, s(:call, nil, :i, s(:arglist)),
1401
+ s(:call, s(:call, nil, :i),
1565
1402
  :%,
1566
- s(:arglist, s(:lit, 4))),
1403
+ s(:lit, 4)),
1567
1404
  :==,
1568
- s(:arglist, s(:lit, 0))),
1405
+ s(:lit, 0)),
1569
1406
  s(:call,
1570
- s(:call, s(:call, nil, :i, s(:arglist)),
1407
+ s(:call, s(:call, nil, :i),
1571
1408
  :%,
1572
- s(:arglist, s(:lit, 3))),
1409
+ s(:lit, 3)),
1573
1410
  :==,
1574
- s(:arglist, s(:lit, 0)))),
1575
- s(:call, nil, :i, s(:arglist)),
1411
+ s(:lit, 0))),
1412
+ s(:call, nil, :i),
1576
1413
  s(:nil))))
1577
1414
 
1578
1415
  add_tests("flip2_method",
@@ -1580,9 +1417,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1580
1417
  "ParseTree" => s(:if,
1581
1418
  s(:flip2,
1582
1419
  s(:lit, 1),
1583
- s(:call, s(:lit, 2), :a?,
1584
- s(:arglist,
1585
- s(:call, nil, :b, s(:arglist))))),
1420
+ s(:call, s(:lit, 2), :a?, s(:call, nil, :b))),
1586
1421
  s(:nil),
1587
1422
  nil))
1588
1423
 
@@ -1593,34 +1428,33 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1593
1428
  s(:if,
1594
1429
  s(:flip3,
1595
1430
  s(:call,
1596
- s(:call, s(:call, nil, :i, s(:arglist)),
1431
+ s(:call, s(:call, nil, :i),
1597
1432
  :%,
1598
- s(:arglist, s(:lit, 4))),
1433
+ s(:lit, 4)),
1599
1434
  :==,
1600
- s(:arglist, s(:lit, 0))),
1435
+ s(:lit, 0)),
1601
1436
  s(:call,
1602
- s(:call, s(:call, nil, :i, s(:arglist)),
1437
+ s(:call, s(:call, nil, :i),
1603
1438
  :%,
1604
- s(:arglist, s(:lit, 3))),
1439
+ s(:lit, 3)),
1605
1440
  :==,
1606
- s(:arglist, s(:lit, 0)))),
1607
- s(:call, nil, :i, s(:arglist)),
1441
+ s(:lit, 0))),
1442
+ s(:call, nil, :i),
1608
1443
  s(:nil))))
1609
1444
 
1610
1445
  add_tests("for",
1611
1446
  "Ruby" => "for o in ary do\n puts(o)\nend",
1612
1447
  "ParseTree" => s(:for,
1613
- s(:call, nil, :ary, s(:arglist)),
1448
+ s(:call, nil, :ary),
1614
1449
  s(:lasgn, :o),
1615
- s(:call, nil, :puts,
1616
- s(:arglist, s(:lvar, :o)))))
1450
+ s(:call, nil, :puts, s(:lvar, :o))))
1617
1451
 
1618
1452
  add_tests("for_no_body",
1619
1453
  "Ruby" => "for i in (0..max) do\n # do nothing\nend",
1620
1454
  "ParseTree" => s(:for,
1621
1455
  s(:dot2,
1622
1456
  s(:lit, 0),
1623
- s(:call, nil, :max, s(:arglist))),
1457
+ s(:call, nil, :max)),
1624
1458
  s(:lasgn, :i)))
1625
1459
 
1626
1460
  add_tests("gasgn",
@@ -1666,10 +1500,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1666
1500
  "ParseTree" => s(:if,
1667
1501
  s(:block,
1668
1502
  s(:lasgn, :x, s(:lit, 5)),
1669
- s(:call,
1670
- s(:lvar, :x),
1671
- :+,
1672
- s(:arglist, s(:lit, 1)))),
1503
+ s(:call, s(:lvar, :x), :+, s(:lit, 1))),
1673
1504
  s(:nil),
1674
1505
  nil))
1675
1506
 
@@ -1678,9 +1509,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1678
1509
  "ParseTree" => s(:if,
1679
1510
  s(:lasgn, :x,
1680
1511
  s(:call,
1681
- s(:call, nil, :obj, s(:arglist)),
1682
- :x, s(:arglist))),
1683
- s(:call, s(:lvar, :x), :do_it, s(:arglist)),
1512
+ s(:call, nil, :obj),
1513
+ :x)),
1514
+ s(:call, s(:lvar, :x), :do_it),
1684
1515
  nil))
1685
1516
 
1686
1517
  add_tests("if_nested",
@@ -1690,61 +1521,54 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1690
1521
 
1691
1522
  add_tests("if_post",
1692
1523
  "Ruby" => "a if b",
1693
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
1694
- s(:call, nil, :a, s(:arglist)), nil))
1524
+ "ParseTree" => s(:if, s(:call, nil, :b),
1525
+ s(:call, nil, :a), nil))
1695
1526
 
1696
1527
  add_tests("if_post_not",
1697
1528
  "Ruby" => "a if not b",
1698
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
1699
- s(:call, nil, :a, s(:arglist))),
1529
+ "ParseTree" => s(:if, s(:call, nil, :b), nil,
1530
+ s(:call, nil, :a)),
1700
1531
  "Ruby2Ruby" => "a unless b")
1701
1532
 
1702
1533
  add_tests("if_pre",
1703
1534
  "Ruby" => "if b then a end",
1704
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
1705
- s(:call, nil, :a, s(:arglist)), nil),
1535
+ "ParseTree" => s(:if, s(:call, nil, :b),
1536
+ s(:call, nil, :a), nil),
1706
1537
  "Ruby2Ruby" => "a if b")
1707
1538
 
1708
1539
  add_tests("if_pre_not",
1709
1540
  "Ruby" => "if not b then a end",
1710
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
1711
- s(:call, nil, :a, s(:arglist))),
1541
+ "ParseTree" => s(:if, s(:call, nil, :b), nil,
1542
+ s(:call, nil, :a)),
1712
1543
  "Ruby2Ruby" => "a unless b")
1713
1544
 
1714
1545
  add_tests("iter_call_arglist_space",
1715
1546
  "Ruby" => "a (1) {|c|d}",
1716
1547
  "ParseTree" => s(:iter,
1717
- s(:call, nil, :a, s(:arglist, s(:lit, 1))),
1548
+ s(:call, nil, :a, s(:lit, 1)),
1718
1549
  s(:lasgn, :c),
1719
- s(:call, nil, :d, s(:arglist))),
1550
+ s(:call, nil, :d)),
1720
1551
  "Ruby2Ruby" => "a(1) { |c| d }")
1721
1552
 
1722
1553
  add_tests("iter_dasgn_curr_dasgn_madness",
1723
1554
  "Ruby" => "as.each { |a|\n b += a.b(false) }",
1724
1555
  "ParseTree" => s(:iter,
1725
- s(:call,
1726
- s(:call, nil, :as, s(:arglist)),
1727
- :each, s(:arglist)),
1556
+ s(:call, s(:call, nil, :as), :each),
1728
1557
  s(:lasgn, :a),
1729
1558
  s(:lasgn, :b,
1730
1559
  s(:call,
1731
1560
  s(:lvar, :b),
1732
1561
  :+,
1733
- s(:arglist,
1734
- s(:call, s(:lvar, :a), :b,
1735
- s(:arglist, s(:false))))))),
1562
+ s(:call, s(:lvar, :a), :b, s(:false))))),
1736
1563
  "Ruby2Ruby" => "as.each { |a| b = (b + a.b(false)) }")
1737
1564
 
1738
1565
  add_tests("iter_downto",
1739
1566
  "Ruby" => "3.downto(1) { |n| puts(n.to_s) }",
1740
1567
  "ParseTree" => s(:iter,
1741
- s(:call, s(:lit, 3), :downto,
1742
- s(:arglist, s(:lit, 1))),
1568
+ s(:call, s(:lit, 3), :downto, s(:lit, 1)),
1743
1569
  s(:lasgn, :n),
1744
1570
  s(:call, nil, :puts,
1745
- s(:arglist,
1746
- s(:call, s(:lvar, :n),
1747
- :to_s, s(:arglist))))))
1571
+ s(:call, s(:lvar, :n), :to_s))))
1748
1572
 
1749
1573
  add_tests("iter_each_lvar",
1750
1574
  "Ruby" => "array = [1, 2, 3]\narray.each { |x| puts(x.to_s) }\n",
@@ -1753,12 +1577,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1753
1577
  s(:array,
1754
1578
  s(:lit, 1), s(:lit, 2), s(:lit, 3))),
1755
1579
  s(:iter,
1756
- s(:call, s(:lvar, :array), :each,
1757
- s(:arglist)),
1580
+ s(:call, s(:lvar, :array), :each),
1758
1581
  s(:lasgn, :x),
1759
1582
  s(:call, nil, :puts,
1760
- s(:arglist, s(:call, s(:lvar, :x),
1761
- :to_s, s(:arglist)))))))
1583
+ s(:call, s(:lvar, :x), :to_s)))))
1762
1584
 
1763
1585
  add_tests("iter_each_nested",
1764
1586
  "Ruby" => "array1 = [1, 2, 3]\narray2 = [4, 5, 6, 7]\narray1.each do |x|\n array2.each do |y|\n puts(x.to_s)\n puts(y.to_s)\n end\nend\n",
@@ -1772,108 +1594,98 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1772
1594
  s(:lit, 6), s(:lit, 7))),
1773
1595
  s(:iter,
1774
1596
  s(:call,
1775
- s(:lvar, :array1), :each, s(:arglist)),
1597
+ s(:lvar, :array1), :each),
1776
1598
  s(:lasgn, :x),
1777
1599
  s(:iter,
1778
1600
  s(:call,
1779
- s(:lvar, :array2), :each, s(:arglist)),
1601
+ s(:lvar, :array2), :each),
1780
1602
  s(:lasgn, :y),
1781
1603
  s(:block,
1782
1604
  s(:call, nil, :puts,
1783
- s(:arglist,
1784
- s(:call, s(:lvar, :x),
1785
- :to_s, s(:arglist)))),
1605
+ s(:call, s(:lvar, :x), :to_s)),
1786
1606
  s(:call, nil, :puts,
1787
- s(:arglist,
1788
- s(:call, s(:lvar, :y),
1789
- :to_s, s(:arglist)))))))))
1607
+ s(:call, s(:lvar, :y), :to_s)))))))
1790
1608
 
1791
1609
  add_tests("iter_loop_empty",
1792
1610
  "Ruby" => "loop { }",
1793
- "ParseTree" => s(:iter, s(:call, nil, :loop, s(:arglist)), nil))
1611
+ "ParseTree" => s(:iter, s(:call, nil, :loop), nil))
1794
1612
 
1795
1613
  add_tests("iter_masgn_2",
1796
1614
  "Ruby" => "a { |b, c| p(c) }",
1797
1615
  "ParseTree" => s(:iter,
1798
- s(:call, nil, :a, s(:arglist)),
1616
+ s(:call, nil, :a),
1799
1617
  s(:masgn,
1800
1618
  s(:array, s(:lasgn, :b), s(:lasgn, :c))),
1801
- s(:call, nil, :p, s(:arglist, s(:lvar, :c)))))
1619
+ s(:call, nil, :p, s(:lvar, :c))))
1802
1620
 
1803
1621
  add_tests("iter_masgn_args_splat",
1804
1622
  "Ruby" => "a { |b, c, *d| p(c) }",
1805
1623
  "ParseTree" => s(:iter,
1806
- s(:call, nil, :a, s(:arglist)),
1624
+ s(:call, nil, :a),
1807
1625
  s(:masgn,
1808
1626
  s(:array,
1809
1627
  s(:lasgn, :b),
1810
1628
  s(:lasgn, :c),
1811
1629
  s(:splat, s(:lasgn, :d)))),
1812
- s(:call, nil, :p, s(:arglist, s(:lvar, :c)))))
1630
+ s(:call, nil, :p, s(:lvar, :c))))
1813
1631
 
1814
1632
  add_tests("iter_masgn_args_splat_no_name",
1815
1633
  "Ruby" => "a { |b, c, *| p(c) }",
1816
1634
  "ParseTree" => s(:iter,
1817
- s(:call, nil, :a, s(:arglist)),
1635
+ s(:call, nil, :a),
1818
1636
  s(:masgn,
1819
1637
  s(:array,
1820
1638
  s(:lasgn, :b),
1821
1639
  s(:lasgn, :c),
1822
1640
  s(:splat))),
1823
- s(:call, nil, :p, s(:arglist, s(:lvar, :c)))))
1641
+ s(:call, nil, :p, s(:lvar, :c))))
1824
1642
 
1825
1643
  add_tests("iter_masgn_splat",
1826
1644
  "Ruby" => "a { |*c| p(c) }",
1827
1645
  "ParseTree" => s(:iter,
1828
- s(:call, nil, :a, s(:arglist)),
1646
+ s(:call, nil, :a),
1829
1647
  s(:masgn, s(:array, s(:splat, s(:lasgn, :c)))),
1830
- s(:call, nil, :p, s(:arglist, s(:lvar, :c)))))
1648
+ s(:call, nil, :p, s(:lvar, :c))))
1831
1649
 
1832
1650
  add_tests("iter_masgn_splat_no_name",
1833
1651
  "Ruby" => "a { |*| p(c) }",
1834
1652
  "ParseTree" => s(:iter,
1835
- s(:call, nil, :a, s(:arglist)),
1653
+ s(:call, nil, :a),
1836
1654
  s(:masgn, s(:array, s(:splat))),
1837
- s(:call, nil, :p,
1838
- s(:arglist, s(:call, nil, :c, s(:arglist))))))
1655
+ s(:call, nil, :p, s(:call, nil, :c))))
1839
1656
 
1840
1657
  add_tests("iter_shadowed_var",
1841
1658
  "Ruby" => "a do |x|\n b do |x|\n puts x\n end\nend",
1842
1659
  "ParseTree" => s(:iter,
1843
- s(:call, nil, :a, s(:arglist)),
1660
+ s(:call, nil, :a),
1844
1661
  s(:lasgn, :x),
1845
1662
  s(:iter,
1846
- s(:call, nil, :b, s(:arglist)),
1663
+ s(:call, nil, :b),
1847
1664
  s(:lasgn, :x),
1848
- s(:call, nil, :puts,
1849
- s(:arglist, s(:lvar, :x))))),
1665
+ s(:call, nil, :puts, s(:lvar, :x)))),
1850
1666
  "Ruby2Ruby" => "a { |x| b { |x| puts(x) } }")
1851
1667
 
1852
1668
  add_tests("iter_upto",
1853
1669
  "Ruby" => "1.upto(3) { |n| puts(n.to_s) }",
1854
1670
  "ParseTree" => s(:iter,
1855
- s(:call, s(:lit, 1), :upto,
1856
- s(:arglist, s(:lit, 3))),
1671
+ s(:call, s(:lit, 1), :upto, s(:lit, 3)),
1857
1672
  s(:lasgn, :n),
1858
1673
  s(:call, nil, :puts,
1859
- s(:arglist,
1860
- s(:call, s(:lvar, :n), :to_s,
1861
- s(:arglist))))))
1674
+ s(:call, s(:lvar, :n), :to_s))))
1862
1675
 
1863
1676
  add_tests("iter_while",
1864
1677
  "Ruby" => "argl = 10\nwhile (argl >= 1) do\n puts(\"hello\")\n argl = (argl - 1)\nend\n",
1865
1678
  "ParseTree" => s(:block,
1866
1679
  s(:lasgn, :argl, s(:lit, 10)),
1867
1680
  s(:while,
1868
- s(:call, s(:lvar, :argl), :">=",
1869
- s(:arglist, s(:lit, 1))),
1681
+ s(:call, s(:lvar, :argl), :">=", s(:lit, 1)),
1870
1682
  s(:block,
1871
- s(:call, nil, :puts,
1872
- s(:arglist, s(:str, "hello"))),
1683
+ s(:call, nil, :puts, s(:str, "hello")),
1873
1684
  s(:lasgn,
1874
1685
  :argl,
1875
1686
  s(:call, s(:lvar, :argl), :"-",
1876
- s(:arglist, s(:lit, 1))))), true)))
1687
+ s(:lit, 1)))),
1688
+ true)))
1877
1689
 
1878
1690
  add_tests("ivar",
1879
1691
  "Ruby" => [Examples, :reader],
@@ -1891,8 +1703,8 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1891
1703
 
1892
1704
  add_tests("lasgn_call",
1893
1705
  "Ruby" => "c = (2 + 3)",
1894
- "ParseTree" => s(:lasgn, :c, s(:call, s(:lit, 2), :+,
1895
- s(:arglist, s(:lit, 3)))))
1706
+ "ParseTree" => s(:lasgn, :c,
1707
+ s(:call, s(:lit, 2), :+, s(:lit, 3))))
1896
1708
 
1897
1709
  add_tests("lit_bool_false",
1898
1710
  "Ruby" => "false",
@@ -1935,8 +1747,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1935
1747
 
1936
1748
  add_tests("lit_regexp_i_wwtt",
1937
1749
  "Ruby" => 'str.split(//i)',
1938
- "ParseTree" => s(:call, s(:call, nil, :str, s(:arglist)), :split,
1939
- s(:arglist, s(:lit, //i))))
1750
+ "ParseTree" => s(:call,
1751
+ s(:call, nil, :str),
1752
+ :split,
1753
+ s(:lit, //i)))
1940
1754
 
1941
1755
  add_tests("lit_regexp_n",
1942
1756
  "Ruby" => "/x/n", # HACK differs on 1.9 - this is easiest
@@ -1960,29 +1774,25 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1960
1774
  "Ruby" => "b = 42\ndef a\n c do\n begin\n do_stuff\n rescue RuntimeError => b\n puts(b)\n end\n end\nend\n",
1961
1775
  "ParseTree" => s(:block,
1962
1776
  s(:lasgn, :b, s(:lit, 42)),
1963
- s(:defn, :a,
1964
- s(:args),
1965
- s(:scope,
1966
- s(:block,
1967
- s(:iter,
1968
- s(:call, nil, :c, s(:arglist)),
1969
- nil,
1970
- s(:rescue,
1971
- s(:call, nil, :do_stuff, s(:arglist)),
1972
- s(:resbody,
1973
- s(:array,
1974
- s(:const, :RuntimeError),
1975
- s(:lasgn, :b, s(:gvar, :$!))),
1976
- s(:call, nil, :puts,
1977
- s(:arglist,
1978
- s(:lvar, :b)))))))))))
1777
+ s(:defn, :a, s(:args),
1778
+ s(:iter,
1779
+ s(:call, nil, :c),
1780
+ nil,
1781
+ s(:rescue,
1782
+ s(:call, nil, :do_stuff),
1783
+ s(:resbody,
1784
+ s(:array,
1785
+ s(:const, :RuntimeError),
1786
+ s(:lasgn, :b, s(:gvar, :$!))),
1787
+ s(:call, nil, :puts,
1788
+ s(:lvar, :b))))))))
1979
1789
 
1980
1790
  add_tests("masgn",
1981
1791
  "Ruby" => "a, b = c, d",
1982
1792
  "ParseTree" => s(:masgn,
1983
1793
  s(:array, s(:lasgn, :a), s(:lasgn, :b)),
1984
- s(:array, s(:call, nil, :c, s(:arglist)),
1985
- s(:call, nil, :d, s(:arglist)))))
1794
+ s(:array, s(:call, nil, :c),
1795
+ s(:call, nil, :d))))
1986
1796
 
1987
1797
  add_tests("masgn_argscat",
1988
1798
  "Ruby" => "a, b, *c = 1, 2, *[3, 4]",
@@ -2002,25 +1812,25 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2002
1812
  s(:array,
2003
1813
  s(:lasgn, :a),
2004
1814
  s(:attrasgn,
2005
- s(:call, nil, :b, s(:arglist)),
2006
- :c=, s(:arglist))),
1815
+ s(:call, nil, :b),
1816
+ :c=)),
2007
1817
  s(:array,
2008
- s(:call, nil, :d, s(:arglist)),
2009
- s(:call, nil, :e, s(:arglist)))))
1818
+ s(:call, nil, :d),
1819
+ s(:call, nil, :e))))
2010
1820
 
2011
1821
  add_tests("masgn_attrasgn_array_rhs",
2012
1822
  "Ruby" => "a.b, a.c, _ = q",
2013
1823
  "ParseTree" => s(:masgn,
2014
1824
  s(:array,
2015
1825
  s(:attrasgn,
2016
- s(:call, nil, :a, s(:arglist)),
2017
- :b=, s(:arglist)),
1826
+ s(:call, nil, :a),
1827
+ :b=),
2018
1828
  s(:attrasgn,
2019
- s(:call, nil, :a, s(:arglist)),
2020
- :c=, s(:arglist)),
1829
+ s(:call, nil, :a),
1830
+ :c=),
2021
1831
  s(:lasgn, :_)),
2022
1832
  s(:to_ary,
2023
- s(:call, nil, :q, s(:arglist)))))
1833
+ s(:call, nil, :q))))
2024
1834
 
2025
1835
  add_tests("masgn_attrasgn_idx",
2026
1836
  "Ruby" => "a, i, j = [], 1, 2\na[i], a[j] = a[j], a[i]\n",
@@ -2032,15 +1842,15 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2032
1842
  s(:array, s(:array), s(:lit, 1), s(:lit, 2))),
2033
1843
  s(:masgn,
2034
1844
  s(:array,
2035
- s(:attrasgn, s(:lvar, :a), :[]=,
2036
- s(:arglist, s(:lvar, :i))),
2037
- s(:attrasgn, s(:lvar, :a), :[]=,
2038
- s(:arglist, s(:lvar, :j)))),
1845
+ s(:attrasgn,
1846
+ s(:lvar, :a), :[]=, s(:lvar, :i)),
1847
+ s(:attrasgn,
1848
+ s(:lvar, :a), :[]=, s(:lvar, :j))),
2039
1849
  s(:array,
2040
- s(:call, s(:lvar, :a), :[],
2041
- s(:arglist, s(:lvar, :j))),
2042
- s(:call, s(:lvar, :a), :[],
2043
- s(:arglist, s(:lvar, :i)))))))
1850
+ s(:call,
1851
+ s(:lvar, :a), :[], s(:lvar, :j)),
1852
+ s(:call,
1853
+ s(:lvar, :a), :[], s(:lvar, :i))))))
2044
1854
 
2045
1855
  add_tests("masgn_cdecl",
2046
1856
  "Ruby" => "A, B, C = 1, 2, 3",
@@ -2055,8 +1865,8 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2055
1865
  "ParseTree" => s(:masgn,
2056
1866
  s(:array, s(:lasgn, :a), s(:iasgn, :"@b")),
2057
1867
  s(:array,
2058
- s(:call, nil, :c, s(:arglist)),
2059
- s(:call, nil, :d, s(:arglist)))))
1868
+ s(:call, nil, :c),
1869
+ s(:call, nil, :d))))
2060
1870
 
2061
1871
  add_tests("masgn_masgn",
2062
1872
  "Ruby" => "a, (b, c) = [1, [2, 3]]",
@@ -2082,10 +1892,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2082
1892
  s(:lasgn, :b),
2083
1893
  s(:splat, s(:lasgn, :c))),
2084
1894
  s(:array,
2085
- s(:call, nil, :d, s(:arglist)),
2086
- s(:call, nil, :e, s(:arglist)),
2087
- s(:call, nil, :f, s(:arglist)),
2088
- s(:call, nil, :g, s(:arglist)))))
1895
+ s(:call, nil, :d),
1896
+ s(:call, nil, :e),
1897
+ s(:call, nil, :f),
1898
+ s(:call, nil, :g))))
2089
1899
 
2090
1900
  add_tests("masgn_splat_rhs_1",
2091
1901
  "Ruby" => "a, b = *c",
@@ -2093,7 +1903,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2093
1903
  s(:array,
2094
1904
  s(:lasgn, :a),
2095
1905
  s(:lasgn, :b)),
2096
- s(:splat, s(:call, nil, :c, s(:arglist)))))
1906
+ s(:splat, s(:call, nil, :c))))
2097
1907
 
2098
1908
  add_tests("masgn_splat_rhs_n",
2099
1909
  "Ruby" => "a, b = c, d, *e",
@@ -2102,9 +1912,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2102
1912
  s(:lasgn, :a),
2103
1913
  s(:lasgn, :b)),
2104
1914
  s(:array,
2105
- s(:call, nil, :c, s(:arglist)),
2106
- s(:call, nil, :d, s(:arglist)),
2107
- s(:splat, s(:call, nil, :e, s(:arglist))))))
1915
+ s(:call, nil, :c),
1916
+ s(:call, nil, :d),
1917
+ s(:splat, s(:call, nil, :e)))))
2108
1918
 
2109
1919
  add_tests("masgn_splat_no_name_to_ary",
2110
1920
  "Ruby" => "a, b, * = c",
@@ -2113,13 +1923,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2113
1923
  s(:lasgn, :a),
2114
1924
  s(:lasgn, :b),
2115
1925
  s(:splat)),
2116
- s(:to_ary, s(:call, nil, :c, s(:arglist)))))
1926
+ s(:to_ary, s(:call, nil, :c))))
2117
1927
 
2118
1928
  add_tests("masgn_splat_no_name_trailing",
2119
1929
  "Ruby" => "a, b, = c",
2120
1930
  "ParseTree" => s(:masgn,
2121
1931
  s(:array, s(:lasgn, :a), s(:lasgn, :b)),
2122
- s(:to_ary, s(:call, nil, :c, s(:arglist)))),
1932
+ s(:to_ary, s(:call, nil, :c))),
2123
1933
  "Ruby2Ruby" => "a, b = c") # TODO: check this is right
2124
1934
 
2125
1935
  add_tests("masgn_splat_to_ary",
@@ -2129,7 +1939,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2129
1939
  s(:lasgn, :a),
2130
1940
  s(:lasgn, :b),
2131
1941
  s(:splat, s(:lasgn, :c))),
2132
- s(:to_ary, s(:call, nil, :d, s(:arglist)))))
1942
+ s(:to_ary, s(:call, nil, :d))))
2133
1943
 
2134
1944
  add_tests("masgn_splat_to_ary2",
2135
1945
  "Ruby" => "a, b, *c = d.e(\"f\")",
@@ -2140,9 +1950,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2140
1950
  s(:splat, s(:lasgn, :c))),
2141
1951
  s(:to_ary,
2142
1952
  s(:call,
2143
- s(:call, nil, :d, s(:arglist)),
1953
+ s(:call, nil, :d),
2144
1954
  :e,
2145
- s(:arglist, s(:str, 'f'))))))
1955
+ s(:str, 'f')))))
2146
1956
 
2147
1957
  add_tests("match",
2148
1958
  "Ruby" => "1 if /x/",
@@ -2159,33 +1969,29 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2159
1969
  add_tests("module",
2160
1970
  "Ruby" => "module X\n def y\n # do nothing\n end\nend",
2161
1971
  "ParseTree" => s(:module, :X,
2162
- s(:scope,
2163
- s(:defn, :y,
2164
- s(:args),
2165
- s(:scope, s(:block, s(:nil)))))))
1972
+ s(:defn, :y, s(:args), s(:nil))))
2166
1973
 
2167
1974
  add_tests("module_scoped",
2168
1975
  "Ruby" => "module X::Y\n c\nend",
2169
1976
  "ParseTree" => s(:module, s(:colon2, s(:const, :X), :Y),
2170
- s(:scope, s(:call, nil, :c, s(:arglist)))))
1977
+ s(:call, nil, :c)))
2171
1978
 
2172
1979
  add_tests("module_scoped3",
2173
1980
  "Ruby" => "module ::Y\n c\nend",
2174
- "ParseTree" => s(:module,
2175
- s(:colon3, :Y),
2176
- s(:scope, s(:call, nil, :c, s(:arglist)))))
1981
+ "ParseTree" => s(:module, s(:colon3, :Y),
1982
+ s(:call, nil, :c)))
2177
1983
 
2178
1984
  add_tests("next",
2179
1985
  "Ruby" => "loop { next if false }",
2180
1986
  "ParseTree" => s(:iter,
2181
- s(:call, nil, :loop, s(:arglist)),
1987
+ s(:call, nil, :loop),
2182
1988
  nil,
2183
1989
  s(:if, s(:false), s(:next), nil)))
2184
1990
 
2185
1991
  add_tests("next_arg",
2186
1992
  "Ruby" => "loop { next 42 if false }",
2187
1993
  "ParseTree" => s(:iter,
2188
- s(:call, nil, :loop, s(:arglist)),
1994
+ s(:call, nil, :loop),
2189
1995
  nil,
2190
1996
  s(:if, s(:false), s(:next, s(:lit, 42)), nil)))
2191
1997
 
@@ -2223,11 +2029,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2223
2029
  "Ruby" => "s = Struct.new(:var)\nc = s.new(nil)\nc.var ||= 20\nc.var &&= 21\nc.var += 22\nc.d.e.f ||= 42\n",
2224
2030
  "ParseTree" => s(:block,
2225
2031
  s(:lasgn, :s,
2226
- s(:call, s(:const, :Struct),
2227
- :new, s(:arglist, s(:lit, :var)))),
2032
+ s(:call,
2033
+ s(:const, :Struct),
2034
+ :new,
2035
+ s(:lit, :var))),
2228
2036
  s(:lasgn, :c,
2229
- s(:call, s(:lvar, :s),
2230
- :new, s(:arglist, s(:nil)))),
2037
+ s(:call, s(:lvar, :s), :new, s(:nil))),
2231
2038
  s(:op_asgn2, s(:lvar, :c),
2232
2039
  :var=, :"||", s(:lit, 20)),
2233
2040
  s(:op_asgn2, s(:lvar, :c),
@@ -2236,14 +2043,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2236
2043
  :var=, :+, s(:lit, 22)),
2237
2044
  s(:op_asgn2,
2238
2045
  s(:call,
2239
- s(:call, s(:lvar, :c), :d, s(:arglist)),
2240
- :e, s(:arglist)),
2046
+ s(:call, s(:lvar, :c), :d),
2047
+ :e),
2241
2048
  :f=, :"||", s(:lit, 42))))
2242
2049
 
2243
2050
  add_tests("op_asgn2_self",
2244
2051
  "Ruby" => "self.Bag ||= Bag.new",
2245
2052
  "ParseTree" => s(:op_asgn2, s(:self), :"Bag=", :"||",
2246
- s(:call, s(:const, :Bag), :new, s(:arglist))))
2053
+ s(:call, s(:const, :Bag), :new)))
2247
2054
 
2248
2055
  add_tests("op_asgn_and",
2249
2056
  "Ruby" => "a = 0\na &&= 2\n",
@@ -2260,13 +2067,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2260
2067
  :@fetcher,
2261
2068
  s(:call, nil,
2262
2069
  :new,
2263
- s(:arglist,
2264
- s(:call,
2265
- s(:call, s(:const, :Gem),
2266
- :configuration,
2267
- s(:arglist)),
2268
- :[],
2269
- s(:arglist, s(:lit, :http_proxy))))))))
2070
+ s(:call,
2071
+ s(:call, s(:const, :Gem), :configuration),
2072
+ :[],
2073
+ s(:lit, :http_proxy))))))
2270
2074
 
2271
2075
  add_tests("op_asgn_or",
2272
2076
  "Ruby" => "a = 0\na ||= 1\n",
@@ -2281,13 +2085,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2281
2085
  s(:lvar, :a),
2282
2086
  s(:lasgn, :a,
2283
2087
  s(:rescue,
2284
- s(:call, nil, :b, s(:arglist)),
2088
+ s(:call, nil, :b),
2285
2089
  s(:resbody, s(:array),
2286
- s(:call, nil, :c, s(:arglist)))))),
2090
+ s(:call, nil, :c))))),
2287
2091
  "Ruby2Ruby" => "a ||= b rescue c")
2288
2092
 
2289
2093
  add_tests("op_asgn_or_ivar",
2290
- "Ruby" => "@v ||= { }",
2094
+ "Ruby" => "@v ||= {}",
2291
2095
  "ParseTree" => s(:op_asgn_or,
2292
2096
  s(:ivar, :@v),
2293
2097
  s(:iasgn, :@v, s(:hash))))
@@ -2299,39 +2103,36 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2299
2103
  s(:iasgn,
2300
2104
  :@fetcher,
2301
2105
  s(:call, nil, :new,
2302
- s(:arglist,
2303
- s(:call,
2304
- s(:call, s(:const, :Gem),
2305
- :configuration,
2306
- s(:arglist)),
2307
- :[],
2308
- s(:arglist, s(:lit, :http_proxy))))))))
2106
+ s(:call,
2107
+ s(:call, s(:const, :Gem), :configuration),
2108
+ :[],
2109
+ s(:lit, :http_proxy))))))
2309
2110
 
2310
2111
  add_tests("or",
2311
2112
  "Ruby" => "(a or b)",
2312
2113
  "ParseTree" => s(:or,
2313
- s(:call, nil, :a, s(:arglist)),
2314
- s(:call, nil, :b, s(:arglist))))
2114
+ s(:call, nil, :a),
2115
+ s(:call, nil, :b)))
2315
2116
 
2316
2117
  add_tests("or_big",
2317
2118
  "Ruby" => "((a or b) or (c and d))",
2318
2119
  "ParseTree" => s(:or,
2319
2120
  s(:or,
2320
- s(:call, nil, :a, s(:arglist)),
2321
- s(:call, nil, :b, s(:arglist))),
2121
+ s(:call, nil, :a),
2122
+ s(:call, nil, :b)),
2322
2123
  s(:and,
2323
- s(:call, nil, :c, s(:arglist)),
2324
- s(:call, nil, :d, s(:arglist)))))
2124
+ s(:call, nil, :c),
2125
+ s(:call, nil, :d))))
2325
2126
 
2326
2127
  add_tests("or_big2",
2327
2128
  "Ruby" => "((a || b) || (c && d))",
2328
2129
  "ParseTree" => s(:or,
2329
2130
  s(:or,
2330
- s(:call, nil, :a, s(:arglist)),
2331
- s(:call, nil, :b, s(:arglist))),
2131
+ s(:call, nil, :a),
2132
+ s(:call, nil, :b)),
2332
2133
  s(:and,
2333
- s(:call, nil, :c, s(:arglist)),
2334
- s(:call, nil, :d, s(:arglist)))),
2134
+ s(:call, nil, :c),
2135
+ s(:call, nil, :d))),
2335
2136
  "Ruby2Ruby" => "((a or b) or (c and d))")
2336
2137
 
2337
2138
  add_tests("parse_floats_as_args",
@@ -2341,10 +2142,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2341
2142
  s(:block,
2342
2143
  s(:lasgn, :a, s(:lit, 0.0)),
2343
2144
  s(:lasgn, :b, s(:lit, 0.0)))),
2344
- s(:scope,
2345
- s(:block,
2346
- s(:call, s(:lvar, :a), :+,
2347
- s(:arglist, s(:lvar, :b)))))),
2145
+ s(:call, s(:lvar, :a), :+, s(:lvar, :b))),
2348
2146
  "Ruby2Ruby" => "def x(a = 0.0, b = 0.0)\n (a + b)\nend")
2349
2147
 
2350
2148
  add_tests("postexe",
@@ -2354,44 +2152,38 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2354
2152
  add_tests("proc_args_0",
2355
2153
  "Ruby" => "proc { || (x + 1) }",
2356
2154
  "ParseTree" => s(:iter,
2357
- s(:call, nil, :proc, s(:arglist)),
2155
+ s(:call, nil, :proc),
2358
2156
  0,
2359
- s(:call,
2360
- s(:call, nil, :x, s(:arglist)),
2361
- :+,
2362
- s(:arglist, s(:lit, 1)))))
2157
+ s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
2363
2158
 
2364
2159
  add_tests("proc_args_1",
2365
2160
  "Ruby" => "proc { |x| (x + 1) }",
2366
2161
  "ParseTree" => s(:iter,
2367
- s(:call, nil, :proc, s(:arglist)),
2162
+ s(:call, nil, :proc),
2368
2163
  s(:lasgn, :x),
2369
- s(:call, s(:lvar, :x), :+,
2370
- s(:arglist, s(:lit, 1)))))
2164
+ s(:call, s(:lvar, :x), :+, s(:lit, 1))))
2371
2165
 
2372
2166
  add_tests("proc_args_2",
2373
2167
  "Ruby" => "proc { |x, y| (x + y) }",
2374
2168
  "ParseTree" => s(:iter,
2375
- s(:call, nil, :proc, s(:arglist)),
2169
+ s(:call, nil, :proc),
2376
2170
  s(:masgn,
2377
2171
  s(:array,
2378
2172
  s(:lasgn, :x),
2379
2173
  s(:lasgn, :y))),
2380
- s(:call, s(:lvar, :x), :+,
2381
- s(:arglist, s(:lvar, :y)))))
2174
+ s(:call, s(:lvar, :x), :+, s(:lvar, :y))))
2382
2175
 
2383
2176
  add_tests("proc_args_no",
2384
2177
  "Ruby" => "proc { (x + 1) }",
2385
2178
  "ParseTree" => s(:iter,
2386
- s(:call, nil, :proc, s(:arglist)),
2179
+ s(:call, nil, :proc),
2387
2180
  nil,
2388
- s(:call, s(:call, nil, :x, s(:arglist)),
2389
- :+, s(:arglist, s(:lit, 1)))))
2181
+ s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
2390
2182
 
2391
2183
  add_tests("redo",
2392
2184
  "Ruby" => "loop { redo if false }",
2393
2185
  "ParseTree" => s(:iter,
2394
- s(:call, nil, :loop, s(:arglist)),
2186
+ s(:call, nil, :loop),
2395
2187
  nil,
2396
2188
  s(:if, s(:false), s(:redo), nil)))
2397
2189
 
@@ -2400,50 +2192,48 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2400
2192
  add_tests("rescue",
2401
2193
  "Ruby" => "blah rescue nil",
2402
2194
  "ParseTree" => s(:rescue,
2403
- s(:call, nil, :blah, s(:arglist)),
2195
+ s(:call, nil, :blah),
2404
2196
  s(:resbody, s(:array), s(:nil))))
2405
2197
 
2406
2198
  add_tests("rescue_block_body",
2407
2199
  "Ruby" => "begin\n a\nrescue => e\n c\n d\nend",
2408
2200
  "ParseTree" => s(:rescue,
2409
- s(:call, nil, :a, s(:arglist)),
2201
+ s(:call, nil, :a),
2410
2202
  s(:resbody,
2411
2203
  s(:array, s(:lasgn, :e, s(:gvar, :$!))),
2412
- s(:block,
2413
- s(:call, nil, :c, s(:arglist)),
2414
- s(:call, nil, :d, s(:arglist))))))
2204
+ s(:call, nil, :c),
2205
+ s(:call, nil, :d))))
2415
2206
 
2416
2207
  add_tests("rescue_block_body_3",
2417
2208
  "Ruby" => "begin\n a\nrescue A\n b\nrescue B\n c\nrescue C\n d\nend",
2418
2209
  "ParseTree" => s(:rescue,
2419
- s(:call, nil, :a, s(:arglist)),
2210
+ s(:call, nil, :a),
2420
2211
  s(:resbody, s(:array, s(:const, :A)),
2421
- s(:call, nil, :b, s(:arglist))),
2212
+ s(:call, nil, :b)),
2422
2213
  s(:resbody, s(:array, s(:const, :B)),
2423
- s(:call, nil, :c, s(:arglist))),
2214
+ s(:call, nil, :c)),
2424
2215
  s(:resbody, s(:array, s(:const, :C)),
2425
- s(:call, nil, :d, s(:arglist)))))
2216
+ s(:call, nil, :d))))
2426
2217
 
2427
2218
  add_tests("rescue_block_body_ivar",
2428
2219
  "Ruby" => "begin\n a\nrescue => @e\n c\n d\nend",
2429
2220
  "ParseTree" => s(:rescue,
2430
- s(:call, nil, :a, s(:arglist)),
2221
+ s(:call, nil, :a),
2431
2222
  s(:resbody,
2432
2223
  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
2433
- s(:block,
2434
- s(:call, nil, :c, s(:arglist)),
2435
- s(:call, nil, :d, s(:arglist))))))
2224
+ s(:call, nil, :c),
2225
+ s(:call, nil, :d))))
2436
2226
 
2437
2227
  add_tests("rescue_block_nada",
2438
2228
  "Ruby" => "begin\n blah\nrescue\n # do nothing\nend",
2439
2229
  "ParseTree" => s(:rescue,
2440
- s(:call, nil, :blah, s(:arglist)),
2230
+ s(:call, nil, :blah),
2441
2231
  s(:resbody, s(:array), nil)))
2442
2232
 
2443
2233
  add_tests("rescue_exceptions",
2444
2234
  "Ruby" => "begin\n blah\nrescue RuntimeError => r\n # do nothing\nend",
2445
2235
  "ParseTree" => s(:rescue,
2446
- s(:call, nil, :blah, s(:arglist)),
2236
+ s(:call, nil, :blah),
2447
2237
  s(:resbody,
2448
2238
  s(:array,
2449
2239
  s(:const, :RuntimeError),
@@ -2508,26 +2298,20 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2508
2298
 
2509
2299
  add_tests("sclass",
2510
2300
  "Ruby" => "class << self\n 42\nend",
2511
- "ParseTree" => s(:sclass, s(:self), s(:scope, s(:lit, 42))))
2301
+ "ParseTree" => s(:sclass, s(:self), s(:lit, 42)))
2512
2302
 
2513
2303
  add_tests("sclass_trailing_class",
2514
- "Ruby" => "class A\n class << self\n a\n end\n class B\n end\nend",
2304
+ "Ruby" => "class A\n class << self\n a\n end\n \n class B\n end\nend",
2515
2305
  "ParseTree" => s(:class, :A, nil,
2516
- s(:scope,
2517
- s(:block,
2518
- s(:sclass, s(:self),
2519
- s(:scope,
2520
- s(:call, nil, :a, s(:arglist)))),
2521
- s(:class, :B, nil, s(:scope))))))
2306
+ s(:sclass, s(:self),
2307
+ s(:call, nil, :a)),
2308
+ s(:class, :B, nil)))
2522
2309
 
2523
2310
  add_tests("splat",
2524
2311
  "Ruby" => "def x(*b)\n a(*b)\nend",
2525
2312
  "ParseTree" => s(:defn, :x,
2526
2313
  s(:args, :"*b"),
2527
- s(:scope,
2528
- s(:block,
2529
- s(:call, nil, :a,
2530
- s(:arglist, s(:splat, s(:lvar, :b))))))))
2314
+ s(:call, nil, :a, s(:splat, s(:lvar, :b)))))
2531
2315
 
2532
2316
  add_tests("splat_array",
2533
2317
  "Ruby" => "[*[1]]",
@@ -2543,14 +2327,15 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2543
2327
 
2544
2328
  add_tests("splat_fcall",
2545
2329
  "Ruby" => "meth(*[1])",
2546
- "ParseTree" => s(:call, nil, :meth,
2547
- s(:arglist, s(:splat, s(:array, s(:lit, 1))))))
2330
+ "ParseTree" => s(:call,
2331
+ nil,
2332
+ :meth,
2333
+ s(:splat, s(:array, s(:lit, 1)))))
2548
2334
 
2549
2335
  add_tests("splat_fcall_array",
2550
2336
  "Ruby" => "meth([*[1]])",
2551
2337
  "ParseTree" => s(:call, nil, :meth,
2552
- s(:arglist,
2553
- s(:array, s(:splat, s(:array, s(:lit, 1)))))))
2338
+ s(:array, s(:splat, s(:array, s(:lit, 1))))))
2554
2339
 
2555
2340
  add_tests("splat_lasgn",
2556
2341
  "Ruby" => "x = *[1]",
@@ -2624,7 +2409,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2624
2409
  add_tests("str_heredoc_call",
2625
2410
  "Ruby" => "<<'EOM'.strip\n blah\nblah\nEOM",
2626
2411
  "ParseTree" => s(:call, s(:str, " blah\nblah\n"),
2627
- :strip, s(:arglist)),
2412
+ :strip),
2628
2413
  "Ruby2Ruby" => "\" blah\\nblah\\n\".strip")
2629
2414
 
2630
2415
  add_tests("str_heredoc_double",
@@ -2633,13 +2418,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2633
2418
  s(:call,
2634
2419
  s(:lvar, :a),
2635
2420
  :+,
2636
- s(:arglist,
2421
+ s(:call,
2637
2422
  s(:call,
2638
- s(:call, s(:str, " first\n"), :+,
2639
- s(:arglist,
2640
- s(:call, nil, :b, s(:arglist)))),
2423
+ s(:str, " first\n"),
2641
2424
  :+,
2642
- s(:arglist, s(:str, " second\n")))))),
2425
+ s(:call, nil, :b)),
2426
+ :+,
2427
+ s(:str, " second\n")))),
2643
2428
  "Ruby2Ruby" => "a = (a + ((\" first\\n\" + b) + \" second\\n\"))")
2644
2429
 
2645
2430
  add_tests("str_heredoc_empty", # yes... tarded
@@ -2661,19 +2446,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2661
2446
  "Ruby" => "a.b do |c, d|\n unless e.f(c) then\n g = false\n d.h { |x, i| g = true }\n end\nend",
2662
2447
  "ParseTree" => s(:iter,
2663
2448
  s(:call,
2664
- s(:call, nil, :a, s(:arglist)),
2665
- :b, s(:arglist)),
2449
+ s(:call, nil, :a),
2450
+ :b),
2666
2451
  s(:masgn, s(:array,
2667
2452
  s(:lasgn, :c),
2668
2453
  s(:lasgn, :d))),
2669
2454
  s(:if,
2670
- s(:call, s(:call, nil, :e, s(:arglist)), :f,
2671
- s(:arglist, s(:lvar, :c))),
2455
+ s(:call, s(:call, nil, :e), :f, s(:lvar, :c)),
2672
2456
  nil,
2673
2457
  s(:block,
2674
2458
  s(:lasgn, :g, s(:false)),
2675
2459
  s(:iter,
2676
- s(:call, s(:lvar, :d), :h, s(:arglist)),
2460
+ s(:call, s(:lvar, :d), :h),
2677
2461
  s(:masgn, s(:array,
2678
2462
  s(:lasgn, :x),
2679
2463
  s(:lasgn, :i))),
@@ -2681,12 +2465,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2681
2465
 
2682
2466
  add_tests("structure_remove_begin_1",
2683
2467
  "Ruby" => "a << begin\n b\n rescue\n c\n end",
2684
- "ParseTree" => s(:call, s(:call, nil, :a, s(:arglist)), :<<,
2685
- s(:arglist,
2686
- s(:rescue,
2687
- s(:call, nil, :b, s(:arglist)),
2688
- s(:resbody, s(:array),
2689
- s(:call, nil, :c, s(:arglist)))))),
2468
+ "ParseTree" => s(:call, s(:call, nil, :a), :<<,
2469
+ s(:rescue,
2470
+ s(:call, nil, :b),
2471
+ s(:resbody, s(:array),
2472
+ s(:call, nil, :c)))),
2690
2473
  "Ruby2Ruby" => "(a << b rescue c)")
2691
2474
 
2692
2475
  add_tests("structure_remove_begin_2",
@@ -2694,8 +2477,8 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2694
2477
  "ParseTree" => s(:block,
2695
2478
  s(:lasgn,
2696
2479
  :a,
2697
- s(:if, s(:call, nil, :c, s(:arglist)),
2698
- s(:rescue, s(:call, nil, :b, s(:arglist)),
2480
+ s(:if, s(:call, nil, :c),
2481
+ s(:rescue, s(:call, nil, :b),
2699
2482
  s(:resbody,
2700
2483
  s(:array), s(:nil))),
2701
2484
  nil)),
@@ -2704,65 +2487,52 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2704
2487
 
2705
2488
  add_tests("structure_unused_literal_wwtt",
2706
2489
  "Ruby" => "\"prevent the above from infecting rdoc\"\n\nmodule Graffle\nend",
2707
- "ParseTree" => s(:module, :Graffle, s(:scope)),
2490
+ "ParseTree" => s(:module, :Graffle),
2708
2491
  "Ruby2Ruby" => "module Graffle\nend")
2709
2492
 
2710
2493
  add_tests("super_0",
2711
2494
  "Ruby" => "def x\n super()\nend",
2712
- "ParseTree" => s(:defn, :x,
2713
- s(:args),
2714
- s(:scope, s(:block, s(:super)))))
2495
+ "ParseTree" => s(:defn, :x, s(:args), s(:super)))
2715
2496
 
2716
2497
  add_tests("super_1",
2717
2498
  "Ruby" => "def x\n super(4)\nend",
2718
- "ParseTree" => s(:defn, :x,
2719
- s(:args),
2720
- s(:scope,
2721
- s(:block,
2722
- s(:super, s(:lit, 4))))))
2499
+ "ParseTree" => s(:defn, :x, s(:args),
2500
+ s(:super, s(:lit, 4))))
2723
2501
 
2724
2502
  add_tests("super_1_array",
2725
2503
  "Ruby" => "def x\n super([24, 42])\nend",
2726
- "ParseTree" => s(:defn, :x,
2727
- s(:args),
2728
- s(:scope,
2729
- s(:block,
2730
- s(:super, s(:array,
2731
- s(:lit, 24),
2732
- s(:lit, 42)))))))
2733
-
2504
+ "ParseTree" => s(:defn, :x, s(:args),
2505
+ s(:super, s(:array, s(:lit, 24), s(:lit, 42)))))
2506
+
2734
2507
  add_tests("super_block_pass",
2735
2508
  "Ruby" => "super(a, &b)",
2736
2509
  "ParseTree" => s(:super,
2737
- s(:call, nil, :a, s(:arglist)),
2510
+ s(:call, nil, :a),
2738
2511
  s(:block_pass,
2739
- s(:call, nil, :b, s(:arglist)))))
2512
+ s(:call, nil, :b))))
2740
2513
 
2741
2514
  add_tests("super_block_splat",
2742
2515
  "Ruby" => "super(a, *b)",
2743
2516
  "ParseTree" => s(:super,
2744
- s(:call, nil, :a, s(:arglist)),
2745
- s(:splat, s(:call, nil, :b, s(:arglist)))))
2517
+ s(:call, nil, :a),
2518
+ s(:splat, s(:call, nil, :b))))
2746
2519
 
2747
2520
  add_tests("super_n",
2748
2521
  "Ruby" => "def x\n super(24, 42)\nend",
2749
- "ParseTree" => s(:defn, :x,
2750
- s(:args),
2751
- s(:scope,
2752
- s(:block,
2753
- s(:super, s(:lit, 24), s(:lit, 42))))))
2522
+ "ParseTree" => s(:defn, :x, s(:args),
2523
+ s(:super, s(:lit, 24), s(:lit, 42))))
2754
2524
 
2755
2525
  add_tests("svalue",
2756
2526
  "Ruby" => "a = *b",
2757
2527
  "ParseTree" => s(:lasgn, :a,
2758
2528
  s(:svalue,
2759
- s(:splat, s(:call, nil, :b, s(:arglist))))))
2529
+ s(:splat, s(:call, nil, :b)))))
2760
2530
 
2761
2531
  add_tests("to_ary",
2762
2532
  "Ruby" => "a, b = c",
2763
2533
  "ParseTree" => s(:masgn,
2764
2534
  s(:array, s(:lasgn, :a), s(:lasgn, :b)),
2765
- s(:to_ary, s(:call, nil, :c, s(:arglist)))))
2535
+ s(:to_ary, s(:call, nil, :c))))
2766
2536
 
2767
2537
  add_tests("true",
2768
2538
  "Ruby" => "true",
@@ -2790,13 +2560,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2790
2560
  add_tests("undef_block_1",
2791
2561
  "Ruby" => "f1\nundef :x\n", # TODO: don't like the extra return
2792
2562
  "ParseTree" => s(:block,
2793
- s(:call, nil, :f1, s(:arglist)),
2563
+ s(:call, nil, :f1),
2794
2564
  s(:undef, s(:lit, :x))))
2795
2565
 
2796
2566
  add_tests("undef_block_2",
2797
2567
  "Ruby" => "f1\nundef :x, :y",
2798
2568
  "ParseTree" => s(:block,
2799
- s(:call, nil, :f1, s(:arglist)),
2569
+ s(:call, nil, :f1),
2800
2570
  s(:block,
2801
2571
  s(:undef, s(:lit, :x)),
2802
2572
  s(:undef, s(:lit, :y)))),
@@ -2805,7 +2575,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2805
2575
  add_tests("undef_block_3",
2806
2576
  "Ruby" => "f1\nundef :x, :y, :z",
2807
2577
  "ParseTree" => s(:block,
2808
- s(:call, nil, :f1, s(:arglist)),
2578
+ s(:call, nil, :f1),
2809
2579
  s(:block,
2810
2580
  s(:undef, s(:lit, :x)),
2811
2581
  s(:undef, s(:lit, :y)),
@@ -2818,82 +2588,76 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2818
2588
  s(:undef, s(:lit, :x)),
2819
2589
  s(:undef, s(:lit, :y)),
2820
2590
  s(:undef, s(:lit, :z)),
2821
- s(:call, nil, :f2, s(:arglist))),
2591
+ s(:call, nil, :f2)),
2822
2592
  "Ruby2Ruby" => "undef :x\nundef :y\nundef :z\nf2\n")
2823
2593
 
2824
2594
  add_tests("undef_block_wtf",
2825
2595
  "Ruby" => "f1\nundef :x, :y, :z\nf2",
2826
2596
  "ParseTree" => s(:block,
2827
- s(:call, nil, :f1, s(:arglist)),
2597
+ s(:call, nil, :f1),
2828
2598
  s(:block,
2829
2599
  s(:undef, s(:lit, :x)),
2830
2600
  s(:undef, s(:lit, :y)),
2831
2601
  s(:undef, s(:lit, :z))),
2832
- s(:call, nil, :f2, s(:arglist))),
2602
+ s(:call, nil, :f2)),
2833
2603
  "Ruby2Ruby" => "f1\n(undef :x\nundef :y\nundef :z)\nf2\n")
2834
2604
 
2835
2605
 
2836
2606
  add_tests("unless_post",
2837
2607
  "Ruby" => "a unless b",
2838
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
2839
- s(:call, nil, :a, s(:arglist))))
2608
+ "ParseTree" => s(:if, s(:call, nil, :b), nil,
2609
+ s(:call, nil, :a)))
2840
2610
 
2841
2611
  add_tests("unless_post_not",
2842
2612
  "Ruby" => "a unless not b",
2843
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
2844
- s(:call, nil, :a, s(:arglist)), nil),
2613
+ "ParseTree" => s(:if, s(:call, nil, :b),
2614
+ s(:call, nil, :a), nil),
2845
2615
  "Ruby2Ruby" => "a if b")
2846
2616
 
2847
2617
  add_tests("unless_pre",
2848
2618
  "Ruby" => "unless b then a end",
2849
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
2850
- s(:call, nil, :a, s(:arglist))),
2619
+ "ParseTree" => s(:if, s(:call, nil, :b), nil,
2620
+ s(:call, nil, :a)),
2851
2621
  "Ruby2Ruby" => "a unless b")
2852
2622
 
2853
2623
  add_tests("unless_pre_not",
2854
2624
  "Ruby" => "unless not b then a end",
2855
- "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
2856
- s(:call, nil, :a, s(:arglist)), nil),
2625
+ "ParseTree" => s(:if, s(:call, nil, :b),
2626
+ s(:call, nil, :a), nil),
2857
2627
  "Ruby2Ruby" => "a if b")
2858
2628
 
2859
2629
  add_tests("until_post",
2860
2630
  "Ruby" => "begin\n (1 + 1)\nend until false",
2861
2631
  "ParseTree" => s(:until, s(:false),
2862
- s(:call, s(:lit, 1), :+,
2863
- s(:arglist, s(:lit, 1))), false))
2632
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), false))
2864
2633
 
2865
2634
  add_tests("until_post_not",
2866
2635
  "Ruby" => "begin\n (1 + 1)\nend until not true",
2867
2636
  "ParseTree" => s(:while, s(:true),
2868
- s(:call, s(:lit, 1), :+,
2869
- s(:arglist, s(:lit, 1))), false),
2637
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), false),
2870
2638
  "Ruby2Ruby" => "begin\n (1 + 1)\nend while true")
2871
2639
 
2872
2640
  add_tests("until_pre",
2873
2641
  "Ruby" => "until false do\n (1 + 1)\nend",
2874
2642
  "ParseTree" => s(:until, s(:false),
2875
- s(:call, s(:lit, 1), :+,
2876
- s(:arglist, s(:lit, 1))), true))
2643
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true))
2877
2644
 
2878
2645
  add_tests("until_pre_mod",
2879
2646
  "Ruby" => "(1 + 1) until false",
2880
2647
  "ParseTree" => s(:until, s(:false),
2881
- s(:call, s(:lit, 1), :+,
2882
- s(:arglist, s(:lit, 1))), true),
2648
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
2883
2649
  "Ruby2Ruby" => "until false do\n (1 + 1)\nend")
2884
2650
 
2885
2651
  add_tests("until_pre_not",
2886
2652
  "Ruby" => "until not true do\n (1 + 1)\nend",
2887
2653
  "ParseTree" => s(:while, s(:true),
2888
- s(:call, s(:lit, 1), :+,
2889
- s(:arglist, s(:lit, 1))), true),
2654
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
2890
2655
  "Ruby2Ruby" => "while true do\n (1 + 1)\nend")
2891
2656
 
2892
2657
  add_tests("until_pre_not_mod",
2893
2658
  "Ruby" => "(1 + 1) until not true",
2894
2659
  "ParseTree" => s(:while, s(:true),
2895
- s(:call, s(:lit, 1), :+,
2896
- s(:arglist, s(:lit, 1))), true),
2660
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
2897
2661
  "Ruby2Ruby" => "while true do\n (1 + 1)\nend")
2898
2662
 
2899
2663
  add_tests("valias",
@@ -2902,42 +2666,36 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2902
2666
 
2903
2667
  add_tests("vcall",
2904
2668
  "Ruby" => "method",
2905
- "ParseTree" => s(:call, nil, :method, s(:arglist)))
2669
+ "ParseTree" => s(:call, nil, :method))
2906
2670
 
2907
2671
  add_tests("while_post",
2908
2672
  "Ruby" => "begin\n (1 + 1)\nend while false",
2909
2673
  "ParseTree" => s(:while, s(:false),
2910
- s(:call, s(:lit, 1), :+,
2911
- s(:arglist, s(:lit, 1))), false))
2674
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), false))
2912
2675
 
2913
2676
  add_tests("while_post2",
2914
2677
  "Ruby" => "begin\n (1 + 2)\n (3 + 4)\nend while false",
2915
2678
  "ParseTree" => s(:while, s(:false),
2916
2679
  s(:block,
2917
- s(:call, s(:lit, 1), :+,
2918
- s(:arglist, s(:lit, 2))),
2919
- s(:call, s(:lit, 3), :+,
2920
- s(:arglist, s(:lit, 4)))),
2680
+ s(:call, s(:lit, 1), :+, s(:lit, 2)),
2681
+ s(:call, s(:lit, 3), :+, s(:lit, 4))),
2921
2682
  false))
2922
2683
 
2923
2684
  add_tests("while_post_not",
2924
2685
  "Ruby" => "begin\n (1 + 1)\nend while not true",
2925
2686
  "ParseTree" => s(:until, s(:true),
2926
- s(:call, s(:lit, 1), :+,
2927
- s(:arglist, s(:lit, 1))), false),
2687
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), false),
2928
2688
  "Ruby2Ruby" => "begin\n (1 + 1)\nend until true")
2929
2689
 
2930
2690
  add_tests("while_pre",
2931
2691
  "Ruby" => "while false do\n (1 + 1)\nend",
2932
2692
  "ParseTree" => s(:while, s(:false),
2933
- s(:call, s(:lit, 1), :+,
2934
- s(:arglist, s(:lit, 1))), true))
2693
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true))
2935
2694
 
2936
2695
  add_tests("while_pre_mod",
2937
2696
  "Ruby" => "(1 + 1) while false",
2938
2697
  "ParseTree" => s(:while, s(:false),
2939
- s(:call, s(:lit, 1), :+,
2940
- s(:arglist, s(:lit, 1))), true),
2698
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
2941
2699
  "Ruby2Ruby" => "while false do\n (1 + 1)\nend") # FIX can be one liner
2942
2700
 
2943
2701
  add_tests("while_pre_nil",
@@ -2947,15 +2705,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2947
2705
  add_tests("while_pre_not",
2948
2706
  "Ruby" => "while not true do\n (1 + 1)\nend",
2949
2707
  "ParseTree" => s(:until, s(:true),
2950
- s(:call, s(:lit, 1), :+,
2951
- s(:arglist, s(:lit, 1))), true),
2708
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
2952
2709
  "Ruby2Ruby" => "until true do\n (1 + 1)\nend")
2953
2710
 
2954
2711
  add_tests("while_pre_not_mod",
2955
2712
  "Ruby" => "(1 + 1) while not true",
2956
2713
  "ParseTree" => s(:until, s(:true),
2957
- s(:call, s(:lit, 1), :+,
2958
- s(:arglist, s(:lit, 1))), true),
2714
+ s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
2959
2715
  "Ruby2Ruby" => "until true do\n (1 + 1)\nend") # FIX
2960
2716
 
2961
2717
  add_tests("xstr",
@@ -2992,28 +2748,27 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2992
2748
 
2993
2749
  add_tests("zsuper",
2994
2750
  "Ruby" => "def x\n super\nend",
2995
- "ParseTree" => s(:defn, :x, s(:args),
2996
- s(:scope, s(:block, s(:zsuper)))))
2751
+ "ParseTree" => s(:defn, :x, s(:args), s(:zsuper)))
2997
2752
 
2998
2753
  add_18tests("if_args_no_space_symbol",
2999
2754
  "Ruby" => "x if y:z",
3000
2755
  "ParseTree" => s(:if,
3001
- s(:call, nil, :y, s(:arglist, s(:lit, :z))),
3002
- s(:call, nil, :x, s(:arglist)),
2756
+ s(:call, nil, :y, s(:lit, :z)),
2757
+ s(:call, nil, :x),
3003
2758
  nil),
3004
2759
  "Ruby2Ruby" => "x if y(:z)")
3005
2760
 
3006
2761
  add_18tests("iter_args_ivar",
3007
2762
  "Ruby" => "a { |@a| 42 }",
3008
2763
  "ParseTree" => s(:iter,
3009
- s(:call, nil, :a, s(:arglist)),
2764
+ s(:call, nil, :a),
3010
2765
  s(:iasgn, :@a),
3011
2766
  s(:lit, 42)))
3012
2767
 
3013
2768
  add_18tests("iter_masgn_args_ivar",
3014
2769
  "Ruby" => "a { |a, @b| 42 }",
3015
2770
  "ParseTree" => s(:iter,
3016
- s(:call, nil, :a, s(:arglist)),
2771
+ s(:call, nil, :a),
3017
2772
  s(:masgn,
3018
2773
  s(:array, s(:lasgn, :a), s(:iasgn, :@b))),
3019
2774
  s(:lit, 42)))
@@ -3052,38 +2807,38 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3052
2807
  add_19tests("call_arglist_norm_hash_colons",
3053
2808
  "Ruby" => "o.m(42, a: 1, b: 2)",
3054
2809
  "ParseTree" => s(:call,
3055
- s(:call, nil, :o, s(:arglist)),
2810
+ s(:call, nil, :o),
3056
2811
  :m,
3057
- s(:arglist,
3058
- s(:lit, 42),
3059
- s(:hash,
3060
- s(:lit, :a), s(:lit, 1),
3061
- s(:lit, :b), s(:lit, 2)))))
2812
+ s(:lit, 42),
2813
+ s(:hash,
2814
+ s(:lit, :a), s(:lit, 1),
2815
+ s(:lit, :b), s(:lit, 2))))
3062
2816
 
3063
2817
  add_19tests("call_arglist_trailing_comma",
3064
2818
  "Ruby" => "a(1,2,3,)",
3065
- "ParseTree" => s(:call, nil, :a,
3066
- s(:arglist,
3067
- s(:lit, 1), s(:lit, 2), s(:lit, 3))))
2819
+ "ParseTree" => s(:call,
2820
+ nil,
2821
+ :a,
2822
+ s(:lit, 1), s(:lit, 2), s(:lit, 3)))
3068
2823
 
3069
2824
  add_19tests("call_not_equal",
3070
2825
  "Ruby" => "a != b",
3071
2826
  "ParseTree" => s(:call,
3072
- s(:call, nil, :a, s(:arglist)),
2827
+ s(:call, nil, :a),
3073
2828
  :"!=",
3074
- s(:arglist, s(:call, nil, :b, s(:arglist)))))
2829
+ s(:call, nil, :b)))
3075
2830
 
3076
2831
  add_19tests("call_unary_not",
3077
2832
  "Ruby" => "!a",
3078
2833
  "ParseTree" => s(:call,
3079
- s(:call, nil, :a, s(:arglist)),
3080
- :"!@", s(:arglist)))
2834
+ s(:call, nil, :a),
2835
+ :"!@"))
3081
2836
 
3082
2837
  add_19tests("defn_args_splat_mand",
3083
2838
  "Ruby" => "def f(*rest, mand)\n # do nothing\nend",
3084
2839
  "ParseTree" => s(:defn, :f,
3085
2840
  s(:args, :"*rest", :mand),
3086
- s(:scope, s(:block, s(:nil)))))
2841
+ s(:nil)))
3087
2842
 
3088
2843
  add_19tests("defn_args_mand_opt_splat_mand",
3089
2844
  "Ruby" => "def f(mand1, opt = 42, *rest, mand2)\n # do nothing\nend",
@@ -3091,7 +2846,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3091
2846
  s(:args, :mand1, :opt, :"*rest", :mand2,
3092
2847
  s(:block,
3093
2848
  s(:lasgn, :opt, s(:lit, 42)))),
3094
- s(:scope, s(:block, s(:nil)))))
2849
+ s(:nil)))
3095
2850
 
3096
2851
  add_19tests("defn_args_mand_opt_mand",
3097
2852
  "Ruby" => "def f(mand1, opt = 42, mand2)\n # do nothing\nend",
@@ -3099,7 +2854,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3099
2854
  s(:args, :mand1, :opt, :mand2,
3100
2855
  s(:block,
3101
2856
  s(:lasgn, :opt, s(:lit, 42)))),
3102
- s(:scope, s(:block, s(:nil)))))
2857
+ s(:nil)))
3103
2858
 
3104
2859
  add_19tests("defn_args_opt_splat_mand",
3105
2860
  "Ruby" => "def f(opt = 42, *rest, mand)\n # do nothing\nend",
@@ -3107,7 +2862,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3107
2862
  s(:args, :opt, :"*rest", :mand,
3108
2863
  s(:block,
3109
2864
  s(:lasgn, :opt, s(:lit, 42)))),
3110
- s(:scope, s(:block, s(:nil)))))
2865
+ s(:nil)))
3111
2866
 
3112
2867
  add_19tests("defn_args_opt_mand",
3113
2868
  "Ruby" => "def f(opt = 42, mand)\n # do nothing\nend",
@@ -3115,21 +2870,20 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3115
2870
  s(:args, :opt, :mand,
3116
2871
  s(:block,
3117
2872
  s(:lasgn, :opt, s(:lit, 42)))),
3118
- s(:scope, s(:block, s(:nil)))))
2873
+ s(:nil)))
3119
2874
 
3120
2875
  add_19tests("defn_args_splat_middle",
3121
2876
  "Ruby" => "def f(first, *middle, last)\n # do nothing\nend",
3122
2877
  "ParseTree" => s(:defn, :f,
3123
2878
  s(:args, :first, :"*middle", :last),
3124
- s(:scope, s(:block, s(:nil)))))
2879
+ s(:nil)))
3125
2880
 
3126
2881
  add_19tests("fcall_arglist_hash_colons",
3127
2882
  "Ruby" => "m(a: 1, b: 2)",
3128
2883
  "ParseTree" => s(:call, nil, :m,
3129
- s(:arglist,
3130
- s(:hash,
3131
- s(:lit, :a), s(:lit, 1),
3132
- s(:lit, :b), s(:lit, 2)))))
2884
+ s(:hash,
2885
+ s(:lit, :a), s(:lit, 1),
2886
+ s(:lit, :b), s(:lit, 2))))
3133
2887
 
3134
2888
  add_19tests("hash_new",
3135
2889
  "Ruby" => "{ a: 1, b: 2 }",
@@ -3146,14 +2900,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3146
2900
  add_tests("lambda_args_anon_star",
3147
2901
  "Ruby" => "lambda { |*| nil }",
3148
2902
  "ParseTree" => s(:iter,
3149
- s(:call, nil, :lambda, s(:arglist)),
2903
+ s(:call, nil, :lambda),
3150
2904
  s(:masgn, s(:array, s(:splat))),
3151
2905
  s(:nil)))
3152
2906
 
3153
2907
  add_tests("lambda_args_anon_star_block",
3154
2908
  "Ruby" => "lambda { |*, &block| block }",
3155
2909
  "ParseTree" => s(:iter,
3156
- s(:call, nil, :lambda, s(:arglist)),
2910
+ s(:call, nil, :lambda),
3157
2911
  s(:masgn, s(:array,
3158
2912
  s(:splat),
3159
2913
  s(:lasgn, :"&block"))),
@@ -3162,14 +2916,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3162
2916
  add_tests("lambda_args_block",
3163
2917
  "Ruby" => "lambda { |&block| block }",
3164
2918
  "ParseTree" => s(:iter,
3165
- s(:call, nil, :lambda, s(:arglist)),
2919
+ s(:call, nil, :lambda),
3166
2920
  s(:lasgn, :"&block"),
3167
2921
  s(:lvar, :block)))
3168
2922
 
3169
2923
  add_tests("lambda_args_norm_anon_star",
3170
2924
  "Ruby" => "lambda { |a, *| a }",
3171
2925
  "ParseTree" => s(:iter,
3172
- s(:call, nil, :lambda, s(:arglist)),
2926
+ s(:call, nil, :lambda),
3173
2927
  s(:masgn, s(:array,
3174
2928
  s(:lasgn, :a),
3175
2929
  s(:splat))),
@@ -3178,7 +2932,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3178
2932
  add_tests("lambda_args_norm_anon_star_block",
3179
2933
  "Ruby" => "lambda { |a, *, &block| block }",
3180
2934
  "ParseTree" => s(:iter,
3181
- s(:call, nil, :lambda, s(:arglist)),
2935
+ s(:call, nil, :lambda),
3182
2936
  s(:masgn, s(:array,
3183
2937
  s(:lasgn, :a),
3184
2938
  s(:splat),
@@ -3188,7 +2942,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3188
2942
  add_tests("lambda_args_norm_block",
3189
2943
  "Ruby" => "lambda { |a, &block| block }",
3190
2944
  "ParseTree" => s(:iter,
3191
- s(:call, nil, :lambda, s(:arglist)),
2945
+ s(:call, nil, :lambda),
3192
2946
  s(:masgn, s(:array,
3193
2947
  s(:lasgn, :a),
3194
2948
  s(:lasgn, :"&block"))),
@@ -3197,7 +2951,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3197
2951
  add_tests("lambda_args_norm_comma",
3198
2952
  "Ruby" => "lambda { |a,| a }",
3199
2953
  "ParseTree" => s(:iter,
3200
- s(:call, nil, :lambda, s(:arglist)),
2954
+ s(:call, nil, :lambda),
3201
2955
  s(:lasgn, :a),
3202
2956
  s(:lvar, :a)),
3203
2957
  "Ruby2Ruby" => "lambda { |a| a }")
@@ -3205,7 +2959,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3205
2959
  add_tests("lambda_args_norm_comma2",
3206
2960
  "Ruby" => "lambda { |a,b,| a }",
3207
2961
  "ParseTree" => s(:iter,
3208
- s(:call, nil, :lambda, s(:arglist)),
2962
+ s(:call, nil, :lambda),
3209
2963
  s(:masgn,
3210
2964
  s(:array, s(:lasgn, :a), s(:lasgn, :b))),
3211
2965
  s(:lvar, :a)),
@@ -3214,7 +2968,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3214
2968
  add_tests("lambda_args_norm_star",
3215
2969
  "Ruby" => "lambda { |a, *star| star }",
3216
2970
  "ParseTree" => s(:iter,
3217
- s(:call, nil, :lambda, s(:arglist)),
2971
+ s(:call, nil, :lambda),
3218
2972
  s(:masgn, s(:array,
3219
2973
  s(:lasgn, :a),
3220
2974
  s(:splat, s(:lasgn, :star)))),
@@ -3223,7 +2977,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3223
2977
  add_tests("lambda_args_norm_star_block",
3224
2978
  "Ruby" => "lambda { |a, *star, &block| block }",
3225
2979
  "ParseTree" => s(:iter,
3226
- s(:call, nil, :lambda, s(:arglist)),
2980
+ s(:call, nil, :lambda),
3227
2981
  s(:masgn, s(:array,
3228
2982
  s(:lasgn, :a),
3229
2983
  s(:splat, s(:lasgn, :star)),
@@ -3233,7 +2987,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3233
2987
  add_tests("lambda_args_star",
3234
2988
  "Ruby" => "lambda { |*star| star }",
3235
2989
  "ParseTree" => s(:iter,
3236
- s(:call, nil, :lambda, s(:arglist)),
2990
+ s(:call, nil, :lambda),
3237
2991
  s(:masgn, s(:array,
3238
2992
  s(:splat, s(:lasgn, :star)))),
3239
2993
  s(:lvar, :star)))
@@ -3241,7 +2995,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3241
2995
  add_tests("lambda_args_star_block",
3242
2996
  "Ruby" => "lambda { |*star, &block| block }",
3243
2997
  "ParseTree" => s(:iter,
3244
- s(:call, nil, :lambda, s(:arglist)),
2998
+ s(:call, nil, :lambda),
3245
2999
  s(:masgn, s(:array,
3246
3000
  s(:splat, s(:lasgn, :star)),
3247
3001
  s(:lasgn, :"&block"))),
@@ -3257,10 +3011,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3257
3011
 
3258
3012
  add19_edgecases("lambda { (x + 1) }",
3259
3013
  s(:iter,
3260
- s(:call, nil, :lambda, s(:arglist)),
3014
+ s(:call, nil, :lambda),
3261
3015
  0,
3262
- s(:call, s(:call, nil, :x, s(:arglist)),
3263
- :+, s(:arglist, s(:lit, 1)))),
3016
+ s(:call, s(:call, nil, :x), :+, s(:lit, 1))),
3264
3017
  "stabby_args_0" => "->() { (x + 1) }",
3265
3018
  "stabby_args_0_doend" => "->() do (x + 1) end",
3266
3019
  "stabby_args_0_no_parens" => "-> { (x + 1) }",
@@ -3269,9 +3022,9 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3269
3022
 
3270
3023
  add19_edgecases("lambda { |x| (x + 1) }",
3271
3024
  s(:iter,
3272
- s(:call, nil, :lambda, s(:arglist)),
3025
+ s(:call, nil, :lambda),
3273
3026
  s(:lasgn, :x),
3274
- s(:call, s(:lvar, :x), :+, s(:arglist, s(:lit, 1)))),
3027
+ s(:call, s(:lvar, :x), :+, s(:lit, 1))),
3275
3028
  "stabby_args_1" => "->(x) { (x + 1) }",
3276
3029
  "stabby_args_1_doend" => "->(x) do (x + 1) end",
3277
3030
  "stabby_args_1_no_parens" => "-> x { (x + 1) }",
@@ -3279,13 +3032,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3279
3032
 
3280
3033
  add19_edgecases("lambda { |x, y| (x + y) }",
3281
3034
  s(:iter,
3282
- s(:call, nil, :lambda, s(:arglist)),
3035
+ s(:call, nil, :lambda),
3283
3036
  s(:masgn,
3284
3037
  s(:array,
3285
3038
  s(:lasgn, :x),
3286
3039
  s(:lasgn, :y))),
3287
- s(:call, s(:lvar, :x), :+,
3288
- s(:arglist, s(:lvar, :y)))),
3040
+ s(:call, s(:lvar, :x), :+, s(:lvar, :y))),
3289
3041
  "stabby_args_2" => "->(x, y) { (x + y) }",
3290
3042
  "stabby_args_2_doend" => "->(x, y) do (x + y) end",
3291
3043
  "stabby_args_2_no_parens" => "-> x, y { (x + y) }",
@@ -3299,11 +3051,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3299
3051
 
3300
3052
  add_19tests("splat_fcall_middle",
3301
3053
  "Ruby" => "meth(1, *[2], 3)",
3302
- "ParseTree" => s(:call, nil, :meth,
3303
- s(:arglist,
3304
- s(:lit, 1),
3305
- s(:splat, s(:array, s(:lit, 2))),
3306
- s(:lit, 3))))
3054
+ "ParseTree" => s(:call,
3055
+ nil,
3056
+ :meth,
3057
+ s(:lit, 1),
3058
+ s(:splat, s(:array, s(:lit, 2))),
3059
+ s(:lit, 3)))
3307
3060
 
3308
3061
  add_19tests("str_question_control",
3309
3062
  "Ruby" => '?\M-\C-a',