ruby_parser 3.6.6 → 3.7.0

data/lib/ruby_parser_extras.rb

@@ -91,7 +91,7 @@ class RPStringScanner < StringScanner
 end
 
 module RubyParserStuff
-  VERSION = "3.6.6" unless constants.include? "VERSION" # SIGH
+  VERSION = "3.7.0" unless constants.include? "VERSION" # SIGH
 
   attr_accessor :lexer, :in_def, :in_single, :file
   attr_reader :env, :comments
@@ -1319,6 +1319,10 @@ module RubyParserStuff
   end
 end
 
+class Ruby22Parser < Racc::Parser
+  include RubyParserStuff
+end
+
 class Ruby21Parser < Racc::Parser
   include RubyParserStuff
 end
@@ -1348,11 +1352,12 @@ class RubyParser
     @p19 = Ruby19Parser.new
     @p20 = Ruby20Parser.new
     @p21 = Ruby21Parser.new
+    @p22 = Ruby22Parser.new
   end
 
   def process s, f = "(string)", t = 10
     e = nil
-    [@p21, @p20, @p19, @p18].each do |parser|
+    [@p22, @p21, @p20, @p19, @p18].each do |parser|
       begin
         return parser.process s, f, t
       rescue Racc::ParseError, RubyParser::SyntaxError => exc
@@ -1369,6 +1374,7 @@ class RubyParser
     @p19.reset
     @p20.reset
     @p21.reset
+    @p22.reset
   end
 
   def self.for_current_ruby
@@ -1381,6 +1387,8 @@ class RubyParser
       Ruby20Parser.new
     when /^2.1/ then
       Ruby21Parser.new
+    when /^2.2/ then
+      Ruby22Parser.new
     else
       raise "unrecognized RUBY_VERSION #{RUBY_VERSION}"
     end

data/test/test_ruby_lexer.rb

@@ -518,10 +518,10 @@ class TestRubyLexer < Minitest::Test
   def test_yylex_const_call_same_name
     assert_lex("X = a { }; b { f :c }",
                s(:block,
-                 s(:cdecl, :X, s(:iter, s(:call, nil, :a), s(:args))),
+                 s(:cdecl, :X, s(:iter, s(:call, nil, :a), 0)),
                  s(:iter,
                    s(:call, nil, :b),
-                   s(:args),
+                   0,
                    s(:call, nil, :f, s(:lit, :c)))),
 
                :tCONSTANT,   "X", :expr_cmdarg, 0, 0,
@@ -539,10 +539,10 @@ class TestRubyLexer < Minitest::Test
 
     assert_lex("X = a { }; b { X :c }",
                s(:block,
-                 s(:cdecl, :X, s(:iter, s(:call, nil, :a), s(:args))),
+                 s(:cdecl, :X, s(:iter, s(:call, nil, :a), 0)),
                  s(:iter,
                    s(:call, nil, :b),
-                   s(:args),
+                   0,
                    s(:call, nil, :X, s(:lit, :c)))),
 
                :tCONSTANT,   "X", :expr_cmdarg, 0, 0,
@@ -2294,10 +2294,12 @@ class TestRubyLexer < Minitest::Test
   end
 
   def test_yylex_string_double_pound_dollar_bad
+    skip if Ruby18Parser === lexer.parser
+
     assert_lex3('"#$%"', nil,
 
                 :tSTRING_BEG,     "\"",  :expr_beg,
-                :tSTRING_CONTENT, "#$%", :expr_beg,
+                :tSTRING_CONTENT, '#$%', :expr_beg,
                 :tSTRING_END,     "\"",  :expr_end)
   end
 
@@ -2641,13 +2643,13 @@ class TestRubyLexer < Minitest::Test
   end
 
   def test_yylex_hash_colon_quoted_22
-    skip "Waiting for 2.2 parser"
+    setup_lexer_class Ruby22Parser
 
     assert_lex("{'a':1}",
                s(:hash, s(:lit, :a), s(:lit, 1)),
 
                :tLBRACE, "{", :expr_beg,    0, 1,
-               :tSYMBOL, "a", :expr_end,    0, 1,
+               :tLABEL,  "a", :expr_end,    0, 1,
                :tINTEGER, 1,  :expr_end,    0, 1,
                :tRCURLY, "}", :expr_endarg, 0, 0)
   end

data/test/test_ruby_parser.rb

@@ -121,7 +121,7 @@ module TestRubyParserShared
     rb = "a.b (1) {c}"
     pt = s(:iter,
            s(:call, s(:call, nil, :a), :b, s(:lit, 1)),
-           s(:args),
+           0,
            s(:call, nil, :c))
 
     assert_parse rb, pt
@@ -131,7 +131,7 @@ module TestRubyParserShared
     rb = "a::b (1) {c}"
     pt =  s(:iter,
             s(:call, s(:call, nil, :a), :b, s(:lit, 1)),
-            s(:args),
+            0,
             s(:call, nil, :c))
 
     assert_parse rb, pt
@@ -226,7 +226,7 @@ module TestRubyParserShared
     rb = "a do\n  v = nil\n  begin\n    yield\n  rescue Exception => v\n    break\n  end\nend"
     pt = s(:iter,
            s(:call, nil, :a),
-           s(:args),
+           0,
            s(:block,
              s(:lasgn, :v, s(:nil)),
              s(:rescue,
@@ -942,6 +942,10 @@ module TestRubyParserShared
     Ruby21Parser === self.processor
   end
 
+  def ruby22
+    Ruby22Parser === self.processor
+  end
+
   def test_bug_comma
     val = if ruby18 then
             s(:lit, 100)
@@ -997,7 +1001,7 @@ module TestRubyParserShared
     rb = "not(a)"
     pt = if ruby18 then
            s(:not, s(:call, nil, :a))
-         elsif ruby19 or ruby20 or ruby21 then
+         elsif ruby19 or ruby20 or ruby21 or ruby22 then
            s(:call, s(:call, nil, :a), :"!")
          else
            raise "wtf"
@@ -1008,7 +1012,7 @@ module TestRubyParserShared
 
   def test_pipe_space
     rb = "a.b do | | end"
-    pt = s(:iter, s(:call, s(:call, nil, :a), :b), 0)
+    pt = s(:iter, s(:call, s(:call, nil, :a), :b), s(:args))
 
     assert_parse rb, pt
   end
@@ -1591,7 +1595,7 @@ module TestRubyParserShared
   end
 end
 
-module TestRubyParserShared19to21
+module TestRubyParserShared19to22
   def test_aref_args_lit_assocs
     rb = "[1, 2 => 3]"
     pt = s(:array, s(:lit, 1), s(:hash, s(:lit, 2), s(:lit, 3)))
@@ -1610,7 +1614,7 @@ module TestRubyParserShared19to21
     rb = "a.b c do end.d"
     pt = s(:call,
            s(:iter,
-             s(:call, s(:call, nil, :a), :b, s(:call, nil, :c)), s(:args)),
+             s(:call, s(:call, nil, :a), :b, s(:call, nil, :c)), 0),
            :d)
 
     assert_parse rb, pt
@@ -1620,7 +1624,7 @@ module TestRubyParserShared19to21
     rb = "a.b c do end::d"
     pt = s(:call,
            s(:iter,
-             s(:call, s(:call, nil, :a), :b, s(:call, nil, :c)), s(:args)),
+             s(:call, s(:call, nil, :a), :b, s(:call, nil, :c)), 0),
            :d)
 
     assert_parse rb, pt
@@ -1629,7 +1633,7 @@ module TestRubyParserShared19to21
   def test_block_command_operation_dot
     rb = "a :b do end.c :d"
     pt = s(:call,
-           s(:iter, s(:call, nil, :a, s(:lit, :b)), s(:args)),
+           s(:iter, s(:call, nil, :a, s(:lit, :b)), 0),
            :c,
            s(:lit, :d))
 
@@ -1639,7 +1643,7 @@ module TestRubyParserShared19to21
   def test_block_command_operation_colon
     rb = "a :b do end::c :d"
     pt = s(:call,
-           s(:iter, s(:call, nil, :a, s(:lit, :b)), s(:args)),
+           s(:iter, s(:call, nil, :a, s(:lit, :b)), 0),
            :c,
            s(:lit, :d))
 
@@ -1707,6 +1711,17 @@ module TestRubyParserShared19to21
     assert_parse rb, pt
   end
 
+  def test_bug_187
+    rb = "private def f\na.b do end\nend"
+    pt = s(:call,
+           nil,
+           :private,
+           s(:defn, :f, s(:args),
+             s(:iter, s(:call, s(:call, nil, :a), :b), 0)))
+
+    assert_parse rb, pt
+  end
+
   def test_defn_opt_reg
     rb = "def f(a=nil, b) end"
     pt = s(:defn, :f, s(:args, s(:lasgn, :a, s(:nil)), :b), s(:nil))
@@ -2006,7 +2021,7 @@ module TestRubyParserShared19to21
 
   def test_do_lambda
     rb = "->() do end"
-    pt = s(:iter, s(:call, nil, :lambda), 0)
+    pt = s(:iter, s(:call, nil, :lambda), s(:args))
 
     assert_parse rb, pt
   end
@@ -2129,9 +2144,26 @@ module TestRubyParserShared19to21
 
     assert_parse rb, pt
   end
+
+  def test_multiline_hash_declaration
+    pt = s(:call, nil, :f, s(:hash, s(:lit, :state), s(:hash)))
+
+    assert_parse "f(state: {})",     pt
+    assert_parse "f(state: {\n})",   pt
+    assert_parse "f(state:\n {\n})", pt
+  end
 end
 
-module TestRubyParserShared20to21
+module TestRubyParserShared20to22
+  def test_defs_kwarg
+    skip "not yet"
+
+    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_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))
@@ -2442,7 +2474,7 @@ end
 
 class TestRuby19Parser < RubyParserTestCase
   include TestRubyParserShared
-  include TestRubyParserShared19to21
+  include TestRubyParserShared19to22
 
   def setup
     super
@@ -2681,7 +2713,7 @@ class TestRuby19Parser < RubyParserTestCase
            s(:lit, :a),
            s(:iter,
              s(:call, nil, :lambda),
-             s(:args),
+             0,
              s(:if, s(:call, nil, :b), s(:call, nil, :c), s(:call, nil, :d))),
 
            s(:lit, :e),
@@ -2690,12 +2722,14 @@ class TestRuby19Parser < RubyParserTestCase
     assert_parse rb, pt
   end
 
-  # def test_pipe_semicolon # HACK
-  #   rb = "a.b do | ; c | end"
-  #   pt = s(:iter, s(:call, s(:call, nil, :a), :b), 0)
-  #
-  #   assert_parse rb, pt
-  # end
+  def test_pipe_semicolon
+    skip "not yet"
+
+    rb = "a.b do | ; c | end"
+    pt = s(:iter, s(:call, s(:call, nil, :a), :b), 0)
+
+    assert_parse rb, pt
+  end
 
   def test_wtf
     # lambda -> f_larglist lambda_body
@@ -2799,12 +2833,14 @@ class TestRuby19Parser < RubyParserTestCase
     assert_parse rb, pt
   end
 
-  # def test_kill_me5
-  #   rb = "f ->() { g do end }"
-  #   pt = 42
-  #
-  #   assert_parse rb, pt
-  # end
+  def test_kill_me5
+    skip "not yet"
+
+    rb = "f ->() { g do end }"
+    pt = 42
+
+    assert_parse rb, pt
+  end
 
   def test_iter_args_4
     rb = "f { |a, *b, c| }"
@@ -2814,6 +2850,8 @@ class TestRuby19Parser < RubyParserTestCase
   end
 
   def test_iter_args_5
+    skip "not yet"
+
     rb = "f { |a, &b| }"
     pt = s(:iter, s(:call, nil, :f), s(:args, :a, :"&b"))
 
@@ -3013,13 +3051,21 @@ class TestRuby19Parser < RubyParserTestCase
   end
 
   def test_lambda_do_vs_brace
-    pt = s(:call, nil, :f, s(:iter, s(:call, nil, :lambda), 0))
+    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
@@ -3042,8 +3088,8 @@ end
 
 class TestRuby20Parser < RubyParserTestCase
   include TestRubyParserShared
-  include TestRubyParserShared20to21
-  include TestRubyParserShared19to21
+  include TestRubyParserShared20to22
+  include TestRubyParserShared19to22
 
   def setup
     super
@@ -3057,7 +3103,7 @@ class TestRuby20Parser < RubyParserTestCase
            s(:call,
              s(:iter,
                s(:call, s(:call, nil, :a), :b, s(:call, nil, :c)),
-               s(:args),
+               0,
                s(:call, nil, :d)),
              :e),
            s(:args, :f),
@@ -3073,7 +3119,7 @@ class TestRuby20Parser < RubyParserTestCase
            s(:call,
              s(:iter,
                s(:call, s(:call, nil, :a), :b, s(:call, nil, :c)),
-               s(:args),
+               0,
                s(:call, nil, :d)),
              :e,
              s(:call, nil, :f)),
@@ -3213,8 +3259,8 @@ end
 
 class TestRuby21Parser < RubyParserTestCase
   include TestRubyParserShared
-  include TestRubyParserShared19to21
-  include TestRubyParserShared20to21
+  include TestRubyParserShared19to22
+  include TestRubyParserShared20to22
 
   def setup
     super
@@ -3289,3 +3335,75 @@ class TestRuby21Parser < RubyParserTestCase
     assert_parse rb, pt
   end
 end
+
+class TestRuby22Parser < RubyParserTestCase
+  include TestRubyParserShared
+  include TestRubyParserShared19to22
+  include TestRubyParserShared20to22
+
+  def setup
+    super
+
+    self.processor = Ruby22Parser.new
+  end
+
+  def test_call_args_assoc_quoted
+    pt = s(:call, nil, :x, s(:hash, s(:lit, :k), s(:lit, 42)))
+
+    rb = "x 'k':42"
+    assert_parse rb, pt
+
+    rb = 'x "k":42'
+    assert_parse rb, pt
+
+    rb = 'x "#{k}":42'
+    pt = s(:call, nil, :x, s(:hash, s(:dsym, "", s(:evstr, s(:call, nil, :k))), s(:lit, 42)))
+
+    assert_parse rb, pt
+  end
+
+  def test_bug191
+    pt = s(:if, s(:call, nil, :a), s(:str, ""), s(:call, nil, :b))
+
+    rb = "a ? '': b"
+    assert_parse rb, pt
+
+    rb = "a ? \"\": b"
+    assert_parse rb, pt
+  end
+end
+
+[18, 19, 20, 21, 22].each do |v|
+  describe "block args arity #{v}" do
+    attr_accessor :parser
+
+    before do
+      self.parser = Object.const_get("Ruby#{v}Parser").new
+    end
+
+    {
+     "->       {    }" => s(:iter, s(:call, nil, :lambda),           0),
+     "lambda   {    }" => s(:iter, s(:call, nil, :lambda),           0),
+     "proc     {    }" => s(:iter, s(:call, nil, :proc),             0),
+     "Proc.new {    }" => s(:iter, s(:call, s(:const, :Proc), :new), 0),
+
+     "-> ()    {    }" => s(:iter, s(:call, nil, :lambda),           s(:args)),
+     "lambda   { || }" => s(:iter, s(:call, nil, :lambda),           s(:args)),
+     "proc     { || }" => s(:iter, s(:call, nil, :proc),             s(:args)),
+     "Proc.new { || }" => s(:iter, s(:call, s(:const, :Proc), :new), s(:args)),
+
+    }.each do |input, expected|
+      next if v == 18 and input =~ /->/
+      next if v == 19 and input =~ /-> \(\)/
+
+      it "parses '#{input}'" do
+        assert_equal expected, parser.parse(input)
+      end
+
+      input = input.sub(/\{/, "do").sub(/\}/, "end")
+      it "parses '#{input}'" do
+        assert_equal expected, parser.parse(input)
+      end
+    end
+  end
+end