ruby_parser 3.15.0 → 3.18.0

data/test/test_ruby_parser.rb

@@ -34,12 +34,15 @@ module TestRubyParserShared
     skip "not ready for this yet"
 
     rb = "def f; if /(?<foo>bar)/ =~ 'bar' && p(foo); foo; end; end; f"
-    pt = s(:if,
-           s(:and,
-             s(:match2, s(:lit, /(?<foo>bar)/), s(:str, "bar")),
-             s(:call, nil, :p, s(:lvar, :foo))),
-           s(:lvar, :foo),
-           nil)
+    pt = s(:block,
+           s(:defn, :f, s(:args),
+             s(:if,
+               s(:and,
+                 s(:match2, s(:lit, /(?<foo>bar)/), s(:str, "bar")),
+                 s(:call, nil, :p, s(:lvar, :foo))),
+               s(:lvar, :foo),
+               nil)),
+           s(:call, nil, :f))
 
     assert_parse rb, pt
   end
@@ -179,10 +182,13 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
-  def test_begin_else_return_value
+  def test_begin_else_return_value # overridden below, warns < 2.6
     rb = "begin; else 2; end"
+    pt = s(:lit, 2)
 
-    assert_syntax_error rb, "else without rescue is useless"
+    assert_output "", "else without rescue is useless\n" do
+      assert_parse rb, pt
+    end
   end
 
   def test_begin_ensure_no_bodies
@@ -322,13 +328,14 @@ module TestRubyParserShared
   end
 
   def test_bug170
-    skip "not ready for this yet"
-
-    # TODO: needs to fail on 2.1 and up
     rb = '$-'
     pt = s(:gvar, :"$-")
 
-    assert_parse rb, pt
+    if processor.class.version >= 21
+      assert_syntax_error rb, /unexpected \$undefined/
+    else
+      assert_parse rb, pt
+    end
   end
 
   def test_bug179
@@ -339,12 +346,9 @@ module TestRubyParserShared
   end
 
   def test_bug190
-    skip "not ready for this yet"
-
     rb = %{%r'\\\''} # stupid emacs
 
-    assert_parse rb, :FUCK
-    assert_syntax_error rb, "FUCK"
+    assert_parse rb, s(:lit, %r%'%)
 
     rb = %{%r'\\''}
     pt = s(:lit, /'/)
@@ -420,10 +424,13 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
-  def test_bug_begin_else
+  def test_bug_begin_else # overridden below, warns < 2.6
     rb = "begin 1; else; 2 end"
+    pt = s(:block, s(:lit, 1), s(:lit, 2))
 
-    assert_syntax_error rb, "else without rescue is useless"
+    assert_output "", "else without rescue is useless\n" do
+      assert_parse rb, pt
+    end
   end
 
   def test_bug_call_arglist_parens
@@ -881,6 +888,29 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
+  def test_heredoc_lineno
+    rb = "c = <<'CCC'\nline2\nline3\nline4\nCCC\n\nd = 42"
+    pt = s(:block,
+           s(:lasgn, :c, s(:str, "line2\nline3\nline4\n").line(1)).line(1),
+           s(:lasgn, :d, s(:lit, 42).line(7)).line(7)).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_pctW_lineno
+    rb = "%W(a\\nb\nc\ d\ne\\\nf\ng\y h\\y i\\\y)"
+    pt = s(:array,
+           s(:str, "a\nb").line(1),
+           s(:str, "c").line(2),
+           s(:str, "d").line(2),
+           s(:str, "e\nf").line(3),
+           s(:str, "gy").line(5),
+           s(:str, "hy").line(5),
+           s(:str, "iy").line(5)).line(1)
+
+    assert_parse rb, pt
+  end
+
   def test_heredoc_bad_oct_escape
     rb = "s = <<-EOS\na\\247b\ncöd\nEOS\n"
     pt = s(:lasgn, :s, s(:str, "a\xa7b\nc\xc3\xb6d\n".b))
@@ -1057,7 +1087,7 @@ module TestRubyParserShared
            s(:array,
              s(:str, "a").line(2),
              s(:str, "b").line(3)).line(1),
-           s(:lit, 1).line(5))
+           s(:lit, 1).line(5)).line(1)
     assert_parse rb, pt
   end
 
@@ -1433,7 +1463,7 @@ module TestRubyParserShared
            s(:array,
              s(:str, "a").line(2),
              s(:str, "b").line(3)).line(1),
-           s(:lit, 1).line(5))
+           s(:lit, 1).line(5)).line(1)
     assert_parse rb, pt
   end
 
@@ -1635,7 +1665,7 @@ module TestRubyParserShared
 
   def test_parse_line_defn_no_parens_args
     rb = "def f a\nend"
-    pt = s(:defn, :f, s(:args, :a).line(1), s(:nil).line(2)).line(1)
+    pt = s(:defn, :f, s(:args, :a).line(1), s(:nil).line(1)).line(1)
 
     assert_parse_line rb, pt, 1
   end
@@ -1656,7 +1686,7 @@ module TestRubyParserShared
   end
 
   def test_parse_line_defn_no_parens
-    pt = s(:defn, :f, s(:args).line(1), s(:nil)).line(1)
+    pt = s(:defn, :f, s(:args).line(1), s(:nil).line(1)).line(1)
 
     rb = "def f\nend"
     assert_parse_line rb, pt, 1
@@ -1691,17 +1721,21 @@ module TestRubyParserShared
     assert_parse_line rb, pt, 1
   end
 
-  def test_parse_line_dstr_newline
-    rb = <<-'CODE'
-            "a\n#{
-            }"
-            true
-    CODE
-
+  def test_parse_line_dstr_escaped_newline
+    rb = "\"a\\n\#{\n}\"\ntrue"
     pt = s(:block,
            s(:dstr, "a\n",
-             s(:evstr)).line(1),
-           s(:true).line(3))
+             s(:evstr).line(1)).line(1),
+           s(:true).line(3)).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_line_dstr_soft_newline
+    rb = "\"a\n#\{\n}\"\ntrue"
+    pt = s(:block,
+           s(:dstr, "a\n", s(:evstr).line(2)).line(1),
+           s(:true).line(4)).line(1)
 
     assert_parse rb, pt
   end
@@ -1726,7 +1760,7 @@ module TestRubyParserShared
 
   def test_parse_line_heredoc
     rb = <<-CODE
-      string = <<-HEREDOC
+      string = <<-HEREDOC.strip
         very long string
       HEREDOC
       puts string
@@ -1734,20 +1768,23 @@ module TestRubyParserShared
 
     pt = s(:block,
            s(:lasgn, :string,
-             s(:str, "        very long string\n").line(1)).line(1),
-           s(:call, nil, :puts, s(:lvar, :string).line(4)).line(4)).line(1)
+             s(:call,
+               s(:str, "        very long string\n").line(1),
+               :strip).line(1),
+              ).line(1),
+           s(:call, nil, :puts,
+             s(:lvar, :string).line(4)).line(4)
+          ).line(1)
 
     assert_parse rb, pt
   end
 
   def test_parse_line_heredoc_evstr
-    skip "heredoc line numbers are just gonna be screwed for a while..."
-
     rb = "<<-A\na\n\#{b}\nA"
-    pt = s(:dstr, "a\n",
-           s(:evstr,
-             s(:call, nil, :b).line(3)),
-             s(:str, "\n")).line(1)
+    pt = s(:dstr,
+           "a\n",
+           s(:evstr, s(:call, nil, :b).line(3)).line(3), s(:str, "\n").line(3)
+          ).line(1)
 
     assert_parse rb, pt
   end
@@ -2055,13 +2092,13 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
-  # def test_str_pct_nested_nested
-  #   rb = "%{ { #\{ \"#\{1}\" } } }"
-  #   assert_equal " { 1 } ", eval(rb)
-  #   pt = s(:dstr, " { ", s(:evstr, s(:lit, 1)), s(:str, " } "))
-  #
-  #   assert_parse rb, pt
-  # end
+  def test_str_pct_nested_nested
+    rb = "%{ { #\{ \"#\{1}\" } } }"
+    assert_equal " { 1 } ", eval(rb)
+    pt = s(:dstr, " { ", s(:evstr, s(:lit, 1)), s(:str, " } "))
+
+    assert_parse rb, pt
+  end
 
   def test_str_pct_Q_nested
     rb = "%Q[before [#\{nest}] after]"
@@ -2077,6 +2114,60 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
+  def test_str_single_newline
+    rp = "a '\n';b"
+    pt = s(:block,
+           s(:call, nil, :a, s(:str, "\n").line(1)).line(1),
+           s(:call, nil, :b).line(2)).line(1)
+
+    assert_parse rp, pt
+  end
+
+  def test_str_single_escaped_newline
+    rp = "a '\\n';b"
+    pt = s(:block,
+           s(:call, nil, :a, s(:str, "\\n").line(1)).line(1),
+           s(:call, nil, :b).line(1)).line(1)
+
+    assert_parse rp, pt
+  end
+
+  def test_str_single_double_escaped_newline
+    rp = "a '\\\\n';b"
+    pt = s(:block,
+           s(:call, nil, :a, s(:str, "\\n").line(1)).line(1),
+           s(:call, nil, :b).line(1)).line(1)
+
+    assert_parse rp, pt
+  end
+
+  def test_str_double_newline
+    rp = "a \"\n\";b"
+    pt = s(:block,
+           s(:call, nil, :a, s(:str, "\n").line(1)).line(1),
+           s(:call, nil, :b).line(2)).line(1)
+
+    assert_parse rp, pt
+  end
+
+  def test_str_double_escaped_newline
+    rp = "a \"\\n\";b"
+    pt = s(:block,
+           s(:call, nil, :a, s(:str, "\n").line(1)).line(1),
+           s(:call, nil, :b).line(1)).line(1)
+
+    assert_parse rp, pt
+  end
+
+  def test_str_double_double_escaped_newline
+    rp = "a \"\\\\n\";b"
+    pt = s(:block,
+           s(:call, nil, :a, s(:str, "\\n").line(1)).line(1),
+           s(:call, nil, :b).line(1)).line(1)
+
+    assert_parse rp, pt
+  end
+
   def test_str_str
     rb = "\"a #\{'b'}\""
     pt = s(:str, "a b")
@@ -2632,7 +2723,7 @@ module TestRubyParserShared19Plus
     rb = "def m arg = false\nend"
     pt = s(:defn, :m,
            s(:args, s(:lasgn, :arg, s(:false).line(1)).line(1)).line(1),
-           s(:nil).line(2)).line(1)
+           s(:nil).line(1)).line(1)
 
     assert_parse rb, pt
   end
@@ -3079,6 +3170,31 @@ module TestRubyParserShared19Plus
     assert_parse rb, pt
   end
 
+  def test_call_leading_dots
+    rb = "a\n.b\n.c"
+    pt = s(:call, s(:call, s(:call, nil, :a), :b), :c)
+
+    assert_parse rb, pt
+  end
+
+  def test_call_leading_dots_comment
+    rb = "a\n.b\n#.c\n.d"
+    pt = s(:call,
+           s(:call,
+             s(:call, nil, :a).line(1),
+             :b).line(1),
+           :d).line(1) # TODO: fix linenos: 1, 2, 4
+
+    assert_parse rb, pt
+  end
+
+  def test_call_trailing_dots
+    rb = "a.\nb.\nc"
+    pt = s(:call, s(:call, s(:call, nil, :a), :b), :c)
+
+    assert_parse rb, pt
+  end
+
   def test_motherfuckin_leading_dots
     rb = "a\n.b"
     pt = s(:call, s(:call, nil, :a), :b)
@@ -3087,9 +3203,15 @@ module TestRubyParserShared19Plus
   end
 
   def test_motherfuckin_leading_dots2
-    rb = "a\n..b"
+    rb = "1\n..3"
+    pt = s(:block, s(:lit, 1).line(1),
+           s(:dot2, nil, s(:lit, 3).line(2)).line(2)).line(1)
 
-    assert_parse_error rb, '(string):2 :: parse error on value ".." (tDOT2)'
+    if processor.class.version >= 27
+      assert_parse rb, pt
+    else
+      assert_parse_error rb, '(string):2 :: parse error on value ".." (tDOT2)'
+    end
   end
 
   def test_multiline_hash_declaration
@@ -3368,6 +3490,98 @@ end
 module TestRubyParserShared20Plus
   include TestRubyParserShared19Plus
 
+  def test_read_escape_unicode_h4
+    rb = '?\u00a0'
+    pt = s(:str, ?\u00a0)
+
+    assert_parse rb, pt
+  end
+
+  def test_read_escape_unicode_curlies
+    rb = '?\u{00a0}'
+    pt = s(:str, ?\u00a0)
+
+    assert_parse rb, pt
+  end
+
+  def test_regexp_unicode_curlies
+    rb = '/\u{df}/'
+    pt = s(:lit, /\u{df}/)
+
+    assert_parse rb, pt
+
+    rb = '/\u{c0de babe}/'
+    pt = s(:lit, /\u{c0de babe}/)
+
+    assert_parse rb, pt
+  end
+
+  def test_qw_escape
+    rb = "%q(\1\\\')"
+    pt = s(:str, "\001\\'")
+
+    assert_parse rb, pt
+  end
+
+  def test_pct_nl
+    rb = "x = %\n\n"
+    pt = s(:lasgn, :x, s(:str, ""))
+
+    assert_parse rb, pt
+  end
+
+  def test_regexp_esc_C_slash
+    rb = "/\\cC\\d/"
+    pt = s(:lit, /\cC\d/)
+
+    assert_parse rb, pt
+  end
+
+  def test_heredoc_wtf_I_hate_you
+    rb = "p <<-END+'b\n  a\n  END\n  c'+'d'"
+    pt = s(:call, nil, :p,
+           s(:call,
+             s(:call, s(:str, "  a\n"), :+,
+               s(:str, "b\n  c")),
+             :+, s(:str, "d")))
+
+    assert_parse rb, pt
+  end
+
+  def test_heredoc_nested
+    rb = "[<<A,\n\#{<<B}\nb\nB\na\nA\n0]"
+    pt = s(:array, s(:str, "b\n\na\n").line(1),
+           s(:lit, 0).line(7)).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_pct_w_heredoc_interp_nested
+    rb = "%W( 1 \#{<<A} 3\n2\nA\n      4 5 )"
+    pt = s(:array,
+           s(:str, "1"),
+           s(:str, "2\n"),
+           s(:str, "3"),
+           s(:str, "4"),
+           s(:str, "5"))
+
+    assert_parse rb, pt
+  end
+
+  def test_regexp_esc_u
+    rb = "/[\\u0021-\\u0027]/"
+    pt = s(:lit, /[\u0021-\u0027]/)
+
+    assert_parse rb, pt
+  end
+
+  def test_qw_escape_term
+    rb = "%q|blah blah \\| blah blah|"
+    pt = s(:str, "blah blah | blah blah")
+
+    assert_parse rb, pt
+  end
+
   def test_args_kw_block
     rb = "def f(a: 1, &b); end"
     pt = s(:defn, :f, s(:args, s(:kwarg, :a, s(:lit, 1)), :"&b"), s(:nil))
@@ -3375,6 +3589,49 @@ module TestRubyParserShared20Plus
     assert_parse rb, pt
   end
 
+  def test_heredoc_backslash_nl
+    rb = %Q("  why would someone do this? \\\n  blah\n")
+    pt = s(:str, "  why would someone do this?   blah\n")
+
+    assert_parse rb, pt
+
+    rb = "<<-DESC\n  why would someone do this? \\\n  blah\nDESC"
+
+    assert_parse rb, pt
+  end
+
+  def test_heredoc_comma_arg
+    rb = "[\"  some text\n\",]"
+    pt = s(:array, s(:str, "  some text\n"))
+
+    assert_parse rb, pt
+
+    rb = "[<<-FILE,\n  some text\nFILE\n]"
+
+    assert_parse rb, pt
+  end
+
+  def test_heredoc_trailing_slash_continued_call
+    rb = "<<END\\\nblah\nEND\n.strip"
+    pt = s(:call, s(:str, "blah\n"), :strip)
+
+    assert_parse rb, pt
+  end
+
+  def test_pct_q_backslash_nl
+    rb = "%q{ \\\n}"
+    pt = s(:str, " \\\n")
+
+    assert_parse rb, pt
+  end
+
+  def test_pct_Q_backslash_nl
+    rb = "%Q{ \\\n}"
+    pt = s(:str, " ")
+
+    assert_parse rb, pt
+  end
+
   def test_block_arg_kwsplat
     rb = "a { |**b| }"
     pt = s(:iter, s(:call, nil, :a), s(:args, :"**b"))
@@ -3619,19 +3876,22 @@ module TestRubyParserShared20Plus
            s(:array,
              s(:lit, :a).line(2),
              s(:lit, :b).line(3)).line(1),
-           s(:lit, 1).line(5))
+           s(:lit, 1).line(5)).line(1)
     assert_parse rb, pt
   end
 
   def test_iter_array_curly
-    skip if processor.class.version >= 25
-
     rb = "f :a, [:b] { |c, d| }" # yes, this is bad code... that's their problem
     pt = s(:iter,
            s(:call, nil, :f, s(:lit, :a), s(:array, s(:lit, :b))),
            s(:args, :c, :d))
 
-    assert_parse rb, pt
+    if processor.class.version >= 25 then
+      msg = /parse error on value "\{" \(tLCURLY\)/
+      assert_syntax_error rb, msg, Racc::ParseError
+    else
+      assert_parse rb, pt
+    end
   end
 
   def test_iter_kwarg
@@ -3745,6 +4005,17 @@ end
 module TestRubyParserShared21Plus
   include TestRubyParserShared20Plus
 
+  def test_array_lits_trailing_calls
+    rb = "[].b"
+    pt = s(:call, s(:array), :b)
+
+    assert_parse rb, pt
+
+    rb = "%w[].b"
+
+    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))))
@@ -3767,7 +4038,7 @@ module TestRubyParserShared21Plus
 
   def test_bug162__21plus
     rb = %q(<<E\nfoo\nE\rO)
-    emsg = "can't match /E(\\r*\\n|\\z)/ anywhere in . near line 1: \"\""
+    emsg = "can't match /E(?=\\r?\\n|\\z)/ anywhere in . near line 1: \"\""
 
     assert_syntax_error rb, emsg
   end
@@ -3963,6 +4234,27 @@ module TestRubyParserShared23Plus
     assert_parse rb, pt
   end
 
+  def test_heredoc_squiggly_blank_lines
+    rb = "a = <<~EOF\n  x\n\n  z\nEOF\n\n"
+    pt = s(:lasgn, :a, s(:str, "x\n\nz\n"))
+
+    assert_parse rb, pt
+  end
+
+  def test_heredoc_squiggly_visually_blank_lines
+    rb = "a = <<~EOF\n  x\n \n  z\nEOF\n\n"
+    pt = s(:lasgn, :a, s(:str, "x\n\nz\n"))
+
+    assert_parse rb, pt
+  end
+
+  def test_heredoc_squiggly_empty
+    rb = "<<~A\nA"
+    pt = s(:str, "")
+
+    assert_parse rb, pt
+  end
+
   def test_integer_with_if_modifier
     rb = "1_234if true"
     pt = s(:if, s(:true), s(:lit, 1234), nil)
@@ -4052,7 +4344,7 @@ module TestRubyParserShared23Plus
   end
 
   def test_safe_op_asgn
-    rb = "a&.b += x 1\n"
+    rb = "a&.b += x 1"
     pt = s(:safe_op_asgn, s(:call, nil, :a), s(:call, nil, :x, s(:lit, 1)), :b, :+).line(1)
 
     assert_parse rb, pt
@@ -4115,6 +4407,18 @@ module TestRubyParserShared26Plus
     assert_parse rb, pt
   end
 
+  def test_begin_else_return_value # overrides above, warns < 2.6
+    rb = "begin; else 2; end"
+
+    assert_syntax_error rb, "else without rescue is useless"
+  end
+
+  def test_bug_begin_else # overrides above, warns < 2.6
+    rb = "begin 1; else; 2 end"
+
+    assert_syntax_error rb, "else without rescue is useless"
+  end
+
   def test_dot3_nil__26
     rb = "a..."
     pt = s(:dot3, s(:call, nil, :a), nil)
@@ -4132,57 +4436,900 @@ module TestRubyParserShared26Plus
   end
 end
 
-module TestRubyParserShared27Plus
-  include TestRubyParserShared26Plus
-end
-
-class TestRubyParser < Minitest::Test
-  def test_cls_version
-    assert_equal 23, RubyParser::V23.version
-    assert_equal 24, RubyParser::V24.version
-    assert_equal 24, Ruby24Parser.version
-    refute RubyParser::Parser.version
+module TestPatternMatching
+  def rip rb
+    require "ripper"
+    puts
+    pp Sexp.from_array Ripper.sexp rb
   end
 
-  def test_parse
-    processor = RubyParser.new
+  def assert_case_in lit, exp_pt
+    rb = "case :a\nin #{lit}\nend"
 
-    rb = "a.()"
-    pt = s(:call, s(:call, nil, :a), :call)
+    if ENV["VERBOSE_TEST"] then
+      puts
+      puts rb
+    end
 
-    assert_equal pt, processor.parse(rb)
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in, exp_pt, nil).line(2),
+           nil).line(1)
 
-    # bad syntax
-    e = assert_raises Racc::ParseError do
-      capture_io do
-        processor.parse "a.("
-      end
-    end
+    assert_parse rb, pt
+  end
 
-    assert_includes e.message, 'parse error on value false ($end)'
+  def test_case_in_09
+    assert_case_in(":b, [:c]",
+                   s(:array_pat, nil,
+                     s(:lit, :b).line(2),
+                     s(:array_pat, nil, s(:lit, :c).line(2)).line(2)).line(2))
   end
 
-  def test_parse_error_from_first
-    processor = RubyParser.new
+  def test_case_in_10
+    assert_case_in "nil, nil, nil", s(:array_pat,
+                                      nil,
+                                      s(:nil).line(2),
+                                      s(:nil).line(2),
+                                      s(:nil).line(2)).line(2)
+  end
 
-    e = assert_raises Racc::ParseError do
-      capture_io do
-        processor.parse "a -> () {"
-      end
-    end
+  def test_case_in_21
+    assert_case_in "Symbol()", s(:array_pat, s(:const, :Symbol).line(2)).line(2)
+  end
 
-    # This is a 2.x error, will fail on 1.8/1.9.
-    assert_includes e.message, 'parse error on value false ($end)'
+  def test_case_in_26
+    assert_case_in "(42)", s(:lit, 42).line(2)
   end
-end
 
-class RubyParserTestCase < ParseTreeTestCase
-  attr_accessor :result, :processor
+  def test_case_in_27
+    assert_case_in("[A, *, B]",
+                   s(:array_pat, nil,
+                     s(:const, :A).line(2),
+                     :*,
+                     s(:const, :B).line(2)).line(2))
+  end
 
-  make_my_diffs_pretty!
+  def test_case_in_28_2
+    assert_case_in '{ "b": }', s(:hash_pat, nil, s(:lit, :b).line(2), nil).line(2)
+  end
 
-  def self.previous key
-    "Ruby"
+  def test_case_in_28
+    assert_case_in "[]", s(:array_pat).line(2)
+  end
+
+  def test_case_in_29
+    assert_case_in "**nil", s(:hash_pat, nil, s(:kwrest, :"**nil").line(2)).line(2)
+  end
+
+  def test_case_in_30
+    assert_case_in "{}", s(:hash_pat, nil).line(2)
+  end
+
+  def test_case_in_31?
+    rb = "case :a\nin [:b, *c]\n  :d\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat, nil, s(:lit, :b).line(2), :"*c").line(2),
+             s(:lit, :d).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_32
+    assert_case_in "(1...3)", s(:dot3, s(:lit, 1).line(2), s(:lit, 3).line(2)).line(2)
+  end
+
+  def test_case_in_33
+    assert_case_in "(1...)", s(:dot3, s(:lit, 1).line(2), nil).line(2)
+  end
+
+  def test_case_in_34
+    assert_case_in "(..10)", s(:dot2, nil, s(:lit, 10).line(2)).line(2)
+  end
+
+  def test_case_in_35
+    assert_case_in "(...10)", s(:dot3, nil, s(:lit, 10).line(2)).line(2)
+  end
+
+  def test_case_in_36
+    rb = "[:a, b, c, [:d, *e, nil]]"
+    pt = s(:array_pat,
+           nil,
+           s(:lit, :a).line(2),
+           s(:lvar, :b).line(2),
+           s(:lvar, :c).line(2),
+           s(:array_pat,
+             nil,
+             s(:lit, :d).line(2),
+             :"*e",
+             s(:nil).line(2)).line(2)).line(2)
+
+    assert_case_in rb, pt
+  end
+
+  def test_case_in_37
+    rb = "case :a\nin { b: [Hash, *] }\n  :c\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               nil,
+               s(:lit, :b).line(2),
+               s(:array_pat, nil, s(:const, :Hash).line(2), :"*").line(2)
+              ).line(2),
+             s(:lit, :c).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_42
+    rb = "case :a\nin :b, *_ then nil\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat,
+               nil,
+               s(:lit, :b).line(2),
+               :"*_",
+              ).line(2),
+             s(:nil).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_42_2
+    rb = "case :a\nin A(*list) then nil\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat,
+               s(:const, :A).line(2),
+               :"*list").line(2),
+             s(:nil).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_42_3
+    assert_case_in ":b, *_, :c", s(:array_pat, nil,
+                                   s(:lit, :b).line(2),
+                                   :"*_",
+                                   s(:lit, :c).line(2)).line(2)
+  end
+
+
+  def test_case_in_47
+    rb = "case :a\nin [*, :b, :c]\n  :d\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat, nil, :*,
+               s(:lit, :b).line(2), s(:lit, :c).line(2)).line(2),
+             s(:lit, :d).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_67
+    rb = "case :a\nin 1.. then nil\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in, s(:dot2, s(:lit, 1).line(2), nil).line(2),
+             s(:nil).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_76
+    assert_case_in "`echo hi`", s(:xstr, "echo hi").line(2)
+  end
+
+  def test_case_in_77
+    assert_case_in "/regexp/", s(:lit, /regexp/).line(2)
+  end
+
+  def test_case_in_78
+    assert_case_in "%W[a b]", s(:array, s(:str, "a").line(2), s(:str, "b").line(2)).line(2)
+  end
+
+  def test_case_in_79
+    assert_case_in "%w[a b]", s(:array, s(:str, "a").line(2), s(:str, "b").line(2)).line(2)
+  end
+
+  def test_case_in_80
+    assert_case_in "%I[a b]", s(:array, s(:lit, :a).line(2), s(:lit, :b).line(2)).line(2)
+  end
+
+  def test_case_in_81
+    assert_case_in "%i[a b]", s(:array, s(:lit, :a).line(2), s(:lit, :b).line(2)).line(2)
+  end
+
+  def test_case_in_83
+    rb = "[->(b) { true }, c]"
+    pt = s(:array_pat, nil,
+           s(:iter, s(:lambda).line(2), s(:args, :b).line(2),
+             s(:true).line(2)).line(2),
+           s(:lvar, :c).line(2)).line(2)
+
+    assert_case_in rb, pt
+  end
+
+  def test_case_in_85
+    rb = "[[:b, c], [:d, ^e]]"
+    pt = s(:array_pat, nil,
+           s(:array_pat, nil,
+             s(:lit, :b).line(2),
+             s(:lvar, :c).line(2)).line(2),
+           s(:array_pat,
+             nil,
+             s(:lit, :d).line(2),
+             s(:lvar, :e).line(2)).line(2),
+          ).line(2)
+
+    assert_case_in rb, pt
+  end
+
+  def test_case_in_86
+    rb = "case [:a, :b]\nin ::NilClass, * then nil\nend"
+    pt = s(:case,
+           s(:array, s(:lit, :a).line(1), s(:lit, :b).line(1)).line(1),
+           s(:in,
+             s(:array_pat,
+               nil,
+               s(:colon3, :NilClass).line(2),
+               :*).line(2),
+             s(:nil).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_86_2
+    rb = "case [:a, :b]\nin *, ::NilClass then nil\nend"
+    pt = s(:case,
+           s(:array, s(:lit, :a).line(1), s(:lit, :b).line(1)).line(1),
+           s(:in,
+             s(:array_pat,
+               nil,
+               :*,
+               s(:colon3, :NilClass).line(2)).line(2),
+             s(:nil).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_array_pat_const
+    rb = "case :a\nin B[c]\n  :d\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat,
+               s(:const, :B).line(2),
+               s(:lvar, :c).line(2)).line(2),
+             s(:lit, :d).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_array_pat_const2
+    rb = "case :a\nin B::C[d]\n  :e\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat,
+               s(:const, s(:colon2, s(:const, :B).line(2), :C).line(2)).line(2),
+               s(:lvar, :d).line(2)).line(2),
+             s(:lit, :e).line(3)).line(2),
+          nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_array_pat_paren_assign
+    rb = "case :a\nin B(C => d)\n  :d\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:array_pat,
+               s(:const, :B).line(2),
+               s(:lasgn, :d, s(:const, :C).line(2)).line(2)).line(2),
+             s(:lit, :d).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_const
+    rb = "case Array\nin Class\n  :b\nend"
+    pt = s(:case, s(:const, :Array).line(1),
+           s(:in, s(:const, :Class).line(2),
+             s(:lit, :b).line(3)).line(2),
+           nil).line 1
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_else
+    rb = "case Array\nin Class\n  :b\nelse\n  :c\nend\n"
+    pt = s(:case, s(:const, :Array).line(1),
+           s(:in, s(:const, :Class).line(2),
+             s(:lit, :b).line(3)).line(2),
+          s(:lit, :c).line(5)).line 1
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_hash_pat
+    rb = "case :a\nin { b: 'c', d: \"e\" } then\n  :f\nend\n"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               nil,
+               s(:lit, :b).line(2), s(:str, "c").line(2),
+               s(:lit, :d).line(2), s(:str, "e").line(2)).line(2),
+             s(:lit, :f).line(3)
+             ).line(2),
+          nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_hash_pat_assign
+    rb = "case :a\nin { b: Integer => x, d: \"e\", f: } then\n  :g\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               nil,
+               s(:lit, :b).line(2), # =>
+               s(:lasgn, :x, s(:const, :Integer).line(2)).line(2),
+               s(:lit, :d).line(2), s(:str, "e").line(2),
+               s(:lit, :f).line(2), nil).line(2),
+             s(:lit, :g).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_hash_pat_paren_assign
+    rb = "case :a\nin B(a: 42)\n  :d\nend"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               s(:const, :B).line(2),
+               s(:lit, :a).line(2), s(:lit, 42).line(2)).line(2),
+             s(:lit, :d).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_hash_pat_paren_true
+    rb = "case :a\nin b: true then\n  :c\nend\n"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               nil,
+               s(:lit, :b).line(2), s(:true).line(2)).line(2),
+             s(:lit, :c).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_hash_pat_rest
+    rb = "case :a\nin b: c, **rest then :d\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               nil,
+               s(:lit, :b).line(2),
+               s(:lvar, :c).line(2),
+               s(:kwrest, :"**rest").line(2)).line(2),
+             s(:lit, :d).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_hash_pat_rest_solo
+    rb = "case :a\nin **rest then :d\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat,
+               nil,
+               s(:kwrest, :"**rest").line(2)).line(2),
+             s(:lit, :d).line(2)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_if_unless_post_mod
+    rb = "case :a\nin A if true\n  :C\nin D unless false\n  :E\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:if, s(:true).line(2), s(:const, :A).line(2), nil).line(2),
+             s(:lit, :C).line(3)).line(2),
+           s(:in,
+             s(:if, s(:false).line(4), nil, s(:const, :D).line(4)).line(4),
+             s(:lit, :E).line(5)).line(4),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_multiple
+    rb = "case :a\nin A::B\n  :C\nin D::E\n  :F\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:const, s(:colon2, s(:const, :A).line(2), :B).line(2)).line(2),
+             s(:lit, :C).line(3)).line(2),
+           s(:in,
+             s(:const, s(:colon2, s(:const, :D).line(4), :E).line(4)).line(4),
+             s(:lit, :F).line(5)).line(4),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_or
+    rb = "case :a\nin B | C\n  :d\nend\n"
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in,
+             s(:or,
+               s(:const, :B).line(2),
+               s(:const, :C).line(2)).line(2),
+             s(:lit, :d).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_in_expr_no_case
+    rb = "'woot' in String"
+    pt = s(:case, s(:str, "woot").line(1),
+           s(:in, s(:const, :String).line(1),
+             nil).line(1),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_019
+    rb = <<~RUBY
+        case 0
+        in -1..1
+          true
+        end
+      RUBY
+
+    pt = s(:case,
+           s(:lit, 0).line(1),
+           s(:in, s(:dot2, s(:lit, -1).line(2), s(:lit, 1).line(2)).line(2),
+             s(:true).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_044
+      rb = <<~RUBY
+        case obj
+        in Object[]
+          true
+        end
+      RUBY
+    pt = s(:case,
+           s(:call, nil, :obj).line(1),
+           s(:in, s(:array_pat, s(:const, :Object).line(2)).line(2),
+             s(:true).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_051
+    rb = <<~RUBY
+        case [0, 1, 2]
+        in [0, 1,]
+          true
+        end
+      RUBY
+    pt = s(:case,
+           s(:array,
+             s(:lit, 0).line(1),
+             s(:lit, 1).line(1),
+             s(:lit, 2).line(1)).line(1),
+           s(:in,
+             s(:array_pat,
+               nil,
+               s(:lit, 0).line(2),
+               s(:lit, 1).line(2),
+               :*).line(666),
+             s(:true).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_058
+    rb = <<~RUBY
+        case {a: 0}
+        in {a:, **rest}
+          [a, rest]
+        end
+      RUBY
+    pt = s(:case,
+           s(:hash,
+             s(:lit, :a).line(1),
+             s(:lit, 0).line(1)).line(1),
+           s(:in,
+             s(:hash_pat, nil, s(:lit, :a).line(2), nil,
+               s(:kwrest, :"**rest").line(2)).line(2),
+             s(:array,
+               s(:lvar, :a).line(3),
+               s(:lvar, :rest).line(3)).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_058_2
+    rb = <<~RUBY
+        case {a: 0}
+        in {a:, **}
+          [a]
+        end
+      RUBY
+    pt = s(:case,
+           s(:hash,
+             s(:lit, :a).line(1),
+             s(:lit, 0).line(1)).line(1),
+           s(:in,
+             s(:hash_pat, nil, s(:lit, :a).line(2), nil,
+               s(:kwrest, :"**").line(2)).line(2),
+             s(:array,
+               s(:lvar, :a).line(3)).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_069
+    rb = <<~RUBY
+        case :a
+        in Object[b: 1]
+          1
+        end
+      RUBY
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:hash_pat, s(:const, :Object).line(2),
+               s(:lit, :b).line(2), s(:lit, 1).line(2)).line(2),
+             s(:lit, 1).line(3)).line(2),
+           nil).line(1)
+
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_pattern_076
+    rb = <<~RUBY
+        case {a: 1}
+        in {a: 1, **nil}
+          true
+        end
+      RUBY
+    pt = s(:case,
+           s(:hash, s(:lit, :a).line(1), s(:lit, 1).line(1)).line(1),
+           s(:in,
+             s(:hash_pat, nil,
+               s(:lit, :a).line(2), s(:lit, 1).line(2),
+               s(:kwrest, :"**nil").line(2)).line(2),
+             s(:true).line(3)).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  # def test_case_in_TEMPLATE
+  #   rb = "case :a\nin XXX then\n  YYY\nend\n"
+  #   pt = s(:case, s(:lit, :a).line(1),
+  #          s(:in,
+  #            ZZZ,
+  #            WWW).line(2),
+  #          nil).line(1)
+  #
+  #   assert_parse rb, pt
+  # end
+end
+
+module TestPatternMatching30
+  def test_case_in_20
+    assert_case_in("Symbol(*lhs, x, *rhs)",
+                   s(:find_pat,
+                     s(:const, :Symbol).line(2),
+                     :"*lhs",
+                     s(:array_pat, s(:lvar, :x).line(2)).line(2),
+                     :"*rhs").line(2))
+  end
+
+  def test_case_in_22
+    assert_case_in("Symbol[*lhs, x, *rhs]",
+                   s(:find_pat, s(:const, :Symbol).line(2),
+                     :"*lhs",
+                     s(:array_pat, s(:lvar, :x).line(2)).line(2),
+                     :"*rhs").line(2))
+  end
+end
+
+module TestRubyParserShared27Plus
+  include TestRubyParserShared26Plus
+  include TestPatternMatching
+
+  def test_block_args_kwargs
+    rb = "f { |**kwargs| kwargs }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :"**kwargs"),
+           s(:lvar, :kwargs))
+
+    assert_parse rb, pt
+  end
+
+  def test_block_args_no_kwargs
+    rb = "f { |**nil| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :"**nil"))
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_defn_forward_args
+    rb = "def a(...); b(...); end"
+    pt = s(:defn, :a, s(:args, s(:forward_args)),
+          s(:call, nil, :b, s(:forward_args)))
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_defn_arg_forward_args
+    rb = "def a(x, ...); b(x, ...); end"
+    pt = s(:defn, :a, s(:args, :x, s(:forward_args)),
+           s(:call, nil, :b, s(:lvar, :x), s(:forward_args)))
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_defn_args_forward_args
+    rb = "def a(x, y, z, ...); b(:get, z, ...); end"
+    pt = s(:defn, :a, s(:args, :x, :y, :z, s(:forward_args)),
+           s(:call, nil, :b, s(:lit, :get), s(:lvar, :z),
+             s(:forward_args)))
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_defn_no_kwargs
+    # def x(**nil)
+    # end
+    #
+    # def y(**kw)
+    # end
+    #
+    # def z()
+    # end
+    #
+    # x arg: 42 # $!: no keywords accepted (ArgumentError)
+    # y arg: 42 # fine
+    # z arg: 42 # $!: wrong number of arguments (given 1, expected 0) (ArgumentError)
+
+    rb = "def x(**nil); end"
+    pt = s(:defn, :x, s(:args, :"**nil").line(1),
+           s(:nil).line(1)).line(1)
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_call_forward_args_outside_method_definition
+    rb = "b(...)"
+
+    assert_syntax_error rb, "Unexpected ..."
+  end
+
+  def test_call_arg_forward_args_outside_method_definition
+    rb = "b(x, ...)"
+
+    assert_syntax_error rb, "Unexpected ..."
+  end
+
+  def test_mlhs_rescue
+    # same:
+    # a = (24 rescue 42)
+    # a = 24 rescue 42
+
+    # same:
+    # a, b = (f rescue 42)
+    # a, b = f rescue 42
+
+    rb = "a, b = f rescue 42"
+    pt = s(:masgn,
+           s(:array, s(:lasgn, :a), s(:lasgn, :b)),
+           s(:to_ary,
+             s(:rescue,
+               s(:call, nil, :f),
+               s(:resbody, s(:array),
+                 s(:lit, 42)))))
+
+    assert_parse rb, pt
+  end
+end
+
+module TestRubyParserShared30Plus
+  include TestRubyParserShared27Plus
+  include TestPatternMatching30
+
+  def test_rhs_asgn
+    rb = "42 => n"
+    pt = s(:case,
+           s(:lit, 42).line(1),
+           s(:in, s(:lvar, :n).line(1), nil).line(1), nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_find
+    rb = "case :a\n  in *a, :+, *b\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:find_pat, nil,
+               :"*a",
+               s(:array_pat, s(:lit, :+).line(2)).line(2),
+               :"*b").line(2),
+             nil).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_case_in_find_array
+    rb = "case :a\nin [*, :b, c, *]\nend"
+    pt = s(:case,
+           s(:lit, :a).line(1),
+           s(:in,
+             s(:find_pat, nil,
+               :*,
+               s(:array_pat, s(:lit, :b).line(2), s(:lvar, :c).line(2)).line(2),
+               :*).line(2),
+             nil).line(2),
+           nil).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_defn_oneliner
+    rb = "def exec(cmd) = system(cmd)"
+    pt = s(:defn, :exec, s(:args, :cmd).line(1),
+           s(:call, nil, :system, s(:lvar, :cmd).line(1)).line(1)).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_defn_oneliner_rescue
+    rb = "def exec(cmd)\n  system(cmd)\nrescue\n  nil\nend\n"
+    pt = s(:defn, :exec, s(:args, :cmd),
+           s(:rescue,
+             s(:call, nil, :system, s(:lvar, :cmd)),
+            s(:resbody, s(:array), s(:nil))))
+    assert_parse rb, pt
+
+    rb = "def exec(cmd)\n  system(cmd) rescue nil\nend\n"
+    assert_parse rb, pt
+
+    rb = "def exec(cmd) = system(cmd) rescue nil"
+    assert_parse rb, pt
+  end
+
+  def test_defs_oneliner
+    rb = "def self.exec(cmd) = system(cmd)"
+    pt = s(:defs,
+           s(:self).line(1),
+           :exec,
+           s(:args, :cmd).line(1),
+           s(:call, nil, :system, s(:lvar, :cmd).line(1)).line(1)).line(1)
+
+    assert_parse rb, pt
+  end
+
+  def test_defs_oneliner_rescue
+    rb = "def self.exec(cmd)\n  system(cmd)\nrescue\n  nil\nend\n"
+    pt = s(:defs, s(:self), :exec, s(:args, :cmd),
+           s(:rescue,
+             s(:call, nil, :system, s(:lvar, :cmd)),
+            s(:resbody, s(:array), s(:nil))))
+    assert_parse rb, pt
+
+    rb = "def self.exec(cmd)\n  system(cmd) rescue nil\nend\n"
+    assert_parse rb, pt
+
+    rb = "def self.exec(cmd) = system(cmd) rescue nil"
+    assert_parse rb, pt
+  end
+
+  def test_defn_oneliner_setter
+    rb = "class X\n  def x=(o) = 42\nend"
+
+    assert_syntax_error rb, /setter method cannot be defined/
+  end
+
+  def test_defs_oneliner_setter
+    rb = "class X\n  def self.x= = 42\nend"
+
+    assert_syntax_error rb, /setter method cannot be defined/
+  end
+end
+
+class Minitest::Test
+  def skip s = "blah"
+    warn "ignoring skip for %s: %s" % [name, s]
+  end
+end if ENV["NOSKIP"]
+
+class TestRubyParser < Minitest::Test
+  def test_cls_version
+    assert_equal 23, RubyParser::V23.version
+    assert_equal 24, RubyParser::V24.version
+    assert_equal 24, Ruby24Parser.version
+    refute RubyParser::Parser.version
+  end
+
+  def test_parse
+    processor = RubyParser.new
+
+    rb = "a.()"
+    pt = s(:call, s(:call, nil, :a), :call)
+
+    assert_equal pt, processor.parse(rb)
+
+    # bad syntax
+    e = assert_raises Racc::ParseError do
+      capture_io do
+        processor.parse "a.("
+      end
+    end
+
+    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
+
+class RubyParserTestCase < ParseTreeTestCase
+  attr_accessor :result, :processor
+
+  make_my_diffs_pretty!
+
+  def self.previous key
+    "Ruby"
   end
 
   def self.generate_test klass, node, data, input_name, output_name
@@ -4195,7 +5342,14 @@ class RubyParserTestCase < ParseTreeTestCase
   end
 
   def assert_parse rb, pt
-    self.result = processor.parse rb
+    timeout = (ENV["RP_TIMEOUT"] || 10).to_i
+
+    if ENV["RP_LINES"] then # TODO: make default once tests cleaned up
+      pt.deep_each { |s| s.line ||= 1 }
+      pt.line ||= 1
+    end
+
+    self.result = processor.parse rb, "(string)", timeout
     assert_equal pt, result
   end
 
@@ -4224,15 +5378,20 @@ class RubyParserTestCase < ParseTreeTestCase
     ENV["VERBOSE"] = old_env
   end
 
-  def assert_syntax_error rb, emsg
+  def assert_syntax_error rb, emsg, klass = RubyParser::SyntaxError
     e = nil
     assert_silent do
-      e = assert_raises RubyParser::SyntaxError do
+      e = assert_raises klass do
         processor.parse rb
       end
     end
 
-    assert_equal emsg, e.message
+    case emsg
+    when String
+      assert_equal emsg, e.message
+    else
+      assert_match emsg, e.message
+    end
   end
 
   def refute_parse rb
@@ -4249,17 +5408,6 @@ class TestRubyParserV20 < RubyParserTestCase
 
     self.processor = RubyParser::V20.new
   end
-
-  def test_bug162__20
-    skip "not ready for this yet"
-
-    # Ignore everything after \r in heredoc marker in <= 2.0 #162
-
-    rb = %q(<<E\nfoo\nE\rO)
-    pt = s(:str, "foo\n")
-
-    assert_parse rb, pt
-  end
 end
 
 class TestRubyParserV21 < RubyParserTestCase
@@ -4318,7 +5466,7 @@ class TestRubyParserV24 < RubyParserTestCase
 
     assert_parse rb, pt
 
-    assert_parse_error "a(b rescue c)", /parse error on value ..rescue/
+    assert_parse_error "a(b rescue c)", /parse error on value .rescue/
   end
 end
 
@@ -4429,10 +5577,11 @@ class TestRubyParserV26 < RubyParserTestCase
 
     assert_parse_line rb, pt, 1
   end
-
 end
 
 class TestRubyParserV27 < RubyParserTestCase
+  make_my_diffs_pretty!
+
   include TestRubyParserShared27Plus
 
   def setup
@@ -4440,8 +5589,37 @@ class TestRubyParserV27 < RubyParserTestCase
 
     self.processor = RubyParser::V27.new
   end
+
+  def test_bdot2
+    rb = "..10\n; ..a\n; c"
+    pt = s(:block,
+           s(:dot2, nil, s(:lit, 10).line(1)).line(1),
+           s(:dot2, nil, s(:call, nil, :a).line(2)).line(2),
+           s(:call, nil, :c).line(3)).line(1)
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_bdot3
+    rb = "...10\n; ...a\n; c"
+    pt = s(:block,
+           s(:dot3, nil, s(:lit, 10).line(1)).line(1),
+           s(:dot3, nil, s(:call, nil, :a).line(2)).line(2),
+           s(:call, nil, :c).line(3)).line(1)
+
+    assert_parse_line rb, pt, 1
+  end
 end
 
+class TestRubyParserV30 < RubyParserTestCase
+  include TestRubyParserShared30Plus
+
+  def setup
+    super
+
+    self.processor = RubyParser::V30.new
+  end
+end
 
 RubyParser::VERSIONS.each do |klass|
   v = klass.version