ruby_parser 2.3.1 → 3.0.0.a1

data/test/test_ruby_parser.rb

@@ -3,6 +3,7 @@
 ENV['VERBOSE'] = "1"
 
 require 'rubygems'
+gem "minitest"
 require 'minitest/autorun'
 require 'ruby_parser'
 
@@ -10,13 +11,21 @@ $: << File.expand_path('~/Work/p4/zss/src/ParseTree/dev/test')
 
 require 'pt_testcase'
 
-class RubyParser
+class Ruby18Parser # FIX
+  def process input
+    parse input
+  end
+end
+
+class Ruby19Parser
   def process input
     parse input
   end
 end
 
 class RubyParserTestCase < ParseTreeTestCase
+  attr_accessor :result, :processor
+
   def self.previous key
     "Ruby"
   end
@@ -29,16 +38,6 @@ class RubyParserTestCase < ParseTreeTestCase
 
     super
   end
-end
-
-class TestRubyParser < RubyParserTestCase
-  attr_accessor :result, :processor
-
-  def setup
-    super
-
-    self.processor = RubyParser.new
-  end
 
   def assert_parse rb, pt
     self.result = processor.parse rb
@@ -49,17 +48,18 @@ class TestRubyParser < RubyParserTestCase
     assert_parse rb, pt
     assert_equal line, result.line,   "call should have line number"
   end
+end
 
+module TestRubyParser
   def test_attrasgn_array_lhs
     rb = '[1, 2, 3, 4][from .. to] = ["a", "b", "c"]'
     pt = s(:attrasgn,
            s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3), s(:lit, 4)),
            :[]=,
-           s(:arglist,
-             s(:dot2,
-               s(:call, nil, :from, s(:arglist)),
-               s(:call, nil, :to, s(:arglist))),
-             s(:array, s(:str, "a"), s(:str, "b"), s(:str, "c"))))
+           s(:dot2,
+             s(:call, nil, :from),
+             s(:call, nil, :to)),
+           s(:array, s(:str, "a"), s(:str, "b"), s(:str, "c")))
 
     assert_parse rb, pt
   end
@@ -100,18 +100,25 @@ class TestRubyParser < RubyParserTestCase
   end
 
   def test_block_append_tail_block
-    head = s(:call, nil, :f1, s(:arglist))
+    head = s(:call, nil, :f1)
     tail = s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y)))
     expected = s(:block,
-                 s(:call, nil, :f1, s(:arglist)),
+                 s(:call, nil, :f1),
                  s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y))))
     assert_equal expected, processor.block_append(head, tail)
   end
 
+  def test_call_array_arg
+    rb = "1 == [:b, :c]"
+    pt = s(:call, s(:lit, 1), :==, s(:array, s(:lit, :b), s(:lit, :c)))
+
+    assert_parse rb, pt
+  end
+
   def test_call_env
     processor.env[:a] = :lvar
     rb = "a.happy"
-    pt = s(:call, s(:lvar, :a), :happy, s(:arglist))
+    pt = s(:call, s(:lvar, :a), :happy)
 
     assert_parse rb, pt
   end
@@ -119,7 +126,7 @@ class TestRubyParser < RubyParserTestCase
   def test_dasgn_icky2
     rb = "a do\n  v = nil\n  begin\n    yield\n  rescue Exception => v\n    break\n  end\nend"
     pt = s(:iter,
-           s(:call, nil, :a, s(:arglist)),
+           s(:call, nil, :a),
            nil,
            s(:block,
              s(:lasgn, :v, s(:nil)),
@@ -135,29 +142,27 @@ class TestRubyParser < RubyParserTestCase
   def test_class_comments
     rb = "# blah 1\n# blah 2\n\nclass X\n  # blah 3\n  def blah\n    # blah 4\n  end\nend"
     pt = s(:class, :X, nil,
-           s(:scope,
-             s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
+           s(:defn, :blah, s(:args), s(:nil)))
 
     assert_parse rb, pt
 
     assert_equal "# blah 1\n# blah 2\n\n", result.comments
-    assert_equal "# blah 3\n", result.scope.defn.comments
+    assert_equal "# blah 3\n", result.defn.comments
   end
 
   def test_module_comments
     rb = "# blah 1\n  \n  # blah 2\n\nmodule X\n  # blah 3\n  def blah\n    # blah 4\n  end\nend"
     pt = s(:module, :X,
-           s(:scope,
-             s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
+           s(:defn, :blah, s(:args), s(:nil)))
 
     assert_parse rb, pt
     assert_equal "# blah 1\n\n# blah 2\n\n", result.comments
-    assert_equal "# blah 3\n", result.scope.defn.comments
+    assert_equal "# blah 3\n", result.defn.comments
   end
 
   def test_defn_comments
     rb = "# blah 1\n# blah 2\n\ndef blah\nend"
-    pt = s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))
+    pt = s(:defn, :blah, s(:args), s(:nil))
 
     assert_parse rb, pt
     assert_equal "# blah 1\n# blah 2\n\n", result.comments
@@ -165,7 +170,7 @@ class TestRubyParser < RubyParserTestCase
 
   def test_defs_comments
     rb = "# blah 1\n# blah 2\n\ndef self.blah\nend"
-    pt = s(:defs, s(:self), :blah, s(:args), s(:scope, s(:block)))
+    pt = s(:defs, s(:self), :blah, s(:args))
 
     assert_parse rb, pt
     assert_equal "# blah 1\n# blah 2\n\n", result.comments
@@ -174,9 +179,9 @@ class TestRubyParser < RubyParserTestCase
   def test_do_bug # TODO: rename
     rb = "a 1\na.b do |c|\n  # do nothing\nend"
     pt = s(:block,
-           s(:call, nil, :a, s(:arglist, s(:lit, 1))),
+           s(:call, nil, :a, s(:lit, 1)),
            s(:iter,
-             s(:call, s(:call, nil, :a, s(:arglist)), :b, s(:arglist)),
+             s(:call, s(:call, nil, :a), :b),
              s(:lasgn, :c)))
 
     assert_parse rb, pt
@@ -193,7 +198,7 @@ class TestRubyParser < RubyParserTestCase
 
   def test_bug_call_arglist_parens
     rb = 'g ( 1), 2'
-    pt = s(:call, nil, :g, s(:arglist, s(:lit, 1), s(:lit, 2)))
+    pt = s(:call, nil, :g, s(:lit, 1), s(:lit, 2))
 
     assert_parse rb, pt
 
@@ -204,11 +209,7 @@ class TestRubyParser < RubyParserTestCase
     CODE
 
     pt = s(:defn, :f, s(:args),
-           s(:scope,
-             s(:block,
-               s(:call, nil, :g,
-                 s(:arglist,
-                   s(:lit, 1), s(:lit, 2))))))
+           s(:call, nil, :g, s(:lit, 1), s(:lit, 2)))
 
     assert_parse rb, pt
 
@@ -223,7 +224,7 @@ class TestRubyParser < RubyParserTestCase
 
   def test_dstr_evstr
     rb = "\"#\{'a'}#\{b}\""
-    pt = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
+    pt = s(:dstr, "a", s(:evstr, s(:call, nil, :b)))
 
     assert_parse rb, pt
   end
@@ -244,14 +245,14 @@ class TestRubyParser < RubyParserTestCase
 
   def test_evstr_evstr
     rb = "\"#\{a}#\{b}\""
-    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:evstr, s(:call, nil, :b, s(:arglist))))
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a)), s(:evstr, s(:call, nil, :b)))
 
     assert_parse rb, pt
   end
 
   def test_evstr_str
     rb = "\"#\{a} b\""
-    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:str, " b"))
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a)), s(:str, " b"))
 
     assert_parse rb, pt
   end
@@ -308,16 +309,16 @@ class TestRubyParser < RubyParserTestCase
 
   def test_literal_concat_dstr_dstr
     lhs      = s(:dstr, "Failed to download spec ",
-                 s(:evstr, s(:call, nil, :spec_name, s(:arglist))),
+                 s(:evstr, s(:call, nil, :spec_name)),
                  s(:str, " from "),
-                 s(:evstr, s(:call, nil, :source_uri, s(:arglist))),
+                 s(:evstr, s(:call, nil, :source_uri)),
                  s(:str, ":\n"))
     rhs      = s(:dstr, "\t",
                  s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
     expected = s(:dstr, "Failed to download spec ",
-                 s(:evstr, s(:call, nil, :spec_name, s(:arglist))),
+                 s(:evstr, s(:call, nil, :spec_name)),
                  s(:str, " from "),
-                 s(:evstr, s(:call, nil, :source_uri, s(:arglist))),
+                 s(:evstr, s(:call, nil, :source_uri)),
                  s(:str, ":\n"),
                  s(:str, "\t"),
                  s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
@@ -326,8 +327,8 @@ class TestRubyParser < RubyParserTestCase
   end
 
   def test_literal_concat_dstr_evstr
-    lhs, rhs = s(:dstr, "a"), s(:evstr, s(:call, nil, :b, s(:arglist)))
-    expected = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
+    lhs, rhs = s(:dstr, "a"), s(:evstr, s(:call, nil, :b))
+    expected = s(:dstr, "a", s(:evstr, s(:call, nil, :b)))
 
     assert_equal expected, processor.literal_concat(lhs, rhs)
   end
@@ -392,11 +393,11 @@ class TestRubyParser < RubyParserTestCase
   end
 
   def test_logop_nested_mix
-    lhs = s(:or, s(:call, nil, :a, s(:arglist)), s(:call, nil, :b, s(:arglist)))
-    rhs = s(:and, s(:call, nil, :c, s(:arglist)), s(:call, nil, :d, s(:arglist)))
+    lhs = s(:or, s(:call, nil, :a), s(:call, nil, :b))
+    rhs = s(:and, s(:call, nil, :c), s(:call, nil, :d))
     exp = s(:or,
-            s(:or, s(:call, nil, :a, s(:arglist)), s(:call, nil, :b, s(:arglist))),
-            s(:and, s(:call, nil, :c, s(:arglist)), s(:call, nil, :d, s(:arglist))))
+            s(:or, s(:call, nil, :a), s(:call, nil, :b)),
+            s(:and, s(:call, nil, :c), s(:call, nil, :d)))
 
     lhs.paren = true
     rhs.paren = true
@@ -406,7 +407,7 @@ class TestRubyParser < RubyParserTestCase
 
   def test_str_evstr
     rb = "\"a #\{b}\""
-    pt = s(:dstr, "a ", s(:evstr, s(:call, nil, :b, s(:arglist))))
+    pt = s(:dstr, "a ", s(:evstr, s(:call, nil, :b)))
 
     assert_parse rb, pt
   end
@@ -439,7 +440,7 @@ class TestRubyParser < RubyParserTestCase
 
   def test_str_pct_Q_nested
     rb = "%Q[before [#\{nest}] after]"
-    pt = s(:dstr, "before [", s(:evstr, s(:call, nil, :nest, s(:arglist))), s(:str, "] after"))
+    pt = s(:dstr, "before [", s(:evstr, s(:call, nil, :nest)), s(:str, "] after"))
 
     assert_parse rb, pt
   end
@@ -493,7 +494,7 @@ class TestRubyParser < RubyParserTestCase
     rb = "a = 42\np a"
     pt = s(:block,
            s(:lasgn, :a, s(:lit, 42)),
-           s(:call, nil, :p, s(:arglist, s(:lvar, :a))))
+           s(:call, nil, :p, s(:lvar, :a)))
 
     assert_parse_line rb, pt, 1
     assert_equal 1, result.lasgn.line, "lasgn should have line number"
@@ -512,9 +513,9 @@ class TestRubyParser < RubyParserTestCase
     rb = "f do |x, y|\n  x + y\nend"
 
     pt = s(:iter,
-           s(:call, nil, :f, s(:arglist)),
+           s(:call, nil, :f),
            s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
-           s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))
+           s(:call, s(:lvar, :x), :+, s(:lvar, :y)))
 
     assert_parse_line rb, pt, 1
     assert_equal 1, result[1].line,   "call should have line number"
@@ -523,7 +524,7 @@ class TestRubyParser < RubyParserTestCase
   end
 
   def test_parse_line_defn_no_parens
-    pt = s(:defn, :f, s(:args), s(:scope, s(:block, s(:nil))))
+    pt = s(:defn, :f, s(:args), s(:nil))
 
     rb = "def f\nend"
     assert_parse_line rb, pt, 1
@@ -535,16 +536,13 @@ class TestRubyParser < RubyParserTestCase
   def test_parse_line_defn_complex
     rb = "def x(y)\n  p(y)\n  y *= 2\n  return y;\nend" # TODO: remove () & ;
     pt = s(:defn, :x, s(:args, :y),
-           s(:scope,
-             s(:block,
-               s(:call, nil, :p, s(:arglist, s(:lvar, :y))),
-               s(:lasgn, :y,
-                 s(:call, s(:lvar, :y), :*, s(:arglist, s(:lit, 2)))),
-               s(:return, s(:lvar, :y)))))
+           s(:call, nil, :p, s(:lvar, :y)),
+           s(:lasgn, :y, s(:call, s(:lvar, :y), :*, s(:lit, 2))),
+           s(:return, s(:lvar, :y)))
 
     assert_parse_line rb, pt, 1
 
-    body = result.scope.block
+    body = result
     assert_equal 2, body.call.line,   "call should have line number"
     assert_equal 3, body.lasgn.line,  "lasgn should have line number"
     assert_equal 4, body.return.line, "return should have line number"
@@ -554,9 +552,9 @@ class TestRubyParser < RubyParserTestCase
     rb = "f(a) do |x, y|\n  x + y\nend"
 
     pt = s(:iter,
-           s(:call, nil, :f, s(:arglist, s(:call, nil, :a, s(:arglist)))),
+           s(:call, nil, :f, s(:call, nil, :a)),
            s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
-           s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))
+           s(:call, s(:lvar, :x), :+, s(:lvar, :y)))
 
     assert_parse_line rb, pt, 1
 
@@ -569,9 +567,9 @@ class TestRubyParser < RubyParserTestCase
     rb = "f a do |x, y|\n  x + y\nend"
 
     pt = s(:iter,
-           s(:call, nil, :f, s(:arglist, s(:call, nil, :a, s(:arglist)))),
+           s(:call, nil, :f, s(:call, nil, :a)),
            s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
-           s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))
+           s(:call, s(:lvar, :x), :+, s(:lvar, :y)))
 
     assert_parse_line rb, pt, 1
 
@@ -610,23 +608,20 @@ class TestRubyParser < RubyParserTestCase
     RUBY
 
     pt = s(:defn, :blah, s(:args),
-           s(:scope,
-             s(:block,
-               s(:if,
-                 s(:true),
-                 s(:return, s(:lit, 42)),
-                 nil))))
+           s(:if, s(:true),
+             s(:return, s(:lit, 42)),
+             nil))
 
     assert_parse_line rb, pt, 1
 
-    assert_equal 3, result.scope.block.if.return.line
-    assert_equal 3, result.scope.block.if.return.lit.line
+    assert_equal 3, result.if.return.line
+    assert_equal 3, result.if.return.lit.line
   end
 
   def test_parse_if_not_canonical
     rb = "if not var.nil? then 'foo' else 'bar'\nend"
     pt = s(:if,
-           s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist)),
+           s(:call, s(:call, nil, :var), :nil?),
            s(:str, "bar"),
            s(:str, "foo"))
 
@@ -637,7 +632,7 @@ class TestRubyParser < RubyParserTestCase
     rb = "if not var.nil? then 'foo' else 'bar'\nend"
     pt = s(:if,
            s(:not,
-             s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist))),
+             s(:call, s(:call, nil, :var), :nil?)),
            s(:str, "foo"),
            s(:str, "bar"))
 
@@ -649,7 +644,7 @@ class TestRubyParser < RubyParserTestCase
   def test_parse_while_not_canonical
     rb = "while not var.nil?\n  'foo'\nend"
     pt = s(:until,
-           s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist)),
+           s(:call, s(:call, nil, :var), :nil?),
            s(:str, "foo"), true)
 
     assert_parse rb, pt
@@ -659,7 +654,7 @@ class TestRubyParser < RubyParserTestCase
     rb = "while not var.nil?\n  'foo'\nend"
     pt = s(:while,
            s(:not,
-             s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist))),
+             s(:call, s(:call, nil, :var), :nil?)),
            s(:str, "foo"), true)
 
     processor.canonicalize_conditions = false
@@ -671,7 +666,7 @@ class TestRubyParser < RubyParserTestCase
     rb = "until not var.nil?\n  'foo'\nend"
 
     pt = s(:while,
-           s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist)),
+           s(:call, s(:call, nil, :var), :nil?),
            s(:str, "foo"), true)
 
     assert_parse rb, pt
@@ -681,7 +676,7 @@ class TestRubyParser < RubyParserTestCase
     rb = "until not var.nil?\n  'foo'\nend"
     pt = s(:until,
            s(:not,
-             s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist))),
+             s(:call, s(:call, nil, :var), :nil?)),
            s(:str, "foo"), true)
 
     processor.canonicalize_conditions = false
@@ -689,3 +684,62 @@ class TestRubyParser < RubyParserTestCase
     assert_parse rb, pt
   end
 end
+
+class TestRuby18Parser < RubyParserTestCase
+  include TestRubyParser
+
+  def setup
+    super
+
+    self.processor = Ruby18Parser.new
+  end
+
+  def test_flip2_env_lvar
+    rb = "if a..b then end"
+    pt = s(:if, s(:flip2, s(:call, nil, :a), s(:call, nil, :b)), nil, nil)
+
+    assert_parse rb, pt
+
+    top_env = processor.env.env.first
+
+    assert_kind_of Hash, top_env
+
+    flip = top_env.find { |k,v| k =~ /^flip/ }
+
+    assert flip
+    assert_equal :lvar, flip.last
+  end
+end
+
+class TestRuby19Parser < RubyParserTestCase
+  include TestRubyParser
+
+  def setup
+    super
+
+    self.processor = Ruby19Parser.new
+  end
+
+  # HACK: need to figure out the desired structure and get this working
+  # def test_wtf
+  #   # lambda -> f_larglist lambda_body
+  #   # f_larglist -> f_args opt_bv_decl
+  #   # opt_bv_decl
+  #   # bv_decls
+  #   # bvar
+  #
+  #   rb = "->(a, b=nil) { p [a, b] }"
+  #   pt = s(:iter,
+  #          s(:call, nil, :lambda),
+  #          s(:args, :a, :b,
+  #            s(:block, s(:lasgn, :b, s(nil)))),
+  #          s(:call, nil, :p, s(:array, s(:lvar, :a), s(:lvar, :b))))
+  #
+  #   assert_parse rb, pt
+  #
+  #   rb = "->(a; b) { p [a, b] }"
+  #
+  #   assert_parse rb, pt
+  # end
+end
+