sexp_processor 3.1.0 → 3.2.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 (6) hide show
  1. data.tar.gz.sig +0 -0
  2. data/History.txt +15 -0
  3. data/lib/pt_testcase.rb +169 -1697
  4. data/lib/sexp_processor.rb +23 -8
  5. metadata +12 -12
  6. metadata.gz.sig +0 -0
data.tar.gz.sig CHANGED
Binary file
data/History.txt CHANGED
@@ -1,3 +1,18 @@
1
+ === 3.2.0 / 2012-04-15
2
+
3
+ * 5 minor enhancements:
4
+
5
+ * Added a ton of block arg tests.
6
+ * Added add19_edgecases to help refactor a bunch of tests that all have the same output.
7
+ * Added better debugging output for rewrites.
8
+ * Cleaned and added a bunch of stabby proc tests.
9
+ * Moved RawParseTree test data to ParseTree project.
10
+
11
+ * 2 bug fixes:
12
+
13
+ * Fixed a bunch of entries for r2r changes against edgecase parse/lex tests
14
+ * Fixes for R2R
15
+
1
16
  === 3.1.0 / 2012-02-29
2
17
 
3
18
  * 4 minor enhancements:
data/lib/pt_testcase.rb CHANGED
@@ -212,37 +212,29 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
212
212
  ############################################################
213
213
  # Shared TestCases:
214
214
 
215
- @@testcase_order = %w(Ruby RawParseTree ParseTree)
215
+ @@testcase_order = %w(Ruby ParseTree)
216
216
 
217
217
  @@testcases = Hash.new { |h,k| h[k] = {} }
218
218
 
219
219
  add_tests("alias",
220
220
  "Ruby" => "class X\n alias :y :x\nend",
221
- "RawParseTree" => [:class, :X, nil,
222
- [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
223
221
  "ParseTree" => s(:class, :X, nil,
224
222
  s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))))
225
223
 
226
224
  add_tests("alias_ugh",
227
225
  "Ruby" => "class X\n alias y x\nend",
228
- "RawParseTree" => [:class, :X, nil,
229
- [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
230
226
  "ParseTree" => s(:class, :X, nil,
231
227
  s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))),
232
228
  "Ruby2Ruby" => "class X\n alias :y :x\nend")
233
229
 
234
230
  add_tests("and",
235
231
  "Ruby" => "a and b",
236
- "RawParseTree" => [:and, [:vcall, :a], [:vcall, :b]],
237
232
  "ParseTree" => s(:and,
238
233
  s(:call, nil, :a, s(:arglist)),
239
234
  s(:call, nil, :b, s(:arglist))))
240
235
 
241
236
  add_tests("argscat_inside",
242
237
  "Ruby" => "a = [b, *c]",
243
- "RawParseTree" => [:lasgn, :a,
244
- [:argscat,
245
- [:array, [:vcall, :b]], [:vcall, :c]]],
246
238
  "ParseTree" => s(:lasgn, :a,
247
239
  s(:array,
248
240
  s(:call, nil, :b, s(:arglist)),
@@ -250,11 +242,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
250
242
 
251
243
  add_tests("argscat_svalue",
252
244
  "Ruby" => "a = b, c, *d",
253
- "RawParseTree" => [:lasgn, :a,
254
- [:svalue,
255
- [:argscat,
256
- [:array, [:vcall, :b], [:vcall, :c]],
257
- [:vcall, :d]]]],
258
245
  "ParseTree" => s(:lasgn, :a,
259
246
  s(:svalue,
260
247
  s(:array,
@@ -265,13 +252,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
265
252
 
266
253
  add_tests("argspush",
267
254
  "Ruby" => "a[*b] = c",
268
- "RawParseTree" => [:attrasgn,
269
- [:vcall, :a],
270
- :[]=,
271
- [:argspush,
272
- [:splat,
273
- [:vcall, :b]],
274
- [:vcall, :c]]],
275
255
  "ParseTree" => s(:attrasgn,
276
256
  s(:call, nil, :a, s(:arglist)),
277
257
  :[]=,
@@ -282,22 +262,16 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
282
262
 
283
263
  add_tests("array",
284
264
  "Ruby" => "[1, :b, \"c\"]",
285
- "RawParseTree" => [:array, [:lit, 1], [:lit, :b], [:str, "c"]],
286
265
  "ParseTree" => s(:array, s(:lit, 1), s(:lit, :b), s(:str, "c")))
287
266
 
288
267
  add_tests("array_pct_W",
289
268
  "Ruby" => "%W[a b c]",
290
- "RawParseTree" => [:array, [:str, "a"], [:str, "b"], [:str, "c"]],
291
269
  "ParseTree" => s(:array,
292
270
  s(:str, "a"), s(:str, "b"), s(:str, "c")),
293
271
  "Ruby2Ruby" => "[\"a\", \"b\", \"c\"]")
294
272
 
295
273
  add_tests("array_pct_W_dstr",
296
274
  "Ruby" => "%W[a #\{@b} c]",
297
- "RawParseTree" => [:array,
298
- [:str, "a"],
299
- [:dstr, "", [:evstr, [:ivar, :@b]]],
300
- [:str, "c"]],
301
275
  "ParseTree" => s(:array,
302
276
  s(:str, "a"),
303
277
  s(:dstr, "", s(:evstr, s(:ivar, :@b))),
@@ -306,17 +280,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
306
280
 
307
281
  add_tests("array_pct_w",
308
282
  "Ruby" => "%w[a b c]",
309
- "RawParseTree" => [:array, [:str, "a"], [:str, "b"], [:str, "c"]],
310
283
  "ParseTree" => s(:array,
311
284
  s(:str, "a"), s(:str, "b"), s(:str, "c")),
312
285
  "Ruby2Ruby" => "[\"a\", \"b\", \"c\"]")
313
286
 
314
287
  add_tests("array_pct_w_dstr",
315
288
  "Ruby" => "%w[a #\{@b} c]",
316
- "RawParseTree" => [:array,
317
- [:str, "a"],
318
- [:str, "#\{@b}"],
319
- [:str, "c"]],
320
289
  "ParseTree" => s(:array,
321
290
  s(:str, "a"),
322
291
  s(:str, "#\{@b}"),
@@ -325,10 +294,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
325
294
 
326
295
  add_tests("attrasgn",
327
296
  "Ruby" => "y = 0\n42.method = y\n",
328
- "RawParseTree" => [:block,
329
- [:lasgn, :y, [:lit, 0]],
330
- [:attrasgn, [:lit, 42], :method=,
331
- [:array, [:lvar, :y]]]],
332
297
  "ParseTree" => s(:block,
333
298
  s(:lasgn, :y, s(:lit, 0)),
334
299
  s(:attrasgn, s(:lit, 42), :method=,
@@ -336,8 +301,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
336
301
 
337
302
  add_tests("attrasgn_index_equals",
338
303
  "Ruby" => "a[42] = 24",
339
- "RawParseTree" => [:attrasgn, [:vcall, :a], :[]=,
340
- [:array, [:lit, 42], [:lit, 24]]],
341
304
  "ParseTree" => s(:attrasgn,
342
305
  s(:call, nil, :a, s(:arglist)),
343
306
  :[]=,
@@ -345,10 +308,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
345
308
 
346
309
  add_tests("attrasgn_index_equals_space",
347
310
  "Ruby" => "a = []; a [42] = 24",
348
- "RawParseTree" => [:block,
349
- [:lasgn, :a, [:zarray]],
350
- [:attrasgn, [:lvar, :a], :[]=,
351
- [:array, [:lit, 42], [:lit, 24]]]],
352
311
  "ParseTree" => s(:block,
353
312
  s(:lasgn, :a, s(:array)),
354
313
  s(:attrasgn, s(:lvar, :a), :[]=,
@@ -357,7 +316,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
357
316
 
358
317
  add_tests("attrset",
359
318
  "Ruby" => [Examples, :writer=],
360
- "RawParseTree" => [:defn, :writer=, [:attrset, :@writer]],
361
319
  "ParseTree" => s(:defn, :writer=,
362
320
  s(:args, :arg),
363
321
  s(:attrset, :@writer)),
@@ -365,11 +323,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
365
323
 
366
324
  add_tests("back_ref",
367
325
  "Ruby" => "[$&, $`, $', $+]",
368
- "RawParseTree" => [:array,
369
- [:back_ref, :&],
370
- [:back_ref, :"`"],
371
- [:back_ref, :"'"],
372
- [:back_ref, :+]],
373
326
  "ParseTree" => s(:array,
374
327
  s(:back_ref, :&),
375
328
  s(:back_ref, :"`"),
@@ -378,25 +331,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
378
331
 
379
332
  add_tests("begin",
380
333
  "Ruby" => "begin\n (1 + 1)\nend",
381
- "RawParseTree" => [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
382
334
  "ParseTree" => s(:call, s(:lit, 1), :+,
383
335
  s(:arglist, s(:lit, 1))),
384
336
  "Ruby2Ruby" => "(1 + 1)")
385
337
 
386
338
  add_tests("begin_def",
387
339
  "Ruby" => "def m\n begin\n\n end\nend",
388
- "RawParseTree" => [:defn, :m, [:scope, [:block, [:args], [:nil]]]],
389
340
  "ParseTree" => s(:defn, :m, s(:args),
390
341
  s(:scope, s(:block, s(:nil)))),
391
342
  "Ruby2Ruby" => "def m\n # do nothing\nend")
392
343
 
393
344
  add_tests("begin_rescue_ensure",
394
345
  "Ruby" => "begin\n a\nrescue\n # do nothing\nensure\n # do nothing\nend",
395
- "RawParseTree" => [:ensure,
396
- [:rescue,
397
- [:vcall, :a],
398
- [:resbody, nil]],
399
- [:nil]],
400
346
  "ParseTree" => s(:ensure,
401
347
  s(:rescue,
402
348
  s(:call, nil, :a, s(:arglist)),
@@ -405,10 +351,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
405
351
 
406
352
  add_tests("begin_rescue_ensure_all_empty",
407
353
  "Ruby" => "begin\n # do nothing\nrescue\n # do nothing\nensure\n # do nothing\nend",
408
- "RawParseTree" => [:ensure,
409
- [:rescue,
410
- [:resbody, nil]],
411
- [:nil]],
412
354
  "ParseTree" => s(:ensure,
413
355
  s(:rescue,
414
356
  s(:resbody, s(:array), nil)),
@@ -416,15 +358,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
416
358
 
417
359
  add_tests("begin_rescue_twice",
418
360
  "Ruby" => "begin\n a\nrescue => mes\n # do nothing\nend\nbegin\n b\nrescue => mes\n # do nothing\nend\n",
419
- "RawParseTree" => [:block,
420
- [:rescue,
421
- [:vcall, :a],
422
- [:resbody, nil,
423
- [:lasgn, :mes, [:gvar, :$!]]]],
424
- [:rescue,
425
- [:vcall, :b],
426
- [:resbody, nil,
427
- [:lasgn, :mes, [:gvar, :$!]]]]],
428
361
  "ParseTree" => s(:block,
429
362
  s(:rescue,
430
363
  s(:call, nil, :a, s(:arglist)),
@@ -438,30 +371,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
438
371
  s(:lasgn, :mes, s(:gvar, :$!))),
439
372
  nil))))
440
373
 
441
- add_tests("begin_rescue_twice_mri_verbose_flag",
442
- "RawParseTree" => [:block,
443
- [:rescue, # no begin
444
- [:vcall, :a],
445
- [:resbody, nil,
446
- [:lasgn, :mes, [:gvar, :$!]]]],
447
- [:rescue,
448
- [:vcall, :b],
449
- [:resbody, nil,
450
- [:lasgn, :mes, [:gvar, :$!]]]]])
451
-
452
374
  copy_test_case "begin_rescue_twice", "Ruby"
453
375
  copy_test_case "begin_rescue_twice", "ParseTree"
454
376
 
455
377
  add_tests("block_attrasgn",
456
378
  "Ruby" => "def self.setup(ctx)\n bind = allocate\n bind.context = ctx\n return bind\nend",
457
- "RawParseTree" => [:defs, [:self], :setup,
458
- [:scope,
459
- [:block,
460
- [:args, :ctx],
461
- [:lasgn, :bind, [:vcall, :allocate]],
462
- [:attrasgn, [:lvar, :bind], :context=,
463
- [:array, [:lvar, :ctx]]],
464
- [:return, [:lvar, :bind]]]]],
465
379
  "ParseTree" => s(:defs, s(:self), :setup,
466
380
  s(:args, :ctx),
467
381
  s(:scope,
@@ -475,10 +389,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
475
389
 
476
390
  add_tests("block_lasgn",
477
391
  "Ruby" => "x = (y = 1\n(y + 2))",
478
- "RawParseTree" => [:lasgn, :x,
479
- [:block,
480
- [:lasgn, :y, [:lit, 1]],
481
- [:call, [:lvar, :y], :+, [:array, [:lit, 2]]]]],
482
392
  "ParseTree" => s(:lasgn, :x,
483
393
  s(:block,
484
394
  s(:lasgn, :y, s(:lit, 1)),
@@ -487,19 +397,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
487
397
 
488
398
  add_tests("block_mystery_block",
489
399
  "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",
490
- "RawParseTree" => [:iter,
491
- [:fcall, :a, [:array, [:vcall, :b]]],
492
- nil,
493
- [:if,
494
- [:vcall, :b],
495
- [:true],
496
- [:block,
497
- [:dasgn_curr, :c, [:false]],
498
- [:iter,
499
- [:fcall, :d],
500
- [:dasgn_curr, :x],
501
- [:dasgn, :c, [:true]]],
502
- [:dvar, :c]]]],
503
400
  "ParseTree" => s(:iter,
504
401
  s(:call, nil, :a,
505
402
  s(:arglist, s(:call, nil, :b, s(:arglist)))),
@@ -517,16 +414,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
517
414
 
518
415
  add_tests("block_pass_args_and_splat",
519
416
  "Ruby" => "def blah(*args, &block)\n other(42, *args, &block)\nend",
520
- "RawParseTree" => [:defn, :blah,
521
- [:scope,
522
- [:block,
523
- [:args, :"*args"],
524
- [:block_arg, :block],
525
- [:block_pass,
526
- [:lvar, :block],
527
- [:fcall, :other,
528
- [:argscat,
529
- [:array, [:lit, 42]], [:lvar, :args]]]]]]],
530
417
  "ParseTree" => s(:defn, :blah,
531
418
  s(:args, :"*args", :"&block"),
532
419
  s(:scope,
@@ -539,8 +426,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
539
426
 
540
427
  add_tests("block_pass_call_0",
541
428
  "Ruby" => "a.b(&c)",
542
- "RawParseTree" => [:block_pass,
543
- [:vcall, :c], [:call, [:vcall, :a], :b]],
544
429
  "ParseTree" => s(:call,
545
430
  s(:call, nil, :a, s(:arglist)),
546
431
  :b,
@@ -550,9 +435,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
550
435
 
551
436
  add_tests("block_pass_call_1",
552
437
  "Ruby" => "a.b(4, &c)",
553
- "RawParseTree" => [:block_pass,
554
- [:vcall, :c],
555
- [:call, [:vcall, :a], :b, [:array, [:lit, 4]]]],
556
438
  "ParseTree" => s(:call,
557
439
  s(:call, nil, :a, s(:arglist)),
558
440
  :b,
@@ -563,10 +445,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
563
445
 
564
446
  add_tests("block_pass_call_n",
565
447
  "Ruby" => "a.b(1, 2, 3, &c)",
566
- "RawParseTree" => [:block_pass,
567
- [:vcall, :c],
568
- [:call, [:vcall, :a], :b,
569
- [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]],
570
448
  "ParseTree" => s(:call,
571
449
  s(:call, nil, :a, s(:arglist)),
572
450
  :b,
@@ -577,7 +455,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
577
455
 
578
456
  add_tests("block_pass_fcall_0",
579
457
  "Ruby" => "a(&b)",
580
- "RawParseTree" => [:block_pass, [:vcall, :b], [:fcall, :a]],
581
458
  "ParseTree" => s(:call, nil, :a,
582
459
  s(:arglist,
583
460
  s(:block_pass,
@@ -585,9 +462,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
585
462
 
586
463
  add_tests("block_pass_fcall_1",
587
464
  "Ruby" => "a(4, &b)",
588
- "RawParseTree" => [:block_pass,
589
- [:vcall, :b],
590
- [:fcall, :a, [:array, [:lit, 4]]]],
591
465
  "ParseTree" => s(:call, nil, :a,
592
466
  s(:arglist,
593
467
  s(:lit, 4),
@@ -596,10 +470,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
596
470
 
597
471
  add_tests("block_pass_fcall_n",
598
472
  "Ruby" => "a(1, 2, 3, &b)",
599
- "RawParseTree" => [:block_pass,
600
- [:vcall, :b],
601
- [:fcall, :a,
602
- [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]],
603
473
  "ParseTree" => s(:call, nil, :a,
604
474
  s(:arglist,
605
475
  s(:lit, 1), s(:lit, 2), s(:lit, 3),
@@ -608,13 +478,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
608
478
 
609
479
  add_tests("block_pass_omgwtf",
610
480
  "Ruby" => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
611
- "RawParseTree" => [:block_pass,
612
- [:iter,
613
- [:call, [:const, :Proc], :new],
614
- [:masgn, nil, [:dasgn_curr, :args], nil],
615
- [:nil]],
616
- [:fcall, :define_attr_method,
617
- [:array, [:lit, :x], [:lit, :sequence_name]]]],
618
481
  "ParseTree" => s(:call, nil, :define_attr_method,
619
482
  s(:arglist,
620
483
  s(:lit, :x),
@@ -629,15 +492,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
629
492
 
630
493
  add_tests("block_pass_splat",
631
494
  "Ruby" => "def blah(*args, &block)\n other(*args, &block)\nend",
632
- "RawParseTree" => [:defn, :blah,
633
- [:scope,
634
- [:block,
635
- [:args, :"*args"],
636
- [:block_arg, :block],
637
- [:block_pass,
638
- [:lvar, :block],
639
- [:fcall, :other,
640
- [:splat, [:lvar, :args]]]]]]],
641
495
  "ParseTree" => s(:defn, :blah,
642
496
  s(:args, :"*args", :"&block"),
643
497
  s(:scope,
@@ -649,10 +503,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
649
503
 
650
504
  add_tests("block_pass_thingy",
651
505
  "Ruby" => "r.read_body(dest, &block)",
652
- "RawParseTree" => [:block_pass,
653
- [:vcall, :block],
654
- [:call, [:vcall, :r], :read_body,
655
- [:array, [:vcall, :dest]]]],
656
506
  "ParseTree" => s(:call,
657
507
  s(:call, nil, :r, s(:arglist)),
658
508
  :read_body,
@@ -663,14 +513,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
663
513
 
664
514
  add_tests("block_stmt_after",
665
515
  "Ruby" => "def f\n begin\n b\n rescue\n c\n end\n\n d\nend",
666
- "RawParseTree" => [:defn, :f,
667
- [:scope,
668
- [:block,
669
- [:args],
670
- [:rescue,
671
- [:vcall, :b],
672
- [:resbody, nil, [:vcall, :c]]],
673
- [:vcall, :d]]]],
674
516
  "ParseTree" => s(:defn, :f,
675
517
  s(:args),
676
518
  s(:scope,
@@ -683,29 +525,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
683
525
  s(:call, nil, :d, s(:arglist))))),
684
526
  "Ruby2Ruby" => "def f\n b rescue c\n d\nend")
685
527
 
686
- add_tests("block_stmt_after_mri_verbose_flag",
687
- "RawParseTree" => [:defn, :f,
688
- [:scope,
689
- [:block,
690
- [:args],
691
- [:rescue, # no begin
692
- [:vcall, :b],
693
- [:resbody, nil, [:vcall, :c]]],
694
- [:vcall, :d]]]])
695
-
696
528
  copy_test_case "block_stmt_after", "Ruby"
697
529
  copy_test_case "block_stmt_after", "ParseTree"
698
530
  copy_test_case "block_stmt_after", "Ruby2Ruby"
699
531
 
700
532
  add_tests("block_stmt_before",
701
533
  "Ruby" => "def f\n a\n begin\n b\n rescue\n c\n end\nend",
702
- "RawParseTree" => [:defn, :f,
703
- [:scope,
704
- [:block,
705
- [:args],
706
- [:vcall, :a],
707
- [:rescue, [:vcall, :b],
708
- [:resbody, nil, [:vcall, :c]]]]]],
709
534
  "ParseTree" => s(:defn, :f,
710
535
  s(:args),
711
536
  s(:scope,
@@ -720,22 +545,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
720
545
  # oddly... this one doesn't HAVE any differences when verbose... new?
721
546
  copy_test_case "block_stmt_before", "Ruby"
722
547
  copy_test_case "block_stmt_before", "ParseTree"
723
- copy_test_case "block_stmt_before", "RawParseTree"
724
548
  copy_test_case "block_stmt_before", "Ruby2Ruby"
725
549
 
726
550
  add_tests("block_stmt_both",
727
551
  "Ruby" => "def f\n a\n begin\n b\n rescue\n c\n end\n d\nend",
728
- "RawParseTree" => [:defn, :f,
729
- [:scope,
730
- [:block,
731
- [:args],
732
- [:vcall, :a],
733
- [:rescue,
734
- [:vcall, :b],
735
- [:resbody,
736
- nil,
737
- [:vcall, :c]]],
738
- [:vcall, :d]]]],
739
552
  "ParseTree" => s(:defn, :f, s(:args),
740
553
  s(:scope,
741
554
  s(:block,
@@ -748,29 +561,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
748
561
  s(:call, nil, :d, s(:arglist))))),
749
562
  "Ruby2Ruby" => "def f\n a\n b rescue c\n d\nend")
750
563
 
751
- add_tests("block_stmt_both_mri_verbose_flag",
752
- "RawParseTree" => [:defn, :f,
753
- [:scope,
754
- [:block,
755
- [:args],
756
- [:vcall, :a],
757
- [:rescue, # no begin
758
- [:vcall, :b],
759
- [:resbody,
760
- nil,
761
- [:vcall, :c]]],
762
- [:vcall, :d]]]])
763
-
764
564
  copy_test_case "block_stmt_both", "Ruby"
765
565
  copy_test_case "block_stmt_both", "ParseTree"
766
566
  copy_test_case "block_stmt_both", "Ruby2Ruby"
767
567
 
768
568
  add_tests("bmethod",
769
569
  "Ruby" => [Examples, :unsplatted],
770
- "RawParseTree" => [:defn, :unsplatted,
771
- [:bmethod,
772
- [:dasgn_curr, :x],
773
- [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
774
570
  "ParseTree" => s(:defn, :unsplatted,
775
571
  s(:args, :x),
776
572
  s(:scope,
@@ -783,11 +579,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
783
579
 
784
580
  add_tests("bmethod_noargs",
785
581
  "Ruby" => [Examples, :bmethod_noargs],
786
- "RawParseTree" => [:defn, :bmethod_noargs,
787
- [:bmethod,
788
- nil,
789
- [:call,
790
- [:vcall, :x], :"+", [:array, [:lit, 1]]]]],
791
582
  "ParseTree" => s(:defn, :bmethod_noargs,
792
583
  s(:args),
793
584
  s(:scope,
@@ -800,14 +591,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
800
591
 
801
592
  add_tests("bmethod_splat",
802
593
  "Ruby" => [Examples, :splatted],
803
- "RawParseTree" => [:defn, :splatted,
804
- [:bmethod,
805
- [:masgn, nil, [:dasgn_curr, :args], nil],
806
- [:block,
807
- [:dasgn_curr, :y,
808
- [:call, [:dvar, :args], :first]],
809
- [:call, [:dvar, :y], :+,
810
- [:array, [:lit, 42]]]]]],
811
594
  "ParseTree" => s(:defn, :splatted,
812
595
  s(:args, :"*args"),
813
596
  s(:scope,
@@ -821,72 +604,54 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
821
604
 
822
605
  add_tests("break",
823
606
  "Ruby" => "loop { break if true }",
824
- "RawParseTree" => [:iter,
825
- [:fcall, :loop], nil,
826
- [:if, [:true], [:break], nil]],
827
607
  "ParseTree" => s(:iter,
828
608
  s(:call, nil, :loop, s(:arglist)), nil,
829
609
  s(:if, s(:true), s(:break), nil)))
830
610
 
831
611
  add_tests("break_arg",
832
612
  "Ruby" => "loop { break 42 if true }",
833
- "RawParseTree" => [:iter,
834
- [:fcall, :loop], nil,
835
- [:if, [:true], [:break, [:lit, 42]], nil]],
836
613
  "ParseTree" => s(:iter,
837
614
  s(:call, nil, :loop, s(:arglist)), nil,
838
615
  s(:if, s(:true), s(:break, s(:lit, 42)), nil)))
839
616
 
840
617
  add_tests("call",
841
618
  "Ruby" => "self.method",
842
- "RawParseTree" => [:call, [:self], :method],
843
619
  "ParseTree" => s(:call, s(:self), :method, s(:arglist)))
844
620
 
845
621
  add_tests("call_arglist",
846
622
  "Ruby" => "o.puts(42)",
847
- "RawParseTree" => [:call, [:vcall, :o], :puts,
848
- [:array, [:lit, 42]]],
849
623
  "ParseTree" => s(:call, s(:call, nil, :o, s(:arglist)), :puts,
850
624
  s(:arglist, s(:lit, 42))))
851
625
 
852
626
  add_tests("call_no_space_symbol",
853
627
  "Ruby" => "foo:bar",
854
- "RawParseTree" => [:call, nil, :foo, [:array, [:lit, :bar]]],
855
- "ParseTree" => s(:call, nil, :foo, s(:arglist, s(:lit, :bar))))
628
+ "ParseTree" => s(:call, nil, :foo, s(:arglist, s(:lit, :bar))),
629
+ "Ruby2Ruby" => "foo(:bar)")
856
630
 
857
631
  add_tests("ternary_symbol_no_spaces",
858
632
  "Ruby" => "1?:x:1",
859
- "RawParseTree" => [:if, [:lit, 1], [:lit, :x], [:lit, 1]],
860
- "ParseTree" => s(:if, s(:lit, 1), s(:lit, :x), s(:lit, 1)))
633
+ "ParseTree" => s(:if, s(:lit, 1), s(:lit, :x), s(:lit, 1)),
634
+ "Ruby2Ruby" => "1 ? (:x) : (1)")
861
635
 
862
636
  add_19tests("label_in_callargs_in_ternary",
863
637
  "Ruby" => "1 ? m(a: 2) : 1",
864
- "RawParseTree" => [:if, [:lit, 1], [:call, :nil, :m, [:array, [:hash, [:lit, :a], [:lit, 1]]]], [:lit, 1]],
865
- "ParseTree" => s(:if, s(:lit, 1), s(:call, nil, :m, s(:arglist, s(:hash, s(:lit, :a), s(:lit, 2)))), s(:lit, 1)))
638
+ "ParseTree" => s(:if, s(:lit, 1),
639
+ s(:call, nil, :m,
640
+ s(:arglist,
641
+ s(:hash, s(:lit, :a), s(:lit, 2)))),
642
+ s(:lit, 1)))
866
643
 
867
644
  add_19tests("label_in_bare_hash_in_array_in_ternary",
868
645
  "Ruby" => "1 ? [:a, b: 2] : 1",
869
- "RawParseTree" => [:if, [:array, [:lit, :a], [:hash, [:lit, :b], [:lit, 2]]], [:lit, 1]],
870
646
  "ParseTree" => s(:if, s(:lit, 1), s(:array, s(:lit, :a), s(:hash, s(:lit, :b), s(:lit, 2))), s(:lit, 1)))
871
647
 
872
- add_tests("ternary_object_no_spaces",
873
- "Ruby" => "1 ?o:1",
874
- "RawParseTree" => [:if, [:lit, 1], [:vcall, :o], [:lit, 1]],
875
- "ParseTree" => s(:if, s(:lit, 1), s(:call, nil, :o, s(:arglist)), s(:lit, 1)))
876
-
877
648
  add_tests("ternary_nil_no_space",
878
649
  "Ruby" => "1 ? nil: 1",
879
- "RawParseTree" => [:if, [:lit, 1], [:nil], [:lit, 1]],
880
- "ParseTree" => s(:if, s(:lit, 1), s(:nil), s(:lit, 1)))
650
+ "ParseTree" => s(:if, s(:lit, 1), s(:nil), s(:lit, 1)),
651
+ "Ruby2Ruby" => "1 ? (nil) : (1)")
881
652
 
882
653
  add_tests("call_arglist_hash",
883
654
  "Ruby" => "o.m(:a => 1, :b => 2)",
884
- "RawParseTree" => [:call,
885
- [:vcall, :o], :m,
886
- [:array,
887
- [:hash,
888
- [:lit, :a], [:lit, 1],
889
- [:lit, :b], [:lit, 2]]]],
890
655
  "ParseTree" => s(:call,
891
656
  s(:call, nil, :o, s(:arglist)), :m,
892
657
  s(:arglist,
@@ -896,13 +661,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
896
661
 
897
662
  add_tests("call_arglist_norm_hash",
898
663
  "Ruby" => "o.m(42, :a => 1, :b => 2)",
899
- "RawParseTree" => [:call,
900
- [:vcall, :o], :m,
901
- [:array,
902
- [:lit, 42],
903
- [:hash,
904
- [:lit, :a], [:lit, 1],
905
- [:lit, :b], [:lit, 2]]]],
906
664
  "ParseTree" => s(:call,
907
665
  s(:call, nil, :o, s(:arglist)), :m,
908
666
  s(:arglist,
@@ -913,15 +671,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
913
671
 
914
672
  add_tests("call_arglist_norm_hash_splat",
915
673
  "Ruby" => "o.m(42, :a => 1, :b => 2, *c)",
916
- "RawParseTree" => [:call,
917
- [:vcall, :o], :m,
918
- [:argscat,
919
- [:array,
920
- [:lit, 42],
921
- [:hash,
922
- [:lit, :a], [:lit, 1],
923
- [:lit, :b], [:lit, 2]]],
924
- [:vcall, :c]]],
925
674
  "ParseTree" => s(:call,
926
675
  s(:call, nil, :o, s(:arglist)), :m,
927
676
  s(:arglist,
@@ -933,8 +682,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
933
682
 
934
683
  add_tests("call_arglist_space",
935
684
  "Ruby" => "a (1,2,3)",
936
- "RawParseTree" => [:fcall, :a,
937
- [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
938
685
  "ParseTree" => s(:call, nil, :a,
939
686
  s(:arglist,
940
687
  s(:lit, 1), s(:lit, 2), s(:lit, 3))),
@@ -942,7 +689,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
942
689
 
943
690
  add_tests("call_command",
944
691
  "Ruby" => "1.b(c)",
945
- "RawParseTree" => [:call, [:lit, 1], :b, [:array, [:vcall, :c]]],
946
692
  "ParseTree" => s(:call,
947
693
  s(:lit, 1),
948
694
  :b,
@@ -950,10 +696,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
950
696
 
951
697
  add_tests("call_expr",
952
698
  "Ruby" => "(v = (1 + 1)).zero?",
953
- "RawParseTree" => [:call,
954
- [:lasgn, :v,
955
- [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
956
- :zero?],
957
699
  "ParseTree" => s(:call,
958
700
  s(:lasgn, :v,
959
701
  s(:call, s(:lit, 1), :+,
@@ -962,9 +704,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
962
704
 
963
705
  add_tests("call_index",
964
706
  "Ruby" => "a = []\na[42]\n",
965
- "RawParseTree" => [:block,
966
- [:lasgn, :a, [:zarray]],
967
- [:call, [:lvar, :a], :[], [:array, [:lit, 42]]]],
968
707
  "ParseTree" => s(:block,
969
708
  s(:lasgn, :a, s(:array)),
970
709
  s(:call, s(:lvar, :a), :[],
@@ -972,15 +711,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
972
711
 
973
712
  add_tests("call_index_no_args",
974
713
  "Ruby" => "a[]",
975
- "RawParseTree" => [:call, [:vcall, :a], :[]],
976
714
  "ParseTree" => s(:call, s(:call, nil, :a, s(:arglist)),
977
715
  :[], s(:arglist)))
978
716
 
979
717
  add_tests("call_index_space",
980
718
  "Ruby" => "a = []\na [42]\n",
981
- "RawParseTree" => [:block,
982
- [:lasgn, :a, [:zarray]],
983
- [:call, [:lvar, :a], :[], [:array, [:lit, 42]]]],
984
719
  "ParseTree" => s(:block,
985
720
  s(:lasgn, :a, s(:array)),
986
721
  s(:call, s(:lvar, :a), :[],
@@ -989,9 +724,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
989
724
 
990
725
  add_tests("call_unary_neg",
991
726
  "Ruby" => "-2**31",
992
- "RawParseTree" => [:call,
993
- [:call, [:lit, 2], :**, [:array, [:lit, 31]]],
994
- :-@],
995
727
  "ParseTree" => s(:call,
996
728
  s(:call,
997
729
  s(:lit, 2),
@@ -1002,31 +734,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1002
734
 
1003
735
  add_tests("case",
1004
736
  "Ruby" => "var = 2\nresult = \"\"\ncase var\nwhen 1 then\n puts(\"something\")\n result = \"red\"\nwhen 2, 3 then\n result = \"yellow\"\nwhen 4 then\n # do nothing\nelse\n result = \"green\"\nend\ncase result\nwhen \"red\" then\n var = 1\nwhen \"yellow\" then\n var = 2\nwhen \"green\" then\n var = 3\nelse\n # do nothing\nend\n",
1005
- "RawParseTree" => [:block,
1006
- [:lasgn, :var, [:lit, 2]],
1007
- [:lasgn, :result, [:str, ""]],
1008
- [:case,
1009
- [:lvar, :var],
1010
- [:when,
1011
- [:array, [:lit, 1]],
1012
- [:block,
1013
- [:fcall, :puts,
1014
- [:array, [:str, "something"]]],
1015
- [:lasgn, :result, [:str, "red"]]]],
1016
- [:when,
1017
- [:array, [:lit, 2], [:lit, 3]],
1018
- [:lasgn, :result, [:str, "yellow"]]],
1019
- [:when, [:array, [:lit, 4]], nil],
1020
- [:lasgn, :result, [:str, "green"]]],
1021
- [:case,
1022
- [:lvar, :result],
1023
- [:when, [:array, [:str, "red"]],
1024
- [:lasgn, :var, [:lit, 1]]],
1025
- [:when, [:array, [:str, "yellow"]],
1026
- [:lasgn, :var, [:lit, 2]]],
1027
- [:when, [:array, [:str, "green"]],
1028
- [:lasgn, :var, [:lit, 3]]],
1029
- nil]],
1030
737
  "ParseTree" => s(:block,
1031
738
  s(:lasgn, :var, s(:lit, 2)),
1032
739
  s(:lasgn, :result, s(:str, "")),
@@ -1055,29 +762,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1055
762
 
1056
763
  add_tests("case_nested",
1057
764
  "Ruby" => "var1 = 1\nvar2 = 2\nresult = nil\ncase var1\nwhen 1 then\n case var2\n when 1 then\n result = 1\n when 2 then\n result = 2\n else\n result = 3\n end\nwhen 2 then\n case var2\n when 1 then\n result = 4\n when 2 then\n result = 5\n else\n result = 6\n end\nelse\n result = 7\nend\n",
1058
- "RawParseTree" => [:block,
1059
- [:lasgn, :var1, [:lit, 1]],
1060
- [:lasgn, :var2, [:lit, 2]],
1061
- [:lasgn, :result, [:nil]],
1062
- [:case,
1063
- [:lvar, :var1],
1064
- [:when, [:array, [:lit, 1]],
1065
- [:case,
1066
- [:lvar, :var2],
1067
- [:when, [:array, [:lit, 1]],
1068
- [:lasgn, :result, [:lit, 1]]],
1069
- [:when, [:array, [:lit, 2]],
1070
- [:lasgn, :result, [:lit, 2]]],
1071
- [:lasgn, :result, [:lit, 3]]]],
1072
- [:when, [:array, [:lit, 2]],
1073
- [:case,
1074
- [:lvar, :var2],
1075
- [:when, [:array, [:lit, 1]],
1076
- [:lasgn, :result, [:lit, 4]]],
1077
- [:when, [:array, [:lit, 2]],
1078
- [:lasgn, :result, [:lit, 5]]],
1079
- [:lasgn, :result, [:lit, 6]]]],
1080
- [:lasgn, :result, [:lit, 7]]]],
1081
765
  "ParseTree" => s(:block,
1082
766
  s(:lasgn, :var1, s(:lit, 1)),
1083
767
  s(:lasgn, :var2, s(:lit, 2)),
@@ -1104,14 +788,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1104
788
 
1105
789
  add_tests("case_nested_inner_no_expr",
1106
790
  "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",
1107
- "RawParseTree" => [:case, [:vcall, :a],
1108
- [:when, [:array, [:vcall, :b]],
1109
- [:case, nil,
1110
- [:when,
1111
- [:array, [:and, [:vcall, :d], [:vcall, :e]]],
1112
- [:vcall, :f]],
1113
- nil]],
1114
- nil],
1115
791
  "ParseTree" => s(:case, s(:call, nil, :a, s(:arglist)),
1116
792
  s(:when,
1117
793
  s(:array, s(:call, nil, :b, s(:arglist))),
@@ -1127,18 +803,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1127
803
 
1128
804
  add_tests("case_no_expr",
1129
805
  "Ruby" => "case\nwhen (a == 1) then\n :a\nwhen (a == 2) then\n :b\nelse\n :c\nend",
1130
- "RawParseTree" => [:case, nil,
1131
- [:when,
1132
- [:array,
1133
- [:call, [:vcall, :a], :==,
1134
- [:array, [:lit, 1]]]],
1135
- [:lit, :a]],
1136
- [:when,
1137
- [:array,
1138
- [:call, [:vcall, :a], :==,
1139
- [:array, [:lit, 2]]]],
1140
- [:lit, :b]],
1141
- [:lit, :c]],
1142
806
  "ParseTree" => s(:case, nil,
1143
807
  s(:when,
1144
808
  s(:array,
@@ -1158,12 +822,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1158
822
 
1159
823
  add_tests("case_splat",
1160
824
  "Ruby" => "case a\nwhen :b, *c then\n d\nelse\n e\nend",
1161
- "RawParseTree" => [:case, [:vcall, :a],
1162
- [:when,
1163
- [:array,
1164
- [:lit, :b], [:when, [:vcall, :c], nil]], # wtf?
1165
- [:vcall, :d]],
1166
- [:vcall, :e]],
1167
825
  "ParseTree" => s(:case, s(:call, nil, :a, s(:arglist)),
1168
826
  s(:when,
1169
827
  s(:array,
@@ -1176,26 +834,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1176
834
 
1177
835
  add_tests("cdecl",
1178
836
  "Ruby" => "X = 42",
1179
- "RawParseTree" => [:cdecl, :X, [:lit, 42]],
1180
837
  "ParseTree" => s(:cdecl, :X, s(:lit, 42)))
1181
838
 
1182
839
  add_tests("class_plain",
1183
840
  "Ruby" => "class X\n puts((1 + 1))\n def blah\n puts(\"hello\")\n end\nend",
1184
- "RawParseTree" => [:class,
1185
- :X,
1186
- nil,
1187
- [:scope,
1188
- [:block,
1189
- [:fcall, :puts,
1190
- [:array,
1191
- [:call, [:lit, 1], :+,
1192
- [:array, [:lit, 1]]]]],
1193
- [:defn, :blah,
1194
- [:scope,
1195
- [:block,
1196
- [:args],
1197
- [:fcall, :puts,
1198
- [:array, [:str, "hello"]]]]]]]]],
1199
841
  "ParseTree" => s(:class,
1200
842
  :X,
1201
843
  nil,
@@ -1215,24 +857,16 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1215
857
 
1216
858
  add_tests("class_scoped",
1217
859
  "Ruby" => "class X::Y\n c\nend",
1218
- "RawParseTree" => [:class, [:colon2, [:const, :X], :Y], nil,
1219
- [:scope, [:vcall, :c]]],
1220
860
  "ParseTree" => s(:class, s(:colon2, s(:const, :X), :Y), nil,
1221
861
  s(:scope, s(:call, nil, :c, s(:arglist)))))
1222
862
 
1223
863
  add_tests("class_scoped3",
1224
864
  "Ruby" => "class ::Y\n c\nend",
1225
- "RawParseTree" => [:class, [:colon3, :Y], nil,
1226
- [:scope, [:vcall, :c]]],
1227
865
  "ParseTree" => s(:class, s(:colon3, :Y), nil,
1228
866
  s(:scope, s(:call, nil, :c, s(:arglist)))))
1229
867
 
1230
868
  add_tests("class_super_array",
1231
869
  "Ruby" => "class X < Array\nend",
1232
- "RawParseTree" => [:class,
1233
- :X,
1234
- [:const, :Array],
1235
- [:scope]],
1236
870
  "ParseTree" => s(:class,
1237
871
  :X,
1238
872
  s(:const, :Array),
@@ -1240,10 +874,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1240
874
 
1241
875
  add_tests("class_super_expr",
1242
876
  "Ruby" => "class X < expr\nend",
1243
- "RawParseTree" => [:class,
1244
- :X,
1245
- [:vcall, :expr],
1246
- [:scope]],
1247
877
  "ParseTree" => s(:class,
1248
878
  :X,
1249
879
  s(:call, nil, :expr, s(:arglist)),
@@ -1251,10 +881,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1251
881
 
1252
882
  add_tests("class_super_object",
1253
883
  "Ruby" => "class X < Object\nend",
1254
- "RawParseTree" => [:class,
1255
- :X,
1256
- [:const, :Object],
1257
- [:scope]],
1258
884
  "ParseTree" => s(:class,
1259
885
  :X,
1260
886
  s(:const, :Object),
@@ -1262,47 +888,36 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1262
888
 
1263
889
  add_tests("colon2",
1264
890
  "Ruby" => "X::Y",
1265
- "RawParseTree" => [:colon2, [:const, :X], :Y],
1266
891
  "ParseTree" => s(:colon2, s(:const, :X), :Y))
1267
892
 
1268
893
  add_tests("colon3",
1269
894
  "Ruby" => "::X",
1270
- "RawParseTree" => [:colon3, :X],
1271
895
  "ParseTree" => s(:colon3, :X))
1272
896
 
1273
897
  add_tests("const",
1274
898
  "Ruby" => "X",
1275
- "RawParseTree" => [:const, :X],
1276
899
  "ParseTree" => s(:const, :X))
1277
900
 
1278
901
  add_tests("constX",
1279
902
  "Ruby" => "X = 1",
1280
- "RawParseTree" => [:cdecl, :X, [:lit, 1]],
1281
903
  "ParseTree" => s(:cdecl, :X, s(:lit, 1)))
1282
904
 
1283
905
  add_tests("constY",
1284
906
  "Ruby" => "::X = 1",
1285
- "RawParseTree" => [:cdecl, [:colon3, :X], [:lit, 1]],
1286
907
  "ParseTree" => s(:cdecl, s(:colon3, :X), s(:lit, 1)))
1287
908
 
1288
909
  add_tests("constZ",
1289
910
  "Ruby" => "X::Y = 1",
1290
- "RawParseTree" => [:cdecl, [:colon2, [:const, :X], :Y], [:lit, 1]],
1291
911
  "ParseTree" => s(:cdecl,
1292
912
  s(:colon2, s(:const, :X), :Y),
1293
913
  s(:lit, 1)))
1294
914
 
1295
915
  add_tests("cvar",
1296
916
  "Ruby" => "@@x",
1297
- "RawParseTree" => [:cvar, :@@x],
1298
917
  "ParseTree" => s(:cvar, :@@x))
1299
918
 
1300
919
  add_tests("cvasgn",
1301
920
  "Ruby" => "def x\n @@blah = 1\nend",
1302
- "RawParseTree" => [:defn, :x,
1303
- [:scope,
1304
- [:block, [:args],
1305
- [:cvasgn, :@@blah, [:lit, 1]]]]],
1306
921
  "ParseTree" => s(:defn, :x,
1307
922
  s(:args),
1308
923
  s(:scope,
@@ -1311,11 +926,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1311
926
 
1312
927
  add_tests("cvasgn_cls_method",
1313
928
  "Ruby" => "def self.quiet_mode=(boolean)\n @@quiet_mode = boolean\nend",
1314
- "RawParseTree" => [:defs, [:self], :quiet_mode=,
1315
- [:scope,
1316
- [:block,
1317
- [:args, :boolean],
1318
- [:cvasgn, :@@quiet_mode, [:lvar, :boolean]]]]],
1319
929
  "ParseTree" => s(:defs, s(:self), :quiet_mode=,
1320
930
  s(:args, :boolean),
1321
931
  s(:scope,
@@ -1325,24 +935,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1325
935
 
1326
936
  add_tests("cvdecl",
1327
937
  "Ruby" => "class X\n @@blah = 1\nend",
1328
- "RawParseTree" => [:class, :X, nil,
1329
- [:scope, [:cvdecl, :@@blah, [:lit, 1]]]],
1330
938
  "ParseTree" => s(:class, :X, nil,
1331
939
  s(:scope, s(:cvdecl, :@@blah, s(:lit, 1)))))
1332
940
 
1333
941
  add_tests("dasgn_0",
1334
942
  "Ruby" => "a.each { |x| b.each { |y| x = (x + 1) } if true }",
1335
- "RawParseTree" => [:iter,
1336
- [:call, [:vcall, :a], :each],
1337
- [:dasgn_curr, :x],
1338
- [:if, [:true],
1339
- [:iter,
1340
- [:call, [:vcall, :b], :each],
1341
- [:dasgn_curr, :y],
1342
- [:dasgn, :x,
1343
- [:call, [:dvar, :x], :+,
1344
- [:array, [:lit, 1]]]]],
1345
- nil]],
1346
943
  "ParseTree" => s(:iter,
1347
944
  s(:call, s(:call, nil, :a, s(:arglist)), :each,
1348
945
  s(:arglist)),
@@ -1360,17 +957,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1360
957
 
1361
958
  add_tests("dasgn_1",
1362
959
  "Ruby" => "a.each { |x| b.each { |y| c = (c + 1) } if true }",
1363
- "RawParseTree" => [:iter,
1364
- [:call, [:vcall, :a], :each],
1365
- [:dasgn_curr, :x],
1366
- [:if, [:true],
1367
- [:iter,
1368
- [:call, [:vcall, :b], :each],
1369
- [:dasgn_curr, :y],
1370
- [:dasgn_curr, :c,
1371
- [:call, [:dvar, :c], :+,
1372
- [:array, [:lit, 1]]]]],
1373
- nil]],
1374
960
  "ParseTree" => s(:iter,
1375
961
  s(:call, s(:call, nil, :a, s(:arglist)), :each,
1376
962
  s(:arglist)),
@@ -1388,19 +974,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1388
974
 
1389
975
  add_tests("dasgn_2",
1390
976
  "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!
1391
- "RawParseTree" => [:iter,
1392
- [:call, [:vcall, :a], :each],
1393
- [:dasgn_curr, :x],
1394
- [:if, [:true],
1395
- [:block,
1396
- [:dasgn_curr, :c, [:lit, 0]],
1397
- [:iter,
1398
- [:call, [:vcall, :b], :each],
1399
- [:dasgn_curr, :y],
1400
- [:dasgn, :c,
1401
- [:call, [:dvar, :c], :+,
1402
- [:array, [:lit, 1]]]]]],
1403
- nil]],
1404
977
  "ParseTree" => s(:iter,
1405
978
  s(:call, s(:call, nil, :a, s(:arglist)), :each,
1406
979
  s(:arglist)),
@@ -1420,16 +993,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1420
993
 
1421
994
  add_tests("dasgn_curr",
1422
995
  "Ruby" => "data.each do |x, y|\n a = 1\n b = a\n b = a = x\nend",
1423
- "RawParseTree" => [:iter,
1424
- [:call, [:vcall, :data], :each],
1425
- [:masgn,
1426
- [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]],
1427
- nil, nil],
1428
- [:block,
1429
- [:dasgn_curr, :a, [:lit, 1]],
1430
- [:dasgn_curr, :b, [:dvar, :a]],
1431
- [:dasgn_curr, :b,
1432
- [:dasgn_curr, :a, [:dvar, :x]]]]],
1433
996
  "ParseTree" => s(:iter,
1434
997
  s(:call, s(:call, nil, :data,
1435
998
  s(:arglist)), :each, s(:arglist)),
@@ -1442,22 +1005,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1442
1005
 
1443
1006
  add_tests("dasgn_icky",
1444
1007
  "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",
1445
- "RawParseTree" => [:iter,
1446
- [:fcall, :a],
1447
- nil,
1448
- [:block,
1449
- [:dasgn_curr, :v, [:nil]],
1450
- [:iter,
1451
- [:fcall, :assert_block,
1452
- [:array, [:vcall, :full_message]]],
1453
- nil,
1454
- [:rescue,
1455
- [:yield],
1456
- [:resbody,
1457
- [:array, [:const, :Exception]],
1458
- [:block,
1459
- [:dasgn, :v,
1460
- [:gvar, :$!]], [:break]]]]]]],
1461
1008
  "ParseTree" => s(:iter,
1462
1009
  s(:call, nil, :a, s(:arglist)),
1463
1010
  nil,
@@ -1479,14 +1026,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1479
1026
 
1480
1027
  add_tests("dasgn_mixed",
1481
1028
  "Ruby" => "t = 0\nns.each { |n| t += n }\n",
1482
- "RawParseTree" => [:block,
1483
- [:lasgn, :t, [:lit, 0]],
1484
- [:iter,
1485
- [:call, [:vcall, :ns], :each],
1486
- [:dasgn_curr, :n],
1487
- [:lasgn, :t,
1488
- [:call, [:lvar, :t], :+,
1489
- [:array, [:dvar, :n]]]]]],
1490
1029
  "ParseTree" => s(:block,
1491
1030
  s(:lasgn, :t, s(:lit, 0)),
1492
1031
  s(:iter,
@@ -1500,54 +1039,29 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1500
1039
 
1501
1040
  add_tests("defined",
1502
1041
  "Ruby" => "defined? $x",
1503
- "RawParseTree" => [:defined, [:gvar, :$x]],
1504
1042
  "ParseTree" => s(:defined, s(:gvar, :$x)))
1505
1043
 
1506
1044
  # TODO: make all the defn_args* p their arglist
1507
1045
  add_tests("defn_args_block",
1508
1046
  "Ruby" => "def f(&block)\n # do nothing\nend",
1509
- "RawParseTree" => [:defn, :f,
1510
- [:scope,
1511
- [:block,
1512
- [:args],
1513
- [:block_arg, :block],
1514
- [:nil]]]],
1515
1047
  "ParseTree" => s(:defn, :f,
1516
1048
  s(:args, :"&block"),
1517
1049
  s(:scope, s(:block, s(:nil)))))
1518
1050
 
1519
1051
  add_tests("defn_args_mand",
1520
1052
  "Ruby" => "def f(mand)\n # do nothing\nend",
1521
- "RawParseTree" => [:defn, :f,
1522
- [:scope,
1523
- [:block,
1524
- [:args, :mand],
1525
- [:nil]]]],
1526
1053
  "ParseTree" => s(:defn, :f,
1527
1054
  s(:args, :mand),
1528
1055
  s(:scope, s(:block, s(:nil)))))
1529
1056
 
1530
1057
  add_tests("defn_args_mand_block",
1531
1058
  "Ruby" => "def f(mand, &block)\n # do nothing\nend",
1532
- "RawParseTree" => [:defn, :f,
1533
- [:scope,
1534
- [:block,
1535
- [:args, :mand],
1536
- [:block_arg, :block],
1537
- [:nil]]]],
1538
1059
  "ParseTree" => s(:defn, :f,
1539
1060
  s(:args, :mand, :"&block"),
1540
1061
  s(:scope, s(:block, s(:nil)))))
1541
1062
 
1542
1063
  add_tests("defn_args_mand_opt",
1543
1064
  "Ruby" => "def f(mand, opt = 42)\n # do nothing\nend",
1544
- "RawParseTree" => [:defn, :f,
1545
- [:scope,
1546
- [:block,
1547
- [:args, :mand, :opt,
1548
- [:block,
1549
- [:lasgn, :opt, [:lit, 42]]]],
1550
- [:nil]]]],
1551
1065
  "ParseTree" => s(:defn, :f,
1552
1066
  s(:args, :mand, :opt,
1553
1067
  s(:block,
@@ -1556,14 +1070,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1556
1070
 
1557
1071
  add_tests("defn_args_mand_opt_block",
1558
1072
  "Ruby" => "def f(mand, opt = 42, &block)\n # do nothing\nend",
1559
- "RawParseTree" => [:defn, :f,
1560
- [:scope,
1561
- [:block,
1562
- [:args, :mand, :opt,
1563
- [:block,
1564
- [:lasgn, :opt, [:lit, 42]]]],
1565
- [:block_arg, :block],
1566
- [:nil]]]],
1567
1073
  "ParseTree" => s(:defn, :f,
1568
1074
  s(:args, :mand, :opt, :"&block",
1569
1075
  s(:block,
@@ -1572,13 +1078,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1572
1078
 
1573
1079
  add_tests("defn_args_mand_opt_splat",
1574
1080
  "Ruby" => "def f(mand, opt = 42, *rest)\n # do nothing\nend",
1575
- "RawParseTree" => [:defn, :f,
1576
- [:scope,
1577
- [:block,
1578
- [:args, :mand, :opt, :"*rest",
1579
- [:block,
1580
- [:lasgn, :opt, [:lit, 42]]]],
1581
- [:nil]]]],
1582
1081
  "ParseTree" => s(:defn, :f,
1583
1082
  s(:args, :mand, :opt, :"*rest",
1584
1083
  s(:block,
@@ -1587,14 +1086,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1587
1086
 
1588
1087
  add_tests("defn_args_mand_opt_splat_block",
1589
1088
  "Ruby" => "def f(mand, opt = 42, *rest, &block)\n # do nothing\nend",
1590
- "RawParseTree" => [:defn, :f,
1591
- [:scope,
1592
- [:block,
1593
- [:args, :mand, :opt, :"*rest",
1594
- [:block,
1595
- [:lasgn, :opt, [:lit, 42]]]],
1596
- [:block_arg, :block],
1597
- [:nil]]]],
1598
1089
  "ParseTree" => s(:defn, :f,
1599
1090
  s(:args, :mand, :opt, :"*rest", :"&block",
1600
1091
  s(:block,
@@ -1603,12 +1094,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1603
1094
 
1604
1095
  add_tests("defn_args_mand_opt_splat_no_name",
1605
1096
  "Ruby" => "def x(a, b = 42, *)\n # do nothing\nend",
1606
- "RawParseTree" => [:defn, :x,
1607
- [:scope,
1608
- [:block,
1609
- [:args, :a, :b, :"*",
1610
- [:block, [:lasgn, :b, [:lit, 42]]]],
1611
- [:nil]]]],
1612
1097
  "ParseTree" => s(:defn, :x,
1613
1098
  s(:args, :a, :b, :"*",
1614
1099
  s(:block, s(:lasgn, :b, s(:lit, 42)))),
@@ -1618,35 +1103,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1618
1103
 
1619
1104
  add_tests("defn_args_mand_splat",
1620
1105
  "Ruby" => "def f(mand, *rest)\n # do nothing\nend",
1621
- "RawParseTree" => [:defn, :f,
1622
- [:scope,
1623
- [:block,
1624
- [:args, :mand, :"*rest"],
1625
- [:nil]]]],
1626
1106
  "ParseTree" => s(:defn, :f,
1627
1107
  s(:args, :mand, :"*rest"),
1628
1108
  s(:scope, s(:block, s(:nil)))))
1629
1109
 
1630
1110
  add_tests("defn_args_mand_splat_block",
1631
1111
  "Ruby" => "def f(mand, *rest, &block)\n # do nothing\nend",
1632
- "RawParseTree" => [:defn, :f,
1633
- [:scope,
1634
- [:block,
1635
- [:args, :mand, :"*rest"],
1636
- [:block_arg, :block],
1637
- [:nil]]]],
1638
1112
  "ParseTree" => s(:defn, :f,
1639
1113
  s(:args, :mand, :"*rest", :"&block"),
1640
1114
  s(:scope, s(:block, s(:nil)))))
1641
1115
 
1642
1116
  add_tests("defn_args_mand_splat_no_name",
1643
1117
  "Ruby" => "def x(a, *args)\n p(a, args)\nend",
1644
- "RawParseTree" => [:defn, :x,
1645
- [:scope,
1646
- [:block,
1647
- [:args, :a, :"*args"],
1648
- [:fcall, :p,
1649
- [:array, [:lvar, :a], [:lvar, :args]]]]]],
1650
1118
  "ParseTree" => s(:defn, :x,
1651
1119
  s(:args, :a, :"*args"),
1652
1120
  s(:scope,
@@ -1656,21 +1124,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1656
1124
 
1657
1125
  add_tests("defn_args_none",
1658
1126
  "Ruby" => "def empty\n # do nothing\nend",
1659
- "RawParseTree" => [:defn, :empty,
1660
- [:scope, [:block, [:args], [:nil]]]],
1661
1127
  "ParseTree" => s(:defn, :empty,
1662
1128
  s(:args),
1663
1129
  s(:scope, s(:block, s(:nil)))))
1664
1130
 
1665
1131
  add_tests("defn_args_opt",
1666
1132
  "Ruby" => "def f(opt = 42)\n # do nothing\nend",
1667
- "RawParseTree" => [:defn, :f,
1668
- [:scope,
1669
- [:block,
1670
- [:args, :opt,
1671
- [:block,
1672
- [:lasgn, :opt, [:lit, 42]]]],
1673
- [:nil]]]],
1674
1133
  "ParseTree" => s(:defn, :f,
1675
1134
  s(:args, :opt,
1676
1135
  s(:block,
@@ -1679,14 +1138,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1679
1138
 
1680
1139
  add_tests("defn_args_opt_block",
1681
1140
  "Ruby" => "def f(opt = 42, &block)\n # do nothing\nend",
1682
- "RawParseTree" => [:defn, :f,
1683
- [:scope,
1684
- [:block,
1685
- [:args, :opt,
1686
- [:block,
1687
- [:lasgn, :opt, [:lit, 42]]]],
1688
- [:block_arg, :block],
1689
- [:nil]]]],
1690
1141
  "ParseTree" => s(:defn, :f,
1691
1142
  s(:args, :opt, :"&block",
1692
1143
  s(:block,
@@ -1695,13 +1146,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1695
1146
 
1696
1147
  add_tests("defn_args_opt_splat",
1697
1148
  "Ruby" => "def f(opt = 42, *rest)\n # do nothing\nend",
1698
- "RawParseTree" => [:defn, :f,
1699
- [:scope,
1700
- [:block,
1701
- [:args, :opt, :"*rest",
1702
- [:block,
1703
- [:lasgn, :opt, [:lit, 42]]]],
1704
- [:nil]]]],
1705
1149
  "ParseTree" => s(:defn, :f,
1706
1150
  s(:args, :opt, :"*rest",
1707
1151
  s(:block,
@@ -1710,14 +1154,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1710
1154
 
1711
1155
  add_tests("defn_args_opt_splat_block",
1712
1156
  "Ruby" => "def f(opt = 42, *rest, &block)\n # do nothing\nend",
1713
- "RawParseTree" => [:defn, :f,
1714
- [:scope,
1715
- [:block,
1716
- [:args, :opt, :"*rest",
1717
- [:block,
1718
- [:lasgn, :opt, [:lit, 42]]]],
1719
- [:block_arg, :block],
1720
- [:nil]]]],
1721
1157
  "ParseTree" => s(:defn, :f,
1722
1158
  s(:args, :opt, :"*rest", :"&block",
1723
1159
  s(:block,
@@ -1726,12 +1162,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1726
1162
 
1727
1163
  add_tests("defn_args_opt_splat_no_name",
1728
1164
  "Ruby" => "def x(b = 42, *)\n # do nothing\nend",
1729
- "RawParseTree" => [:defn, :x,
1730
- [:scope,
1731
- [:block,
1732
- [:args, :b, :"*",
1733
- [:block, [:lasgn, :b, [:lit, 42]]]],
1734
- [:nil]]]],
1735
1165
  "ParseTree" => s(:defn, :x,
1736
1166
  s(:args, :b, :"*",
1737
1167
  s(:block, s(:lasgn, :b, s(:lit, 42)))),
@@ -1741,22 +1171,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1741
1171
 
1742
1172
  add_tests("defn_args_splat",
1743
1173
  "Ruby" => "def f(*rest)\n # do nothing\nend",
1744
- "RawParseTree" => [:defn, :f,
1745
- [:scope,
1746
- [:block,
1747
- [:args, :"*rest"],
1748
- [:nil]]]],
1749
1174
  "ParseTree" => s(:defn, :f,
1750
1175
  s(:args, :"*rest"),
1751
1176
  s(:scope, s(:block, s(:nil)))))
1752
1177
 
1753
1178
  add_tests("defn_args_splat_no_name",
1754
1179
  "Ruby" => "def x(*)\n # do nothing\nend",
1755
- "RawParseTree" => [:defn, :x,
1756
- [:scope,
1757
- [:block,
1758
- [:args, :"*"],
1759
- [:nil]]]],
1760
1180
  "ParseTree" => s(:defn, :x,
1761
1181
  s(:args, :"*"),
1762
1182
  s(:scope,
@@ -1765,25 +1185,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1765
1185
 
1766
1186
  add_tests("defn_or",
1767
1187
  "Ruby" => "def |(o)\n # do nothing\nend",
1768
- "RawParseTree" => [:defn, :|,
1769
- [:scope, [:block, [:args, :o], [:nil]]]],
1770
1188
  "ParseTree" => s(:defn, :|,
1771
1189
  s(:args, :o),
1772
1190
  s(:scope, s(:block, s(:nil)))))
1773
1191
 
1774
1192
  add_tests("defn_rescue",
1775
1193
  "Ruby" => "def eql?(resource)\n (self.uuid == resource.uuid)\nrescue\n false\nend",
1776
- "RawParseTree" => [:defn, :eql?,
1777
- [:scope,
1778
- [:block,
1779
- [:args, :resource],
1780
- [:rescue,
1781
- [:call,
1782
- [:call, [:self], :uuid],
1783
- :==,
1784
- [:array,
1785
- [:call, [:lvar, :resource], :uuid]]],
1786
- [:resbody, nil, [:false]]]]]],
1787
1194
  "ParseTree" => s(:defn, :eql?,
1788
1195
  s(:args, :resource),
1789
1196
  s(:scope,
@@ -1800,17 +1207,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1800
1207
 
1801
1208
  add_tests("defn_rescue_mri_verbose_flag",
1802
1209
  "Ruby" => "def eql?(resource)\n (self.uuid == resource.uuid)\nrescue\n false\nend",
1803
- "RawParseTree" => [:defn, :eql?,
1804
- [:scope,
1805
- [:block,
1806
- [:args, :resource],
1807
- [:rescue,
1808
- [:call,
1809
- [:call, [:self], :uuid],
1810
- :==,
1811
- [:array,
1812
- [:call, [:lvar, :resource], :uuid]]],
1813
- [:resbody, nil, [:false]]]]]],
1814
1210
  "ParseTree" => s(:defn, :eql?,
1815
1211
  s(:args, :resource),
1816
1212
  s(:scope,
@@ -1827,20 +1223,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1827
1223
 
1828
1224
  add_tests("defn_something_eh",
1829
1225
  "Ruby" => "def something?\n # do nothing\nend",
1830
- "RawParseTree" => [:defn, :something?,
1831
- [:scope, [:block, [:args], [:nil]]]],
1832
1226
  "ParseTree" => s(:defn, :something?,
1833
1227
  s(:args),
1834
1228
  s(:scope, s(:block, s(:nil)))))
1835
1229
 
1836
1230
  add_tests("defn_splat_no_name",
1837
1231
  "Ruby" => "def x(a, *)\n p(a)\nend",
1838
- "RawParseTree" => [:defn, :x,
1839
- [:scope,
1840
- [:block,
1841
- [:args, :a, :"*"],
1842
- [:fcall, :p,
1843
- [:array, [:lvar, :a]]]]]],
1844
1232
  "ParseTree" => s(:defn, :x,
1845
1233
  s(:args, :a, :"*"),
1846
1234
  s(:scope,
@@ -1850,11 +1238,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1850
1238
 
1851
1239
  add_tests("defn_zarray",
1852
1240
  "Ruby" => "def zarray\n a = []\n return a\nend",
1853
- "RawParseTree" => [:defn, :zarray,
1854
- [:scope,
1855
- [:block, [:args],
1856
- [:lasgn, :a, [:zarray]],
1857
- [:return, [:lvar, :a]]]]],
1858
1241
  "ParseTree" => s(:defn, :zarray,
1859
1242
  s(:args),
1860
1243
  s(:scope,
@@ -1864,12 +1247,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1864
1247
 
1865
1248
  add_tests("defs",
1866
1249
  "Ruby" => "def self.x(y)\n (y + 1)\nend",
1867
- "RawParseTree" => [:defs, [:self], :x,
1868
- [:scope,
1869
- [:block,
1870
- [:args, :y],
1871
- [:call, [:lvar, :y], :+,
1872
- [:array, [:lit, 1]]]]]],
1873
1250
  "ParseTree" => s(:defs, s(:self), :x,
1874
1251
  s(:args, :y),
1875
1252
  s(:scope,
@@ -1879,26 +1256,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1879
1256
 
1880
1257
  add_tests("defs_empty",
1881
1258
  "Ruby" => "def self.empty\n # do nothing\nend",
1882
- "RawParseTree" => [:defs, [:self], :empty,
1883
- [:scope, [:args]]],
1884
1259
  "ParseTree" => s(:defs, s(:self), :empty,
1885
1260
  s(:args),
1886
1261
  s(:scope, s(:block))))
1887
1262
 
1888
1263
  add_tests("defs_empty_args",
1889
1264
  "Ruby" => "def self.empty(*)\n # do nothing\nend",
1890
- "RawParseTree" => [:defs, [:self], :empty,
1891
- [:scope, [:args, :*]]],
1892
1265
  "ParseTree" => s(:defs, s(:self), :empty,
1893
1266
  s(:args, :*),
1894
1267
  s(:scope, s(:block))))
1895
1268
 
1896
1269
  add_tests("defs_expr_wtf",
1897
1270
  "Ruby" => "def (a.b).empty(*)\n # do nothing\nend",
1898
- "RawParseTree" => [:defs,
1899
- [:call, [:vcall, :a], :b],
1900
- :empty,
1901
- [:scope, [:args, :*]]],
1902
1271
  "ParseTree" => s(:defs,
1903
1272
  s(:call,
1904
1273
  s(:call, nil, :a, s(:arglist)),
@@ -1909,14 +1278,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1909
1278
 
1910
1279
  add_tests("dmethod",
1911
1280
  "Ruby" => [Examples, :dmethod_added],
1912
- "RawParseTree" => [:defn, :dmethod_added,
1913
- [:dmethod,
1914
- :a_method,
1915
- [:scope,
1916
- [:block,
1917
- [:args, :x],
1918
- [:call, [:lvar, :x], :+,
1919
- [:array, [:lit, 1]]]]]]],
1920
1281
  "ParseTree" => s(:defn, :dmethod_added,
1921
1282
  s(:args, :x),
1922
1283
  s(:scope,
@@ -1927,24 +1288,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1927
1288
 
1928
1289
  add_tests("dot2",
1929
1290
  "Ruby" => "(a..b)",
1930
- "RawParseTree" => [:dot2, [:vcall, :a], [:vcall, :b]],
1931
1291
  "ParseTree" => s(:dot2,
1932
1292
  s(:call, nil, :a, s(:arglist)),
1933
1293
  s(:call, nil, :b, s(:arglist))))
1934
1294
 
1935
1295
  add_tests("dot3",
1936
1296
  "Ruby" => "(a...b)",
1937
- "RawParseTree" => [:dot3, [:vcall, :a], [:vcall, :b]],
1938
1297
  "ParseTree" => s(:dot3,
1939
1298
  s(:call, nil, :a, s(:arglist)),
1940
1299
  s(:call, nil, :b, s(:arglist))))
1941
1300
 
1942
1301
  add_tests("dregx",
1943
1302
  "Ruby" => "/x#\{(1 + 1)}y/",
1944
- "RawParseTree" => [:dregx, "x",
1945
- [:evstr,
1946
- [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
1947
- [:str, "y"]],
1948
1303
  "ParseTree" => s(:dregx, "x",
1949
1304
  s(:evstr,
1950
1305
  s(:call, s(:lit, 1), :+,
@@ -1953,26 +1308,19 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1953
1308
 
1954
1309
  add_tests("dregx_interp",
1955
1310
  "Ruby" => "/#\{@rakefile}/",
1956
- "RawParseTree" => [:dregx, '', [:evstr, [:ivar, :@rakefile]]],
1957
1311
  "ParseTree" => s(:dregx, '', s(:evstr, s(:ivar, :@rakefile))))
1958
1312
 
1959
1313
  add_tests("dregx_interp_empty",
1960
1314
  "Ruby" => "/a#\{}b/",
1961
- "RawParseTree" => [:dregx, 'a', [:evstr], [:str, "b"]],
1962
1315
  "ParseTree" => s(:dregx, 'a', s(:evstr), s(:str, "b")))
1963
1316
 
1964
1317
  add_tests("dregx_n",
1965
1318
  "Ruby" => '/#{1}/n',
1966
- "RawParseTree" => [:dregx, '', [:evstr, [:lit, 1]], /x/n.options],
1967
1319
  "ParseTree" => s(:dregx, '',
1968
1320
  s(:evstr, s(:lit, 1)), /x/n.options))
1969
1321
 
1970
1322
  add_tests("dregx_once",
1971
1323
  "Ruby" => "/x#\{(1 + 1)}y/o",
1972
- "RawParseTree" => [:dregx_once, "x",
1973
- [:evstr,
1974
- [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
1975
- [:str, "y"]],
1976
1324
  "ParseTree" => s(:dregx_once, "x",
1977
1325
  s(:evstr,
1978
1326
  s(:call, s(:lit, 1), :+,
@@ -1981,19 +1329,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1981
1329
 
1982
1330
  add_tests("dregx_once_n_interp",
1983
1331
  "Ruby" => "/#\{IAC}#\{SB}/no",
1984
- "RawParseTree" => [:dregx_once, '',
1985
- [:evstr, [:const, :IAC]],
1986
- [:evstr, [:const, :SB]], /x/n.options],
1987
1332
  "ParseTree" => s(:dregx_once, '',
1988
1333
  s(:evstr, s(:const, :IAC)),
1989
1334
  s(:evstr, s(:const, :SB)), /x/n.options))
1990
1335
 
1991
1336
  add_tests("dstr",
1992
1337
  "Ruby" => "argl = 1\n\"x#\{argl}y\"\n",
1993
- "RawParseTree" => [:block,
1994
- [:lasgn, :argl, [:lit, 1]],
1995
- [:dstr, "x", [:evstr, [:lvar, :argl]],
1996
- [:str, "y"]]],
1997
1338
  "ParseTree" => s(:block,
1998
1339
  s(:lasgn, :argl, s(:lit, 1)),
1999
1340
  s(:dstr, "x", s(:evstr, s(:lvar, :argl)),
@@ -2001,14 +1342,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2001
1342
 
2002
1343
  add_tests("dstr_2",
2003
1344
  "Ruby" => "argl = 1\n\"x#\{(\"%.2f\" % 3.14159)}y\"\n",
2004
- "RawParseTree" => [:block,
2005
- [:lasgn, :argl, [:lit, 1]],
2006
- [:dstr,
2007
- "x",
2008
- [:evstr,
2009
- [:call, [:str, "%.2f"], :%,
2010
- [:array, [:lit, 3.14159]]]],
2011
- [:str, "y"]]],
2012
1345
  "ParseTree" => s(:block,
2013
1346
  s(:lasgn, :argl, s(:lit, 1)),
2014
1347
  s(:dstr,
@@ -2020,18 +1353,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2020
1353
 
2021
1354
  add_tests("dstr_3",
2022
1355
  "Ruby" => "max = 2\nargl = 1\n\"x#\{(\"%.#\{max}f\" % 3.14159)}y\"\n",
2023
- "RawParseTree" => [:block,
2024
- [:lasgn, :max, [:lit, 2]],
2025
- [:lasgn, :argl, [:lit, 1]],
2026
- [:dstr, "x",
2027
- [:evstr,
2028
- [:call,
2029
- [:dstr, "%.",
2030
- [:evstr, [:lvar, :max]],
2031
- [:str, "f"]],
2032
- :%,
2033
- [:array, [:lit, 3.14159]]]],
2034
- [:str, "y"]]],
2035
1356
  "ParseTree" => s(:block,
2036
1357
  s(:lasgn, :max, s(:lit, 2)),
2037
1358
  s(:lasgn, :argl, s(:lit, 1)),
@@ -2047,14 +1368,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2047
1368
 
2048
1369
  add_tests("dstr_concat",
2049
1370
  "Ruby" => '"#{22}aa" "cd#{44}" "55" "#{66}"',
2050
- "RawParseTree" => [:dstr,
2051
- "",
2052
- [:evstr, [:lit, 22]],
2053
- [:str, "aa"],
2054
- [:str, "cd"],
2055
- [:evstr, [:lit, 44]],
2056
- [:str, "55"],
2057
- [:evstr, [:lit, 66]]],
2058
1371
  "ParseTree" => s(:dstr,
2059
1372
  "",
2060
1373
  s(:evstr, s(:lit, 22)),
@@ -2067,13 +1380,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2067
1380
 
2068
1381
  add_tests("dstr_gross",
2069
1382
  "Ruby" => '"a #$global b #@ivar c #@@cvar d"',
2070
- "RawParseTree" => [:dstr, "a ",
2071
- [:evstr, [:gvar, :$global]],
2072
- [:str, " b "],
2073
- [:evstr, [:ivar, :@ivar]],
2074
- [:str, " c "],
2075
- [:evstr, [:cvar, :@@cvar]],
2076
- [:str, " d"]],
2077
1383
  "ParseTree" => s(:dstr, "a ",
2078
1384
  s(:evstr, s(:gvar, :$global)),
2079
1385
  s(:str, " b "),
@@ -2085,10 +1391,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2085
1391
 
2086
1392
  add_tests("dstr_heredoc_expand",
2087
1393
  "Ruby" => "<<EOM\n blah\n#\{1 + 1}blah\nEOM\n",
2088
- "RawParseTree" => [:dstr, " blah\n",
2089
- [:evstr, [:call, [:lit, 1], :+,
2090
- [:array, [:lit, 1]]]],
2091
- [:str, "blah\n"]],
2092
1394
  "ParseTree" => s(:dstr, " blah\n",
2093
1395
  s(:evstr, s(:call, s(:lit, 1), :+,
2094
1396
  s(:arglist, s(:lit, 1)))),
@@ -2097,10 +1399,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2097
1399
 
2098
1400
  add_tests("dstr_heredoc_windoze_sucks",
2099
1401
  "Ruby" => "<<-EOF\r\ndef test_#\{action}_valid_feed\r\n EOF\r\n",
2100
- "RawParseTree" => [:dstr,
2101
- 'def test_',
2102
- [:evstr, [:vcall, :action]],
2103
- [:str, "_valid_feed\n"]],
2104
1402
  "ParseTree" => s(:dstr,
2105
1403
  'def test_',
2106
1404
  s(:evstr, s(:call, nil, :action, s(:arglist))),
@@ -2109,11 +1407,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2109
1407
 
2110
1408
  add_tests("dstr_heredoc_yet_again",
2111
1409
  "Ruby" => "<<-EOF\ns1 '#\{RUBY_PLATFORM}' s2\n#\{__FILE__}\n EOF\n",
2112
- "RawParseTree" => [:dstr, "s1 '",
2113
- [:evstr, [:const, :RUBY_PLATFORM]],
2114
- [:str, "' s2\n"],
2115
- [:str, "(string)"],
2116
- [:str, "\n"]],
2117
1410
  "ParseTree" => s(:dstr, "s1 '",
2118
1411
  s(:evstr, s(:const, :RUBY_PLATFORM)),
2119
1412
  s(:str, "' s2\n"),
@@ -2123,8 +1416,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2123
1416
 
2124
1417
  add_tests("dstr_nest",
2125
1418
  "Ruby" => "%Q[before [#\{nest}] after]",
2126
- "RawParseTree" => [:dstr, "before [",
2127
- [:evstr, [:vcall, :nest]], [:str, "] after"]],
2128
1419
  "ParseTree" => s(:dstr, "before [",
2129
1420
  s(:evstr, s(:call, nil, :nest, s(:arglist))),
2130
1421
  s(:str, "] after")),
@@ -2132,14 +1423,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2132
1423
 
2133
1424
  add_tests("dstr_str_lit_start",
2134
1425
  "Ruby" => '"#{"blah"}#{__FILE__}:#{__LINE__}: warning: #{$!.message} (#{$!.class})"',
2135
- "RawParseTree" => [:dstr,
2136
- "blah(string):",
2137
- [:evstr, [:lit, 1]],
2138
- [:str, ": warning: "],
2139
- [:evstr, [:call, [:gvar, :$!], :message]],
2140
- [:str, " ("],
2141
- [:evstr, [:call, [:gvar, :$!], :class]],
2142
- [:str, ")"]],
2143
1426
  "ParseTree" => s(:dstr,
2144
1427
  "blah(string):",
2145
1428
  s(:evstr, s(:lit, 1)),
@@ -2154,16 +1437,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2154
1437
 
2155
1438
  add_tests("dstr_the_revenge",
2156
1439
  "Ruby" => '"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"',
2157
- "RawParseTree" => [:dstr,
2158
- "before ",
2159
- [:evstr, [:vcall, :from]],
2160
- [:str, " middle "],
2161
- [:evstr, [:vcall, :to]],
2162
- [:str, " ("],
2163
- [:str, "(string)"],
2164
- [:str, ":"],
2165
- [:evstr, [:lit, 1]],
2166
- [:str, ")"]],
2167
1440
  "ParseTree" => s(:dstr,
2168
1441
  "before ",
2169
1442
  s(:evstr, s(:call, nil, :from, s(:arglist))),
@@ -2178,37 +1451,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2178
1451
 
2179
1452
  add_tests("dsym",
2180
1453
  "Ruby" => ":\"x#\{(1 + 1)}y\"",
2181
- "RawParseTree" => [:dsym, "x",
2182
- [:evstr, [:call, [:lit, 1], :+,
2183
- [:array, [:lit, 1]]]], [:str, "y"]],
2184
1454
  "ParseTree" => s(:dsym, "x",
2185
1455
  s(:evstr, s(:call, s(:lit, 1), :+,
2186
1456
  s(:arglist, s(:lit, 1)))), s(:str, "y")))
2187
1457
 
2188
1458
  add_tests("dxstr",
2189
1459
  "Ruby" => "t = 5\n`touch #\{t}`\n",
2190
- "RawParseTree" => [:block,
2191
- [:lasgn, :t, [:lit, 5]],
2192
- [:dxstr, 'touch ', [:evstr, [:lvar, :t]]]],
2193
1460
  "ParseTree" => s(:block,
2194
1461
  s(:lasgn, :t, s(:lit, 5)),
2195
1462
  s(:dxstr, 'touch ', s(:evstr, s(:lvar, :t)))))
2196
1463
 
2197
1464
  add_tests("ensure",
2198
1465
  "Ruby" => "begin\n (1 + 1)\nrescue SyntaxError => e1\n 2\nrescue Exception => e2\n 3\nelse\n 4\nensure\n 5\nend",
2199
- "RawParseTree" => [:ensure,
2200
- [:rescue,
2201
- [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
2202
- [:resbody,
2203
- [:array, [:const, :SyntaxError]],
2204
- [:block,
2205
- [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
2206
- [:resbody,
2207
- [:array, [:const, :Exception]],
2208
- [:block,
2209
- [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
2210
- [:lit, 4]],
2211
- [:lit, 5]],
2212
1466
  "ParseTree" => s(:ensure,
2213
1467
  s(:rescue,
2214
1468
  s(:call, s(:lit, 1), :+,
@@ -2228,18 +1482,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2228
1482
 
2229
1483
  add_tests("false",
2230
1484
  "Ruby" => "false",
2231
- "RawParseTree" => [:false],
2232
1485
  "ParseTree" => s(:false))
2233
1486
 
2234
1487
  add_tests("fbody",
2235
1488
  "Ruby" => [Examples, :an_alias],
2236
- "RawParseTree" => [:defn, :an_alias,
2237
- [:fbody,
2238
- [:scope,
2239
- [:block,
2240
- [:args, :x],
2241
- [:call, [:lvar, :x], :+,
2242
- [:array, [:lit, 1]]]]]]],
2243
1489
  "ParseTree" => s(:defn, :an_alias,
2244
1490
  s(:args, :x),
2245
1491
  s(:scope,
@@ -2250,16 +1496,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2250
1496
 
2251
1497
  add_tests("fcall_arglist",
2252
1498
  "Ruby" => "m(42)",
2253
- "RawParseTree" => [:fcall, :m, [:array, [:lit, 42]]],
2254
1499
  "ParseTree" => s(:call, nil, :m, s(:arglist, s(:lit, 42))))
2255
1500
 
2256
1501
  add_tests("fcall_arglist_hash",
2257
1502
  "Ruby" => "m(:a => 1, :b => 2)",
2258
- "RawParseTree" => [:fcall, :m,
2259
- [:array,
2260
- [:hash,
2261
- [:lit, :a], [:lit, 1],
2262
- [:lit, :b], [:lit, 2]]]],
2263
1503
  "ParseTree" => s(:call, nil, :m,
2264
1504
  s(:arglist,
2265
1505
  s(:hash,
@@ -2268,12 +1508,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2268
1508
 
2269
1509
  add_tests("fcall_arglist_norm_hash",
2270
1510
  "Ruby" => "m(42, :a => 1, :b => 2)",
2271
- "RawParseTree" => [:fcall, :m,
2272
- [:array,
2273
- [:lit, 42],
2274
- [:hash,
2275
- [:lit, :a], [:lit, 1],
2276
- [:lit, :b], [:lit, 2]]]],
2277
1511
  "ParseTree" => s(:call, nil, :m,
2278
1512
  s(:arglist,
2279
1513
  s(:lit, 42),
@@ -2283,14 +1517,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2283
1517
 
2284
1518
  add_tests("fcall_arglist_norm_hash_splat",
2285
1519
  "Ruby" => "m(42, :a => 1, :b => 2, *c)",
2286
- "RawParseTree" => [:fcall, :m,
2287
- [:argscat,
2288
- [:array,
2289
- [:lit, 42],
2290
- [:hash,
2291
- [:lit, :a], [:lit, 1],
2292
- [:lit, :b], [:lit, 2]]],
2293
- [:vcall, :c]]],
2294
1520
  "ParseTree" => s(:call, nil, :m,
2295
1521
  s(:arglist,
2296
1522
  s(:lit, 42),
@@ -2301,9 +1527,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2301
1527
 
2302
1528
  add_tests("fcall_block",
2303
1529
  "Ruby" => "a(:b) { :c }",
2304
- "RawParseTree" => [:iter,
2305
- [:fcall, :a, [:array, [:lit, :b]]], nil,
2306
- [:lit, :c]],
2307
1530
  "ParseTree" => s(:iter,
2308
1531
  s(:call, nil, :a,
2309
1532
  s(:arglist, s(:lit, :b))), nil,
@@ -2311,43 +1534,28 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2311
1534
 
2312
1535
  add_tests("fcall_index_space",
2313
1536
  "Ruby" => "a [42]",
2314
- "RawParseTree" => [:fcall, :a, [:array, [:array, [:lit, 42]]]],
2315
1537
  "ParseTree" => s(:call, nil, :a,
2316
1538
  s(:arglist, s(:array, s(:lit, 42)))),
2317
1539
  "Ruby2Ruby" => "a([42])")
2318
1540
 
2319
1541
  add_tests("fcall_keyword",
2320
1542
  "Ruby" => "42 if block_given?",
2321
- "RawParseTree" => [:if, [:fcall, :block_given?], [:lit, 42], nil],
2322
1543
  "ParseTree" => s(:if,
2323
1544
  s(:call, nil, :block_given?, s(:arglist)),
2324
1545
  s(:lit, 42), nil))
2325
1546
 
2326
1547
  add_tests("fcall_inside_parens",
2327
- "Ruby" => "( c (d), e)",
1548
+ "Ruby" => "( a (b), c)",
2328
1549
  "ParseTree" => s(:call,
2329
- nil,
2330
- :c,
2331
- s(:arglist, s(:call, nil, :d, s(:arglist)), s(:call, nil, :e, s(:arglist)))))
1550
+ nil,
1551
+ :a,
1552
+ s(:arglist,
1553
+ s(:call, nil, :b, s(:arglist)),
1554
+ s(:call, nil, :c, s(:arglist)))),
1555
+ "Ruby2Ruby" => "a(b, c)")
2332
1556
 
2333
1557
  add_tests("flip2",
2334
1558
  "Ruby" => "x = if ((i % 4) == 0)..((i % 3) == 0) then\n i\nelse\n nil\nend",
2335
- "RawParseTree" => [:lasgn,
2336
- :x,
2337
- [:if,
2338
- [:flip2,
2339
- [:call,
2340
- [:call, [:vcall, :i], :%,
2341
- [:array, [:lit, 4]]],
2342
- :==,
2343
- [:array, [:lit, 0]]],
2344
- [:call,
2345
- [:call, [:vcall, :i], :%,
2346
- [:array, [:lit, 3]]],
2347
- :==,
2348
- [:array, [:lit, 0]]]],
2349
- [:vcall, :i],
2350
- [:nil]]],
2351
1559
  "ParseTree" => s(:lasgn,
2352
1560
  :x,
2353
1561
  s(:if,
@@ -2369,14 +1577,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2369
1577
 
2370
1578
  add_tests("flip2_method",
2371
1579
  "Ruby" => "if 1..2.a?(b) then\n nil\nend",
2372
- "RawParseTree" => [:if,
2373
- [:flip2,
2374
- [:call, [:lit, 1], :==,
2375
- [:array, [:gvar, :$.]]],
2376
- [:call, [:lit, 2], :a?,
2377
- [:array, [:vcall, :b]]]],
2378
- [:nil],
2379
- nil],
2380
1580
  "ParseTree" => s(:if,
2381
1581
  s(:flip2,
2382
1582
  s(:lit, 1),
@@ -2388,22 +1588,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2388
1588
 
2389
1589
  add_tests("flip3",
2390
1590
  "Ruby" => "x = if ((i % 4) == 0)...((i % 3) == 0) then\n i\nelse\n nil\nend",
2391
- "RawParseTree" => [:lasgn,
2392
- :x,
2393
- [:if,
2394
- [:flip3,
2395
- [:call,
2396
- [:call, [:vcall, :i], :%,
2397
- [:array, [:lit, 4]]],
2398
- :==,
2399
- [:array, [:lit, 0]]],
2400
- [:call,
2401
- [:call, [:vcall, :i], :%,
2402
- [:array, [:lit, 3]]],
2403
- :==,
2404
- [:array, [:lit, 0]]]],
2405
- [:vcall, :i],
2406
- [:nil]]],
2407
1591
  "ParseTree" => s(:lasgn,
2408
1592
  :x,
2409
1593
  s(:if,
@@ -2425,10 +1609,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2425
1609
 
2426
1610
  add_tests("for",
2427
1611
  "Ruby" => "for o in ary do\n puts(o)\nend",
2428
- "RawParseTree" => [:for,
2429
- [:vcall, :ary],
2430
- [:lasgn, :o],
2431
- [:fcall, :puts, [:array, [:lvar, :o]]]],
2432
1612
  "ParseTree" => s(:for,
2433
1613
  s(:call, nil, :ary, s(:arglist)),
2434
1614
  s(:lasgn, :o),
@@ -2437,9 +1617,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2437
1617
 
2438
1618
  add_tests("for_no_body",
2439
1619
  "Ruby" => "for i in (0..max) do\n # do nothing\nend",
2440
- "RawParseTree" => [:for,
2441
- [:dot2, [:lit, 0], [:vcall, :max]],
2442
- [:lasgn, :i]],
2443
1620
  "ParseTree" => s(:for,
2444
1621
  s(:dot2,
2445
1622
  s(:lit, 0),
@@ -2448,45 +1625,32 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2448
1625
 
2449
1626
  add_tests("gasgn",
2450
1627
  "Ruby" => "$x = 42",
2451
- "RawParseTree" => [:gasgn, :$x, [:lit, 42]],
2452
1628
  "ParseTree" => s(:gasgn, :$x, s(:lit, 42)))
2453
1629
 
2454
1630
  add_tests("global",
2455
1631
  "Ruby" => "$stderr",
2456
- "RawParseTree" => [:gvar, :$stderr],
2457
1632
  "ParseTree" => s(:gvar, :$stderr))
2458
1633
 
2459
1634
  add_tests("gvar",
2460
1635
  "Ruby" => "$x",
2461
- "RawParseTree" => [:gvar, :$x],
2462
1636
  "ParseTree" => s(:gvar, :$x))
2463
1637
 
2464
1638
  add_tests("gvar_underscore",
2465
1639
  "Ruby" => "$_",
2466
- "RawParseTree" => [:gvar, :$_],
2467
1640
  "ParseTree" => s(:gvar, :$_))
2468
1641
 
2469
1642
  add_tests("gvar_underscore_blah",
2470
1643
  "Ruby" => "$__blah",
2471
- "RawParseTree" => [:gvar, :$__blah],
2472
1644
  "ParseTree" => s(:gvar, :$__blah))
2473
1645
 
2474
1646
  add_tests("hash",
2475
1647
  "Ruby" => "{ 1 => 2, 3 => 4 }",
2476
- "RawParseTree" => [:hash,
2477
- [:lit, 1], [:lit, 2],
2478
- [:lit, 3], [:lit, 4]],
2479
1648
  "ParseTree" => s(:hash,
2480
1649
  s(:lit, 1), s(:lit, 2),
2481
1650
  s(:lit, 3), s(:lit, 4)))
2482
1651
 
2483
1652
  add_tests("hash_rescue",
2484
1653
  "Ruby" => "{ 1 => (2 rescue 3) }",
2485
- "RawParseTree" => [:hash,
2486
- [:lit, 1],
2487
- [:rescue,
2488
- [:lit, 2],
2489
- [:resbody, nil, [:lit, 3]]]],
2490
1654
  "ParseTree" => s(:hash,
2491
1655
  s(:lit, 1),
2492
1656
  s(:rescue,
@@ -2495,20 +1659,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2495
1659
 
2496
1660
  add_tests("iasgn",
2497
1661
  "Ruby" => "@a = 4",
2498
- "RawParseTree" => [:iasgn, :@a, [:lit, 4]],
2499
1662
  "ParseTree" => s(:iasgn, :@a, s(:lit, 4)))
2500
1663
 
2501
1664
  add_tests("if_block_condition",
2502
1665
  "Ruby" => "if (x = 5\n(x + 1)) then\n nil\nend",
2503
- "RawParseTree" => [:if,
2504
- [:block,
2505
- [:lasgn, :x, [:lit, 5]],
2506
- [:call,
2507
- [:lvar, :x],
2508
- :+,
2509
- [:array, [:lit, 1]]]],
2510
- [:nil],
2511
- nil],
2512
1666
  "ParseTree" => s(:if,
2513
1667
  s(:block,
2514
1668
  s(:lasgn, :x, s(:lit, 5)),
@@ -2521,12 +1675,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2521
1675
 
2522
1676
  add_tests("if_lasgn_short",
2523
1677
  "Ruby" => "if x = obj.x then\n x.do_it\nend",
2524
- "RawParseTree" => [:if,
2525
- [:lasgn, :x,
2526
- [:call, [:vcall, :obj], :x]],
2527
- [:call,
2528
- [:lvar, :x], :do_it],
2529
- nil],
2530
1678
  "ParseTree" => s(:if,
2531
1679
  s(:lasgn, :x,
2532
1680
  s(:call,
@@ -2537,44 +1685,34 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2537
1685
 
2538
1686
  add_tests("if_nested",
2539
1687
  "Ruby" => "return if false unless true",
2540
- "RawParseTree" => [:if, [:true], nil,
2541
- [:if, [:false], [:return], nil]],
2542
1688
  "ParseTree" => s(:if, s(:true), nil,
2543
1689
  s(:if, s(:false), s(:return), nil)))
2544
1690
 
2545
1691
  add_tests("if_post",
2546
1692
  "Ruby" => "a if b",
2547
- "RawParseTree" => [:if, [:vcall, :b], [:vcall, :a], nil],
2548
1693
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
2549
1694
  s(:call, nil, :a, s(:arglist)), nil))
2550
1695
 
2551
1696
  add_tests("if_post_not",
2552
1697
  "Ruby" => "a if not b",
2553
- "RawParseTree" => [:if, [:vcall, :b], nil, [:vcall, :a]],
2554
1698
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
2555
1699
  s(:call, nil, :a, s(:arglist))),
2556
1700
  "Ruby2Ruby" => "a unless b")
2557
1701
 
2558
1702
  add_tests("if_pre",
2559
1703
  "Ruby" => "if b then a end",
2560
- "RawParseTree" => [:if, [:vcall, :b], [:vcall, :a], nil],
2561
1704
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
2562
1705
  s(:call, nil, :a, s(:arglist)), nil),
2563
1706
  "Ruby2Ruby" => "a if b")
2564
1707
 
2565
1708
  add_tests("if_pre_not",
2566
1709
  "Ruby" => "if not b then a end",
2567
- "RawParseTree" => [:if, [:vcall, :b], nil, [:vcall, :a]],
2568
1710
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
2569
1711
  s(:call, nil, :a, s(:arglist))),
2570
1712
  "Ruby2Ruby" => "a unless b")
2571
1713
 
2572
1714
  add_tests("iter_call_arglist_space",
2573
1715
  "Ruby" => "a (1) {|c|d}",
2574
- "RawParseTree" => [:iter,
2575
- [:fcall, :a, [:array, [:lit, 1]]],
2576
- [:dasgn_curr, :c],
2577
- [:vcall, :d]],
2578
1716
  "ParseTree" => s(:iter,
2579
1717
  s(:call, nil, :a, s(:arglist, s(:lit, 1))),
2580
1718
  s(:lasgn, :c),
@@ -2583,17 +1721,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2583
1721
 
2584
1722
  add_tests("iter_dasgn_curr_dasgn_madness",
2585
1723
  "Ruby" => "as.each { |a|\n b += a.b(false) }",
2586
- "RawParseTree" => [:iter,
2587
- [:call, [:vcall, :as], :each],
2588
- [:dasgn_curr, :a],
2589
- [:dasgn_curr,
2590
- :b,
2591
- [:call,
2592
- [:dvar, :b],
2593
- :+,
2594
- [:array,
2595
- [:call, [:dvar, :a], :b,
2596
- [:array, [:false]]]]]]],
2597
1724
  "ParseTree" => s(:iter,
2598
1725
  s(:call,
2599
1726
  s(:call, nil, :as, s(:arglist)),
@@ -2610,11 +1737,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2610
1737
 
2611
1738
  add_tests("iter_downto",
2612
1739
  "Ruby" => "3.downto(1) { |n| puts(n.to_s) }",
2613
- "RawParseTree" => [:iter,
2614
- [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
2615
- [:dasgn_curr, :n],
2616
- [:fcall, :puts,
2617
- [:array, [:call, [:dvar, :n], :to_s]]]],
2618
1740
  "ParseTree" => s(:iter,
2619
1741
  s(:call, s(:lit, 3), :downto,
2620
1742
  s(:arglist, s(:lit, 1))),
@@ -2626,14 +1748,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2626
1748
 
2627
1749
  add_tests("iter_each_lvar",
2628
1750
  "Ruby" => "array = [1, 2, 3]\narray.each { |x| puts(x.to_s) }\n",
2629
- "RawParseTree" => [:block,
2630
- [:lasgn, :array,
2631
- [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
2632
- [:iter,
2633
- [:call, [:lvar, :array], :each],
2634
- [:dasgn_curr, :x],
2635
- [:fcall, :puts,
2636
- [:array, [:call, [:dvar, :x], :to_s]]]]],
2637
1751
  "ParseTree" => s(:block,
2638
1752
  s(:lasgn, :array,
2639
1753
  s(:array,
@@ -2648,25 +1762,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2648
1762
 
2649
1763
  add_tests("iter_each_nested",
2650
1764
  "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",
2651
- "RawParseTree" => [:block,
2652
- [:lasgn, :array1,
2653
- [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
2654
- [:lasgn, :array2,
2655
- [:array,
2656
- [:lit, 4], [:lit, 5], [:lit, 6], [:lit, 7]]],
2657
- [:iter,
2658
- [:call,
2659
- [:lvar, :array1], :each],
2660
- [:dasgn_curr, :x],
2661
- [:iter,
2662
- [:call,
2663
- [:lvar, :array2], :each],
2664
- [:dasgn_curr, :y],
2665
- [:block,
2666
- [:fcall, :puts,
2667
- [:array, [:call, [:dvar, :x], :to_s]]],
2668
- [:fcall, :puts,
2669
- [:array, [:call, [:dvar, :y], :to_s]]]]]]],
2670
1765
  "ParseTree" => s(:block,
2671
1766
  s(:lasgn, :array1,
2672
1767
  s(:array,
@@ -2695,17 +1790,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2695
1790
 
2696
1791
  add_tests("iter_loop_empty",
2697
1792
  "Ruby" => "loop { }",
2698
- "RawParseTree" => [:iter, [:fcall, :loop], nil],
2699
1793
  "ParseTree" => s(:iter, s(:call, nil, :loop, s(:arglist)), nil))
2700
1794
 
2701
1795
  add_tests("iter_masgn_2",
2702
1796
  "Ruby" => "a { |b, c| p(c) }",
2703
- "RawParseTree" => [:iter,
2704
- [:fcall, :a],
2705
- [:masgn,
2706
- [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]],
2707
- nil, nil],
2708
- [:fcall, :p, [:array, [:dvar, :c]]]],
2709
1797
  "ParseTree" => s(:iter,
2710
1798
  s(:call, nil, :a, s(:arglist)),
2711
1799
  s(:masgn,
@@ -2714,12 +1802,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2714
1802
 
2715
1803
  add_tests("iter_masgn_args_splat",
2716
1804
  "Ruby" => "a { |b, c, *d| p(c) }",
2717
- "RawParseTree" => [:iter,
2718
- [:fcall, :a],
2719
- [:masgn,
2720
- [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]],
2721
- [:dasgn_curr, :d], nil],
2722
- [:fcall, :p, [:array, [:dvar, :c]]]],
2723
1805
  "ParseTree" => s(:iter,
2724
1806
  s(:call, nil, :a, s(:arglist)),
2725
1807
  s(:masgn,
@@ -2731,12 +1813,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2731
1813
 
2732
1814
  add_tests("iter_masgn_args_splat_no_name",
2733
1815
  "Ruby" => "a { |b, c, *| p(c) }",
2734
- "RawParseTree" => [:iter,
2735
- [:fcall, :a],
2736
- [:masgn,
2737
- [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]],
2738
- [:splat], nil],
2739
- [:fcall, :p, [:array, [:dvar, :c]]]],
2740
1816
  "ParseTree" => s(:iter,
2741
1817
  s(:call, nil, :a, s(:arglist)),
2742
1818
  s(:masgn,
@@ -2748,10 +1824,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2748
1824
 
2749
1825
  add_tests("iter_masgn_splat",
2750
1826
  "Ruby" => "a { |*c| p(c) }",
2751
- "RawParseTree" => [:iter,
2752
- [:fcall, :a],
2753
- [:masgn, nil, [:dasgn_curr, :c], nil],
2754
- [:fcall, :p, [:array, [:dvar, :c]]]],
2755
1827
  "ParseTree" => s(:iter,
2756
1828
  s(:call, nil, :a, s(:arglist)),
2757
1829
  s(:masgn, s(:array, s(:splat, s(:lasgn, :c)))),
@@ -2759,10 +1831,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2759
1831
 
2760
1832
  add_tests("iter_masgn_splat_no_name",
2761
1833
  "Ruby" => "a { |*| p(c) }",
2762
- "RawParseTree" => [:iter,
2763
- [:fcall, :a],
2764
- [:masgn, nil, [:splat], nil],
2765
- [:fcall, :p, [:array, [:vcall, :c]]]],
2766
1834
  "ParseTree" => s(:iter,
2767
1835
  s(:call, nil, :a, s(:arglist)),
2768
1836
  s(:masgn, s(:array, s(:splat))),
@@ -2771,13 +1839,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2771
1839
 
2772
1840
  add_tests("iter_shadowed_var",
2773
1841
  "Ruby" => "a do |x|\n b do |x|\n puts x\n end\nend",
2774
- "RawParseTree" => [:iter,
2775
- [:fcall, :a],
2776
- [:dasgn_curr, :x],
2777
- [:iter,
2778
- [:fcall, :b],
2779
- [:dasgn, :x],
2780
- [:fcall, :puts, [:array, [:dvar, :x]]]]],
2781
1842
  "ParseTree" => s(:iter,
2782
1843
  s(:call, nil, :a, s(:arglist)),
2783
1844
  s(:lasgn, :x),
@@ -2790,11 +1851,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2790
1851
 
2791
1852
  add_tests("iter_upto",
2792
1853
  "Ruby" => "1.upto(3) { |n| puts(n.to_s) }",
2793
- "RawParseTree" => [:iter,
2794
- [:call, [:lit, 1], :upto, [:array, [:lit, 3]]],
2795
- [:dasgn_curr, :n],
2796
- [:fcall, :puts,
2797
- [:array, [:call, [:dvar, :n], :to_s]]]],
2798
1854
  "ParseTree" => s(:iter,
2799
1855
  s(:call, s(:lit, 1), :upto,
2800
1856
  s(:arglist, s(:lit, 3))),
@@ -2806,17 +1862,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2806
1862
 
2807
1863
  add_tests("iter_while",
2808
1864
  "Ruby" => "argl = 10\nwhile (argl >= 1) do\n puts(\"hello\")\n argl = (argl - 1)\nend\n",
2809
- "RawParseTree" => [:block,
2810
- [:lasgn, :argl, [:lit, 10]],
2811
- [:while,
2812
- [:call, [:lvar, :argl], :">=",
2813
- [:array, [:lit, 1]]],
2814
- [:block,
2815
- [:fcall, :puts, [:array, [:str, "hello"]]],
2816
- [:lasgn,
2817
- :argl,
2818
- [:call, [:lvar, :argl],
2819
- :"-", [:array, [:lit, 1]]]]], true]],
2820
1865
  "ParseTree" => s(:block,
2821
1866
  s(:lasgn, :argl, s(:lit, 10)),
2822
1867
  s(:while,
@@ -2832,7 +1877,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2832
1877
 
2833
1878
  add_tests("ivar",
2834
1879
  "Ruby" => [Examples, :reader],
2835
- "RawParseTree" => [:defn, :reader, [:ivar, :@reader]],
2836
1880
  "ParseTree" => s(:defn, :reader, # FIX should be unified?
2837
1881
  s(:args),
2838
1882
  s(:ivar, :@reader)),
@@ -2840,10 +1884,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2840
1884
 
2841
1885
  add_tests("lasgn_array",
2842
1886
  "Ruby" => "var = [\"foo\", \"bar\"]",
2843
- "RawParseTree" => [:lasgn, :var,
2844
- [:array,
2845
- [:str, "foo"],
2846
- [:str, "bar"]]],
2847
1887
  "ParseTree" => s(:lasgn, :var,
2848
1888
  s(:array,
2849
1889
  s(:str, "foo"),
@@ -2851,44 +1891,35 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2851
1891
 
2852
1892
  add_tests("lasgn_call",
2853
1893
  "Ruby" => "c = (2 + 3)",
2854
- "RawParseTree" => [:lasgn, :c, [:call, [:lit, 2], :+,
2855
- [:array, [:lit, 3]]]],
2856
1894
  "ParseTree" => s(:lasgn, :c, s(:call, s(:lit, 2), :+,
2857
1895
  s(:arglist, s(:lit, 3)))))
2858
1896
 
2859
1897
  add_tests("lit_bool_false",
2860
1898
  "Ruby" => "false",
2861
- "RawParseTree" => [:false],
2862
1899
  "ParseTree" => s(:false))
2863
1900
 
2864
1901
  add_tests("lit_bool_true",
2865
1902
  "Ruby" => "true",
2866
- "RawParseTree" => [:true],
2867
1903
  "ParseTree" => s(:true))
2868
1904
 
2869
1905
  add_tests("lit_float",
2870
1906
  "Ruby" => "1.1",
2871
- "RawParseTree" => [:lit, 1.1],
2872
1907
  "ParseTree" => s(:lit, 1.1))
2873
1908
 
2874
1909
  add_tests("lit_long",
2875
1910
  "Ruby" => "1",
2876
- "RawParseTree" => [:lit, 1],
2877
1911
  "ParseTree" => s(:lit, 1))
2878
1912
 
2879
1913
  add_tests("lit_long_negative",
2880
1914
  "Ruby" => "-1",
2881
- "RawParseTree" => [:lit, -1],
2882
1915
  "ParseTree" => s(:lit, -1))
2883
1916
 
2884
1917
  add_tests("lit_range2",
2885
1918
  "Ruby" => "(1..10)",
2886
- "RawParseTree" => [:lit, 1..10],
2887
1919
  "ParseTree" => s(:lit, 1..10))
2888
1920
 
2889
1921
  add_tests("lit_range3",
2890
1922
  "Ruby" => "(1...10)",
2891
- "RawParseTree" => [:lit, 1...10],
2892
1923
  "ParseTree" => s(:lit, 1...10))
2893
1924
 
2894
1925
  # TODO: discuss and decide which lit we like
@@ -2900,57 +1931,33 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2900
1931
 
2901
1932
  add_tests("lit_regexp",
2902
1933
  "Ruby" => "/x/",
2903
- "RawParseTree" => [:lit, /x/],
2904
1934
  "ParseTree" => s(:lit, /x/))
2905
1935
 
2906
1936
  add_tests("lit_regexp_i_wwtt",
2907
1937
  "Ruby" => 'str.split(//i)',
2908
- "RawParseTree" => [:call, [:vcall, :str], :split,
2909
- [:array, [:lit, //i]]],
2910
1938
  "ParseTree" => s(:call, s(:call, nil, :str, s(:arglist)), :split,
2911
1939
  s(:arglist, s(:lit, //i))))
2912
1940
 
2913
1941
  add_tests("lit_regexp_n",
2914
1942
  "Ruby" => "/x/n", # HACK differs on 1.9 - this is easiest
2915
- "RawParseTree" => [:lit, /x/n],
2916
1943
  "ParseTree" => s(:lit, /x/n),
2917
1944
  "Ruby2Ruby" => /x/n.inspect)
2918
1945
 
2919
1946
  add_tests("lit_regexp_once",
2920
1947
  "Ruby" => "/x/o",
2921
- "RawParseTree" => [:lit, /x/],
2922
1948
  "ParseTree" => s(:lit, /x/),
2923
1949
  "Ruby2Ruby" => "/x/")
2924
1950
 
2925
1951
  add_tests("lit_sym",
2926
1952
  "Ruby" => ":x",
2927
- "RawParseTree" => [:lit, :x],
2928
1953
  "ParseTree" => s(:lit, :x))
2929
1954
 
2930
1955
  add_tests("lit_sym_splat",
2931
1956
  "Ruby" => ":\"*args\"",
2932
- "RawParseTree" => [:lit, :"*args"],
2933
1957
  "ParseTree" => s(:lit, :"*args"))
2934
1958
 
2935
1959
  add_tests("lvar_def_boundary",
2936
1960
  "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",
2937
- "RawParseTree" => [:block,
2938
- [:lasgn, :b, [:lit, 42]],
2939
- [:defn, :a,
2940
- [:scope,
2941
- [:block,
2942
- [:args],
2943
- [:iter,
2944
- [:fcall, :c],
2945
- nil,
2946
- [:rescue,
2947
- [:vcall, :do_stuff],
2948
- [:resbody,
2949
- [:array, [:const, :RuntimeError]],
2950
- [:block,
2951
- [:dasgn_curr, :b, [:gvar, :$!]],
2952
- [:fcall, :puts,
2953
- [:array, [:dvar, :b]]]]]]]]]]],
2954
1961
  "ParseTree" => s(:block,
2955
1962
  s(:lasgn, :b, s(:lit, 42)),
2956
1963
  s(:defn, :a,
@@ -2972,9 +1979,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2972
1979
 
2973
1980
  add_tests("masgn",
2974
1981
  "Ruby" => "a, b = c, d",
2975
- "RawParseTree" => [:masgn,
2976
- [:array, [:lasgn, :a], [:lasgn, :b]], nil,
2977
- [:array, [:vcall, :c], [:vcall, :d]]],
2978
1982
  "ParseTree" => s(:masgn,
2979
1983
  s(:array, s(:lasgn, :a), s(:lasgn, :b)),
2980
1984
  s(:array, s(:call, nil, :c, s(:arglist)),
@@ -2982,12 +1986,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2982
1986
 
2983
1987
  add_tests("masgn_argscat",
2984
1988
  "Ruby" => "a, b, *c = 1, 2, *[3, 4]",
2985
- "RawParseTree" => [:masgn,
2986
- [:array, [:lasgn, :a], [:lasgn, :b]],
2987
- [:lasgn, :c],
2988
- [:argscat,
2989
- [:array, [:lit, 1], [:lit, 2]],
2990
- [:array, [:lit, 3], [:lit, 4]]]],
2991
1989
  "ParseTree" => s(:masgn,
2992
1990
  s(:array,
2993
1991
  s(:lasgn, :a),
@@ -3000,10 +1998,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3000
1998
 
3001
1999
  add_tests("masgn_attrasgn",
3002
2000
  "Ruby" => "a, b.c = d, e",
3003
- "RawParseTree" => [:masgn,
3004
- [:array, [:lasgn, :a],
3005
- [:attrasgn, [:vcall, :b], :c=]], nil,
3006
- [:array, [:vcall, :d], [:vcall, :e]]],
3007
2001
  "ParseTree" => s(:masgn,
3008
2002
  s(:array,
3009
2003
  s(:lasgn, :a),
@@ -3016,12 +2010,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3016
2010
 
3017
2011
  add_tests("masgn_attrasgn_array_rhs",
3018
2012
  "Ruby" => "a.b, a.c, _ = q",
3019
- "RawParseTree" => [:masgn,
3020
- [:array,
3021
- [:attrasgn, [:vcall, :a], :b=],
3022
- [:attrasgn, [:vcall, :a], :c=],
3023
- [:lasgn, :_]], nil,
3024
- [:to_ary, [:vcall, :q]]],
3025
2013
  "ParseTree" => s(:masgn,
3026
2014
  s(:array,
3027
2015
  s(:attrasgn,
@@ -3036,23 +2024,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3036
2024
 
3037
2025
  add_tests("masgn_attrasgn_idx",
3038
2026
  "Ruby" => "a, i, j = [], 1, 2\na[i], a[j] = a[j], a[i]\n",
3039
- "RawParseTree" => [:block,
3040
- [:masgn,
3041
- [:array,
3042
- [:lasgn, :a], [:lasgn, :i], [:lasgn, :j]], nil,
3043
- [:array, [:zarray], [:lit, 1], [:lit, 2]]],
3044
- [:masgn,
3045
- [:array,
3046
- [:attrasgn,
3047
- [:lvar, :a], :[]=, [:array, [:lvar, :i]]],
3048
- [:attrasgn,
3049
- [:lvar, :a], :[]=, [:array, [:lvar, :j]]]],
3050
- nil,
3051
- [:array,
3052
- [:call, [:lvar, :a], :[],
3053
- [:array, [:lvar, :j]]],
3054
- [:call, [:lvar, :a], :[],
3055
- [:array, [:lvar, :i]]]]]],
3056
2027
  "ParseTree" => s(:block,
3057
2028
  s(:masgn,
3058
2029
  s(:array,
@@ -3073,10 +2044,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3073
2044
 
3074
2045
  add_tests("masgn_cdecl",
3075
2046
  "Ruby" => "A, B, C = 1, 2, 3",
3076
- "RawParseTree" => [:masgn,
3077
- [:array, [:cdecl, :A], [:cdecl, :B],
3078
- [:cdecl, :C]], nil,
3079
- [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
3080
2047
  "ParseTree" => s(:masgn,
3081
2048
  s(:array, s(:cdecl, :A), s(:cdecl, :B),
3082
2049
  s(:cdecl, :C)),
@@ -3085,9 +2052,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3085
2052
 
3086
2053
  add_tests("masgn_iasgn",
3087
2054
  "Ruby" => "a, @b = c, d",
3088
- "RawParseTree" => [:masgn,
3089
- [:array, [:lasgn, :a], [:iasgn, :"@b"]], nil,
3090
- [:array, [:vcall, :c], [:vcall, :d]]],
3091
2055
  "ParseTree" => s(:masgn,
3092
2056
  s(:array, s(:lasgn, :a), s(:iasgn, :"@b")),
3093
2057
  s(:array,
@@ -3096,20 +2060,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3096
2060
 
3097
2061
  add_tests("masgn_masgn",
3098
2062
  "Ruby" => "a, (b, c) = [1, [2, 3]]",
3099
- "RawParseTree" => [:masgn,
3100
- [:array,
3101
- [:lasgn, :a],
3102
- [:masgn,
3103
- [:array,
3104
- [:lasgn, :b],
3105
- [:lasgn, :c]], nil, nil]],
3106
- nil,
3107
- [:to_ary,
3108
- [:array,
3109
- [:lit, 1],
3110
- [:array,
3111
- [:lit, 2],
3112
- [:lit, 3]]]]],
3113
2063
  "ParseTree" => s(:masgn,
3114
2064
  s(:array,
3115
2065
  s(:lasgn, :a),
@@ -3126,12 +2076,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3126
2076
 
3127
2077
  add_tests("masgn_splat_lhs",
3128
2078
  "Ruby" => "a, b, *c = d, e, f, g",
3129
- "RawParseTree" => [:masgn,
3130
- [:array, [:lasgn, :a], [:lasgn, :b]],
3131
- [:lasgn, :c],
3132
- [:array,
3133
- [:vcall, :d], [:vcall, :e],
3134
- [:vcall, :f], [:vcall, :g]]],
3135
2079
  "ParseTree" => s(:masgn,
3136
2080
  s(:array,
3137
2081
  s(:lasgn, :a),
@@ -3145,10 +2089,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3145
2089
 
3146
2090
  add_tests("masgn_splat_rhs_1",
3147
2091
  "Ruby" => "a, b = *c",
3148
- "RawParseTree" => [:masgn,
3149
- [:array, [:lasgn, :a], [:lasgn, :b]],
3150
- nil,
3151
- [:splat, [:vcall, :c]]],
3152
2092
  "ParseTree" => s(:masgn,
3153
2093
  s(:array,
3154
2094
  s(:lasgn, :a),
@@ -3157,12 +2097,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3157
2097
 
3158
2098
  add_tests("masgn_splat_rhs_n",
3159
2099
  "Ruby" => "a, b = c, d, *e",
3160
- "RawParseTree" => [:masgn,
3161
- [:array, [:lasgn, :a], [:lasgn, :b]],
3162
- nil,
3163
- [:argscat,
3164
- [:array, [:vcall, :c], [:vcall, :d]],
3165
- [:vcall, :e]]],
3166
2100
  "ParseTree" => s(:masgn,
3167
2101
  s(:array,
3168
2102
  s(:lasgn, :a),
@@ -3174,10 +2108,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3174
2108
 
3175
2109
  add_tests("masgn_splat_no_name_to_ary",
3176
2110
  "Ruby" => "a, b, * = c",
3177
- "RawParseTree" => [:masgn,
3178
- [:array, [:lasgn, :a], [:lasgn, :b]],
3179
- [:splat],
3180
- [:to_ary, [:vcall, :c]]],
3181
2111
  "ParseTree" => s(:masgn,
3182
2112
  s(:array,
3183
2113
  s(:lasgn, :a),
@@ -3187,9 +2117,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3187
2117
 
3188
2118
  add_tests("masgn_splat_no_name_trailing",
3189
2119
  "Ruby" => "a, b, = c",
3190
- "RawParseTree" => [:masgn,
3191
- [:array, [:lasgn, :a], [:lasgn, :b]], nil,
3192
- [:to_ary, [:vcall, :c]]],
3193
2120
  "ParseTree" => s(:masgn,
3194
2121
  s(:array, s(:lasgn, :a), s(:lasgn, :b)),
3195
2122
  s(:to_ary, s(:call, nil, :c, s(:arglist)))),
@@ -3197,10 +2124,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3197
2124
 
3198
2125
  add_tests("masgn_splat_to_ary",
3199
2126
  "Ruby" => "a, b, *c = d",
3200
- "RawParseTree" => [:masgn,
3201
- [:array, [:lasgn, :a], [:lasgn, :b]],
3202
- [:lasgn, :c],
3203
- [:to_ary, [:vcall, :d]]],
3204
2127
  "ParseTree" => s(:masgn,
3205
2128
  s(:array,
3206
2129
  s(:lasgn, :a),
@@ -3210,12 +2133,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3210
2133
 
3211
2134
  add_tests("masgn_splat_to_ary2",
3212
2135
  "Ruby" => "a, b, *c = d.e(\"f\")",
3213
- "RawParseTree" => [:masgn,
3214
- [:array, [:lasgn, :a], [:lasgn, :b]],
3215
- [:lasgn, :c],
3216
- [:to_ary,
3217
- [:call, [:vcall, :d], :e,
3218
- [:array, [:str, 'f']]]]],
3219
2136
  "ParseTree" => s(:masgn,
3220
2137
  s(:array,
3221
2138
  s(:lasgn, :a),
@@ -3229,25 +2146,18 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3229
2146
 
3230
2147
  add_tests("match",
3231
2148
  "Ruby" => "1 if /x/",
3232
- "RawParseTree" => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
3233
2149
  "ParseTree" => s(:if, s(:match, s(:lit, /x/)), s(:lit, 1), nil))
3234
2150
 
3235
2151
  add_tests("match2",
3236
2152
  "Ruby" => "/x/ =~ \"blah\"",
3237
- "RawParseTree" => [:match2, [:lit, /x/], [:str, "blah"]],
3238
2153
  "ParseTree" => s(:match2, s(:lit, /x/), s(:str, "blah")))
3239
2154
 
3240
2155
  add_tests("match3",
3241
2156
  "Ruby" => "\"blah\" =~ /x/",
3242
- "RawParseTree" => [:match3, [:lit, /x/], [:str, "blah"]],
3243
2157
  "ParseTree" => s(:match3, s(:lit, /x/), s(:str, "blah")))
3244
2158
 
3245
2159
  add_tests("module",
3246
2160
  "Ruby" => "module X\n def y\n # do nothing\n end\nend",
3247
- "RawParseTree" => [:module, :X,
3248
- [:scope,
3249
- [:defn, :y,
3250
- [:scope, [:block, [:args], [:nil]]]]]],
3251
2161
  "ParseTree" => s(:module, :X,
3252
2162
  s(:scope,
3253
2163
  s(:defn, :y,
@@ -3256,24 +2166,17 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3256
2166
 
3257
2167
  add_tests("module_scoped",
3258
2168
  "Ruby" => "module X::Y\n c\nend",
3259
- "RawParseTree" => [:module, [:colon2, [:const, :X], :Y],
3260
- [:scope, [:vcall, :c]]],
3261
2169
  "ParseTree" => s(:module, s(:colon2, s(:const, :X), :Y),
3262
2170
  s(:scope, s(:call, nil, :c, s(:arglist)))))
3263
2171
 
3264
2172
  add_tests("module_scoped3",
3265
2173
  "Ruby" => "module ::Y\n c\nend",
3266
- "RawParseTree" => [:module, [:colon3, :Y], [:scope, [:vcall, :c]]],
3267
2174
  "ParseTree" => s(:module,
3268
2175
  s(:colon3, :Y),
3269
2176
  s(:scope, s(:call, nil, :c, s(:arglist)))))
3270
2177
 
3271
2178
  add_tests("next",
3272
2179
  "Ruby" => "loop { next if false }",
3273
- "RawParseTree" => [:iter,
3274
- [:fcall, :loop],
3275
- nil,
3276
- [:if, [:false], [:next], nil]],
3277
2180
  "ParseTree" => s(:iter,
3278
2181
  s(:call, nil, :loop, s(:arglist)),
3279
2182
  nil,
@@ -3281,10 +2184,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3281
2184
 
3282
2185
  add_tests("next_arg",
3283
2186
  "Ruby" => "loop { next 42 if false }",
3284
- "RawParseTree" => [:iter,
3285
- [:fcall, :loop],
3286
- nil,
3287
- [:if, [:false], [:next, [:lit, 42]], nil]],
3288
2187
  "ParseTree" => s(:iter,
3289
2188
  s(:call, nil, :loop, s(:arglist)),
3290
2189
  nil,
@@ -3292,24 +2191,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3292
2191
 
3293
2192
  add_tests("not",
3294
2193
  "Ruby" => "(not true)",
3295
- "RawParseTree" => [:not, [:true]],
3296
2194
  "ParseTree" => s(:not, s(:true)))
3297
2195
 
3298
2196
  add_tests("nth_ref",
3299
2197
  "Ruby" => "$1",
3300
- "RawParseTree" => [:nth_ref, 1],
3301
2198
  "ParseTree" => s(:nth_ref, 1))
3302
2199
 
3303
2200
  add_tests("op_asgn1",
3304
2201
  "Ruby" => "b = []\nb[1] ||= 10\nb[2] &&= 11\nb[3] += 12\n",
3305
- "RawParseTree" => [:block,
3306
- [:lasgn, :b, [:zarray]],
3307
- [:op_asgn1, [:lvar, :b],
3308
- [:array, [:lit, 1]], :"||", [:lit, 10]],
3309
- [:op_asgn1, [:lvar, :b],
3310
- [:array, [:lit, 2]], :"&&", [:lit, 11]],
3311
- [:op_asgn1, [:lvar, :b],
3312
- [:array, [:lit, 3]], :+, [:lit, 12]]],
3313
2202
  "ParseTree" => s(:block,
3314
2203
  s(:lasgn, :b, s(:array)),
3315
2204
  s(:op_asgn1, s(:lvar, :b),
@@ -3321,14 +2210,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3321
2210
 
3322
2211
  add_tests("op_asgn1_ivar",
3323
2212
  "Ruby" => "@b = []\n@b[1] ||= 10\n@b[2] &&= 11\n@b[3] += 12\n",
3324
- "RawParseTree" => [:block,
3325
- [:iasgn, :@b, [:zarray]],
3326
- [:op_asgn1, [:ivar, :@b],
3327
- [:array, [:lit, 1]], :"||", [:lit, 10]],
3328
- [:op_asgn1, [:ivar, :@b],
3329
- [:array, [:lit, 2]], :"&&", [:lit, 11]],
3330
- [:op_asgn1, [:ivar, :@b],
3331
- [:array, [:lit, 3]], :+, [:lit, 12]]],
3332
2213
  "ParseTree" => s(:block,
3333
2214
  s(:iasgn, :@b, s(:array)),
3334
2215
  s(:op_asgn1, s(:ivar, :@b),
@@ -3340,23 +2221,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3340
2221
 
3341
2222
  add_tests("op_asgn2",
3342
2223
  "Ruby" => "s = Struct.new(:var)\nc = s.new(nil)\nc.var ||= 20\nc.var &&= 21\nc.var += 22\nc.d.e.f ||= 42\n",
3343
- "RawParseTree" => [:block,
3344
- [:lasgn, :s,
3345
- [:call, [:const, :Struct],
3346
- :new, [:array, [:lit, :var]]]],
3347
- [:lasgn, :c,
3348
- [:call, [:lvar, :s], :new, [:array, [:nil]]]],
3349
-
3350
- [:op_asgn2, [:lvar, :c], :var=, :"||",
3351
- [:lit, 20]],
3352
- [:op_asgn2, [:lvar, :c], :var=, :"&&",
3353
- [:lit, 21]],
3354
- [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
3355
-
3356
- [:op_asgn2,
3357
- [:call,
3358
- [:call, [:lvar, :c], :d], :e], :f=, :"||",
3359
- [:lit, 42]]],
3360
2224
  "ParseTree" => s(:block,
3361
2225
  s(:lasgn, :s,
3362
2226
  s(:call, s(:const, :Struct),
@@ -3378,17 +2242,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3378
2242
 
3379
2243
  add_tests("op_asgn2_self",
3380
2244
  "Ruby" => "self.Bag ||= Bag.new",
3381
- "RawParseTree" => [:op_asgn2, [:self], :"Bag=", :"||",
3382
- [:call, [:const, :Bag], :new]],
3383
2245
  "ParseTree" => s(:op_asgn2, s(:self), :"Bag=", :"||",
3384
2246
  s(:call, s(:const, :Bag), :new, s(:arglist))))
3385
2247
 
3386
2248
  add_tests("op_asgn_and",
3387
2249
  "Ruby" => "a = 0\na &&= 2\n",
3388
- "RawParseTree" => [:block,
3389
- [:lasgn, :a, [:lit, 0]],
3390
- [:op_asgn_and,
3391
- [:lvar, :a], [:lasgn, :a, [:lit, 2]]]],
3392
2250
  "ParseTree" => s(:block,
3393
2251
  s(:lasgn, :a, s(:lit, 0)),
3394
2252
  s(:op_asgn_and,
@@ -3396,17 +2254,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3396
2254
 
3397
2255
  add_tests("op_asgn_and_ivar2",
3398
2256
  "Ruby" => "@fetcher &&= new(Gem.configuration[:http_proxy])",
3399
- "RawParseTree" => [:op_asgn_and,
3400
- [:ivar, :@fetcher],
3401
- [:iasgn,
3402
- :@fetcher,
3403
- [:fcall,
3404
- :new,
3405
- [:array,
3406
- [:call,
3407
- [:call, [:const, :Gem], :configuration],
3408
- :[],
3409
- [:array, [:lit, :http_proxy]]]]]]],
3410
2257
  "ParseTree" => s(:op_asgn_and,
3411
2258
  s(:ivar, :@fetcher),
3412
2259
  s(:iasgn,
@@ -3423,10 +2270,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3423
2270
 
3424
2271
  add_tests("op_asgn_or",
3425
2272
  "Ruby" => "a = 0\na ||= 1\n",
3426
- "RawParseTree" => [:block,
3427
- [:lasgn, :a, [:lit, 0]],
3428
- [:op_asgn_or,
3429
- [:lvar, :a], [:lasgn, :a, [:lit, 1]]]],
3430
2273
  "ParseTree" => s(:block,
3431
2274
  s(:lasgn, :a, s(:lit, 0)),
3432
2275
  s(:op_asgn_or,
@@ -3434,12 +2277,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3434
2277
 
3435
2278
  add_tests("op_asgn_or_block",
3436
2279
  "Ruby" => "a ||= begin\n b\n rescue\n c\n end",
3437
- "RawParseTree" => [:op_asgn_or,
3438
- [:lvar, :a],
3439
- [:lasgn, :a,
3440
- [:rescue,
3441
- [:vcall, :b],
3442
- [:resbody, nil, [:vcall, :c]]]]],
3443
2280
  "ParseTree" => s(:op_asgn_or,
3444
2281
  s(:lvar, :a),
3445
2282
  s(:lasgn, :a,
@@ -3451,26 +2288,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3451
2288
 
3452
2289
  add_tests("op_asgn_or_ivar",
3453
2290
  "Ruby" => "@v ||= { }",
3454
- "RawParseTree" => [:op_asgn_or,
3455
- [:ivar, :@v],
3456
- [:iasgn, :@v, [:hash]]],
3457
2291
  "ParseTree" => s(:op_asgn_or,
3458
2292
  s(:ivar, :@v),
3459
2293
  s(:iasgn, :@v, s(:hash))))
3460
2294
 
3461
2295
  add_tests("op_asgn_or_ivar2",
3462
2296
  "Ruby" => "@fetcher ||= new(Gem.configuration[:http_proxy])",
3463
- "RawParseTree" => [:op_asgn_or,
3464
- [:ivar, :@fetcher],
3465
- [:iasgn,
3466
- :@fetcher,
3467
- [:fcall,
3468
- :new,
3469
- [:array,
3470
- [:call,
3471
- [:call, [:const, :Gem], :configuration],
3472
- :[],
3473
- [:array, [:lit, :http_proxy]]]]]]],
3474
2297
  "ParseTree" => s(:op_asgn_or,
3475
2298
  s(:ivar, :@fetcher),
3476
2299
  s(:iasgn,
@@ -3486,16 +2309,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3486
2309
 
3487
2310
  add_tests("or",
3488
2311
  "Ruby" => "(a or b)",
3489
- "RawParseTree" => [:or, [:vcall, :a], [:vcall, :b]],
3490
2312
  "ParseTree" => s(:or,
3491
2313
  s(:call, nil, :a, s(:arglist)),
3492
2314
  s(:call, nil, :b, s(:arglist))))
3493
2315
 
3494
2316
  add_tests("or_big",
3495
2317
  "Ruby" => "((a or b) or (c and d))",
3496
- "RawParseTree" => [:or,
3497
- [:or, [:vcall, :a], [:vcall, :b]],
3498
- [:and, [:vcall, :c], [:vcall, :d]]],
3499
2318
  "ParseTree" => s(:or,
3500
2319
  s(:or,
3501
2320
  s(:call, nil, :a, s(:arglist)),
@@ -3506,9 +2325,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3506
2325
 
3507
2326
  add_tests("or_big2",
3508
2327
  "Ruby" => "((a || b) || (c && d))",
3509
- "RawParseTree" => [:or,
3510
- [:or, [:vcall, :a], [:vcall, :b]],
3511
- [:and, [:vcall, :c], [:vcall, :d]]],
3512
2328
  "ParseTree" => s(:or,
3513
2329
  s(:or,
3514
2330
  s(:call, nil, :a, s(:arglist)),
@@ -3520,15 +2336,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3520
2336
 
3521
2337
  add_tests("parse_floats_as_args",
3522
2338
  "Ruby" => "def x(a=0.0,b=0.0)\n a+b\nend",
3523
- "RawParseTree" => [:defn, :x,
3524
- [:scope,
3525
- [:block,
3526
- [:args, :a, :b,
3527
- [:block,
3528
- [:lasgn, :a, [:lit, 0.0]],
3529
- [:lasgn, :b, [:lit, 0.0]]]],
3530
- [:call, [:lvar, :a], :+,
3531
- [:array, [:lvar, :b]]]]]],
3532
2339
  "ParseTree" => s(:defn, :x,
3533
2340
  s(:args, :a, :b,
3534
2341
  s(:block,
@@ -3542,15 +2349,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3542
2349
 
3543
2350
  add_tests("postexe",
3544
2351
  "Ruby" => "END { 1 }",
3545
- "RawParseTree" => [:iter, [:postexe], nil, [:lit, 1]],
3546
2352
  "ParseTree" => s(:iter, s(:postexe), nil, s(:lit, 1)))
3547
2353
 
3548
2354
  add_tests("proc_args_0",
3549
2355
  "Ruby" => "proc { || (x + 1) }",
3550
- "RawParseTree" => [:iter,
3551
- [:fcall, :proc],
3552
- 0,
3553
- [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
3554
2356
  "ParseTree" => s(:iter,
3555
2357
  s(:call, nil, :proc, s(:arglist)),
3556
2358
  0,
@@ -3561,10 +2363,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3561
2363
 
3562
2364
  add_tests("proc_args_1",
3563
2365
  "Ruby" => "proc { |x| (x + 1) }",
3564
- "RawParseTree" => [:iter,
3565
- [:fcall, :proc],
3566
- [:dasgn_curr, :x],
3567
- [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
3568
2366
  "ParseTree" => s(:iter,
3569
2367
  s(:call, nil, :proc, s(:arglist)),
3570
2368
  s(:lasgn, :x),
@@ -3573,12 +2371,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3573
2371
 
3574
2372
  add_tests("proc_args_2",
3575
2373
  "Ruby" => "proc { |x, y| (x + y) }",
3576
- "RawParseTree" => [:iter,
3577
- [:fcall, :proc],
3578
- [:masgn, [:array,
3579
- [:dasgn_curr, :x],
3580
- [:dasgn_curr, :y]], nil, nil],
3581
- [:call, [:dvar, :x], :+, [:array, [:dvar, :y]]]],
3582
2374
  "ParseTree" => s(:iter,
3583
2375
  s(:call, nil, :proc, s(:arglist)),
3584
2376
  s(:masgn,
@@ -3590,10 +2382,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3590
2382
 
3591
2383
  add_tests("proc_args_no",
3592
2384
  "Ruby" => "proc { (x + 1) }",
3593
- "RawParseTree" => [:iter,
3594
- [:fcall, :proc],
3595
- nil,
3596
- [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
3597
2385
  "ParseTree" => s(:iter,
3598
2386
  s(:call, nil, :proc, s(:arglist)),
3599
2387
  nil,
@@ -3602,9 +2390,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3602
2390
 
3603
2391
  add_tests("redo",
3604
2392
  "Ruby" => "loop { redo if false }",
3605
- "RawParseTree" => [:iter,
3606
- [:fcall, :loop], nil,
3607
- [:if, [:false], [:redo], nil]],
3608
2393
  "ParseTree" => s(:iter,
3609
2394
  s(:call, nil, :loop, s(:arglist)),
3610
2395
  nil,
@@ -3614,21 +2399,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3614
2399
 
3615
2400
  add_tests("rescue",
3616
2401
  "Ruby" => "blah rescue nil",
3617
- "RawParseTree" => [:rescue,
3618
- [:vcall, :blah], [:resbody, nil, [:nil]]],
3619
2402
  "ParseTree" => s(:rescue,
3620
2403
  s(:call, nil, :blah, s(:arglist)),
3621
2404
  s(:resbody, s(:array), s(:nil))))
3622
2405
 
3623
2406
  add_tests("rescue_block_body",
3624
2407
  "Ruby" => "begin\n a\nrescue => e\n c\n d\nend",
3625
- "RawParseTree" => [:rescue,
3626
- [:vcall, :a],
3627
- [:resbody, nil,
3628
- [:block,
3629
- [:lasgn, :e, [:gvar, :$!]],
3630
- [:vcall, :c],
3631
- [:vcall, :d]]]],
3632
2408
  "ParseTree" => s(:rescue,
3633
2409
  s(:call, nil, :a, s(:arglist)),
3634
2410
  s(:resbody,
@@ -3639,14 +2415,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3639
2415
 
3640
2416
  add_tests("rescue_block_body_3",
3641
2417
  "Ruby" => "begin\n a\nrescue A\n b\nrescue B\n c\nrescue C\n d\nend",
3642
- "RawParseTree" => [:rescue,
3643
- [:vcall, :a],
3644
- [:resbody, [:array, [:const, :A]],
3645
- [:vcall, :b],
3646
- [:resbody, [:array, [:const, :B]],
3647
- [:vcall, :c],
3648
- [:resbody, [:array, [:const, :C]],
3649
- [:vcall, :d]]]]],
3650
2418
  "ParseTree" => s(:rescue,
3651
2419
  s(:call, nil, :a, s(:arglist)),
3652
2420
  s(:resbody, s(:array, s(:const, :A)),
@@ -3658,13 +2426,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3658
2426
 
3659
2427
  add_tests("rescue_block_body_ivar",
3660
2428
  "Ruby" => "begin\n a\nrescue => @e\n c\n d\nend",
3661
- "RawParseTree" => [:rescue,
3662
- [:vcall, :a],
3663
- [:resbody, nil,
3664
- [:block,
3665
- [:iasgn, :@e, [:gvar, :$!]],
3666
- [:vcall, :c],
3667
- [:vcall, :d]]]],
3668
2429
  "ParseTree" => s(:rescue,
3669
2430
  s(:call, nil, :a, s(:arglist)),
3670
2431
  s(:resbody,
@@ -3675,18 +2436,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3675
2436
 
3676
2437
  add_tests("rescue_block_nada",
3677
2438
  "Ruby" => "begin\n blah\nrescue\n # do nothing\nend",
3678
- "RawParseTree" => [:rescue, [:vcall, :blah], [:resbody, nil]],
3679
2439
  "ParseTree" => s(:rescue,
3680
2440
  s(:call, nil, :blah, s(:arglist)),
3681
2441
  s(:resbody, s(:array), nil)))
3682
2442
 
3683
2443
  add_tests("rescue_exceptions",
3684
2444
  "Ruby" => "begin\n blah\nrescue RuntimeError => r\n # do nothing\nend",
3685
- "RawParseTree" => [:rescue,
3686
- [:vcall, :blah],
3687
- [:resbody,
3688
- [:array, [:const, :RuntimeError]],
3689
- [:lasgn, :r, [:gvar, :$!]]]],
3690
2445
  "ParseTree" => s(:rescue,
3691
2446
  s(:call, nil, :blah, s(:arglist)),
3692
2447
  s(:resbody,
@@ -3698,9 +2453,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3698
2453
 
3699
2454
  add_tests("rescue_iasgn_var_empty",
3700
2455
  "Ruby" => "begin\n 1\nrescue => @e\n # do nothing\nend",
3701
- "RawParseTree" => [:rescue,
3702
- [:lit, 1],
3703
- [:resbody, nil, [:iasgn, :@e, [:gvar, :$!]]]],
3704
2456
  "ParseTree" => s(:rescue,
3705
2457
  s(:lit, 1),
3706
2458
  s(:resbody,
@@ -3709,9 +2461,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3709
2461
 
3710
2462
  add_tests("rescue_lasgn",
3711
2463
  "Ruby" => "begin\n 1\nrescue\n var = 2\nend",
3712
- "RawParseTree" => [:rescue,
3713
- [:lit, 1],
3714
- [:resbody, nil, [:lasgn, :var, [:lit, 2]]]],
3715
2464
  "ParseTree" => s(:rescue,
3716
2465
  s(:lit, 1),
3717
2466
  s(:resbody,
@@ -3721,12 +2470,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3721
2470
 
3722
2471
  add_tests("rescue_lasgn_var",
3723
2472
  "Ruby" => "begin\n 1\nrescue => e\n var = 2\nend",
3724
- "RawParseTree" => [:rescue,
3725
- [:lit, 1],
3726
- [:resbody, nil,
3727
- [:block,
3728
- [:lasgn, :e, [:gvar, :$!]],
3729
- [:lasgn, :var, [:lit, 2]]]]],
3730
2473
  "ParseTree" => s(:rescue,
3731
2474
  s(:lit, 1),
3732
2475
  s(:resbody,
@@ -3735,9 +2478,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3735
2478
 
3736
2479
  add_tests("rescue_lasgn_var_empty",
3737
2480
  "Ruby" => "begin\n 1\nrescue => e\n # do nothing\nend",
3738
- "RawParseTree" => [:rescue,
3739
- [:lit, 1],
3740
- [:resbody, nil, [:lasgn, :e, [:gvar, :$!]]]],
3741
2481
  "ParseTree" => s(:rescue,
3742
2482
  s(:lit, 1),
3743
2483
  s(:resbody,
@@ -3746,44 +2486,32 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3746
2486
 
3747
2487
  add_tests("retry",
3748
2488
  "Ruby" => "retry",
3749
- "RawParseTree" => [:retry],
3750
2489
  "ParseTree" => s(:retry))
3751
2490
 
3752
2491
  add_tests("return_0",
3753
2492
  "Ruby" => "return",
3754
- "RawParseTree" => [:return],
3755
2493
  "ParseTree" => s(:return))
3756
2494
 
3757
2495
  add_tests("return_1",
3758
2496
  "Ruby" => "return 1",
3759
- "RawParseTree" => [:return, [:lit, 1]],
3760
2497
  "ParseTree" => s(:return, s(:lit, 1)))
3761
2498
 
3762
2499
  add_tests("return_1_splatted",
3763
2500
  "Ruby" => "return *1",
3764
- "RawParseTree" => [:return, [:svalue, [:splat, [:lit, 1]]]],
3765
2501
  "ParseTree" => s(:return, s(:svalue, s(:splat, s(:lit, 1)))))
3766
2502
 
3767
2503
  add_tests("return_n",
3768
2504
  "Ruby" => "return 1, 2, 3",
3769
- "RawParseTree" => [:return, [:array,
3770
- [:lit, 1], [:lit, 2], [:lit, 3]]],
3771
2505
  "ParseTree" => s(:return, s(:array,
3772
2506
  s(:lit, 1), s(:lit, 2), s(:lit, 3))),
3773
2507
  "Ruby2Ruby" => "return [1, 2, 3]")
3774
2508
 
3775
2509
  add_tests("sclass",
3776
2510
  "Ruby" => "class << self\n 42\nend",
3777
- "RawParseTree" => [:sclass, [:self], [:scope, [:lit, 42]]],
3778
2511
  "ParseTree" => s(:sclass, s(:self), s(:scope, s(:lit, 42))))
3779
2512
 
3780
2513
  add_tests("sclass_trailing_class",
3781
2514
  "Ruby" => "class A\n class << self\n a\n end\n class B\n end\nend",
3782
- "RawParseTree" => [:class, :A, nil,
3783
- [:scope,
3784
- [:block,
3785
- [:sclass, [:self], [:scope, [:vcall, :a]]],
3786
- [:class, :B, nil, [:scope]]]]],
3787
2515
  "ParseTree" => s(:class, :A, nil,
3788
2516
  s(:scope,
3789
2517
  s(:block,
@@ -3794,11 +2522,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3794
2522
 
3795
2523
  add_tests("splat",
3796
2524
  "Ruby" => "def x(*b)\n a(*b)\nend",
3797
- "RawParseTree" => [:defn, :x,
3798
- [:scope,
3799
- [:block,
3800
- [:args, :"*b"],
3801
- [:fcall, :a, [:splat, [:lvar, :b]]]]]],
3802
2525
  "ParseTree" => s(:defn, :x,
3803
2526
  s(:args, :"*b"),
3804
2527
  s(:scope,
@@ -3808,137 +2531,104 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3808
2531
 
3809
2532
  add_tests("splat_array",
3810
2533
  "Ruby" => "[*[1]]",
3811
- "RawParseTree" => [:splat, [:array, [:lit, 1]]],
3812
2534
  "ParseTree" => s(:array, s(:splat, s(:array, s(:lit, 1)))))
3813
2535
 
3814
2536
  add_tests("splat_break",
3815
2537
  "Ruby" => "break *[1]",
3816
- "RawParseTree" => [:break, [:svalue, [:splat, [:array, [:lit, 1]]]]],
3817
2538
  "ParseTree" => s(:break, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
3818
2539
 
3819
2540
  add_tests("splat_break_array",
3820
2541
  "Ruby" => "break [*[1]]",
3821
- "RawParseTree" => [:break, [:splat, [:array, [:lit, 1]]]],
3822
2542
  "ParseTree" => s(:break, s(:array, s(:splat, s(:array, s(:lit, 1))))))
3823
2543
 
3824
2544
  add_tests("splat_fcall",
3825
2545
  "Ruby" => "meth(*[1])",
3826
- "RawParseTree" => [:fcall, :meth,
3827
- [:splat, [:array, [:lit, 1]]]],
3828
2546
  "ParseTree" => s(:call, nil, :meth,
3829
2547
  s(:arglist, s(:splat, s(:array, s(:lit, 1))))))
3830
2548
 
3831
2549
  add_tests("splat_fcall_array",
3832
2550
  "Ruby" => "meth([*[1]])",
3833
- "RawParseTree" => [:fcall, :meth,
3834
- [:array, [:splat, [:array, [:lit, 1]]]]],
3835
2551
  "ParseTree" => s(:call, nil, :meth,
3836
2552
  s(:arglist,
3837
2553
  s(:array, s(:splat, s(:array, s(:lit, 1)))))))
3838
2554
 
3839
2555
  add_tests("splat_lasgn",
3840
2556
  "Ruby" => "x = *[1]",
3841
- "RawParseTree" => [:lasgn, :x, [:svalue, [:splat, [:array, [:lit, 1]]]]],
3842
2557
  "ParseTree" => s(:lasgn, :x, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
3843
2558
 
3844
2559
  add_tests("splat_lasgn_array",
3845
2560
  "Ruby" => "x = [*[1]]",
3846
- "RawParseTree" => [:lasgn, :x, [:splat, [:array, [:lit, 1]]]],
3847
2561
  "ParseTree" => s(:lasgn, :x, s(:array, s(:splat, s(:array, s(:lit, 1))))))
3848
2562
 
3849
2563
  add_tests("splat_lit_1",
3850
2564
  "Ruby" => "[*1]",
3851
- "RawParseTree" => [:splat, [:lit, 1]], # UGH - damn MRI
2565
+ # UGH - damn MRI
3852
2566
  "ParseTree" => s(:array, s(:splat, s(:lit, 1))))
3853
2567
 
3854
2568
  add_tests("splat_lit_n",
3855
2569
  "Ruby" => "[1, *2]",
3856
- "RawParseTree" => [:argscat, [:array, [:lit, 1]], [:lit, 2]],
3857
2570
  "ParseTree" => s(:array, s(:lit, 1), s(:splat, s(:lit, 2))))
3858
2571
 
3859
2572
  add_tests("splat_next",
3860
2573
  "Ruby" => "next *[1]",
3861
- "RawParseTree" => [:next, [:svalue, [:splat, [:array, [:lit, 1]]]]],
3862
2574
  "ParseTree" => s(:next, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
3863
2575
 
3864
2576
  add_tests("splat_next_array",
3865
2577
  "Ruby" => "next [*[1]]",
3866
- "RawParseTree" => [:next, [:splat, [:array, [:lit, 1]]]],
3867
2578
  "ParseTree" => s(:next, s(:array, s(:splat, s(:array, s(:lit, 1))))))
3868
2579
 
3869
2580
  add_tests("splat_return",
3870
2581
  "Ruby" => "return *[1]",
3871
- "RawParseTree" => [:return, [:svalue, [:splat, [:array, [:lit, 1]]]]],
3872
2582
  "ParseTree" => s(:return, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
3873
2583
 
3874
2584
  add_tests("splat_return_array",
3875
2585
  "Ruby" => "return [*[1]]",
3876
- "RawParseTree" => [:return, [:splat, [:array, [:lit, 1]]]],
3877
2586
  "ParseTree" => s(:return, s(:array, s(:splat, s(:array, s(:lit, 1))))))
3878
2587
 
3879
2588
  add_tests("splat_super",
3880
2589
  "Ruby" => "super(*[1])",
3881
- "RawParseTree" => [:super, [:splat, [:array, [:lit, 1]]]],
3882
2590
  "ParseTree" => s(:super, s(:splat, s(:array, s(:lit, 1)))))
3883
2591
 
3884
2592
  add_tests("splat_super_array",
3885
2593
  "Ruby" => "super([*[1]])",
3886
- "RawParseTree" => [:super, [:array, [:splat, [:array, [:lit, 1]]]]],
3887
2594
  "ParseTree" => s(:super, s(:array, s(:splat, s(:array, s(:lit, 1))))))
3888
2595
 
3889
2596
  add_tests("splat_yield",
3890
2597
  "Ruby" => "yield(*[1])",
3891
- "RawParseTree" => [:yield, [:splat, [:array, [:lit, 1]]]],
3892
2598
  "ParseTree" => s(:yield, s(:splat, s(:array, s(:lit, 1)))))
3893
2599
 
3894
2600
  add_tests("splat_yield_array",
3895
2601
  "Ruby" => "yield([*[1]])",
3896
- "RawParseTree" => [:yield, [:splat, [:array, [:lit, 1]]], true],
3897
2602
  "ParseTree" => s(:yield, s(:array, s(:splat, s(:array, s(:lit, 1))))))
3898
2603
 
3899
2604
  add_tests("str",
3900
2605
  "Ruby" => '"x"',
3901
- "RawParseTree" => [:str, "x"],
3902
2606
  "ParseTree" => s(:str, "x"))
3903
2607
 
3904
2608
  add_tests("str_concat_newline", # FIX? make prettier? possible?
3905
2609
  "Ruby" => '"before" \\
3906
2610
  " after"',
3907
- "RawParseTree" => [:str, "before after"],
3908
2611
  "ParseTree" => s(:str, "before after"),
3909
2612
  "Ruby2Ruby" => '"before after"')
3910
2613
 
3911
2614
  add_tests("str_concat_space",
3912
2615
  "Ruby" => '"before" " after"',
3913
- "RawParseTree" => [:str, "before after"],
3914
2616
  "ParseTree" => s(:str, "before after"),
3915
2617
  "Ruby2Ruby" => '"before after"')
3916
2618
 
3917
2619
  add_tests("str_heredoc",
3918
2620
  "Ruby" => "<<'EOM'\n blah\nblah\nEOM",
3919
- "RawParseTree" => [:str, " blah\nblah\n"],
3920
2621
  "ParseTree" => s(:str, " blah\nblah\n"),
3921
2622
  "Ruby2Ruby" => "\" blah\\nblah\\n\"")
3922
2623
 
3923
2624
  add_tests("str_heredoc_call",
3924
2625
  "Ruby" => "<<'EOM'.strip\n blah\nblah\nEOM",
3925
- "RawParseTree" => [:call, [:str, " blah\nblah\n"], :strip],
3926
2626
  "ParseTree" => s(:call, s(:str, " blah\nblah\n"),
3927
2627
  :strip, s(:arglist)),
3928
2628
  "Ruby2Ruby" => "\" blah\\nblah\\n\".strip")
3929
2629
 
3930
2630
  add_tests("str_heredoc_double",
3931
2631
  "Ruby" => "a += <<-H1 + b + <<-H2\n first\nH1\n second\nH2",
3932
- "RawParseTree" => [:lasgn, :a,
3933
- [:call,
3934
- [:lvar, :a],
3935
- :+,
3936
- [:array,
3937
- [:call,
3938
- [:call, [:str, " first\n"], :+,
3939
- [:array, [:vcall, :b]]],
3940
- :+,
3941
- [:array, [:str, " second\n"]]]]]],
3942
2632
  "ParseTree" => s(:lasgn, :a,
3943
2633
  s(:call,
3944
2634
  s(:lvar, :a),
@@ -3954,41 +2644,21 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
3954
2644
 
3955
2645
  add_tests("str_heredoc_empty", # yes... tarded
3956
2646
  "Ruby" => "<<'EOM'\nEOM",
3957
- "RawParseTree" => [:str, ""],
3958
2647
  "ParseTree" => s(:str, ""),
3959
2648
  "Ruby2Ruby" => '""')
3960
2649
 
3961
2650
  add_tests("str_heredoc_indent",
3962
2651
  "Ruby" => "<<-EOM\n blah\nblah\n\n EOM",
3963
- "RawParseTree" => [:str, " blah\nblah\n\n"],
3964
2652
  "ParseTree" => s(:str, " blah\nblah\n\n"),
3965
2653
  "Ruby2Ruby" => "\" blah\\nblah\\n\\n\"")
3966
2654
 
3967
2655
  add_tests("str_interp_file",
3968
2656
  "Ruby" => '"file = #{__FILE__}\n"',
3969
- "RawParseTree" => [:str, "file = (string)\n"],
3970
2657
  "ParseTree" => s(:str, "file = (string)\n"),
3971
2658
  "Ruby2Ruby" => '"file = (string)\\n"')
3972
2659
 
3973
2660
  add_tests("structure_extra_block_for_dvar_scoping",
3974
2661
  "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",
3975
- "RawParseTree" => [:iter,
3976
- [:call, [:vcall, :a], :b],
3977
- [:masgn, [:array,
3978
- [:dasgn_curr, :c],
3979
- [:dasgn_curr, :d]], nil, nil],
3980
- [:if,
3981
- [:call, [:vcall, :e], :f,
3982
- [:array, [:dvar, :c]]],
3983
- nil,
3984
- [:block,
3985
- [:dasgn_curr, :g, [:false]],
3986
- [:iter,
3987
- [:call, [:dvar, :d], :h],
3988
- [:masgn, [:array,
3989
- [:dasgn_curr, :x],
3990
- [:dasgn_curr, :i]], nil, nil],
3991
- [:dasgn, :g, [:true]]]]]],
3992
2662
  "ParseTree" => s(:iter,
3993
2663
  s(:call,
3994
2664
  s(:call, nil, :a, s(:arglist)),
@@ -4011,9 +2681,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4011
2681
 
4012
2682
  add_tests("structure_remove_begin_1",
4013
2683
  "Ruby" => "a << begin\n b\n rescue\n c\n end",
4014
- "RawParseTree" => [:call, [:vcall, :a], :<<,
4015
- [:array, [:rescue, [:vcall, :b],
4016
- [:resbody, nil, [:vcall, :c]]]]],
4017
2684
  "ParseTree" => s(:call, s(:call, nil, :a, s(:arglist)), :<<,
4018
2685
  s(:arglist,
4019
2686
  s(:rescue,
@@ -4024,15 +2691,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4024
2691
 
4025
2692
  add_tests("structure_remove_begin_2",
4026
2693
  "Ruby" => "a = if c\n begin\n b\n rescue\n nil\n end\n end\na",
4027
- "RawParseTree" => [:block,
4028
- [:lasgn,
4029
- :a,
4030
- [:if, [:vcall, :c],
4031
- [:rescue,
4032
- [:vcall, :b],
4033
- [:resbody, nil, [:nil]]],
4034
- nil]],
4035
- [:lvar, :a]],
4036
2694
  "ParseTree" => s(:block,
4037
2695
  s(:lasgn,
4038
2696
  :a,
@@ -4046,26 +2704,17 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4046
2704
 
4047
2705
  add_tests("structure_unused_literal_wwtt",
4048
2706
  "Ruby" => "\"prevent the above from infecting rdoc\"\n\nmodule Graffle\nend",
4049
- "RawParseTree" => [:module, :Graffle, [:scope]],
4050
2707
  "ParseTree" => s(:module, :Graffle, s(:scope)),
4051
2708
  "Ruby2Ruby" => "module Graffle\nend")
4052
2709
 
4053
2710
  add_tests("super_0",
4054
2711
  "Ruby" => "def x\n super()\nend",
4055
- "RawParseTree" => [:defn, :x,
4056
- [:scope,
4057
- [:block, [:args], [:super]]]],
4058
2712
  "ParseTree" => s(:defn, :x,
4059
2713
  s(:args),
4060
2714
  s(:scope, s(:block, s(:super)))))
4061
2715
 
4062
2716
  add_tests("super_1",
4063
2717
  "Ruby" => "def x\n super(4)\nend",
4064
- "RawParseTree" => [:defn, :x,
4065
- [:scope,
4066
- [:block,
4067
- [:args],
4068
- [:super, [:array, [:lit, 4]]]]]],
4069
2718
  "ParseTree" => s(:defn, :x,
4070
2719
  s(:args),
4071
2720
  s(:scope,
@@ -4074,13 +2723,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4074
2723
 
4075
2724
  add_tests("super_1_array",
4076
2725
  "Ruby" => "def x\n super([24, 42])\nend",
4077
- "RawParseTree" => [:defn, :x,
4078
- [:scope,
4079
- [:block,
4080
- [:args],
4081
- [:super,
4082
- [:array,
4083
- [:array, [:lit, 24], [:lit, 42]]]]]]],
4084
2726
  "ParseTree" => s(:defn, :x,
4085
2727
  s(:args),
4086
2728
  s(:scope,
@@ -4091,8 +2733,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4091
2733
 
4092
2734
  add_tests("super_block_pass",
4093
2735
  "Ruby" => "super(a, &b)",
4094
- "RawParseTree" => [:block_pass,
4095
- [:vcall, :b], [:super, [:array, [:vcall, :a]]]],
4096
2736
  "ParseTree" => s(:super,
4097
2737
  s(:call, nil, :a, s(:arglist)),
4098
2738
  s(:block_pass,
@@ -4100,21 +2740,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4100
2740
 
4101
2741
  add_tests("super_block_splat",
4102
2742
  "Ruby" => "super(a, *b)",
4103
- "RawParseTree" => [:super,
4104
- [:argscat,
4105
- [:array, [:vcall, :a]],
4106
- [:vcall, :b]]],
4107
2743
  "ParseTree" => s(:super,
4108
2744
  s(:call, nil, :a, s(:arglist)),
4109
2745
  s(:splat, s(:call, nil, :b, s(:arglist)))))
4110
2746
 
4111
2747
  add_tests("super_n",
4112
2748
  "Ruby" => "def x\n super(24, 42)\nend",
4113
- "RawParseTree" => [:defn, :x,
4114
- [:scope,
4115
- [:block,
4116
- [:args],
4117
- [:super, [:array, [:lit, 24], [:lit, 42]]]]]],
4118
2749
  "ParseTree" => s(:defn, :x,
4119
2750
  s(:args),
4120
2751
  s(:scope,
@@ -4123,35 +2754,26 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4123
2754
 
4124
2755
  add_tests("svalue",
4125
2756
  "Ruby" => "a = *b",
4126
- "RawParseTree" => [:lasgn, :a, [:svalue, [:splat, [:vcall, :b]]]],
4127
2757
  "ParseTree" => s(:lasgn, :a,
4128
2758
  s(:svalue,
4129
2759
  s(:splat, s(:call, nil, :b, s(:arglist))))))
4130
2760
 
4131
2761
  add_tests("to_ary",
4132
2762
  "Ruby" => "a, b = c",
4133
- "RawParseTree" => [:masgn,
4134
- [:array, [:lasgn, :a], [:lasgn, :b]], nil,
4135
- [:to_ary, [:vcall, :c]]],
4136
2763
  "ParseTree" => s(:masgn,
4137
2764
  s(:array, s(:lasgn, :a), s(:lasgn, :b)),
4138
2765
  s(:to_ary, s(:call, nil, :c, s(:arglist)))))
4139
2766
 
4140
2767
  add_tests("true",
4141
2768
  "Ruby" => "true",
4142
- "RawParseTree" => [:true],
4143
2769
  "ParseTree" => s(:true))
4144
2770
 
4145
2771
  add_tests("undef",
4146
2772
  "Ruby" => "undef :x",
4147
- "RawParseTree" => [:undef, [:lit, :x]],
4148
2773
  "ParseTree" => s(:undef, s(:lit, :x)))
4149
2774
 
4150
2775
  add_tests("undef_2",
4151
2776
  "Ruby" => "undef :x, :y",
4152
- "RawParseTree" => [:block,
4153
- [:undef, [:lit, :x]],
4154
- [:undef, [:lit, :y]]],
4155
2777
  "ParseTree" => s(:block,
4156
2778
  s(:undef, s(:lit, :x)),
4157
2779
  s(:undef, s(:lit, :y))),
@@ -4159,10 +2781,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4159
2781
 
4160
2782
  add_tests("undef_3",
4161
2783
  "Ruby" => "undef :x, :y, :z",
4162
- "RawParseTree" => [:block,
4163
- [:undef, [:lit, :x]],
4164
- [:undef, [:lit, :y]],
4165
- [:undef, [:lit, :z]]],
4166
2784
  "ParseTree" => s(:block,
4167
2785
  s(:undef, s(:lit, :x)),
4168
2786
  s(:undef, s(:lit, :y)),
@@ -4171,21 +2789,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4171
2789
 
4172
2790
  add_tests("undef_block_1",
4173
2791
  "Ruby" => "f1\nundef :x\n", # TODO: don't like the extra return
4174
- "RawParseTree" => [:block,
4175
- [:vcall, :f1],
4176
- [:undef, [:lit, :x]]],
4177
2792
  "ParseTree" => s(:block,
4178
2793
  s(:call, nil, :f1, s(:arglist)),
4179
2794
  s(:undef, s(:lit, :x))))
4180
2795
 
4181
2796
  add_tests("undef_block_2",
4182
2797
  "Ruby" => "f1\nundef :x, :y",
4183
- "RawParseTree" => [:block,
4184
- [:vcall, :f1],
4185
- [:block,
4186
- [:undef, [:lit, :x]],
4187
- [:undef, [:lit, :y]],
4188
- ]],
4189
2798
  "ParseTree" => s(:block,
4190
2799
  s(:call, nil, :f1, s(:arglist)),
4191
2800
  s(:block,
@@ -4195,13 +2804,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4195
2804
 
4196
2805
  add_tests("undef_block_3",
4197
2806
  "Ruby" => "f1\nundef :x, :y, :z",
4198
- "RawParseTree" => [:block,
4199
- [:vcall, :f1],
4200
- [:block,
4201
- [:undef, [:lit, :x]],
4202
- [:undef, [:lit, :y]],
4203
- [:undef, [:lit, :z]],
4204
- ]],
4205
2807
  "ParseTree" => s(:block,
4206
2808
  s(:call, nil, :f1, s(:arglist)),
4207
2809
  s(:block,
@@ -4212,11 +2814,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4212
2814
 
4213
2815
  add_tests("undef_block_3_post",
4214
2816
  "Ruby" => "undef :x, :y, :z\nf2",
4215
- "RawParseTree" => [:block,
4216
- [:undef, [:lit, :x]],
4217
- [:undef, [:lit, :y]],
4218
- [:undef, [:lit, :z]],
4219
- [:vcall, :f2]],
4220
2817
  "ParseTree" => s(:block,
4221
2818
  s(:undef, s(:lit, :x)),
4222
2819
  s(:undef, s(:lit, :y)),
@@ -4226,13 +2823,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4226
2823
 
4227
2824
  add_tests("undef_block_wtf",
4228
2825
  "Ruby" => "f1\nundef :x, :y, :z\nf2",
4229
- "RawParseTree" => [:block,
4230
- [:vcall, :f1],
4231
- [:block,
4232
- [:undef, [:lit, :x]],
4233
- [:undef, [:lit, :y]],
4234
- [:undef, [:lit, :z]]],
4235
- [:vcall, :f2]],
4236
2826
  "ParseTree" => s(:block,
4237
2827
  s(:call, nil, :f1, s(:arglist)),
4238
2828
  s(:block,
@@ -4245,45 +2835,35 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4245
2835
 
4246
2836
  add_tests("unless_post",
4247
2837
  "Ruby" => "a unless b",
4248
- "RawParseTree" => [:if, [:vcall, :b], nil, [:vcall, :a]],
4249
2838
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
4250
2839
  s(:call, nil, :a, s(:arglist))))
4251
2840
 
4252
2841
  add_tests("unless_post_not",
4253
2842
  "Ruby" => "a unless not b",
4254
- "RawParseTree" => [:if, [:vcall, :b], [:vcall, :a], nil],
4255
2843
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
4256
2844
  s(:call, nil, :a, s(:arglist)), nil),
4257
2845
  "Ruby2Ruby" => "a if b")
4258
2846
 
4259
2847
  add_tests("unless_pre",
4260
2848
  "Ruby" => "unless b then a end",
4261
- "RawParseTree" => [:if, [:vcall, :b], nil, [:vcall, :a]],
4262
2849
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)), nil,
4263
2850
  s(:call, nil, :a, s(:arglist))),
4264
2851
  "Ruby2Ruby" => "a unless b")
4265
2852
 
4266
2853
  add_tests("unless_pre_not",
4267
2854
  "Ruby" => "unless not b then a end",
4268
- "RawParseTree" => [:if, [:vcall, :b], [:vcall, :a], nil],
4269
2855
  "ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
4270
2856
  s(:call, nil, :a, s(:arglist)), nil),
4271
2857
  "Ruby2Ruby" => "a if b")
4272
2858
 
4273
2859
  add_tests("until_post",
4274
2860
  "Ruby" => "begin\n (1 + 1)\nend until false",
4275
- "RawParseTree" => [:until, [:false],
4276
- [:call, [:lit, 1], :+,
4277
- [:array, [:lit, 1]]], false],
4278
2861
  "ParseTree" => s(:until, s(:false),
4279
2862
  s(:call, s(:lit, 1), :+,
4280
2863
  s(:arglist, s(:lit, 1))), false))
4281
2864
 
4282
2865
  add_tests("until_post_not",
4283
2866
  "Ruby" => "begin\n (1 + 1)\nend until not true",
4284
- "RawParseTree" => [:while, [:true],
4285
- [:call, [:lit, 1], :+,
4286
- [:array, [:lit, 1]]], false],
4287
2867
  "ParseTree" => s(:while, s(:true),
4288
2868
  s(:call, s(:lit, 1), :+,
4289
2869
  s(:arglist, s(:lit, 1))), false),
@@ -4291,18 +2871,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4291
2871
 
4292
2872
  add_tests("until_pre",
4293
2873
  "Ruby" => "until false do\n (1 + 1)\nend",
4294
- "RawParseTree" => [:until, [:false],
4295
- [:call, [:lit, 1], :+,
4296
- [:array, [:lit, 1]]], true],
4297
2874
  "ParseTree" => s(:until, s(:false),
4298
2875
  s(:call, s(:lit, 1), :+,
4299
2876
  s(:arglist, s(:lit, 1))), true))
4300
2877
 
4301
2878
  add_tests("until_pre_mod",
4302
2879
  "Ruby" => "(1 + 1) until false",
4303
- "RawParseTree" => [:until, [:false],
4304
- [:call, [:lit, 1], :+,
4305
- [:array, [:lit, 1]]], true],
4306
2880
  "ParseTree" => s(:until, s(:false),
4307
2881
  s(:call, s(:lit, 1), :+,
4308
2882
  s(:arglist, s(:lit, 1))), true),
@@ -4310,9 +2884,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4310
2884
 
4311
2885
  add_tests("until_pre_not",
4312
2886
  "Ruby" => "until not true do\n (1 + 1)\nend",
4313
- "RawParseTree" => [:while, [:true],
4314
- [:call, [:lit, 1], :+,
4315
- [:array, [:lit, 1]]], true],
4316
2887
  "ParseTree" => s(:while, s(:true),
4317
2888
  s(:call, s(:lit, 1), :+,
4318
2889
  s(:arglist, s(:lit, 1))), true),
@@ -4320,9 +2891,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4320
2891
 
4321
2892
  add_tests("until_pre_not_mod",
4322
2893
  "Ruby" => "(1 + 1) until not true",
4323
- "RawParseTree" => [:while, [:true],
4324
- [:call, [:lit, 1], :+,
4325
- [:array, [:lit, 1]]], true],
4326
2894
  "ParseTree" => s(:while, s(:true),
4327
2895
  s(:call, s(:lit, 1), :+,
4328
2896
  s(:arglist, s(:lit, 1))), true),
@@ -4330,30 +2898,20 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4330
2898
 
4331
2899
  add_tests("valias",
4332
2900
  "Ruby" => "alias $y $x",
4333
- "RawParseTree" => [:valias, :$y, :$x],
4334
2901
  "ParseTree" => s(:valias, :$y, :$x))
4335
2902
 
4336
2903
  add_tests("vcall",
4337
2904
  "Ruby" => "method",
4338
- "RawParseTree" => [:vcall, :method],
4339
2905
  "ParseTree" => s(:call, nil, :method, s(:arglist)))
4340
2906
 
4341
2907
  add_tests("while_post",
4342
2908
  "Ruby" => "begin\n (1 + 1)\nend while false",
4343
- "RawParseTree" => [:while, [:false],
4344
- [:call, [:lit, 1], :+,
4345
- [:array, [:lit, 1]]], false],
4346
2909
  "ParseTree" => s(:while, s(:false),
4347
2910
  s(:call, s(:lit, 1), :+,
4348
2911
  s(:arglist, s(:lit, 1))), false))
4349
2912
 
4350
2913
  add_tests("while_post2",
4351
2914
  "Ruby" => "begin\n (1 + 2)\n (3 + 4)\nend while false",
4352
- "RawParseTree" => [:while, [:false],
4353
- [:block,
4354
- [:call, [:lit, 1], :+, [:array, [:lit, 2]]],
4355
- [:call, [:lit, 3], :+, [:array, [:lit, 4]]]],
4356
- false],
4357
2915
  "ParseTree" => s(:while, s(:false),
4358
2916
  s(:block,
4359
2917
  s(:call, s(:lit, 1), :+,
@@ -4364,9 +2922,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4364
2922
 
4365
2923
  add_tests("while_post_not",
4366
2924
  "Ruby" => "begin\n (1 + 1)\nend while not true",
4367
- "RawParseTree" => [:until, [:true],
4368
- [:call, [:lit, 1], :+,
4369
- [:array, [:lit, 1]]], false],
4370
2925
  "ParseTree" => s(:until, s(:true),
4371
2926
  s(:call, s(:lit, 1), :+,
4372
2927
  s(:arglist, s(:lit, 1))), false),
@@ -4374,18 +2929,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4374
2929
 
4375
2930
  add_tests("while_pre",
4376
2931
  "Ruby" => "while false do\n (1 + 1)\nend",
4377
- "RawParseTree" => [:while, [:false],
4378
- [:call, [:lit, 1], :+,
4379
- [:array, [:lit, 1]]], true],
4380
2932
  "ParseTree" => s(:while, s(:false),
4381
2933
  s(:call, s(:lit, 1), :+,
4382
2934
  s(:arglist, s(:lit, 1))), true))
4383
2935
 
4384
2936
  add_tests("while_pre_mod",
4385
2937
  "Ruby" => "(1 + 1) while false",
4386
- "RawParseTree" => [:while, [:false],
4387
- [:call, [:lit, 1], :+,
4388
- [:array, [:lit, 1]]], true],
4389
2938
  "ParseTree" => s(:while, s(:false),
4390
2939
  s(:call, s(:lit, 1), :+,
4391
2940
  s(:arglist, s(:lit, 1))), true),
@@ -4393,14 +2942,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4393
2942
 
4394
2943
  add_tests("while_pre_nil",
4395
2944
  "Ruby" => "while false do\nend",
4396
- "RawParseTree" => [:while, [:false], nil, true],
4397
2945
  "ParseTree" => s(:while, s(:false), nil, true))
4398
2946
 
4399
2947
  add_tests("while_pre_not",
4400
2948
  "Ruby" => "while not true do\n (1 + 1)\nend",
4401
- "RawParseTree" => [:until, [:true],
4402
- [:call, [:lit, 1], :+,
4403
- [:array, [:lit, 1]]], true],
4404
2949
  "ParseTree" => s(:until, s(:true),
4405
2950
  s(:call, s(:lit, 1), :+,
4406
2951
  s(:arglist, s(:lit, 1))), true),
@@ -4408,9 +2953,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4408
2953
 
4409
2954
  add_tests("while_pre_not_mod",
4410
2955
  "Ruby" => "(1 + 1) while not true",
4411
- "RawParseTree" => [:until, [:true],
4412
- [:call, [:lit, 1], :+,
4413
- [:array, [:lit, 1]]], true],
4414
2956
  "ParseTree" => s(:until, s(:true),
4415
2957
  s(:call, s(:lit, 1), :+,
4416
2958
  s(:arglist, s(:lit, 1))), true),
@@ -4418,48 +2960,38 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4418
2960
 
4419
2961
  add_tests("xstr",
4420
2962
  "Ruby" => "`touch 5`",
4421
- "RawParseTree" => [:xstr, 'touch 5'],
4422
2963
  "ParseTree" => s(:xstr, 'touch 5'))
4423
2964
 
4424
2965
  add_tests("yield_0",
4425
2966
  "Ruby" => "yield",
4426
- "RawParseTree" => [:yield],
4427
2967
  "ParseTree" => s(:yield))
4428
2968
 
4429
2969
  add_tests("yield_1",
4430
2970
  "Ruby" => "yield(42)",
4431
- "RawParseTree" => [:yield, [:lit, 42]],
4432
2971
  "ParseTree" => s(:yield, s(:lit, 42)))
4433
2972
 
4434
2973
  add_tests("yield_array_0",
4435
2974
  "Ruby" => "yield([])",
4436
- "RawParseTree" => [:yield, [:zarray], true],
4437
2975
  "ParseTree" => s(:yield, s(:array)))
4438
2976
 
4439
2977
  add_tests("yield_array_1",
4440
2978
  "Ruby" => "yield([42])",
4441
- "RawParseTree" => [:yield, [:array, [:lit, 42]], true],
4442
2979
  "ParseTree" => s(:yield, s(:array, s(:lit, 42))))
4443
2980
 
4444
2981
  add_tests("yield_array_n",
4445
2982
  "Ruby" => "yield([42, 24])",
4446
- "RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]], true],
4447
2983
  "ParseTree" => s(:yield, s(:array, s(:lit, 42), s(:lit, 24))))
4448
2984
 
4449
2985
  add_tests("yield_n",
4450
2986
  "Ruby" => "yield(42, 24)",
4451
- "RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]]],
4452
2987
  "ParseTree" => s(:yield, s(:lit, 42), s(:lit, 24)))
4453
2988
 
4454
2989
  add_tests("zarray",
4455
2990
  "Ruby" => "a = []",
4456
- "RawParseTree" => [:lasgn, :a, [:zarray]],
4457
2991
  "ParseTree" => s(:lasgn, :a, s(:array)))
4458
2992
 
4459
2993
  add_tests("zsuper",
4460
2994
  "Ruby" => "def x\n super\nend",
4461
- "RawParseTree" => [:defn, :x,
4462
- [:scope, [:block, [:args], [:zsuper]]]],
4463
2995
  "ParseTree" => s(:defn, :x, s(:args),
4464
2996
  s(:scope, s(:block, s(:zsuper)))))
4465
2997
 
@@ -4468,14 +3000,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4468
3000
  "ParseTree" => s(:if,
4469
3001
  s(:call, nil, :y, s(:arglist, s(:lit, :z))),
4470
3002
  s(:call, nil, :x, s(:arglist)),
4471
- nil))
3003
+ nil),
3004
+ "Ruby2Ruby" => "x if y(:z)")
4472
3005
 
4473
3006
  add_18tests("iter_args_ivar",
4474
3007
  "Ruby" => "a { |@a| 42 }",
4475
- "RawParseTree" => [:iter,
4476
- [:fcall, :a],
4477
- [:iasgn, :@a],
4478
- [:lit, 42]],
4479
3008
  "ParseTree" => s(:iter,
4480
3009
  s(:call, nil, :a, s(:arglist)),
4481
3010
  s(:iasgn, :@a),
@@ -4483,12 +3012,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4483
3012
 
4484
3013
  add_18tests("iter_masgn_args_ivar",
4485
3014
  "Ruby" => "a { |a, @b| 42 }",
4486
- "RawParseTree" => [:iter,
4487
- [:fcall, :a],
4488
- [:masgn,
4489
- [:array, [:dasgn_curr, :a], [:iasgn, :@b]],
4490
- nil, nil],
4491
- [:lit, 42]],
4492
3015
  "ParseTree" => s(:iter,
4493
3016
  s(:call, nil, :a, s(:arglist)),
4494
3017
  s(:masgn,
@@ -4497,19 +3020,16 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4497
3020
 
4498
3021
  add_18tests("str_question_control",
4499
3022
  "Ruby" => '?\M-\C-a',
4500
- "RawParseTree" => [:lit, 129],
4501
3023
  "ParseTree" => s(:lit, 129),
4502
3024
  "Ruby2Ruby" => "129")
4503
3025
 
4504
3026
  add_18tests("str_question_escape",
4505
3027
  "Ruby" => '?\n',
4506
- "RawParseTree" => [:lit, 10],
4507
3028
  "ParseTree" => s(:lit, 10),
4508
3029
  "Ruby2Ruby" => "10")
4509
3030
 
4510
3031
  add_18tests("str_question_literal",
4511
3032
  "Ruby" => '?a',
4512
- "RawParseTree" => [:lit, 97],
4513
3033
  "ParseTree" => s(:lit, 97),
4514
3034
  "Ruby2Ruby" => "97")
4515
3035
 
@@ -4531,13 +3051,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4531
3051
 
4532
3052
  add_19tests("call_arglist_norm_hash_colons",
4533
3053
  "Ruby" => "o.m(42, a: 1, b: 2)",
4534
- "RawParseTree" => [:call,
4535
- [:vcall, :o], :m,
4536
- [:array,
4537
- [:lit, 42],
4538
- [:hash,
4539
- [:lit, :a], [:lit, 1],
4540
- [:lit, :b], [:lit, 2]]]],
4541
3054
  "ParseTree" => s(:call,
4542
3055
  s(:call, nil, :o, s(:arglist)),
4543
3056
  :m,
@@ -4555,8 +3068,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4555
3068
 
4556
3069
  add_19tests("call_not_equal",
4557
3070
  "Ruby" => "a != b",
4558
- "RawParseTree" => [:call, [:vcall, :a], :"!=",
4559
- [:array, [:vcall, :b]]],
4560
3071
  "ParseTree" => s(:call,
4561
3072
  s(:call, nil, :a, s(:arglist)),
4562
3073
  :"!=",
@@ -4564,7 +3075,6 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4564
3075
 
4565
3076
  add_19tests("call_unary_not",
4566
3077
  "Ruby" => "!a",
4567
- "RawParseTree" => [:call, [:vcall, :a], :"!@"],
4568
3078
  "ParseTree" => s(:call,
4569
3079
  s(:call, nil, :a, s(:arglist)),
4570
3080
  :"!@", s(:arglist)))
@@ -4609,22 +3119,12 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4609
3119
 
4610
3120
  add_19tests("defn_args_splat_middle",
4611
3121
  "Ruby" => "def f(first, *middle, last)\n # do nothing\nend",
4612
- "RawParseTree" => [:defn, :f,
4613
- [:scope,
4614
- [:block,
4615
- [:args, :first, :"*middle", :last],
4616
- [:nil]]]],
4617
3122
  "ParseTree" => s(:defn, :f,
4618
3123
  s(:args, :first, :"*middle", :last),
4619
3124
  s(:scope, s(:block, s(:nil)))))
4620
3125
 
4621
3126
  add_19tests("fcall_arglist_hash_colons",
4622
3127
  "Ruby" => "m(a: 1, b: 2)",
4623
- "RawParseTree" => [:fcall, :m,
4624
- [:array,
4625
- [:hash,
4626
- [:lit, :a], [:lit, 1],
4627
- [:lit, :b], [:lit, 2]]]],
4628
3128
  "ParseTree" => s(:call, nil, :m,
4629
3129
  s(:arglist,
4630
3130
  s(:hash,
@@ -4633,196 +3133,172 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4633
3133
 
4634
3134
  add_19tests("hash_new",
4635
3135
  "Ruby" => "{ a: 1, b: 2 }",
4636
- "RawParseTree" => [:hash,
4637
- [:lit, :a], [:lit, 1],
4638
- [:lit, :b], [:lit, 2]],
4639
3136
  "ParseTree" => s(:hash,
4640
3137
  s(:lit, :a), s(:lit, 1),
4641
3138
  s(:lit, :b), s(:lit, 2)))
4642
3139
 
4643
3140
  add_19tests("hash_new_no_space",
4644
3141
  "Ruby" => "{a:1,b:2}",
4645
- "RawParseTree" => [:hash,
4646
- [:lit, :a], [:lit, 1],
4647
- [:lit, :b], [:lit, 2]],
4648
3142
  "ParseTree" => s(:hash,
4649
3143
  s(:lit, :a), s(:lit, 1),
4650
3144
  s(:lit, :b), s(:lit, 2)))
4651
3145
 
4652
- add_19tests("lambda_args_block",
4653
- "Ruby" => "lambda { |&block| block }",
4654
- "ParseTree" => s(:iter,
4655
- s(:call, nil, :lambda, s(:arglist)),
4656
- s(:lasgn, :"&block"),
4657
- s(:lvar, :block)))
4658
-
4659
- add_19tests("lambda_args_0",
4660
- "Ruby" => "->(){ (x + 1) }",
4661
- "RawParseTree" => [:iter,
4662
- [:fcall, :lambda],
4663
- 0,
4664
- [:call, [:vcall, :x], :+,
4665
- [:array, [:lit, 1]]]],
4666
- "ParseTree" => s(:iter,
4667
- s(:call, nil, :lambda, s(:arglist)),
4668
- 0,
4669
- s(:call,
4670
- s(:call, nil, :x, s(:arglist)),
4671
- :+,
4672
- s(:arglist, s(:lit, 1)))))
4673
-
4674
- add_19tests("lambda_args_1",
4675
- "Ruby" => "-> (x) { (x + 1) }",
4676
- "RawParseTree" => [:iter,
4677
- [:fcall, :lambda],
4678
- [:dasgn_curr, :x],
4679
- [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
4680
- "ParseTree" => s(:iter,
4681
- s(:call, nil, :lambda, s(:arglist)),
4682
- s(:lasgn, :x),
4683
- s(:call, s(:lvar, :x), :+,
4684
- s(:arglist, s(:lit, 1)))))
4685
-
4686
- add_19tests("lambda_args_2",
4687
- "Ruby" => "-> (x, y) { (x + y) }",
4688
- "RawParseTree" => [:iter,
4689
- [:fcall, :lambda],
4690
- [:masgn, [:array,
4691
- [:dasgn_curr, :x],
4692
- [:dasgn_curr, :y]], nil, nil],
4693
- [:call, [:dvar, :x], :+,
4694
- [:array, [:dvar, :y]]]],
4695
- "ParseTree" => s(:iter,
4696
- s(:call, nil, :lambda, s(:arglist)),
4697
- s(:masgn,
4698
- s(:array,
4699
- s(:lasgn, :x),
4700
- s(:lasgn, :y))),
4701
- s(:call, s(:lvar, :x), :+,
4702
- s(:arglist, s(:lvar, :y)))))
4703
-
4704
- add_19tests("lambda_args_2_no_parens",
4705
- "Ruby" => "-> x, y { (x + y) }",
4706
- "RawParseTree" => [:iter,
4707
- [:fcall, :lambda],
4708
- [:masgn, [:array,
4709
- [:dasgn_curr, :x],
4710
- [:dasgn_curr, :y]], nil, nil],
4711
- [:call, [:dvar, :x], :+,
4712
- [:array, [:dvar, :y]]]],
4713
- "ParseTree" => s(:iter,
4714
- s(:call, nil, :lambda, s(:arglist)),
4715
- s(:masgn,
4716
- s(:array,
4717
- s(:lasgn, :x),
4718
- s(:lasgn, :y))),
4719
- s(:call, s(:lvar, :x), :+,
4720
- s(:arglist, s(:lvar, :y)))))
4721
-
4722
- add_19tests("lambda_args_no",
4723
- "Ruby" => "-> { (x + 1) }",
4724
- "RawParseTree" => [:iter,
4725
- [:fcall, :lambda],
4726
- nil,
4727
- [:call, [:vcall, :x], :+,
4728
- [:array, [:lit, 1]]]],
4729
- "ParseTree" => s(:iter,
4730
- s(:call, nil, :lambda, s(:arglist)),
4731
- nil,
4732
- s(:call, s(:call, nil, :x, s(:arglist)),
4733
- :+, s(:arglist, s(:lit, 1)))))
4734
-
4735
- add_19tests("lambda_args_no_do",
4736
- "Ruby" => "-> do (x + 1) end",
4737
- "RawParseTree" => [:iter,
4738
- [:fcall, :lambda],
4739
- nil,
4740
- [:call, [:vcall, :x], :+,
4741
- [:array, [:lit, 1]]]],
4742
- "ParseTree" => s(:iter,
4743
- s(:call, nil, :lambda, s(:arglist)),
4744
- nil,
4745
- s(:call, s(:call, nil, :x, s(:arglist)),
4746
- :+, s(:arglist, s(:lit, 1)))))
4747
-
4748
- add_19tests("lambda_args_0_do",
4749
- "Ruby" => "->() do (x + 1) end",
4750
- "RawParseTree" => [:iter,
4751
- [:fcall, :lambda],
4752
- 0,
4753
- [:call, [:vcall, :x], :+,
4754
- [:array, [:lit, 1]]]],
4755
- "ParseTree" => s(:iter,
4756
- s(:call, nil, :lambda, s(:arglist)),
4757
- 0,
4758
- s(:call,
4759
- s(:call, nil, :x, s(:arglist)),
4760
- :+,
4761
- s(:arglist, s(:lit, 1)))))
4762
-
4763
- add_19tests("lambda_args_1_do",
4764
- "Ruby" => "-> (x) do (x + 1) end",
4765
- "RawParseTree" => [:iter,
4766
- [:fcall, :lambda],
4767
- [:dasgn_curr, :x],
4768
- [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
4769
- "ParseTree" => s(:iter,
4770
- s(:call, nil, :lambda, s(:arglist)),
4771
- s(:lasgn, :x),
4772
- s(:call, s(:lvar, :x), :+,
4773
- s(:arglist, s(:lit, 1)))))
4774
-
4775
- add_19tests("lambda_args_2_do",
4776
- "Ruby" => "-> (x, y) do (x + y) end",
4777
- "RawParseTree" => [:iter,
4778
- [:fcall, :lambda],
4779
- [:masgn, [:array,
4780
- [:dasgn_curr, :x],
4781
- [:dasgn_curr, :y]], nil, nil],
4782
- [:call, [:dvar, :x], :+,
4783
- [:array, [:dvar, :y]]]],
4784
- "ParseTree" => s(:iter,
4785
- s(:call, nil, :lambda, s(:arglist)),
4786
- s(:masgn,
4787
- s(:array,
4788
- s(:lasgn, :x),
4789
- s(:lasgn, :y))),
4790
- s(:call, s(:lvar, :x), :+,
4791
- s(:arglist, s(:lvar, :y)))))
4792
-
4793
- add_19tests("lambda_args_2_no_parens_do",
4794
- "Ruby" => "-> x, y do (x + y) end",
4795
- "RawParseTree" => [:iter,
4796
- [:fcall, :lambda],
4797
- [:masgn, [:array,
4798
- [:dasgn_curr, :x],
4799
- [:dasgn_curr, :y]], nil, nil],
4800
- [:call, [:dvar, :x], :+,
4801
- [:array, [:dvar, :y]]]],
4802
- "ParseTree" => s(:iter,
4803
- s(:call, nil, :lambda, s(:arglist)),
4804
- s(:masgn,
4805
- s(:array,
4806
- s(:lasgn, :x),
4807
- s(:lasgn, :y))),
4808
- s(:call, s(:lvar, :x), :+,
4809
- s(:arglist, s(:lvar, :y)))))
3146
+ add_tests("lambda_args_anon_star",
3147
+ "Ruby" => "lambda { |*| nil }",
3148
+ "ParseTree" => s(:iter,
3149
+ s(:call, nil, :lambda, s(:arglist)),
3150
+ s(:masgn, s(:array, s(:splat))),
3151
+ s(:nil)))
3152
+
3153
+ add_tests("lambda_args_anon_star_block",
3154
+ "Ruby" => "lambda { |*, &block| block }",
3155
+ "ParseTree" => s(:iter,
3156
+ s(:call, nil, :lambda, s(:arglist)),
3157
+ s(:masgn, s(:array,
3158
+ s(:splat),
3159
+ s(:lasgn, :"&block"))),
3160
+ s(:lvar, :block)))
3161
+
3162
+ add_tests("lambda_args_block",
3163
+ "Ruby" => "lambda { |&block| block }",
3164
+ "ParseTree" => s(:iter,
3165
+ s(:call, nil, :lambda, s(:arglist)),
3166
+ s(:lasgn, :"&block"),
3167
+ s(:lvar, :block)))
3168
+
3169
+ add_tests("lambda_args_norm_anon_star",
3170
+ "Ruby" => "lambda { |a, *| a }",
3171
+ "ParseTree" => s(:iter,
3172
+ s(:call, nil, :lambda, s(:arglist)),
3173
+ s(:masgn, s(:array,
3174
+ s(:lasgn, :a),
3175
+ s(:splat))),
3176
+ s(:lvar, :a)))
3177
+
3178
+ add_tests("lambda_args_norm_anon_star_block",
3179
+ "Ruby" => "lambda { |a, *, &block| block }",
3180
+ "ParseTree" => s(:iter,
3181
+ s(:call, nil, :lambda, s(:arglist)),
3182
+ s(:masgn, s(:array,
3183
+ s(:lasgn, :a),
3184
+ s(:splat),
3185
+ s(:lasgn, :"&block"))),
3186
+ s(:lvar, :block)))
3187
+
3188
+ add_tests("lambda_args_norm_block",
3189
+ "Ruby" => "lambda { |a, &block| block }",
3190
+ "ParseTree" => s(:iter,
3191
+ s(:call, nil, :lambda, s(:arglist)),
3192
+ s(:masgn, s(:array,
3193
+ s(:lasgn, :a),
3194
+ s(:lasgn, :"&block"))),
3195
+ s(:lvar, :block)))
3196
+
3197
+ add_tests("lambda_args_norm_comma",
3198
+ "Ruby" => "lambda { |a,| a }",
3199
+ "ParseTree" => s(:iter,
3200
+ s(:call, nil, :lambda, s(:arglist)),
3201
+ s(:lasgn, :a),
3202
+ s(:lvar, :a)),
3203
+ "Ruby2Ruby" => "lambda { |a| a }")
3204
+
3205
+ add_tests("lambda_args_norm_comma2",
3206
+ "Ruby" => "lambda { |a,b,| a }",
3207
+ "ParseTree" => s(:iter,
3208
+ s(:call, nil, :lambda, s(:arglist)),
3209
+ s(:masgn,
3210
+ s(:array, s(:lasgn, :a), s(:lasgn, :b))),
3211
+ s(:lvar, :a)),
3212
+ "Ruby2Ruby" => "lambda { |a, b| a }")
3213
+
3214
+ add_tests("lambda_args_norm_star",
3215
+ "Ruby" => "lambda { |a, *star| star }",
3216
+ "ParseTree" => s(:iter,
3217
+ s(:call, nil, :lambda, s(:arglist)),
3218
+ s(:masgn, s(:array,
3219
+ s(:lasgn, :a),
3220
+ s(:splat, s(:lasgn, :star)))),
3221
+ s(:lvar, :star)))
3222
+
3223
+ add_tests("lambda_args_norm_star_block",
3224
+ "Ruby" => "lambda { |a, *star, &block| block }",
3225
+ "ParseTree" => s(:iter,
3226
+ s(:call, nil, :lambda, s(:arglist)),
3227
+ s(:masgn, s(:array,
3228
+ s(:lasgn, :a),
3229
+ s(:splat, s(:lasgn, :star)),
3230
+ s(:lasgn, :"&block"))),
3231
+ s(:lvar, :block)))
3232
+
3233
+ add_tests("lambda_args_star",
3234
+ "Ruby" => "lambda { |*star| star }",
3235
+ "ParseTree" => s(:iter,
3236
+ s(:call, nil, :lambda, s(:arglist)),
3237
+ s(:masgn, s(:array,
3238
+ s(:splat, s(:lasgn, :star)))),
3239
+ s(:lvar, :star)))
3240
+
3241
+ add_tests("lambda_args_star_block",
3242
+ "Ruby" => "lambda { |*star, &block| block }",
3243
+ "ParseTree" => s(:iter,
3244
+ s(:call, nil, :lambda, s(:arglist)),
3245
+ s(:masgn, s(:array,
3246
+ s(:splat, s(:lasgn, :star)),
3247
+ s(:lasgn, :"&block"))),
3248
+ s(:lvar, :block)))
3249
+
3250
+ # REFACTOR: we've got 4 sets of edge cases w/ the same output
3251
+
3252
+ def self.add19_edgecases ruby, sexp, cases
3253
+ cases.each do |name, code|
3254
+ add_19tests name, "Ruby" => code, "ParseTree" => sexp, "Ruby2Ruby" => ruby
3255
+ end
3256
+ end
3257
+
3258
+ add19_edgecases("lambda { (x + 1) }",
3259
+ s(:iter,
3260
+ s(:call, nil, :lambda, s(:arglist)),
3261
+ 0,
3262
+ s(:call, s(:call, nil, :x, s(:arglist)),
3263
+ :+, s(:arglist, s(:lit, 1)))),
3264
+ "stabby_args_0" => "->() { (x + 1) }",
3265
+ "stabby_args_0_doend" => "->() do (x + 1) end",
3266
+ "stabby_args_0_no_parens" => "-> { (x + 1) }",
3267
+ "stabby_args_0_no_parens_doend" => "-> do (x + 1) end",
3268
+ "stabby_args_0_spacebar_broken" => "->{x+1}") # I hate you
3269
+
3270
+ add19_edgecases("lambda { |x| (x + 1) }",
3271
+ s(:iter,
3272
+ s(:call, nil, :lambda, s(:arglist)),
3273
+ s(:lasgn, :x),
3274
+ s(:call, s(:lvar, :x), :+, s(:arglist, s(:lit, 1)))),
3275
+ "stabby_args_1" => "->(x) { (x + 1) }",
3276
+ "stabby_args_1_doend" => "->(x) do (x + 1) end",
3277
+ "stabby_args_1_no_parens" => "-> x { (x + 1) }",
3278
+ "stabby_args_1_no_parens_doend" => "-> x do (x + 1) end")
3279
+
3280
+ add19_edgecases("lambda { |x, y| (x + y) }",
3281
+ s(:iter,
3282
+ s(:call, nil, :lambda, s(:arglist)),
3283
+ s(:masgn,
3284
+ s(:array,
3285
+ s(:lasgn, :x),
3286
+ s(:lasgn, :y))),
3287
+ s(:call, s(:lvar, :x), :+,
3288
+ s(:arglist, s(:lvar, :y)))),
3289
+ "stabby_args_2" => "->(x, y) { (x + y) }",
3290
+ "stabby_args_2_doend" => "->(x, y) do (x + y) end",
3291
+ "stabby_args_2_no_parens" => "-> x, y { (x + y) }",
3292
+ "stabby_args_2_no_parens_doend" => "-> x, y do (x + y) end")
4810
3293
 
4811
3294
  add_19tests("hash_new_with_keyword",
4812
3295
  "Ruby" => "{ true: 1, b: 2 }",
4813
- "RawParseTree" => [:hash,
4814
- [:lit, :true], [:lit, 1],
4815
- [:lit, :b], [:lit, 2]],
4816
3296
  "ParseTree" => s(:hash,
4817
3297
  s(:lit, :true), s(:lit, 1),
4818
3298
  s(:lit, :b), s(:lit, 2)))
4819
3299
 
4820
3300
  add_19tests("splat_fcall_middle",
4821
3301
  "Ruby" => "meth(1, *[2], 3)",
4822
- "RawParseTree" => [:fcall, :meth,
4823
- [:lit, 1],
4824
- [:splat, [:array, [:lit, 2]]],
4825
- [:lit, 3]],
4826
3302
  "ParseTree" => s(:call, nil, :meth,
4827
3303
  s(:arglist,
4828
3304
  s(:lit, 1),
@@ -4831,17 +3307,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
4831
3307
 
4832
3308
  add_19tests("str_question_control",
4833
3309
  "Ruby" => '?\M-\C-a',
4834
- "RawParseTree" => [:str, "\x81"],
4835
3310
  "ParseTree" => s(:str, "\x81"))
4836
3311
 
4837
3312
  add_19tests("str_question_escape",
4838
3313
  "Ruby" => '?\n',
4839
- "RawParseTree" => [:str, "\n"],
4840
3314
  "ParseTree" => s(:str, "\n"))
4841
3315
 
4842
3316
  add_19tests("str_question_literal",
4843
3317
  "Ruby" => '?a',
4844
- "RawParseTree" => [:str, "a"],
4845
3318
  "ParseTree" => s(:str, "a"))
4846
-
4847
3319
  end