ruby_parser 3.8.4 → 3.9.0

data/test/test_ruby_parser.rb

@@ -2,16 +2,16 @@
 
 # ENV['VERBOSE'] = "1"
 
-require 'rubygems'
-require 'minitest/autorun'
-require 'ruby_parser'
+require "minitest/autorun"
+require "ruby_parser"
 
-$: << File.expand_path('~/Work/p4/zss/src/sexp_processor/dev/lib')
+$: << File.expand_path("~/Work/p4/zss/src/sexp_processor/dev/lib")
 
-require 'pt_testcase'
+require "pt_testcase"
 
 class Sexp
   alias oldeq2 ==
+  # TODO: push up to Sexp
   def ==(obj) # :nodoc:
     if obj.class == self.class then
       super and
@@ -22,62 +22,6 @@ class Sexp
   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
-    return if node.to_s =~ /bmethod|dmethod/
-    return if Array === data['Ruby']
-
-    output_name = "ParseTree"
-
-    super
-  end
-
-  def assert_parse rb, pt
-    self.result = processor.parse rb
-    assert_equal pt, result
-  end
-
-  def refute_parse rb
-    self.result = processor.parse rb
-    assert_nil result
-  end
-
-  def assert_syntax_error rb, emsg
-    e = nil
-    assert_silent do
-      e = assert_raises RubyParser::SyntaxError do
-        processor.parse rb
-      end
-    end
-
-    assert_equal emsg, e.message
-  end
-
-  def assert_parse_error rb, emsg
-    e = nil
-    assert_silent do
-      e = assert_raises Racc::ParseError do
-        processor.parse rb
-      end
-    end
-
-    assert_equal emsg, e.message
-  end
-
-  def assert_parse_line rb, pt, line
-    assert_parse rb, pt
-    assert_equal line, result.line,   "call should have line number"
-  end
-end
-
 module TestRubyParserShared
   def setup
     super
@@ -388,7 +332,7 @@ module TestRubyParserShared
   end
 
   def test_lasgn_env
-    rb = 'a = 42'
+    rb = "a = 42"
     pt = s(:lasgn, :a, s(:lit, 42))
     expected_env = { :a => :lvar }
 
@@ -397,7 +341,7 @@ module TestRubyParserShared
   end
 
   def test_lasgn_ivar_env
-    rb = '@a = 42'
+    rb = "@a = 42"
     pt = s(:iasgn, :@a, s(:lit, 42))
 
     assert_parse rb, pt
@@ -484,15 +428,15 @@ module TestRubyParserShared
     assert_equal s(:str, "blah"), processor.literal_concat(lhs, rhs)
   end
 
-  def test_logop_12
+  def test_logical_op_12
     lhs = s(:lit, 1)
     rhs = s(:lit, 2)
     exp = s(:and, s(:lit, 1), s(:lit, 2))
 
-    assert_equal exp, processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logical_op(:and, lhs, rhs)
   end
 
-  def test_logop_1234_5
+  def test_logical_op_1234_5
     lhs = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:and, s(:lit, 3), s(:lit, 4))))
     rhs = s(:lit, 5)
     exp = s(:and,
@@ -505,10 +449,10 @@ module TestRubyParserShared
                   s(:lit, 4),
                   s(:lit, 5)))))
 
-    assert_equal exp, processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logical_op(:and, lhs, rhs)
   end
 
-  def test_logop_123_4
+  def test_logical_op_123_4
     lhs = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:lit, 3)))
     rhs = s(:lit, 4)
     exp = s(:and,
@@ -519,18 +463,18 @@ module TestRubyParserShared
                 s(:lit, 3),
                 s(:lit, 4))))
 
-    assert_equal exp, processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logical_op(:and, lhs, rhs)
   end
 
-  def test_logop_12_3
+  def test_logical_op_12_3
     lhs = s(:and, s(:lit, 1), s(:lit, 2))
     rhs = s(:lit, 3)
     exp = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:lit, 3)))
 
-    assert_equal exp, processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logical_op(:and, lhs, rhs)
   end
 
-  def test_logop_nested_mix
+  def test_logical_op_nested_mix
     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,
@@ -540,7 +484,7 @@ module TestRubyParserShared
     lhs.paren = true
     rhs.paren = true
 
-    assert_equal exp, processor.logop(:or, lhs, rhs)
+    assert_equal exp, processor.logical_op(:or, lhs, rhs)
   end
 
   def test_str_evstr
@@ -553,7 +497,7 @@ module TestRubyParserShared
   def test_dsym_to_sym
     pt = s(:alias, s(:lit, :<<), s(:lit, :>>))
 
-    rb = 'alias :<< :>>'
+    rb = "alias :<< :>>"
     assert_parse rb, pt
 
     rb = 'alias :"<<" :">>"'
@@ -761,6 +705,15 @@ module TestRubyParserShared
     assert_parse rb, pt
   end
 
+  def test_parse_line_hash_lit
+    rb = "{\n:s1 => 1,\n}"
+    pt = s(:hash,
+           s(:lit, :s1).line(2), s(:lit, 1).line(2),
+          ).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..."
 
@@ -857,6 +810,19 @@ module TestRubyParserShared
     assert_parse_line rb, pt, 1
   end
 
+  def test_parse_line_rescue
+    skip "not yet"
+    rb = "begin\n a\n rescue\n b\n rescue\n c\n end\n"
+    pt = s(:rescue,
+           s(:call, nil, :a).line(2),
+           s(:resbody, s(:array).line(3),
+             s(:call, nil, :b).line(4)).line(3),
+           s(:resbody, s(:array).line(5),
+             s(:call, nil, :c).line(6)).line(5)).line(1)
+
+    assert_parse_line rb, pt, 1
+  end
+
   def test_parse_line_return
     rb = <<-RUBY
       def blah
@@ -943,27 +909,7 @@ module TestRubyParserShared
   end
 
   def ruby18
-    Ruby18Parser === self.processor
-  end
-
-  def ruby19
-    Ruby19Parser === self.processor
-  end
-
-  def ruby20
-    Ruby20Parser === self.processor
-  end
-
-  def ruby21
-    Ruby21Parser === self.processor
-  end
-
-  def ruby22
-    Ruby22Parser === self.processor
-  end
-
-  def ruby23
-    Ruby23Parser === self.processor
+    RubyParser::V18 === self.processor
   end
 
   def test_bug_comma
@@ -1021,10 +967,8 @@ module TestRubyParserShared
     rb = "not(a)"
     pt = if ruby18 then
            s(:not, s(:call, nil, :a))
-         elsif ruby19 or ruby20 or ruby21 or ruby22 or ruby23 then
-           s(:call, s(:call, nil, :a), :"!")
          else
-           raise "wtf"
+           s(:call, s(:call, nil, :a), :"!")
          end
 
     assert_parse rb, pt
@@ -1627,11 +1571,11 @@ module TestRubyParserShared
 
   def test___ENCODING__
     rb = "__ENCODING__"
-    pt = if Ruby18Parser === processor then
+    pt = if RubyParser::V18 === processor then
            s(:call, nil, :__ENCODING__)
          else
            if defined? Encoding then
-             if Ruby18Parser === processor then
+             if RubyParser::V18 === processor then
                s(:call, nil, :__ENCODING__)
              else
                s(:colon2, s(:const, :Encoding), :UTF_8)
@@ -1657,9 +1601,117 @@ module TestRubyParserShared
     assert_syntax_error "def a; class B; end; end", err
     assert_syntax_error "def a; def b; end; class B; end; end", err
   end
+
+  def test_call_not
+    rb = "not 42"
+    pt = s(:not, s(:lit, 42))
+
+    assert_parse rb, pt
+  end
+
+  def test_call_bang_command_call
+    rb = "! a.b 1"
+    pt = s(:not, s(:call, s(:call, nil, :a), :b, s(:lit, 1)))
+
+    assert_parse rb, pt
+  end
+
+  def test_call_unary_bang
+    rb = "!1"
+    pt = s(:not, s(:lit, 1))
+
+    assert_parse rb, pt
+  end
+
+  def test_bang_eq
+    rb = "1 != 2"
+    pt = s(:not, s(:call, s(:lit, 1), :"==", s(:lit, 2)))
+
+    assert_parse rb, pt
+  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
+
+  def test_parse_until_not_canonical
+    rb = "until not var.nil?\n  'foo'\nend"
+
+    pt = s(:while,
+           s(:call, s(:call, nil, :var), :nil?),
+           s(:str, "foo"), true)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_until_not_noncanonical
+    rb = "until not var.nil?\n  'foo'\nend"
+    pt = s(:until,
+           s(:not, s(:call, s(:call, nil, :var), :nil?)),
+           s(:str, "foo"), true)
+
+    processor.canonicalize_conditions = false
+
+    assert_parse rb, pt
+  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), :nil?),
+           s(:str, "bar"),
+           s(:str, "foo"))
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_if_not_noncanonical
+    rb = "if not var.nil? then 'foo' else 'bar'\nend"
+    pt = s(:if,
+           s(:not, s(:call, s(:call, nil, :var), :nil?)),
+           s(:str, "foo"),
+           s(:str, "bar"))
+
+    processor.canonicalize_conditions = false
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_while_not_canonical
+    rb = "while not var.nil?\n  'foo'\nend"
+    pt = s(:until,
+           s(:call, s(:call, nil, :var), :nil?),
+           s(:str, "foo"), true)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_while_not_noncanonical
+    rb = "while not var.nil?\n  'foo'\nend"
+    pt = s(:while,
+           s(:not, s(:call, s(:call, nil, :var), :nil?)),
+           s(:str, "foo"), true)
+
+    processor.canonicalize_conditions = false
+
+    assert_parse rb, pt
+  end
+
 end
 
-module TestRubyParserShared19to22
+module TestRubyParserShared19Plus
   def test_aref_args_lit_assocs
     rb = "[1, 2 => 3]"
     pt = s(:array, s(:lit, 1), s(:hash, s(:lit, 2), s(:lit, 3)))
@@ -2223,429 +2275,66 @@ module TestRubyParserShared19to22
     assert_parse "f(state: {\n})",   pt
     assert_parse "f(state:\n {\n})", pt
   end
-end
-
-module TestRubyParserShared20to22
-  def test_non_interpolated_symbol_array_line_breaks
 
-    rb = "%i(\na\nb\n)\n1"
-    pt = s(:block,
+  def test_mlhs_back_splat
+    rb = "a, b, c, *s = f"
+    pt = s(:masgn,
            s(:array,
-             s(:lit, :a).line(2),
-             s(:lit, :b).line(3)).line(1),
-           s(:lit, 1).line(5))
+             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
+             s(:splat, s(:lasgn, :s))),
+           s(:to_ary, s(:call, nil, :f)))
+
     assert_parse rb, pt
   end
 
-  def test_interpolated_symbol_array_line_breaks
-
-    rb = "%I(\na\nb\n)\n1"
-    pt = s(:block,
+  def test_mlhs_back_anonsplat
+    rb = "a, b, c, * = f"
+    pt = s(:masgn,
            s(:array,
-             s(:lit, :a).line(2),
-             s(:lit, :b).line(3)).line(1),
-           s(:lit, 1).line(5))
+             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
+             s(:splat)),
+           s(:to_ary, s(:call, nil, :f)))
+
     assert_parse rb, pt
   end
 
-  def test_defs_kwarg
-    rb = "def self.a b: 1\nend"
-    pt = s(:defs, s(:self), :a, s(:args, s(:kwarg, :b, s(:lit, 1))), s(:nil))
+  def test_mlhs_mid_splat
+    rb = "a, b, c, *s, x, y, z = f"
+    pt = s(:masgn,
+           s(:array,
+             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
+             s(:splat, s(:lasgn, :s)),
+             s(:lasgn, :x), s(:lasgn, :y), s(:lasgn, :z)),
+           s(:to_ary, s(:call, nil, :f)))
 
     assert_parse rb, pt
   end
 
-  def test_defn_kwarg_kwsplat
-    rb = "def a(b: 1, **c) end"
-    pt = s(:defn, :a, s(:args, s(:kwarg, :b, s(:lit, 1)), :"**c"), s(:nil))
+  def test_mlhs_mid_anonsplat
+    rb = "a, b, c, *, x, y, z = f"
+    pt = s(:masgn,
+           s(:array, s(:lasgn, :a), s(:splat), s(:lasgn, :z)),
+           s(:to_ary, s(:call, nil, :f)))
+    pt = s(:masgn,
+           s(:array,
+             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
+             s(:splat),
+             s(:lasgn, :x), s(:lasgn, :y), s(:lasgn, :z)),
+           s(:to_ary, s(:call, nil, :f)))
 
     assert_parse rb, pt
   end
 
-  def test_defn_kwarg_kwsplat_anon
-    rb = "def a(b: 1, **) end"
-    pt = s(:defn, :a, s(:args, s(:kwarg, :b, s(:lit, 1)), :"**"), s(:nil))
-
-    assert_parse rb, pt
-  end
-
-  def test_defn_kwarg_env
-    rb = "def test(**testing) test_splat(**testing) end"
-    pt = s(:defn, :test, s(:args, :"**testing"),
-           s(:call, nil, :test_splat, s(:hash, s(:kwsplat, s(:lvar, :testing)))))
-
-    assert_parse rb, pt
-  end
-
-  def test_dstr_lex_state
-    rb = '"#{p:a}"'
-    pt = s(:dstr, "", s(:evstr, s(:call, nil, :p, s(:lit, :a))))
-
-    assert_parse rb, pt
-  end
-
-  def test_call_arg_kwsplat
-    rb = "a(b, **1)"
-    pt = s(:call, nil, :a, s(:call, nil, :b), s(:hash, s(:kwsplat, s(:lit, 1))))
-
-    assert_parse rb, pt
-  end
-
-  def test_call_arg_assoc_kwsplat
-    rb = "f(1, kw: 2, **3)"
-    pt = s(:call, nil, :f,
-           s(:lit, 1),
-           s(:hash, s(:lit, :kw), s(:lit, 2), s(:kwsplat, s(:lit, 3))))
-
-    assert_parse rb, pt
-  end
-
-  def test_call_kwsplat
-    rb = "a(**1)"
-    pt = s(:call, nil, :a, s(:hash, s(:kwsplat, s(:lit, 1))))
-
-    assert_parse rb, pt
-  end
-
-  def test_iter_kwarg
-    rb = "a { |b: 1| }"
-    pt = s(:iter, s(:call, nil, :a), s(:args, s(:kwarg, :b, s(:lit, 1))))
-
-    assert_parse rb, pt
-  end
-
-  def test_iter_kwarg_kwsplat
-    rb = "a { |b: 1, **c| }"
-    pt = s(:iter, s(:call, nil, :a), s(:args, s(:kwarg, :b, s(:lit, 1)), :"**c"))
-
-    assert_parse rb, pt
-  end
-
-  def test_block_kwarg_lvar
-    rb = "bl { |kw: :val| kw }"
-    pt = s(:iter, s(:call, nil, :bl), s(:args, s(:kwarg, :kw, s(:lit, :val))),
-           s(:lvar, :kw))
-
-    assert_parse rb, pt
-  end
-
-  def test_block_kwarg_lvar_multiple
-    rb = "bl { |kw: :val, kw2: :val2 | kw }"
-    pt = s(:iter, s(:call, nil, :bl),
-           s(:args,
-             s(:kwarg, :kw, s(:lit, :val)),
-             s(:kwarg, :kw2, s(:lit, :val2))),
-           s(:lvar, :kw))
-
-    assert_parse rb, pt
-  end
-end
-
-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)
-
-    assert_equal pt, processor.parse(rb)
-
-    # bad syntax
-    e = assert_raises Racc::ParseError do
-      capture_io do
-        processor.parse "a.("
-      end
-    end
-
-    msg = "(string):1 :: parse error on value \"(\" (tLPAREN2)"
-    assert_equal msg, e.message.strip
-  end
-end
-
-class TestRuby18Parser < RubyParserTestCase
-  include TestRubyParserShared
-
-  def setup
-    super
-
-    self.processor = Ruby18Parser.new
-  end
-
-  def test_call_space_before_paren_args
-    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
-
-  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
-
-  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_parse_until_not_canonical
-    rb = "until not var.nil?\n  'foo'\nend"
-
-    pt = s(:while,
-           s(:call, s(:call, nil, :var), :nil?),
-           s(:str, "foo"), true)
-
-    assert_parse rb, pt
-  end
-
-  def test_parse_until_not_noncanonical
-    rb = "until not var.nil?\n  'foo'\nend"
-    pt = s(:until,
-           s(:not, s(:call, s(:call, nil, :var), :nil?)),
-           s(:str, "foo"), true)
-
-    processor.canonicalize_conditions = false
-
-    assert_parse rb, pt
-  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), :nil?),
-           s(:str, "bar"),
-           s(:str, "foo"))
-
-    assert_parse rb, pt
-  end
-
-  def test_parse_if_not_noncanonical
-    rb = "if not var.nil? then 'foo' else 'bar'\nend"
-    pt = s(:if,
-           s(:not, s(:call, s(:call, nil, :var), :nil?)),
-           s(:str, "foo"),
-           s(:str, "bar"))
-
-    processor.canonicalize_conditions = false
-
-    assert_parse rb, pt
-  end
-
-  def test_parse_while_not_canonical
-    rb = "while not var.nil?\n  'foo'\nend"
-    pt = s(:until,
-           s(:call, s(:call, nil, :var), :nil?),
-           s(:str, "foo"), true)
-
-    assert_parse rb, pt
-  end
-
-  def test_parse_while_not_noncanonical
-    rb = "while not var.nil?\n  'foo'\nend"
-    pt = s(:while,
-           s(:not, s(:call, s(:call, nil, :var), :nil?)),
-           s(:str, "foo"), true)
-
-    processor.canonicalize_conditions = false
-
-    assert_parse rb, pt
-  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
-
-  # 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_call_unary_bang
-    rb = "!1"
-    pt = s(:not, s(:lit, 1))
-
-    assert_parse rb, pt
-  end
-
-  def test_bang_eq
-    rb = "1 != 2"
-    pt = s(:not, s(:call, s(:lit, 1), :"==", s(:lit, 2)))
-
-    assert_parse rb, pt
-  end
-
-  def test_call_not
-    rb = "not 42"
-    pt = s(:not, s(:lit, 42))
-
-    assert_parse rb, pt
-  end
-
-  def test_call_bang_command_call
-    rb = "! a.b 1"
-    pt = s(:not, s(:call, s(:call, nil, :a), :b, s(:lit, 1)))
-
-    assert_parse rb, pt
-  end
-end
-
-class TestRuby19Parser < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19to22
-
-  def setup
-    super
-
-    self.processor = Ruby19Parser.new
-  end
-
-  def test_mlhs_back_splat
-    rb = "a, b, c, *s = f"
-    pt = s(:masgn,
-           s(:array,
-             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
-             s(:splat, s(:lasgn, :s))),
-           s(:to_ary, s(:call, nil, :f)))
-
-    assert_parse rb, pt
-  end
-
-  def test_mlhs_back_anonsplat
-    rb = "a, b, c, * = f"
-    pt = s(:masgn,
-           s(:array,
-             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
-             s(:splat)),
-           s(:to_ary, s(:call, nil, :f)))
-
-    assert_parse rb, pt
-  end
-
-  def test_mlhs_mid_splat
-    rb = "a, b, c, *s, x, y, z = f"
-    pt = s(:masgn,
-           s(:array,
-             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
-             s(:splat, s(:lasgn, :s)),
-             s(:lasgn, :x), s(:lasgn, :y), s(:lasgn, :z)),
-           s(:to_ary, s(:call, nil, :f)))
-
-    assert_parse rb, pt
-  end
-
-  def test_mlhs_mid_anonsplat
-    rb = "a, b, c, *, x, y, z = f"
-    pt = s(:masgn,
-           s(:array, s(:lasgn, :a), s(:splat), s(:lasgn, :z)),
-           s(:to_ary, s(:call, nil, :f)))
-    pt = s(:masgn,
-           s(:array,
-             s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c),
-             s(:splat),
-             s(:lasgn, :x), s(:lasgn, :y), s(:lasgn, :z)),
-           s(:to_ary, s(:call, nil, :f)))
-
-    assert_parse rb, pt
-  end
-
-  def test_mlhs_front_splat
-    rb = "*s, x, y, z = f"
-    pt = s(:masgn,
-           s(:array, s(:splat, s(:lasgn, :s)), s(:lasgn, :z)),
-           s(:to_ary, s(:call, nil, :f)))
-    pt = s(:masgn,
-           s(:array,
-             s(:splat, s(:lasgn, :s)),
-             s(:lasgn, :x), s(:lasgn, :y), s(:lasgn, :z)),
-           s(:to_ary, s(:call, nil, :f)))
+  def test_mlhs_front_splat
+    rb = "*s, x, y, z = f"
+    pt = s(:masgn,
+           s(:array, s(:splat, s(:lasgn, :s)), s(:lasgn, :z)),
+           s(:to_ary, s(:call, nil, :f)))
+    pt = s(:masgn,
+           s(:array,
+             s(:splat, s(:lasgn, :s)),
+             s(:lasgn, :x), s(:lasgn, :y), s(:lasgn, :z)),
+           s(:to_ary, s(:call, nil, :f)))
 
     assert_parse rb, pt
   end
@@ -2866,7 +2555,7 @@ class TestRuby19Parser < RubyParserTestCase
     assert_parse rb, pt
   end
 
-  def test_block_args_opt2
+  def test_block_args_opt2_2
     rb = "f { |a, b = 42, c = 24| [a, b, c] }"
     pt = s(:iter,
            s(:call, nil, :f),
@@ -3062,144 +2751,341 @@ class TestRuby19Parser < RubyParserTestCase
     assert_parse rb, pt
   end
 
-  def test_iter_args_11_1
-    rb = "f { |a, b = 42, *c, d| }"
-    pt = s(:iter, s(:call, nil, :f),
-           s(:args, :a, s(:lasgn, :b, s(:lit, 42)), :"*c", :d))
+  def test_iter_args_11_1
+    rb = "f { |a, b = 42, *c, d| }"
+    pt = s(:iter, s(:call, nil, :f),
+           s(:args, :a, s(:lasgn, :b, s(:lit, 42)), :"*c", :d))
+
+    assert_parse rb, pt
+  end
+
+  def test_iter_args_11_2
+    rb = "f { |a, b = 42, *c, d, &e| }"
+    pt = s(:iter, s(:call, nil, :f),
+           s(:args, :a, s(:lasgn, :b, s(:lit, 42)), :"*c", :d, :"&e"))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_6
+    # | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
+    rb = "f { |a, (b, *c, d)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :b, :"*c", :d)))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_7
+    # | f_marg_list tCOMMA tSTAR
+    rb = "f { |a, (b, *)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :b, :*)))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_8
+    # | f_marg_list tCOMMA tSTAR tCOMMA f_marg_list
+    rb = "f { |a, (b, *, c)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :b, :*, :c)))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_9
+    # | tSTAR f_norm_arg
+    rb = "f { |a, (*b)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :"*b")))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_10
+    # | tSTAR f_norm_arg tCOMMA f_marg_list
+    rb = "f { |a, (*b, c)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :"*b", :c)))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_11
+    # | tSTAR
+    rb = "f { |a, (*)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :*)))
+
+    assert_parse rb, pt
+  end
+
+  def test_kill_me_12
+    # | tSTAR tCOMMA f_marg_list
+    rb = "f { |a, (*, b)| }"
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:args, :a, s(:masgn, :*, :b)))
+
+    assert_parse rb, pt
+  end
+
+  def test_index_0
+    rb = "a[] = b"
+    pt = s(:attrasgn, s(:call, nil, :a), :[]=, s(:call, nil, :b))
+
+    assert_parse rb, pt
+  end
+
+  def test_lambda_do_vs_brace
+    pt = s(:call, nil, :f, s(:iter, s(:call, nil, :lambda), s(:args)))
+
+    rb = "f ->() {}"
+    assert_parse rb, pt
+
+    rb = "f ->() do end"
+    assert_parse rb, pt
+
+    pt = s(:call, nil, :f, s(:iter, s(:call, nil, :lambda), 0))
+
+    rb = "f -> {}"
+    assert_parse rb, pt
+
+    rb = "f -> do end"
+    assert_parse rb, pt
+  end
+
+  def test_thingy
+    pt = s(:call, s(:call, nil, :f), :call, s(:lit, 42))
+
+    rb = "f.(42)"
+    assert_parse rb, pt
+
+    rb = "f::(42)"
+    assert_parse rb, pt
+  end
+
+  def test_unary_plus_on_literal
+    rb = "+:a"
+    pt = s(:call, s(:lit, :a), :+@)
+
+    assert_parse rb, pt
+  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_iter_args_11_2
-    rb = "f { |a, b = 42, *c, d, &e| }"
-    pt = s(:iter, s(:call, nil, :f),
-           s(:args, :a, s(:lasgn, :b, s(:lit, 42)), :"*c", :d, :"&e"))
+  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
 
-  def test_kill_me_6
-    # | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
-    rb = "f { |a, (b, *c, d)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :b, :"*c", :d)))
+module TestRubyParserShared20Plus
+  def test_non_interpolated_symbol_array_line_breaks
 
+    rb = "%i(\na\nb\n)\n1"
+    pt = s(:block,
+           s(:array,
+             s(:lit, :a).line(2),
+             s(:lit, :b).line(3)).line(1),
+           s(:lit, 1).line(5))
     assert_parse rb, pt
   end
 
-  def test_kill_me_7
-    # | f_marg_list tCOMMA tSTAR
-    rb = "f { |a, (b, *)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :b, :*)))
+  def test_interpolated_symbol_array_line_breaks
 
+    rb = "%I(\na\nb\n)\n1"
+    pt = s(:block,
+           s(:array,
+             s(:lit, :a).line(2),
+             s(:lit, :b).line(3)).line(1),
+           s(:lit, 1).line(5))
     assert_parse rb, pt
   end
 
-  def test_kill_me_8
-    # | f_marg_list tCOMMA tSTAR tCOMMA f_marg_list
-    rb = "f { |a, (b, *, c)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :b, :*, :c)))
+  def test_defs_kwarg
+    rb = "def self.a b: 1\nend"
+    pt = s(:defs, s(:self), :a, s(:args, s(:kwarg, :b, s(:lit, 1))), s(:nil))
 
     assert_parse rb, pt
   end
 
-  def test_kill_me_9
-    # | tSTAR f_norm_arg
-    rb = "f { |a, (*b)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :"*b")))
+  def test_defn_kwarg_kwsplat
+    rb = "def a(b: 1, **c) end"
+    pt = s(:defn, :a, s(:args, s(:kwarg, :b, s(:lit, 1)), :"**c"), s(:nil))
 
     assert_parse rb, pt
   end
 
-  def test_kill_me_10
-    # | tSTAR f_norm_arg tCOMMA f_marg_list
-    rb = "f { |a, (*b, c)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :"*b", :c)))
+  def test_defn_kwarg_kwsplat_anon
+    rb = "def a(b: 1, **) end"
+    pt = s(:defn, :a, s(:args, s(:kwarg, :b, s(:lit, 1)), :"**"), s(:nil))
 
     assert_parse rb, pt
   end
 
-  def test_kill_me_11
-    # | tSTAR
-    rb = "f { |a, (*)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :*)))
+  def test_defn_kwarg_env
+    rb = "def test(**testing) test_splat(**testing) end"
+    pt = s(:defn, :test, s(:args, :"**testing"),
+           s(:call, nil, :test_splat, s(:hash, s(:kwsplat, s(:lvar, :testing)))))
 
     assert_parse rb, pt
   end
 
-  def test_kill_me_12
-    # | tSTAR tCOMMA f_marg_list
-    rb = "f { |a, (*, b)| }"
-    pt = s(:iter,
-           s(:call, nil, :f),
-           s(:args, :a, s(:masgn, :*, :b)))
+  def test_dstr_lex_state
+    rb = '"#{p:a}"'
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :p, s(:lit, :a))))
 
     assert_parse rb, pt
   end
 
-  def test_index_0
-    rb = "a[] = b"
-    pt = s(:attrasgn, s(:call, nil, :a), :[]=, s(:call, nil, :b))
+  def test_call_arg_kwsplat
+    rb = "a(b, **1)"
+    pt = s(:call, nil, :a, s(:call, nil, :b), s(:hash, s(:kwsplat, s(:lit, 1))))
 
     assert_parse rb, pt
   end
 
-  def test_lambda_do_vs_brace
-    pt = s(:call, nil, :f, s(:iter, s(:call, nil, :lambda), s(:args)))
+  def test_call_arg_assoc_kwsplat
+    rb = "f(1, kw: 2, **3)"
+    pt = s(:call, nil, :f,
+           s(:lit, 1),
+           s(:hash, s(:lit, :kw), s(:lit, 2), s(:kwsplat, s(:lit, 3))))
 
-    rb = "f ->() {}"
     assert_parse rb, pt
+  end
+
+  def test_call_kwsplat
+    rb = "a(**1)"
+    pt = s(:call, nil, :a, s(:hash, s(:kwsplat, s(:lit, 1))))
 
-    rb = "f ->() do end"
     assert_parse rb, pt
+  end
 
-    pt = s(:call, nil, :f, s(:iter, s(:call, nil, :lambda), 0))
+  def test_iter_kwarg
+    rb = "a { |b: 1| }"
+    pt = s(:iter, s(:call, nil, :a), s(:args, s(:kwarg, :b, s(:lit, 1))))
 
-    rb = "f -> {}"
     assert_parse rb, pt
+  end
+
+  def test_iter_kwarg_kwsplat
+    rb = "a { |b: 1, **c| }"
+    pt = s(:iter, s(:call, nil, :a), s(:args, s(:kwarg, :b, s(:lit, 1)), :"**c"))
 
-    rb = "f -> do end"
     assert_parse rb, pt
   end
 
-  def test_thingy
-    pt = s(:call, s(:call, nil, :f), :call, s(:lit, 42))
+  def test_block_kwarg_lvar
+    rb = "bl { |kw: :val| kw }"
+    pt = s(:iter, s(:call, nil, :bl), s(:args, s(:kwarg, :kw, s(:lit, :val))),
+           s(:lvar, :kw))
 
-    rb = "f.(42)"
     assert_parse rb, pt
+  end
+
+  def test_block_kwarg_lvar_multiple
+    rb = "bl { |kw: :val, kw2: :val2 | kw }"
+    pt = s(:iter, s(:call, nil, :bl),
+           s(:args,
+             s(:kwarg, :kw, s(:lit, :val)),
+             s(:kwarg, :kw2, s(:lit, :val2))),
+           s(:lvar, :kw))
 
-    rb = "f::(42)"
     assert_parse rb, pt
   end
 
-  def test_unary_plus_on_literal
-    rb = "+:a"
-    pt = s(:call, s(:lit, :a), :+@)
+  def test_stabby_block_iter_call
+    rb = "x -> () do\na.b do\nend\nend"
+    pt = s(:call, nil, :x,
+           s(:iter,
+             s(:call, nil, :lambda),
+             s(:args),
+             s(:iter, s(:call, s(:call, nil, :a), :b), 0)))
 
     assert_parse rb, pt
   end
-end
-
-class TestRuby20Parser < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared20to22
-  include TestRubyParserShared19to22
 
-  def setup
-    super
+  def test_stabby_block_iter_call_no_target_with_arg
+    rb = "x -> () do\na(1) do\nend\nend"
+    pt = s(:call, nil, :x,
+           s(:iter,
+             s(:call, nil, :lambda),
+             s(:args),
+             s(:iter,
+               s(:call, nil, :a,
+                 s(:lit, 1)), 0)))
 
-    self.processor = Ruby20Parser.new
+    assert_parse rb, pt
   end
 
   def test_block_call_dot_op2_brace_block
@@ -3345,113 +3231,17 @@ class TestRuby20Parser < RubyParserTestCase
     assert_parse rb, pt
   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
-
   def test_iter_array_curly
     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
-  end
-end
-
-class TestRuby21Parser < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19to22
-  include TestRubyParserShared20to22
-
-  def setup
-    super
-
-    self.processor = Ruby21Parser.new
-  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
-
-class TestRuby22Parser < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19to22
-  include TestRubyParserShared20to22
-
-  def setup
-    super
-
-    self.processor = Ruby22Parser.new
+    assert_parse rb, pt
   end
+end
 
+module TestRubyParserShared22Plus
   def test_call_args_assoc_quoted
     pt = s(:call, nil, :x, s(:hash, s(:lit, :k), s(:lit, 42)))
 
@@ -3492,17 +3282,7 @@ class TestRuby22Parser < RubyParserTestCase
   end
 end
 
-class TestRuby23Parser < RubyParserTestCase
-  include TestRubyParserShared
-  include TestRubyParserShared19to22
-  include TestRubyParserShared20to22
-
-  def setup
-    super
-
-    self.processor = Ruby23Parser.new
-  end
-
+module TestRubyParserShared23Plus
   def test_safe_call
     rb = "a&.b"
     pt = s(:safe_call, s(:call, nil, :a), :b)
@@ -3524,6 +3304,13 @@ class TestRuby23Parser < RubyParserTestCase
     assert_parse rb, pt
   end
 
+  def test_safe_call_after_newline
+    rb = "a\n&.b"
+    pt = s(:safe_call, s(:call, nil, :a), :b)
+
+    assert_parse rb, pt
+  end
+
   def test_safe_calls
     rb = "a&.b&.c(1)"
     pt = s(:safe_call, s(:safe_call, s(:call, nil, :a), :b), :c, s(:lit, 1))
@@ -3604,22 +3391,311 @@ a + b
     )
 
     pt = s(:block,
-            s(:call, nil, :puts, s(:str, "hello my dear friend").line(1)).line(1),
-            s(:call, s(:call, nil, :a).line(6),
-              :+,
-              s(:call, nil, :b).line(6)).line(6)
+           s(:call, nil, :puts, s(:str, "hello my dear friend").line(1)).line(1),
+           s(:call, s(:call, nil, :a).line(6),
+             :+,
+             s(:call, nil, :b).line(6)).line(6)
           ).line(1)
 
     assert_parse rb, pt
   end
 end
 
-[18, 19, 20, 21, 22, 23].each do |v|
+module TestRubyParserShared24Plus
+  # ...version specific tests to go here...
+end
+
+class TestRubyParser < Minitest::Test
+  def test_cls_version
+    assert_equal 18, RubyParser::V18.version
+    assert_equal 23, RubyParser::V23.version
+    refute RubyParser::Parser.version
+  end
+
+  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)
+
+    assert_equal pt, processor.parse(rb)
+
+    # bad syntax
+    e = assert_raises Racc::ParseError do
+      capture_io do
+        processor.parse "a.("
+      end
+    end
+
+    msg = "(string):1 :: parse error on value \"(\" (tLPAREN2)"
+    assert_equal msg, e.message.strip
+  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
+    return if node.to_s =~ /bmethod|dmethod/
+    return if Array === data['Ruby']
+
+    output_name = "ParseTree"
+
+    super
+  end
+
+  def assert_parse rb, pt
+    self.result = processor.parse rb
+    assert_equal pt, result
+  end
+
+  def refute_parse rb
+    self.result = processor.parse rb
+    assert_nil result
+  end
+
+  def assert_syntax_error rb, emsg
+    e = nil
+    assert_silent do
+      e = assert_raises RubyParser::SyntaxError do
+        processor.parse rb
+      end
+    end
+
+    assert_equal emsg, e.message
+  end
+
+  def assert_parse_error rb, emsg
+    e = nil
+    assert_silent do
+      e = assert_raises Racc::ParseError do
+        processor.parse rb
+      end
+    end
+
+    assert_equal emsg, e.message
+  end
+
+  def assert_parse_line rb, pt, line
+    old_env = ENV["VERBOSE"]
+    ENV["VERBOSE"] = "1"
+
+    assert_parse rb, pt
+    assert_equal line, result.line,   "call should have line number"
+  ensure
+    ENV["VERBOSE"] = old_env
+  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
+    super
+
+    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
+    super
+
+    self.processor = RubyParser::V21.new
+  end
+end
+
+class TestRubyParserV22 < RubyParserTestCase
+  include TestRubyParserShared
+  include TestRubyParserShared19Plus
+  include TestRubyParserShared20Plus
+  include TestRubyParserShared21Plus
+  include TestRubyParserShared22Plus
+
+  def setup
+    super
+
+    self.processor = RubyParser::V22.new
+  end
+end
+
+class TestRubyParserV23 < RubyParserTestCase
+  include TestRubyParserShared
+  include TestRubyParserShared19Plus
+  include TestRubyParserShared20Plus
+  include TestRubyParserShared21Plus
+  include TestRubyParserShared22Plus
+  include TestRubyParserShared23Plus
+
+  def setup
+    super
+
+    self.processor = RubyParser::V23.new
+  end
+end
+
+class TestRubyParserV24 < RubyParserTestCase
+  include TestRubyParserShared
+  include TestRubyParserShared19Plus
+  include TestRubyParserShared20Plus
+  include TestRubyParserShared21Plus
+  include TestRubyParserShared22Plus
+  include TestRubyParserShared23Plus
+  include TestRubyParserShared24Plus
+
+  def setup
+    super
+
+    self.processor = RubyParser::V24.new
+  end
+end
+
+RubyParser::VERSIONS.each do |klass|
+  v = klass.version
   describe "block args arity #{v}" do
     attr_accessor :parser
 
     before do
-      self.parser = Object.const_get("Ruby#{v}Parser").new
+      self.parser = RubyParser.const_get("V#{v}").new
     end
 
     {