parser 1.1.0 → 1.2.0

data/test/test_parse_helper.rb

@@ -68,6 +68,7 @@ class TestParseHelper < MiniTest::Unit::TestCase
     assert_equal nil, traverse_ast(ast, %w(str))
 
     assert_equal s(:str, "foo"), traverse_ast(ast, %w(dstr str))
+    assert_equal s(:int, 2), traverse_ast(ast, %w(dstr int))
     assert_equal s(:int, 2), traverse_ast(ast, %w(dstr int/1))
     assert_equal s(:int, 3), traverse_ast(ast, %w(dstr int/2))
     assert_equal nil, traverse_ast(ast, %w(dstr int/3))

data/test/test_parser.rb

@@ -107,6 +107,13 @@ class TestParser < MiniTest::Unit::TestCase
       %q{^ begin
         |       ^ end
         |~~~~~~~~ expression})
+
+    assert_parses(
+      s(:str, 'foobar'),
+      %q{%q(foobar)},
+      %q{^^^ begin
+        |         ^ end
+        |~~~~~~~~~~ expression})
   end
 
   def test_string_interp
@@ -140,12 +147,10 @@ class TestParser < MiniTest::Unit::TestCase
           s(:ivar, :@a)),
         s(:str, 'bar')),
       %q{"foo#@a" "bar"},
-      %q{^ begin
-        |^ begin (dstr)
+      %q{^ begin (dstr)
         |       ^ end (dstr)
         |         ^ begin (str)
         |             ^ end (str)
-        |             ^ end
         |~~~~~~~~~~~~~~ expression})
   end
 
@@ -167,7 +172,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses(
       s(:sym, :foo),
       %q{:'foo'},
-      %q{ ^ begin
+      %q{^^ begin
         |     ^ end
         |~~~~~~ expression})
   end
@@ -179,9 +184,9 @@ class TestParser < MiniTest::Unit::TestCase
         s(:lvar, :bar),
         s(:str, 'baz')),
       %q{:"foo#{bar}baz"},
-      %q{ ^ begin
+      %q{^^ begin
         |              ^ end
-        | ~~~~~~~~~~~~~~ expression})
+        |~~~~~~~~~~~~~~~ expression})
   end
 
   def test_symbol_empty
@@ -429,8 +434,7 @@ class TestParser < MiniTest::Unit::TestCase
       %q[{ foo: 2 }],
       %q{^ begin
         |         ^ end
-        |     ^ operator (pair)
-        |  ~~~ expression (pair.sym)
+        |  ~~~~ expression (pair.sym)
         |  ~~~~~~ expression (pair)
         |~~~~~~~~~~ expression},
         ALL_VERSIONS - %w(1.8))
@@ -546,6 +550,7 @@ class TestParser < MiniTest::Unit::TestCase
       s(:const, s(:cbase), :Foo),
       %q{::Foo},
       %q{  ~~~ name
+        |~~ double_colon
         |~~~~~ expression})
   end
 
@@ -554,6 +559,7 @@ class TestParser < MiniTest::Unit::TestCase
       s(:const, s(:const, nil, :Bar), :Foo),
       %q{Bar::Foo},
       %q{     ~~~ name
+        |   ~~ double_colon
         |~~~~~~~~ expression})
   end
 
@@ -715,6 +721,7 @@ class TestParser < MiniTest::Unit::TestCase
       %q{::Foo = 10},
       %q{  ~~~ name
         |      ^ operator
+        |~~ double_colon
         |~~~~~~~~~~ expression
         })
   end
@@ -725,6 +732,7 @@ class TestParser < MiniTest::Unit::TestCase
       %q{Bar::Foo = 10},
       %q{     ~~~ name
         |         ^ operator
+        |   ~~ double_colon
         |~~~~~~~~~~~~~ expression
         })
   end
@@ -775,8 +783,10 @@ class TestParser < MiniTest::Unit::TestCase
         s(:mlhs, s(:lvasgn, :foo), s(:lvasgn, :bar)),
         s(:array, s(:int, 1), s(:int, 2))),
       %q{(foo, bar) = 1, 2},
-      %q{^ begin
-        |         ^ end})
+      %q{^ begin (mlhs)
+        |         ^ end (mlhs)
+        |~~~~~~~~~~ expression (mlhs)
+        |~~~~~~~~~~~~~~~~~ expression})
 
     assert_parses(
       s(:masgn,
@@ -962,7 +972,7 @@ class TestParser < MiniTest::Unit::TestCase
       s(:lvasgn, :foo,
         s(:array, s(:lvar, :bar), s(:int, 1))),
       %q{foo = bar, 1},
-      %q{      ~~~~~~ array
+      %q{      ~~~~~~ expression (array)
         |~~~~~~~~~~~~ expression})
 
     assert_parses(
@@ -1367,6 +1377,14 @@ class TestParser < MiniTest::Unit::TestCase
       %q{~~~ keyword
         |    ~~~ name
         |              ~~~ end})
+
+    assert_parses(
+      s(:def, :String, s(:args), s(:nil)),
+      %q{def String; end})
+
+    assert_parses(
+      s(:def, :String=, s(:args), s(:nil)),
+      %q{def String=; end})
   end
 
   def test_defs
@@ -1389,6 +1407,16 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses(
       s(:defs, s(:lvar, :foo), :foo, s(:args), s(:nil)),
       %q{def (foo).foo; end})
+
+    assert_parses(
+      s(:defs, s(:const, nil, :String), :foo,
+        s(:args), s(:nil)),
+      %q{def String.foo; end})
+
+    assert_parses(
+      s(:defs, s(:const, nil, :String), :foo,
+        s(:args), s(:nil)),
+      %q{def String::foo; end})
   end
 
   def test_defs_invalid
@@ -1410,7 +1438,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_diagnoses(
       [:error, :singleton_literal],
       %q{def (:foo).foo; end},
-      %q{     ~ location})
+      %q{     ~~~~ location})
 
     assert_diagnoses(
       [:error, :singleton_literal],
@@ -1442,8 +1470,8 @@ class TestParser < MiniTest::Unit::TestCase
       %q{undef foo, :bar, :"foo#{1}"},
       %q{~~~~~ keyword
         |      ~~~ expression (sym/1)
-        |          ~~~~ expression (sym/2)
-        |~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+        |           ~~~~ expression (sym/2)
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
   end
 
   #
@@ -2700,7 +2728,8 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses(
       s(:send, s(:lvar, :foo), :a=, s(:int, 1)),
       %q{foo.a = 1},
-      %q{    ~~~ selector
+      %q{    ~ selector
+        |      ^ operator
         |~~~~~~~~~ expression})
 
     assert_parses(
@@ -2722,8 +2751,6 @@ class TestParser < MiniTest::Unit::TestCase
         s(:int, 1), s(:int, 2)),
       %q{foo[1, 2]},
       %q{   ~~~~~~ selector
-        |   ^ begin
-        |        ^ end
         |~~~~~~~~~ expression})
   end
 
@@ -2739,9 +2766,8 @@ class TestParser < MiniTest::Unit::TestCase
       s(:send, s(:lvar, :foo), :[]=,
         s(:int, 1), s(:int, 2), s(:int, 3)),
       %q{foo[1, 2] = 3},
-      %q{   ~~~~~~~~ selector
-        |   ^ begin
-        |        ^ end
+      %q{   ~~~~~~ selector
+        |          ^ operator
         |~~~~~~~~~~~~~ expression})
   end
 
@@ -2779,7 +2805,7 @@ class TestParser < MiniTest::Unit::TestCase
         |    ^ end (args)
         |      ^ begin
         |        ^ end
-        |~~~~~ expression},
+        |~~~~~~~~~ expression},
       ALL_VERSIONS - %w(1.8))
 
     assert_parses(
@@ -3034,32 +3060,32 @@ class TestParser < MiniTest::Unit::TestCase
   def test_space_args_cmd
     assert_parses(
       s(:send, nil, :fun,
-        s(:send, nil, :f, s(:lvar, :bar))),
+        s(:begin, s(:send, nil, :f, s(:lvar, :bar)))),
       %q{fun (f bar)})
   end
 
   def test_space_args_arg
     assert_parses(
-      s(:send, nil, :fun, s(:int, 1)),
+      s(:send, nil, :fun, s(:begin, s(:int, 1))),
       %q{fun (1)})
   end
 
   def test_space_args_arg_block
     assert_parses(
       s(:block,
-        s(:send, nil, :fun, s(:int, 1)),
+        s(:send, nil, :fun, s(:begin, s(:int, 1))),
         s(:args), s(:nil)),
       %q{fun (1) {}})
 
     assert_parses(
       s(:block,
-        s(:send, s(:lvar, :foo), :fun, s(:int, 1)),
+        s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
         s(:args), s(:nil)),
       %q{foo.fun (1) {}})
 
     assert_parses(
       s(:block,
-        s(:send, s(:lvar, :foo), :fun, s(:int, 1)),
+        s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
         s(:args), s(:nil)),
       %q{foo::fun (1) {}})
   end
@@ -3067,7 +3093,7 @@ class TestParser < MiniTest::Unit::TestCase
   def test_space_args_arg_call
     assert_parses(
       s(:send, nil, :fun,
-        s(:send, s(:int, 1), :to_i)),
+        s(:send, s(:begin, s(:int, 1)), :to_i)),
       %q{fun (1).to_i})
   end
 
@@ -3461,8 +3487,8 @@ class TestParser < MiniTest::Unit::TestCase
       %q{~~ keyword
         |             ~~~~~ else
         |             ~~~~~ keyword (if)
+        |                           ~~~~ else (if)
         |                                   ~~~ end
-        |                                   ~~~ end (if)
         |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
   end
 
@@ -3479,21 +3505,28 @@ class TestParser < MiniTest::Unit::TestCase
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{if (a, b = foo); end},
-      %q{   ~~~~~~~~~~~~ location})
+      %q{    ~~~~~~~~~~ location})
   end
 
   def test_if_mod_masgn
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{1 if (a, b = foo)},
-      %q{     ~~~~~~~~~~~~ location})
+      %q{      ~~~~~~~~~~ location})
   end
 
   def test_tern_masgn
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{(a, b = foo) ? 1 : 2},
-      %q{~~~~~~~~~~~~ location})
+      %q{ ~~~~~~~~~~ location})
+  end
+
+  def test_cond_begin_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{if (bar; a, b = foo); end},
+      %q{         ~~~~~~~~~~ location})
   end
 
   # Case matching
@@ -3672,14 +3705,14 @@ class TestParser < MiniTest::Unit::TestCase
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{while (a, b = foo); end},
-      %q{      ~~~~~~~~~~~~ location})
+      %q{       ~~~~~~~~~~ location})
   end
 
   def test_while_mod_masgn
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{foo while (a, b = foo)},
-      %q{          ~~~~~~~~~~~~ location})
+      %q{           ~~~~~~~~~~ location})
   end
 
   def test_for
@@ -3719,16 +3752,14 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_break
     assert_parses(
-      s(:break, s(:lvar, :foo)),
+      s(:break, s(:begin, s(:lvar, :foo))),
       %q{break(foo)},
       %q{~~~~~ keyword
-        |     ^ begin
-        |         ^ end
         |~~~~~~~~~~ expression},
       ALL_VERSIONS - %w(1.8))
 
     assert_parses(
-      s(:break, s(:lvar, :foo)),
+      s(:break, s(:begin, s(:lvar, :foo))),
       %q{break(foo)},
       %q{~~~~~ keyword
         |~~~~~~~~~~ expression},
@@ -3756,16 +3787,14 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_return
     assert_parses(
-      s(:return, s(:lvar, :foo)),
+      s(:return, s(:begin, s(:lvar, :foo))),
       %q{return(foo)},
       %q{~~~~~~ keyword
-        |      ^ begin
-        |          ^ end
         |~~~~~~~~~~~ expression},
       ALL_VERSIONS - %w(1.8))
 
     assert_parses(
-      s(:return, s(:lvar, :foo)),
+      s(:return, s(:begin, s(:lvar, :foo))),
       %q{return(foo)},
       %q{~~~~~~ keyword
         |~~~~~~~~~~~ expression},
@@ -3793,16 +3822,14 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_next
     assert_parses(
-      s(:next, s(:lvar, :foo)),
+      s(:next, s(:begin, s(:lvar, :foo))),
       %q{next(foo)},
       %q{~~~~ keyword
-        |    ^ begin
-        |        ^ end
         |~~~~~~~~~ expression},
       ALL_VERSIONS - %w(1.8))
 
     assert_parses(
-      s(:next, s(:lvar, :foo)),
+      s(:next, s(:begin, s(:lvar, :foo))),
       %q{next(foo)},
       %q{~~~~ keyword
         |~~~~~~~~~ expression},
@@ -3840,25 +3867,28 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_rescue
     assert_parses(
-      s(:rescue, s(:send, nil, :meth),
-        s(:resbody, nil, nil, s(:lvar, :foo)),
-        nil),
+      s(:begin,
+        s(:rescue, s(:send, nil, :meth),
+          s(:resbody, nil, nil, s(:lvar, :foo)),
+          nil)),
       %q{begin; meth; rescue; foo; end},
       %q{~~~~~ begin
+        |             ~~~~~~ keyword (rescue.resbody)
+        |             ~~~~~~~~~~~ expression (rescue.resbody)
+        |       ~~~~~~~~~~~~~~~~~ expression (rescue)
         |                          ~~~ end
         |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
   end
 
   def test_rescue_else
     assert_parses(
-      s(:rescue, s(:send, nil, :meth),
-        s(:resbody, nil, nil, s(:lvar, :foo)),
-        s(:lvar, :bar)),
+      s(:begin,
+        s(:rescue, s(:send, nil, :meth),
+          s(:resbody, nil, nil, s(:lvar, :foo)),
+          s(:lvar, :bar))),
       %q{begin; meth; rescue; foo; else; bar; end},
-      %q{~~~~~ begin
-        |                          ~~~~ else
-        |                                     ~~~ end
-        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+      %q{                          ~~~~ else (rescue)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)})
   end
 
   def test_rescue_else_useless
@@ -3870,52 +3900,61 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_ensure
     assert_parses(
-      s(:ensure, s(:send, nil, :meth),
-        s(:lvar, :bar)),
+      s(:begin,
+        s(:ensure, s(:send, nil, :meth),
+          s(:lvar, :bar))),
       %q{begin; meth; ensure; bar; end},
       %q{~~~~~ begin
-        |             ~~~~~~ keyword
+        |             ~~~~~~ keyword (ensure)
+        |       ~~~~~~~~~~~~~~~~~ expression (ensure)
         |                          ~~~ end
         |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
   end
 
+  def test_ensure_empty
+    assert_parses(
+      s(:begin,
+        s(:ensure, s(:nil),
+          s(:nil))),
+      %q{begin ensure end},
+      %q{~~~~~ begin
+        |      ~~~~~~ keyword (ensure)
+        |      ~~~~~~ expression (ensure)
+        |             ~~~ end
+        |~~~~~~~~~~~~~~~~ expression})
+  end
+
   def test_rescue_ensure
     assert_parses(
-      s(:ensure,
-        s(:rescue,
-          s(:send, nil, :meth),
-          s(:resbody, nil, nil, s(:lvar, :baz)),
-          nil),
-        s(:lvar, :bar)),
+      s(:begin,
+        s(:ensure,
+          s(:rescue,
+            s(:send, nil, :meth),
+            s(:resbody, nil, nil, s(:lvar, :baz)),
+            nil),
+          s(:lvar, :bar))),
       %q{begin; meth; rescue; baz; ensure; bar; end},
-      %q{~~~~~ begin
-        |~~~~~ begin (rescue)
-        |                          ~~~~~~ keyword
-        |             ~~~~~~ keyword (rescue)
-        |                                       ~~~ end
-        |                                       ~~~ end (rescue)
-        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
-        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)})
+      %q{                          ~~~~~~ keyword (ensure)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure)
+        |             ~~~~~~ keyword (ensure.rescue.resbody)
+        |       ~~~~~~~~~~~~~~~~~ expression (ensure.rescue)})
   end
 
   def test_rescue_else_ensure
     assert_parses(
-      s(:ensure,
-        s(:rescue,
-          s(:send, nil, :meth),
-          s(:resbody, nil, nil, s(:lvar, :baz)),
-          s(:lvar, :foo)),
-        s(:lvar, :bar)),
+      s(:begin,
+        s(:ensure,
+          s(:rescue,
+            s(:send, nil, :meth),
+            s(:resbody, nil, nil, s(:lvar, :baz)),
+            s(:lvar, :foo)),
+          s(:lvar, :bar))),
       %q{begin; meth; rescue; baz; else foo; ensure; bar end},
-      %q{~~~~~ begin
-        |~~~~~ begin (rescue)
-        |                                    ~~~~~~ keyword
-        |             ~~~~~~ keyword (rescue)
-        |                          ~~~~ else (rescue)
-        |                                                ~~~ end
-        |                                                ~~~ end (rescue)
-        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
-        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)})
+      %q{                                    ~~~~~~ keyword (ensure)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure)
+        |             ~~~~~~ keyword (ensure.rescue.resbody)
+        |                          ~~~~ else (ensure.rescue)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure.rescue)})
   end
 
   def test_rescue_mod
@@ -3926,6 +3965,7 @@ class TestParser < MiniTest::Unit::TestCase
         nil),
       %q{meth rescue bar},
       %q{     ~~~~~~ keyword (resbody)
+        |     ~~~~~~~~~~ expression (resbody)
         |~~~~~~~~~~~~~~~ expression})
   end
 
@@ -3938,6 +3978,7 @@ class TestParser < MiniTest::Unit::TestCase
           nil)),
       %q{foo = meth rescue bar},
       %q{           ~~~~~~ keyword (rescue.resbody)
+        |           ~~~~~~~~~~ expression (rescue.resbody)
         |      ~~~~~~~~~~~~~~~ expression (rescue)
         |~~~~~~~~~~~~~~~~~~~~~ expression})
   end
@@ -3952,6 +3993,7 @@ class TestParser < MiniTest::Unit::TestCase
           nil)),
       %q{foo += meth rescue bar},
       %q{            ~~~~~~ keyword (rescue.resbody)
+        |            ~~~~~~~~~~ expression (rescue.resbody)
         |       ~~~~~~~~~~~~~~~ expression (rescue)
         |~~~~~~~~~~~~~~~~~~~~~~ expression},
       ALL_VERSIONS - %w(1.8))
@@ -3959,55 +4001,60 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_resbody_list
     assert_parses(
-      s(:rescue,
-        s(:send, nil, :meth),
-        s(:resbody,
-          s(:array, s(:const, nil, :Exception)),
-          nil,
-          s(:lvar, :bar)),
-        nil),
+      s(:begin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody,
+            s(:array, s(:const, nil, :Exception)),
+            nil,
+            s(:lvar, :bar)),
+          nil)),
       %q{begin; meth; rescue Exception; bar; end})
   end
 
   def test_resbody_list_mrhs
     assert_parses(
-      s(:rescue,
-        s(:send, nil, :meth),
-        s(:resbody,
-          s(:array,
-            s(:const, nil, :Exception),
-            s(:lvar, :foo)),
-          nil,
-          s(:lvar, :bar)),
-        nil),
+      s(:begin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody,
+            s(:array,
+              s(:const, nil, :Exception),
+              s(:lvar, :foo)),
+            nil,
+            s(:lvar, :bar)),
+          nil)),
       %q{begin; meth; rescue Exception, foo; bar; end})
   end
 
   def test_resbody_var
     assert_parses(
-      s(:rescue,
-        s(:send, nil, :meth),
-        s(:resbody, nil, s(:lvasgn, :ex), s(:lvar, :bar)),
-        nil),
+      s(:begin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody, nil, s(:lvasgn, :ex), s(:lvar, :bar)),
+          nil)),
       %q{begin; meth; rescue => ex; bar; end})
 
     assert_parses(
-      s(:rescue,
-        s(:send, nil, :meth),
-        s(:resbody, nil, s(:ivasgn, :@ex), s(:lvar, :bar)),
-        nil),
+      s(:begin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody, nil, s(:ivasgn, :@ex), s(:lvar, :bar)),
+          nil)),
       %q{begin; meth; rescue => @ex; bar; end})
   end
 
   def test_resbody_list_var
     assert_parses(
-      s(:rescue,
-        s(:send, nil, :meth),
-        s(:resbody,
-          s(:array, s(:lvar, :foo)),
-          s(:lvasgn, :ex),
-          s(:lvar, :bar)),
-        nil),
+      s(:begin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody,
+            s(:array, s(:lvar, :foo)),
+            s(:lvasgn, :ex),
+            s(:lvar, :bar)),
+          nil)),
       %q{begin; meth; rescue foo => ex; bar; end})
   end
 
@@ -4025,9 +4072,9 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses(
       s(:preexe, s(:int, 1)),
       %q{BEGIN { 1 }},
-      %q{~~~~~ keyword
-        |      ^ begin
-        |          ^ end})
+      %q{      ^ begin
+        |          ^ end
+        |~~~~~~~~~~~ expression})
   end
 
   def test_preexe_invalid
@@ -4043,9 +4090,9 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses(
       s(:postexe, s(:int, 1)),
       %q{END { 1 }},
-      %q{~~~ keyword
-        |    ^ begin
-        |        ^ end})
+      %q{    ^ begin
+        |        ^ end
+        |~~~~~~~~~ expression})
 
     assert_diagnoses(
       [:warning, :end_in_method],
@@ -4060,10 +4107,11 @@ class TestParser < MiniTest::Unit::TestCase
   def test_begin_cmdarg
     assert_parses(
       s(:send, nil, :p,
-        s(:block,
-          s(:send, s(:int, 1), :times),
-          s(:args),
-          s(:int, 1))),
+        s(:begin,
+          s(:block,
+            s(:send, s(:int, 1), :times),
+            s(:args),
+            s(:int, 1)))),
       %q{p begin 1.times do 1 end end},
       %{},
       ALL_VERSIONS - %w(1.8 1.9))