ruby_parser 3.12.0 → 3.13.0

data/test/test_ruby_parser.rb

@@ -244,16 +244,14 @@ module TestRubyParserShared
 
   def test_bug_begin_else
     rb = "begin 1; else; 2 end"
-    pt = s(:block, s(:lit, 1), s(:lit, 2))
 
-    assert_parse rb, pt
+    assert_syntax_error rb, "else without rescue is useless"
   end
 
   def test_begin_else_return_value
     rb = "begin; else 2; end"
-    pt = s(:lit, 2)
 
-    assert_parse rb, pt
+    assert_syntax_error rb, "else without rescue is useless"
   end
 
   def test_bug_comment_eq_begin
@@ -894,16 +892,6 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
-  # according to 2.3.1 parser -- added: ON 1.8 only:
-  # rp.process("f { |(a,b),c| }") == rp.process("f { |((a,b),c)| }")
-
-  # ruby18 -e "p lambda { |(a,b)|     }.arity" # =>  2
-  # ruby19 -e "p lambda { |(a,b)|     }.arity" # =>  1
-  # ruby18 -e "p lambda { |(a,b),c|   }.arity" # =>  2
-  # ruby19 -e "p lambda { |(a,b),c|   }.arity" # =>  2
-  # ruby18 -e "p lambda { |((a,b),c)| }.arity" # =>  2
-  # ruby19 -e "p lambda { |((a,b),c)| }.arity" # =>  1
-
   def test_bug_args_masgn
     rb = "f { |(a, b), c| }"
     pt = s(:iter,
@@ -922,20 +910,10 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
-  def ruby18
-    RubyParser::V18 === self.processor
-  end
-
   def test_bug_comma
-    val = if ruby18 then
-            s(:lit, 100)
-          else
-            s(:str, "d")
-          end
-
     rb = "if test ?d, dir then end"
     pt = s(:if,
-           s(:call, nil, :test, val, s(:call, nil, :dir)),
+           s(:call, nil, :test, s(:str, "d"), s(:call, nil, :dir)),
            nil,
            nil)
 
@@ -979,11 +957,7 @@ module TestRubyParserShared
 
   def test_bug_not_parens
     rb = "not(a)"
-    pt = if ruby18 then
-           s(:not, s(:call, nil, :a))
-         else
-           s(:call, s(:call, nil, :a), :"!")
-         end
+    pt = s(:call, s(:call, nil, :a), :"!")
 
     assert_parse rb, pt
   end
@@ -1008,6 +982,14 @@ module TestRubyParserShared
            s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, s(:call, nil, :b))),
            s(:resbody, s(:array), s(:nil)))
 
+    # TODO: HRM: this seems more correct IMO. Check against other versions
+    pt = s(:op_asgn_or,
+           s(:lvar, :a),
+           s(:lasgn, :a,
+             s(:rescue,
+               s(:call, nil, :b),
+               s(:resbody, s(:array), s(:nil)))))
+
     assert_parse rb, pt
   end
 
@@ -1427,7 +1409,7 @@ module TestRubyParserShared
 
   def test_BEGIN
     rb = "BEGIN { 42 }"
-    pt = s(:iter, s(:preexe), s(:args), s(:lit, 42))
+    pt = s(:iter, s(:preexe), 0, s(:lit, 42))
 
     assert_parse rb, pt
   end
@@ -1520,8 +1502,6 @@ module TestRubyParserShared
   end
 
   def test_block_decomp_splat
-    skip "not that smart yet" if ruby18 # HACK
-
     rb = "f { |(*a)| }"
     pt = s(:iter, s(:call, nil, :f), s(:args, s(:masgn, :"*a")))
 
@@ -1546,6 +1526,13 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
+  def test_alias_resword
+    rb = "alias in out"
+    pt = s(:alias, s(:lit, :in), s(:lit, :out))
+
+    assert_parse rb, pt
+  end
+
   def test_alias_gvar_backref
     rb = "alias $MATCH $&"
     pt = s(:valias, :$MATCH, :$&)
@@ -1585,19 +1572,7 @@ module TestRubyParserShared
 
   def test___ENCODING__
     rb = "__ENCODING__"
-    pt = if RubyParser::V18 === processor then
-           s(:call, nil, :__ENCODING__)
-         else
-           if defined? Encoding then
-             if RubyParser::V18 === processor then
-               s(:call, nil, :__ENCODING__)
-             else
-               s(:colon2, s(:const, :Encoding), :UTF_8)
-             end
-           else
-             s(:str, "Unsupported!")
-           end
-         end
+    pt = s(:colon2, s(:const, :Encoding), :UTF_8)
 
     assert_parse rb, pt
   end
@@ -1736,6 +1711,8 @@ module TestRubyParserShared
 end
 
 module TestRubyParserShared19Plus
+  include TestRubyParserShared
+
   def test_aref_args_lit_assocs
     rb = "[1, 2 => 3]"
     pt = s(:array, s(:lit, 1), s(:hash, s(:lit, 2), s(:lit, 3)))
@@ -2275,8 +2252,6 @@ module TestRubyParserShared19Plus
   end
 
   def test_symbol_empty
-    skip "can't do this in ruby 1.8" if RUBY_VERSION < "1.9"
-
     rb = ":''"
     pt = s(:lit, "".to_sym)
 
@@ -2430,6 +2405,13 @@ module TestRubyParserShared19Plus
     assert_parse_error rb, '(string):1 :: parse error on value "=" (tEQL)'
   end
 
+  def test_parse_def_special_name
+    rb = 'def next; end'
+    pt = s(:defn, :next, s(:args), s(:nil))
+
+    assert_parse rb, pt
+  end
+
   def test_parse_until_not_canonical
     rb = "until not var.nil?\n  'foo'\nend"
     pt = s(:until,
@@ -2697,9 +2679,6 @@ module TestRubyParserShared19Plus
     assert_parse rb, pt
   end
 
-  # In 1.8, block args with an outer set of parens are superfluous.
-  # In 1.9, outer set of parens are NOT... they are an explicit extra masgn.
-
   def test_iter_args_2__19
     rb = "f { |(a, b)| }"
     pt = s(:iter, s(:call, nil, :f), s(:args, s(:masgn, :a, :b)))
@@ -2918,76 +2897,9 @@ module TestRubyParserShared19Plus
   end
 end
 
-module TestRubyParserShared21Plus
-  def test_f_kw
-    rb = "def x k:42; end"
-    pt = s(:defn, :x, s(:args, s(:kwarg, :k, s(:lit, 42))), s(:nil))
-
-    assert_parse rb, pt
-  end
-
-  def test_f_kw__required
-    rb = "def x k:; end"
-    pt = s(:defn, :x, s(:args, s(:kwarg, :k)), s(:nil))
-
-    assert_parse rb, pt
-  end
-
-  def test_block_kw
-    rb = "blah { |k:42| }"
-    pt = s(:iter, s(:call, nil, :blah), s(:args, s(:kwarg, :k, s(:lit, 42))))
-
-    assert_parse rb, pt
-
-    rb = "blah { |k:42| }"
-    assert_parse rb, pt
-  end
-
-  def test_block_kw__required
-    rb = "blah do |k:| end"
-    pt = s(:iter, s(:call, nil, :blah), s(:args, s(:kwarg, :k)))
-
-    assert_parse rb, pt
-
-    rb = "blah do |k:| end"
-    assert_parse rb, pt
-  end
-
-  def test_stabby_block_kw
-    rb = "-> (k:42) { }"
-    pt = s(:iter, s(:call, nil, :lambda), s(:args, s(:kwarg, :k, s(:lit, 42))))
-
-    assert_parse rb, pt
-  end
-
-  def test_stabby_block_kw__required
-    rb = "-> (k:) { }"
-    pt = s(:iter, s(:call, nil, :lambda), s(:args, s(:kwarg, :k)))
-
-    assert_parse rb, pt
-  end
-
-  def test_parse_line_heredoc_hardnewline
-    skip "not yet"
-
-    rb = <<-'CODE'.gsub(/^      /, '')
-      <<-EOFOO
-      \n\n\n\n\n\n\n\n\n
-      EOFOO
-
-      class Foo
-      end
-    CODE
-
-    pt = s(:block,
-           s(:str, "\n\n\n\n\n\n\n\n\n\n").line(1),
-           s(:class, :Foo, nil).line(5)).line(1)
-
-    assert_parse rb, pt
-  end
-end
-
 module TestRubyParserShared20Plus
+  include TestRubyParserShared19Plus
+
   def test_non_interpolated_symbol_array_line_breaks
 
     rb = "%i(\na\nb\n)\n1"
@@ -3293,7 +3205,87 @@ module TestRubyParserShared20Plus
   end
 end
 
+module TestRubyParserShared21Plus
+  include TestRubyParserShared20Plus
+
+  def test_defn_unary_not
+    rb = "def !@; true; end" # I seriously HATE this
+    pt = s(:defn, :"!@", s(:args), s(:true))
+
+    assert_parse rb, pt
+  end
+
+  def test_f_kw
+    rb = "def x k:42; end"
+    pt = s(:defn, :x, s(:args, s(:kwarg, :k, s(:lit, 42))), s(:nil))
+
+    assert_parse rb, pt
+  end
+
+  def test_f_kw__required
+    rb = "def x k:; end"
+    pt = s(:defn, :x, s(:args, s(:kwarg, :k)), s(:nil))
+
+    assert_parse rb, pt
+  end
+
+  def test_block_kw
+    rb = "blah { |k:42| }"
+    pt = s(:iter, s(:call, nil, :blah), s(:args, s(:kwarg, :k, s(:lit, 42))))
+
+    assert_parse rb, pt
+
+    rb = "blah { |k:42| }"
+    assert_parse rb, pt
+  end
+
+  def test_block_kw__required
+    rb = "blah do |k:| end"
+    pt = s(:iter, s(:call, nil, :blah), s(:args, s(:kwarg, :k)))
+
+    assert_parse rb, pt
+
+    rb = "blah do |k:| end"
+    assert_parse rb, pt
+  end
+
+  def test_stabby_block_kw
+    rb = "-> (k:42) { }"
+    pt = s(:iter, s(:call, nil, :lambda), s(:args, s(:kwarg, :k, s(:lit, 42))))
+
+    assert_parse rb, pt
+  end
+
+  def test_stabby_block_kw__required
+    rb = "-> (k:) { }"
+    pt = s(:iter, s(:call, nil, :lambda), s(:args, s(:kwarg, :k)))
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_line_heredoc_hardnewline
+    skip "not yet"
+
+    rb = <<-'CODE'.gsub(/^      /, '')
+      <<-EOFOO
+      \n\n\n\n\n\n\n\n\n
+      EOFOO
+
+      class Foo
+      end
+    CODE
+
+    pt = s(:block,
+           s(:str, "\n\n\n\n\n\n\n\n\n\n").line(1),
+           s(:class, :Foo, nil).line(5)).line(1)
+
+    assert_parse rb, pt
+  end
+end
+
 module TestRubyParserShared22Plus
+  include TestRubyParserShared21Plus
+
   def test_call_args_assoc_quoted
     pt = s(:call, nil, :x, s(:hash, s(:lit, :k), s(:lit, 42)))
 
@@ -3335,6 +3327,8 @@ module TestRubyParserShared22Plus
 end
 
 module TestRubyParserShared23Plus
+  include TestRubyParserShared22Plus
+
   def test_safe_call
     rb = "a&.b"
     pt = s(:safe_call, s(:call, nil, :a), :b)
@@ -3472,16 +3466,46 @@ a + b
 end
 
 module TestRubyParserShared24Plus
+  include TestRubyParserShared23Plus
+
   # ...version specific tests to go here...
 end
 
 module TestRubyParserShared25Plus
+  include TestRubyParserShared24Plus
+
   # ...version specific tests to go here...
 end
 
+module TestRubyParserShared26Plus
+  include TestRubyParserShared25Plus
+
+  def test_symbol_list
+    rb = '%I[#{a} #{b}]'
+    pt = s(:array,
+           s(:dsym, "", s(:evstr, s(:call, nil, :a))),
+           s(:dsym, "", s(:evstr, s(:call, nil, :b))))
+
+    assert_parse rb, pt
+  end
+
+  def test_dot2_nil__26
+    rb = "a.."
+    pt = s(:dot2, s(:call, nil, :a), nil)
+
+    assert_parse rb, pt
+  end
+
+  def test_dot3_nil__26
+    rb = "a..."
+    pt = s(:dot3, s(:call, nil, :a), nil)
+
+    assert_parse rb, pt
+  end
+end
+
 class TestRubyParser < Minitest::Test
   def test_cls_version
-    assert_equal 18, RubyParser::V18.version
     assert_equal 23, RubyParser::V23.version
     assert_equal 24, RubyParser::V24.version
     assert_equal 24, Ruby24Parser.version
@@ -3491,15 +3515,6 @@ class TestRubyParser < Minitest::Test
   def test_parse
     processor = RubyParser.new
 
-    # 1.8 only syntax
-    rb = "while false : 42 end"
-    pt = s(:while, s(:false), s(:lit, 42), true)
-
-    assert_silent do
-      assert_equal pt, processor.parse(rb)
-    end
-
-    # 1.9 only syntax
     rb = "a.()"
     pt = s(:call, s(:call, nil, :a), :call)
 
@@ -3512,8 +3527,20 @@ class TestRubyParser < Minitest::Test
       end
     end
 
-    msg = "(string):1 :: parse error on value \"(\" (tLPAREN2)"
-    assert_equal msg, e.message.strip
+    assert_includes e.message, 'parse error on value "$end"'
+  end
+
+  def test_parse_error_from_first
+    processor = RubyParser.new
+
+    e = assert_raises Racc::ParseError do
+      capture_io do
+        processor.parse "a -> () {"
+      end
+    end
+
+    # This is a 2.x error, will fail on 1.8/1.9.
+    assert_includes e.message, 'parse error on value "$end"'
   end
 end
 
@@ -3578,119 +3605,7 @@ class RubyParserTestCase < ParseTreeTestCase
   end
 end
 
-class TestRubyParserV18 < RubyParserTestCase
-  include TestRubyParserShared
-
-  def setup
-    super
-
-    self.processor = RubyParser::V18.new
-  end
-
-  def test_assoc_list_18
-    rb = "{1, 2, 3, 4}"
-    pt = s(:hash, s(:lit, 1), s(:lit, 2), s(:lit, 3), s(:lit, 4))
-
-    assert_parse rb, pt
-  end
-
-  def test_case_then_colon_18
-    rb = "case x; when Fixnum: 42; end"
-    pt = s(:case,
-           s(:call, nil, :x),
-           s(:when, s(:array, s(:const, :Fixnum)), s(:lit, 42)),
-           nil)
-
-    assert_parse rb, pt
-  end
-
-  def test_do_colon_18
-    rb = "while false : 42 end"
-    pt = s(:while, s(:false), s(:lit, 42), true)
-
-    assert_parse rb, pt
-  end
-
-  def test_call_space_before_paren_args_18
-    rb = "a (:b, :c, :d => :e)"
-    pt = s(:call, nil, :a,
-           s(:lit, :b),
-           s(:lit, :c),
-           s(:hash, s(:lit, :d), s(:lit, :e)))
-
-    assert_parse rb, pt
-  end
-
-  # In 1.8, block args with an outer set of parens are superfluous.
-  # In 1.9, outer set of parens are NOT... they are an explicit extra masgn.
-
-  def test_iter_args_2_18
-    rb = "f { |(a, b)| }"
-    pt = s(:iter, s(:call, nil, :f), s(:args, :a, :b))
-
-    assert_parse rb, pt
-  end
-
-  def test_bug_args__18
-    rb = "f { |(a, b)| }"
-    pt = s(:iter, s(:call, nil, :f),
-           s(:args, :a, :b))
-
-    assert_parse rb, pt
-  end
-
-  def test_bug_args_masgn_outer_parens__18
-    rb = "f { |((a, b), c)| }"
-    pt = s(:iter,               # NOTE: same sexp as test_bug_args_masgn
-           s(:call, nil, :f),
-           s(:args, s(:masgn, :a, :b), :c))
-
-    assert_parse rb, pt.dup
-  end
-
-  def test_double_block_error_10
-    assert_syntax_error "a.b (&b) {}", BLOCK_DUP_MSG
-  end
-
-  def test_double_block_error_11
-    assert_syntax_error "a (1, &b) { }", BLOCK_DUP_MSG
-  end
-
-  def test_double_block_error_12
-    assert_syntax_error "a (1, &b) do end", BLOCK_DUP_MSG
-  end
-
-  def test_double_block_error_13
-    assert_syntax_error "m.a (1, &b) { }", BLOCK_DUP_MSG
-  end
-
-  def test_double_block_error_14
-    assert_syntax_error "m.a (1, &b) do end", BLOCK_DUP_MSG
-  end
-
-  def test_double_block_error_15
-    assert_syntax_error "m::a (1, &b) { }", BLOCK_DUP_MSG
-  end
-
-  def test_double_block_error_16
-    assert_syntax_error "m::a (1, &b) do end", BLOCK_DUP_MSG
-  end
-end
-
-class TestRubyParserV19 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
-
-  def setup
-    super
-
-    self.processor = RubyParser::V19.new
-  end
-end
-
 class TestRubyParserV20 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
   include TestRubyParserShared20Plus
 
   def setup
@@ -3698,19 +3613,9 @@ class TestRubyParserV20 < RubyParserTestCase
 
     self.processor = RubyParser::V20.new
   end
-
-  def test_defn_unary_not
-    rb = "def !@; true; end" # I seriously HATE this
-    pt = s(:defn, :"!@", s(:args), s(:true))
-
-    assert_parse rb, pt
-  end
 end
 
 class TestRubyParserV21 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
-  include TestRubyParserShared20Plus
   include TestRubyParserShared21Plus
 
   def setup
@@ -3721,10 +3626,6 @@ class TestRubyParserV21 < RubyParserTestCase
 end
 
 class TestRubyParserV22 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
-  include TestRubyParserShared20Plus
-  include TestRubyParserShared21Plus
   include TestRubyParserShared22Plus
 
   def setup
@@ -3735,11 +3636,6 @@ class TestRubyParserV22 < RubyParserTestCase
 end
 
 class TestRubyParserV23 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
-  include TestRubyParserShared20Plus
-  include TestRubyParserShared21Plus
-  include TestRubyParserShared22Plus
   include TestRubyParserShared23Plus
 
   def setup
@@ -3750,12 +3646,6 @@ class TestRubyParserV23 < RubyParserTestCase
 end
 
 class TestRubyParserV24 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
-  include TestRubyParserShared20Plus
-  include TestRubyParserShared21Plus
-  include TestRubyParserShared22Plus
-  include TestRubyParserShared23Plus
   include TestRubyParserShared24Plus
 
   def setup
@@ -3766,13 +3656,6 @@ class TestRubyParserV24 < RubyParserTestCase
 end
 
 class TestRubyParserV25 < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19Plus
-  include TestRubyParserShared20Plus
-  include TestRubyParserShared21Plus
-  include TestRubyParserShared22Plus
-  include TestRubyParserShared23Plus
-  include TestRubyParserShared24Plus
   include TestRubyParserShared25Plus
 
   def setup
@@ -3783,7 +3666,10 @@ class TestRubyParserV25 < RubyParserTestCase
 
   def test_rescue_in_block
     rb = "blah do\nrescue\n  stuff\nend"
-    pt = s(:iter, s(:call, nil, :blah), 0, s(:rescue, s(:resbody, s(:array), s(:call, nil, :stuff))))
+    pt = s(:iter,
+           s(:call, nil, :blah),
+           0,
+           s(:rescue, s(:resbody, s(:array), s(:call, nil, :stuff))))
     assert_parse rb, pt
   end
 
@@ -3848,6 +3734,16 @@ class TestRubyParserV25 < RubyParserTestCase
   end
 end
 
+class TestRubyParserV26 < RubyParserTestCase
+  include TestRubyParserShared26Plus
+
+  def setup
+    super
+
+    self.processor = RubyParser::V26.new
+  end
+end
+
 RubyParser::VERSIONS.each do |klass|
   v = klass.version
   describe "block args arity #{v}" do