ripper_ruby_parser 0.0.8 → 1.0.0

data/test/unit/parser_loops_test.rb

@@ -6,46 +6,45 @@ describe RipperRubyParser::Parser do
       it "works in the single-line postfix case" do
         "foo while bar".
           must_be_parsed_as s(:while,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :foo, s(:arglist)), true)
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), true)
       end
 
       it "works in the block postfix case" do
         "begin; foo; end while bar".
           must_be_parsed_as s(:while,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :foo, s(:arglist)), false)
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), false)
       end
 
-      it "normalizes a negative condition" do
+      it "handles a negative condition" do
         "while not foo; bar; end".
-          must_be_parsed_as s(:until,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist)), true)
+          must_be_parsed_as s(:while,
+                              s(:call, s(:call, nil, :foo), :!),
+                              s(:call, nil, :bar), true)
       end
 
-      it "normalizes a negative condition in the postfix case" do
+      it "handles a negative condition in the postfix case" do
         "foo while not bar".
-          must_be_parsed_as s(:until,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :foo, s(:arglist)), true)
+          must_be_parsed_as s(:while,
+                              s(:call, s(:call, nil, :bar), :!),
+                              s(:call, nil, :foo), true)
       end
     end
 
     describe "for the until statement" do
-      it "normalizes a negative condition" do
+      it "handles a negative condition" do
         "until not foo; bar; end".
-          must_be_parsed_as s(:while,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist)), true)
-
+          must_be_parsed_as s(:until,
+                              s(:call, s(:call, nil, :foo), :!),
+                              s(:call, nil, :bar), true)
       end
 
-      it "normalizes a negative condition in the postfix case" do
+      it "handles a negative condition in the postfix case" do
         "foo until not bar".
-          must_be_parsed_as s(:while,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :foo, s(:arglist)), true)
+          must_be_parsed_as s(:until,
+                              s(:call, s(:call, nil, :bar), :!),
+                              s(:call, nil, :foo), true)
       end
     end
   end

data/test/unit/parser_method_calls_test.rb

@@ -2,25 +2,149 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe "#parse" do
+    describe "for method calls" do
+      describe "without a receiver" do
+        it "works without brackets" do
+          "foo bar".
+            must_be_parsed_as s(:call, nil, :foo,
+                                s(:call, nil, :bar))
+        end
+
+        it "works with brackets" do
+          "foo(bar)".
+            must_be_parsed_as s(:call, nil, :foo,
+                                s(:call, nil, :bar))
+        end
+
+        it "works with an empty parameter list and no brackets" do
+          "foo".
+            must_be_parsed_as s(:call, nil, :foo)
+        end
+
+        it "works with brackets around an empty parameter list" do
+          "foo()".
+            must_be_parsed_as s(:call, nil, :foo)
+        end
+
+        it "works for methods ending in a question mark" do
+          "foo?".
+            must_be_parsed_as s(:call, nil, :foo?)
+        end
+
+        it "works with nested calls without brackets" do
+          "foo bar baz".
+            must_be_parsed_as s(:call, nil, :foo,
+                                s(:call, nil, :bar,
+                                  s(:call, nil, :baz)))
+        end
+
+        it "works with a non-final splat argument" do
+          "foo(bar, *baz, qux)".
+            must_be_parsed_as s(:call,
+                                nil,
+                                :foo,
+                                s(:call, nil, :bar),
+                                s(:splat, s(:call, nil, :baz)),
+                                s(:call, nil, :qux))
+        end
+
+        it "works with a splat argument followed by several regular arguments" do
+          "foo(bar, *baz, qux, quuz)".
+            must_be_parsed_as s(:call,
+                                nil,
+                                :foo,
+                                s(:call, nil, :bar),
+                                s(:splat, s(:call, nil, :baz)),
+                                s(:call, nil, :qux),
+                                s(:call, nil, :quuz))
+        end
+      end
+
+      describe "with a receiver" do
+        it "works without brackets" do
+          "foo.bar baz".
+            must_be_parsed_as s(:call,
+                                s(:call, nil, :foo),
+                                :bar,
+                                s(:call, nil, :baz))
+        end
+
+        it "works with brackets" do
+          "foo.bar(baz)".
+            must_be_parsed_as s(:call,
+                                s(:call, nil, :foo),
+                                :bar,
+                                s(:call, nil, :baz))
+        end
+
+        it "works with brackets around a call with no brackets" do
+          "foo.bar(baz qux)".
+            must_be_parsed_as s(:call,
+                                s(:call, nil, :foo),
+                                :bar,
+                                s(:call, nil, :baz,
+                                  s(:call, nil, :qux)))
+        end
+
+        it "works with nested calls without brackets" do
+          "foo.bar baz qux".
+            must_be_parsed_as s(:call,
+                                s(:call, nil, :foo),
+                                :bar,
+                                s(:call, nil, :baz,
+                                  s(:call, nil, :qux)))
+        end
+      end
+
+      describe "with blocks" do
+        it "works for a do block" do
+          "foo.bar do baz; end".
+            must_be_parsed_as s(:iter,
+                                s(:call,
+                                  s(:call, nil, :foo),
+                                  :bar),
+                                  s(:args),
+                                  s(:call, nil, :baz))
+        end
+
+        it "works for a do block with several statements" do
+          "foo.bar do baz; qux; end".
+            must_be_parsed_as s(:iter,
+                                s(:call,
+                                  s(:call, nil, :foo),
+                                  :bar),
+                                  s(:args),
+                                  s(:block,
+                                    s(:call, nil, :baz),
+                                    s(:call, nil, :qux)))
+        end
+      end
+    end
+
     describe "for calls to super" do
       specify { "super".must_be_parsed_as s(:zsuper) }
       specify { "super foo".must_be_parsed_as s(:super,
-                                                s(:call, nil, :foo, s(:arglist))) }
+                                                s(:call, nil, :foo)) }
       specify {
         "super foo, bar".must_be_parsed_as s(:super,
-                                             s(:call, nil, :foo, s(:arglist)),
-                                             s(:call, nil, :bar, s(:arglist))) }
+                                             s(:call, nil, :foo),
+                                             s(:call, nil, :bar)) }
       specify {
         "super foo, *bar".must_be_parsed_as s(:super,
-                                              s(:call, nil, :foo, s(:arglist)),
+                                              s(:call, nil, :foo),
                                               s(:splat,
-                                                s(:call, nil, :bar, s(:arglist)))) }
+                                                s(:call, nil, :bar))) }
       specify {
         "super foo, *bar, &baz".
           must_be_parsed_as s(:super,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:splat, s(:call, nil, :bar, s(:arglist))),
-                              s(:block_pass, s(:call, nil, :baz, s(:arglist)))) }
+                              s(:call, nil, :foo),
+                              s(:splat, s(:call, nil, :bar)),
+                              s(:block_pass, s(:call, nil, :baz))) }
+    end
+
+    it "handles calling a proc" do
+      "foo.()".
+        must_be_parsed_as s(:call, s(:call, nil, :foo), :call)
     end
   end
 end

data/test/unit/parser_operators_test.rb

@@ -6,23 +6,113 @@ describe RipperRubyParser::Parser do
       specify do
         "foo !~ bar".must_be_parsed_as s(:not,
                                          s(:call,
-                                           s(:call, nil, :foo, s(:arglist)),
+                                           s(:call, nil, :foo),
                                            :=~,
-                                           s(:arglist,
-                                             s(:call, nil, :bar, s(:arglist)))))
+                                           s(:call, nil, :bar)))
       end
     end
 
     describe "for boolean operators" do
+      it "handles :and" do
+        "foo and bar".
+          must_be_parsed_as s(:and,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it "handles double :and" do
+        "foo and bar and baz".
+          must_be_parsed_as s(:and,
+                              s(:call, nil, :foo),
+                              s(:and,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)))
+      end
+
+      it "handles :or" do
+        "foo or bar".
+          must_be_parsed_as s(:or,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it "handles double :or" do
+        "foo or bar or baz".
+          must_be_parsed_as s(:or,
+                              s(:call, nil, :foo),
+                              s(:or,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)))
+      end
+
+      it "handles :or after :and" do
+        "foo and bar or baz".
+          must_be_parsed_as s(:or,
+                              s(:and,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz))
+      end
+
+      it "handles :and after :or" do
+        "foo or bar and baz".
+          must_be_parsed_as s(:and,
+                              s(:or,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz))
+      end
+
+      it "converts :&& to :and" do
+        "foo && bar".
+          must_be_parsed_as s(:and,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it "handles :|| after :&&" do
+        "foo && bar || baz".
+          must_be_parsed_as s(:or,
+                              s(:and,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz))
+      end
+
+      it "handles :&& after :||" do
+        "foo || bar && baz".
+          must_be_parsed_as s(:or,
+                              s(:call, nil, :foo),
+                              s(:and,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)))
+      end
+
+      it "handles bracketed :||" do
+        "(foo || bar) || baz".
+          must_be_parsed_as s(:or,
+                              s(:or,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz))
+      end
+
+      it "converts :|| to :or" do
+        "foo || bar".
+          must_be_parsed_as s(:or,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
       it "handles triple :and" do
         "foo and bar and baz and qux".
           must_be_parsed_as s(:and,
-                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :foo),
                               s(:and,
-                                s(:call, nil, :bar, s(:arglist)),
+                                s(:call, nil, :bar),
                                 s(:and,
-                                  s(:call, nil, :baz, s(:arglist)),
-                                  s(:call, nil, :qux, s(:arglist)))))
+                                  s(:call, nil, :baz),
+                                  s(:call, nil, :qux))))
       end
     end
   end

data/test/unit/parser_test.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
@@ -29,1127 +30,543 @@ describe RipperRubyParser::Parser do
 
     describe "for a class declaration" do
       it "works with a namespaced class name" do
-        result = parser.parse "class Foo::Bar; end"
-        result.must_equal s(:class,
-                            s(:colon2, s(:const, :Foo), :Bar),
-                            nil,
-                            s(:scope))
+        "class Foo::Bar; end".
+          must_be_parsed_as s(:class,
+                              s(:colon2, s(:const, :Foo), :Bar),
+                              nil)
       end
 
       it "works for singleton classes" do
-        "class << self; end".must_be_parsed_as s(:sclass, s(:self), s(:scope))
+        "class << self; end".must_be_parsed_as s(:sclass, s(:self))
       end
     end
 
     describe "for a module declaration" do
       it "works with a namespaced module name" do
-        result = parser.parse "module Foo::Bar; end"
-        result.must_equal s(:module,
-                            s(:colon2, s(:const, :Foo), :Bar),
-                            s(:scope))
-      end
-    end
-
-    describe "for if" do
-      it "works in the postfix case" do
-        result = parser.parse "foo if bar"
-        result.must_equal s(:if,
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil)
-      end
-
-      it "works in the block case" do
-        result = parser.parse "if foo; bar; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)),
-                            nil)
-      end
-
-      it "works with an else clause" do
-        result = parser.parse "if foo; bar; else; baz; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:call, nil, :baz, s(:arglist)))
-      end
-
-      it "works with an elsif clause" do
-        result = parser.parse "if foo; bar; elsif baz; qux; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:if,
-                              s(:call, nil, :baz, s(:arglist)),
-                              s(:call, nil, :qux, s(:arglist)),
-                              nil))
-      end
-
-      it "handles a negative condition correctly" do
-        result = parser.parse "if not foo; bar; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
-      it "handles a negative condition in elsif correctly" do
-        result = parser.parse "if foo; bar; elsif not baz; qux; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:if,
-                              s(:not, s(:call, nil, :baz, s(:arglist))),
-                              s(:call, nil, :qux, s(:arglist)), nil))
-      end
-    end
-
-    describe "for unless" do
-      it "works in the postfix case" do
-        result = parser.parse "foo unless bar"
-        result.must_equal s(:if,
-                            s(:call, nil, :bar, s(:arglist)),
-                            nil,
-                            s(:call, nil, :foo, s(:arglist)))
-      end
-
-      it "works in the block case" do
-        result = parser.parse "unless bar; foo; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :bar, s(:arglist)),
-                            nil,
-                            s(:call, nil, :foo, s(:arglist)))
-      end
-
-      it "works with an else clause" do
-        result = parser.parse "unless foo; bar; else; baz; end"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :baz, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
+        "module Foo::Bar; end".
+          must_be_parsed_as s(:module,
+                              s(:colon2, s(:const, :Foo), :Bar))
       end
     end
 
-    describe "for a case block" do
-      it "works with a single when clause" do
-        result = parser.parse "case foo; when bar; baz; end"
-        result.must_equal s(:case,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:when,
-                              s(:array, s(:call, nil, :bar, s(:arglist))),
-                              s(:call, nil, :baz, s(:arglist))),
-                            nil)
-      end
-
-      it "works with multiple when clauses" do
-        result = parser.parse "case foo; when bar; baz; when qux; quux; end"
-        result.must_equal s(:case,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:when,
-                              s(:array, s(:call, nil, :bar, s(:arglist))),
-                              s(:call, nil, :baz, s(:arglist))),
-                            s(:when,
-                              s(:array, s(:call, nil, :qux, s(:arglist))),
-                              s(:call, nil, :quux, s(:arglist))),
-                            nil)
-      end
-
-      it "works with multiple statements in the when block" do
-        result = parser.parse "case foo; when bar; baz; qux; end"
-        result.must_equal s(:case,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:when,
-                              s(:array, s(:call, nil, :bar, s(:arglist))),
-                              s(:block,
-                                s(:call, nil, :baz, s(:arglist)),
-                                s(:call, nil, :qux, s(:arglist)))),
-                            nil)
-      end
-
-      it "works with an else clause" do
-        result = parser.parse "case foo; when bar; baz; else; qux; end"
-        result.must_equal s(:case,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:when,
-                              s(:array, s(:call, nil, :bar, s(:arglist))),
-                              s(:call, nil, :baz, s(:arglist))),
-                            s(:call, nil, :qux, s(:arglist)))
+    describe "for empty brackets" do
+      it "works with lone ()" do
+        "()".must_be_parsed_as s(:nil)
       end
     end
 
     describe "for the return statement" do
       it "works with no arguments" do
-        result = parser.parse "return"
-        result.must_equal s(:return)
+        "return".
+          must_be_parsed_as s(:return)
       end
 
       it "works with one argument" do
-        result = parser.parse "return foo"
-        result.must_equal s(:return,
-                            s(:call, nil, :foo, s(:arglist)))
+        "return foo".
+          must_be_parsed_as s(:return,
+                              s(:call, nil, :foo))
       end
 
       it "works with a splat argument" do
-        result = parser.parse "return *foo"
-        result.must_equal s(:return,
-                            s(:svalue,
-                              s(:splat,
-                                s(:call, nil, :foo, s(:arglist)))))
+        "return *foo".
+          must_be_parsed_as s(:return,
+                              s(:svalue,
+                                s(:splat,
+                                  s(:call, nil, :foo))))
       end
 
       it "works with multiple arguments" do
-        result = parser.parse "return foo, bar"
-        result.must_equal s(:return,
-                            s(:array,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist))))
+        "return foo, bar".
+          must_be_parsed_as s(:return,
+                              s(:array,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)))
       end
 
       it "works with a regular argument and a splat argument" do
-        result = parser.parse "return foo, *bar"
-        result.must_equal s(:return,
-                            s(:array,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:splat,
-                                s(:call, nil, :bar, s(:arglist)))))
+        "return foo, *bar".
+          must_be_parsed_as s(:return,
+                              s(:array,
+                                s(:call, nil, :foo),
+                                s(:splat,
+                                  s(:call, nil, :bar))))
       end
     end
 
     describe "for the until statement" do
       it "works in the prefix block case with do" do
-        result = parser.parse "until foo do; bar; end"
-        result.must_equal s(:until,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)), true)
+        "until foo do; bar; end".
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), true)
       end
 
       it "works in the prefix block case without do" do
-        result = parser.parse "until foo; bar; end"
-        result.must_equal s(:until,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)), true)
+        "until foo; bar; end".
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), true)
       end
 
       it "works in the single-line postfix case" do
-        result = parser.parse "foo until bar"
-        result.must_equal s(:until,
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:call, nil, :foo, s(:arglist)), true)
+        "foo until bar".
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), true)
       end
 
       it "works in the block postfix case" do
-        result = parser.parse "begin; foo; end until bar"
-        result.must_equal s(:until,
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:call, nil, :foo, s(:arglist)), false)
+        "begin; foo; end until bar".
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), false)
       end
     end
 
     describe "for the while statement" do
       it "works with do" do
-        result = parser.parse "while foo do; bar; end"
-        result.must_equal s(:while,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)), true)
+        "while foo do; bar; end".
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), true)
       end
 
       it "works without do" do
-        result = parser.parse "while foo; bar; end"
-        result.must_equal s(:while,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)), true)
+        "while foo; bar; end".
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), true)
       end
     end
 
     describe "for the for statement" do
       it "works with do" do
-        result = parser.parse "for foo in bar do; baz; end"
-        result.must_equal s(:for,
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:lasgn, :foo),
-                            s(:call, nil, :baz, s(:arglist)))
+        "for foo in bar do; baz; end".
+          must_be_parsed_as s(:for,
+                              s(:call, nil, :bar),
+                              s(:lasgn, :foo),
+                              s(:call, nil, :baz))
       end
 
       it "works without do" do
-        result = parser.parse "for foo in bar; baz; end"
-        result.must_equal s(:for,
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:lasgn, :foo),
-                            s(:call, nil, :baz, s(:arglist)))
+        "for foo in bar; baz; end".
+          must_be_parsed_as s(:for,
+                              s(:call, nil, :bar),
+                              s(:lasgn, :foo),
+                              s(:call, nil, :baz))
+      end
+
+      it "works with an empty body" do
+        "for foo in bar; end".
+          must_be_parsed_as s(:for,
+                              s(:call, nil, :bar),
+                              s(:lasgn, :foo))
       end
     end
 
     describe "for a begin..end block" do
       it "works with no statements" do
-        result = parser.parse "begin; end"
-        result.must_equal s(:nil)
+        "begin; end".
+          must_be_parsed_as s(:nil)
       end
 
       it "works with one statement" do
-        result = parser.parse "begin; foo; end"
-        result.must_equal s(:call, nil, :foo, s(:arglist))
+        "begin; foo; end".
+          must_be_parsed_as s(:call, nil, :foo)
       end
 
       it "works with multiple statements" do
-        result = parser.parse "begin; foo; bar; end"
-        result.must_equal s(:block,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-    end
-
-    describe "for the rescue statement" do
-      it "works with empty main and rescue bodies" do
-        result = parser.parse "begin; rescue; end"
-        result.must_equal s(:rescue,
-                            s(:resbody, s(:array), nil))
-      end
-
-      it "works with single statement main and rescue bodies" do
-        result = parser.parse "begin; foo; rescue; bar; end"
-        result.must_equal s(:rescue,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:resbody,
-                              s(:array),
-                              s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works with multi-statement main and rescue bodies" do
-        result = parser.parse "begin; foo; bar; rescue; baz; qux; end"
-        result.must_equal s(:rescue,
-                            s(:block,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist))),
-                            s(:resbody,
-                              s(:array),
-                              s(:block,
-                                s(:call, nil, :baz, s(:arglist)),
-                                s(:call, nil, :qux, s(:arglist)))))
-      end
-
-      it "works with assignment to an error variable" do
-        result = parser.parse "begin; foo; rescue => e; bar; end"
-        result.must_equal s(:rescue,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:resbody,
-                              s(:array, s(:lasgn, :e, s(:gvar, :$!))),
-                              s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works with filtering of the exception type" do
-        result = parser.parse "begin; foo; rescue Bar; baz; end"
-        result.must_equal s(:rescue,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:resbody,
-                              s(:array, s(:const, :Bar)),
-                              s(:call, nil, :baz, s(:arglist))))
-      end
-
-      it "works with filtering of the exception type and assignment to an error variable" do
-        result = parser.parse "begin; foo; rescue Bar => e; baz; end"
-        result.must_equal s(:rescue,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:resbody,
-                              s(:array,
-                                s(:const, :Bar),
-                                s(:lasgn, :e, s(:gvar, :$!))),
-                              s(:call, nil, :baz, s(:arglist))))
-      end
-
-      it "works rescuing multiple exception types" do
-        result = parser.parse "begin; foo; rescue Bar, Baz; qux; end"
-        result.must_equal s(:rescue,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:resbody,
-                              s(:array, s(:const, :Bar), s(:const, :Baz)),
-                              s(:call, nil, :qux, s(:arglist))))
-      end
-
-      it "works in the postfix case" do
-        result = parser.parse "foo rescue bar"
-        result.must_equal s(:rescue,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:resbody,
-                              s(:array),
-                              s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works in a plain method body" do
-        result = parser.parse "def foo; bar; rescue; baz; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args),
-                            s(:scope,
-                              s(:block,
-                                s(:rescue,
-                                  s(:call, nil, :bar, s(:arglist)),
-                                  s(:resbody,
-                                    s(:array),
-                                    s(:call, nil, :baz, s(:arglist)))))))
-      end
-    end
-
-    describe "for the ensure statement" do
-      it "works with single statement main and ensure bodies" do
-        result = parser.parse "begin; foo; ensure; bar; end"
-        result.must_equal s(:ensure,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
-      it "works with multi-statement main and ensure bodies" do
-        result = parser.parse "begin; foo; bar; ensure; baz; qux; end"
-        result.must_equal s(:ensure,
-                            s(:block,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist))),
-                            s(:block,
-                              s(:call, nil, :baz, s(:arglist)),
-                              s(:call, nil, :qux, s(:arglist))))
-      end
-
-      it "works together with rescue" do
-        result = parser.parse "begin; foo; rescue; bar; ensure; baz; end"
-        result.must_equal s(:ensure,
-                            s(:rescue,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:resbody,
-                                s(:array),
-                                s(:call, nil, :bar, s(:arglist)))),
-                            s(:call, nil, :baz, s(:arglist)))
+        "begin; foo; bar; end".
+          must_be_parsed_as s(:block,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
       end
     end
 
     describe "for the undef statement" do
       it "works with a single bareword identifier" do
-        result = parser.parse "undef foo"
-        result.must_equal s(:undef, s(:lit, :foo))
+        "undef foo".
+          must_be_parsed_as s(:undef, s(:lit, :foo))
       end
 
       it "works with a single symbol" do
-        result = parser.parse "undef :foo"
-        result.must_equal s(:undef, s(:lit, :foo))
+        "undef :foo".
+          must_be_parsed_as s(:undef, s(:lit, :foo))
       end
 
       it "works with multiple bareword identifiers" do
-        result = parser.parse "undef foo, bar"
-        result.must_equal s(:block,
-                            s(:undef, s(:lit, :foo)),
-                            s(:undef, s(:lit, :bar)))
+        "undef foo, bar".
+          must_be_parsed_as s(:block,
+                              s(:undef, s(:lit, :foo)),
+                              s(:undef, s(:lit, :bar)))
       end
 
       it "works with multiple bareword symbols" do
-        result = parser.parse "undef :foo, :bar"
-        result.must_equal s(:block,
-                            s(:undef, s(:lit, :foo)),
-                            s(:undef, s(:lit, :bar)))
+        "undef :foo, :bar".
+          must_be_parsed_as s(:block,
+                              s(:undef, s(:lit, :foo)),
+                              s(:undef, s(:lit, :bar)))
       end
     end
 
     describe "for the alias statement" do
       it "works with regular barewords" do
-        result = parser.parse "alias foo bar"
-        result.must_equal s(:alias,
-                            s(:lit, :foo), s(:lit, :bar))
+        "alias foo bar".
+          must_be_parsed_as s(:alias,
+                              s(:lit, :foo), s(:lit, :bar))
       end
 
       it "works with symbols" do
-        result = parser.parse "alias :foo :bar"
-        result.must_equal s(:alias,
-                            s(:lit, :foo), s(:lit, :bar))
+        "alias :foo :bar".
+          must_be_parsed_as s(:alias,
+                              s(:lit, :foo), s(:lit, :bar))
       end
 
       it "works with operator barewords" do
-        result = parser.parse "alias + -"
-        result.must_equal s(:alias,
-                            s(:lit, :+), s(:lit, :-))
+        "alias + -".
+          must_be_parsed_as s(:alias,
+                              s(:lit, :+), s(:lit, :-))
+      end
+
+      it "works with global variables" do
+        "alias $foo $bar".
+          must_be_parsed_as s(:valias, :$foo, :$bar)
       end
     end
 
     describe "for arguments" do
       it "works for a simple case with splat" do
-        result = parser.parse "foo *bar"
-        result.must_equal s(:call,
-                            nil,
-                            :foo,
-                            s(:arglist,
-                              s(:splat, s(:call, nil, :bar, s(:arglist)))))
+        "foo *bar".
+          must_be_parsed_as s(:call,
+                              nil,
+                              :foo,
+                              s(:splat, s(:call, nil, :bar)))
       end
 
       it "works for a multi-argument case with splat" do
-        result = parser.parse "foo bar, *baz"
-        result.must_equal s(:call,
-                            nil,
-                            :foo,
-                            s(:arglist,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:splat, s(:call, nil, :baz, s(:arglist)))))
+        "foo bar, *baz".
+          must_be_parsed_as s(:call,
+                              nil,
+                              :foo,
+                              s(:call, nil, :bar),
+                              s(:splat, s(:call, nil, :baz)))
       end
 
       it "works for a simple case passing a block" do
-        result = parser.parse "foo &bar"
-        result.must_equal s(:call, nil, :foo,
-                            s(:arglist,
+        "foo &bar".
+          must_be_parsed_as s(:call, nil, :foo,
                               s(:block_pass,
-                                s(:call, nil, :bar, s(:arglist)))))
+                                s(:call, nil, :bar)))
       end
 
       it "works for a bare hash" do
-        result = parser.parse "foo bar => baz"
-        result.must_equal s(:call, nil, :foo,
-                            s(:arglist,
+        "foo bar => baz".
+          must_be_parsed_as s(:call, nil, :foo,
                               s(:hash,
-                                s(:call, nil, :bar, s(:arglist)),
-                                s(:call, nil, :baz, s(:arglist)))))
-      end
-    end
-
-    describe "for array literals" do
-      it "works for an empty array" do
-        result = parser.parse "[]"
-        result.must_equal s(:array)
-      end
-
-      it "works for a simple case with splat" do
-        result = parser.parse "[*foo]"
-        result.must_equal s(:array,
-                            s(:splat, s(:call, nil, :foo, s(:arglist))))
-      end
-
-      it "works for a multi-element case with splat" do
-        result = parser.parse "[foo, *bar]"
-        result.must_equal s(:array,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:splat, s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works for an array created with %W" do
-        result = parser.parse "%W(foo bar)"
-        result.must_equal s(:array, s(:str, "foo"), s(:str, "bar"))
-      end
-    end
-
-    describe "for hash literals" do
-      it "works for an empty hash" do
-        result = parser.parse "{}"
-        result.must_equal s(:hash)
-      end
-
-      it "works for a hash with one pair" do
-        result = parser.parse "{foo => bar}"
-        result.must_equal s(:hash,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
-      it "works for a hash with multiple pairs" do
-        result = parser.parse "{foo => bar, baz => qux}"
-        result.must_equal s(:hash,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:call, nil, :baz, s(:arglist)),
-                            s(:call, nil, :qux, s(:arglist)))
-      end
-
-      it "works for a hash with label keys (Ruby 1.9 only)" do
-        result = parser.parse "{foo: bar, baz: qux}"
-        result.must_equal s(:hash,
-                            s(:lit, :foo),
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:lit, :baz),
-                            s(:call, nil, :qux, s(:arglist)))
-      end
-    end
-
-    describe "for number literals" do
-      it "works for floats" do
-        result = parser.parse "3.14"
-        result.must_equal s(:lit, 3.14)
-      end
-
-      it "works for octal integer literals" do
-        result = parser.parse "0700"
-        result.must_equal s(:lit, 448)
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)))
       end
     end
 
     describe "for collection indexing" do
       it "works in the simple case" do
-        result = parser.parse "foo[bar]"
-        result.must_equal s(:call,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :[],
-                            s(:arglist, s(:call, nil, :bar, s(:arglist))))
+        "foo[bar]".
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :[],
+                              s(:call, nil, :bar))
       end
 
       it "works without any indexes" do
-        "foo[]".must_be_parsed_as s(:call, s(:call, nil, :foo, s(:arglist)),
-                                    :[], s(:arglist))
+        "foo[]".must_be_parsed_as s(:call, s(:call, nil, :foo),
+                                    :[])
       end
 
       it "drops self from self[]" do
         "self[foo]".must_be_parsed_as s(:call, nil, :[],
-                                        s(:arglist,
-                                          s(:call, nil, :foo, s(:arglist))))
+                                        s(:call, nil, :foo))
       end
     end
 
     describe "for method definitions" do
       it "works with def with receiver" do
-        result = parser.parse "def foo.bar; end"
-        result.must_equal s(:defs,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :bar,
-                            s(:args),
-                            s(:scope, s(:block)))
+        "def foo.bar; end".
+          must_be_parsed_as s(:defs,
+                              s(:call, nil, :foo),
+                              :bar,
+                              s(:args))
+      end
+
+      it "works with def with receiver and multiple statements" do
+        "def foo.bar; baz; qux; end".
+          must_be_parsed_as s(:defs,
+                              s(:call, nil, :foo),
+                              :bar,
+                              s(:args),
+                              s(:call, nil, :baz),
+                              s(:call, nil, :qux))
       end
 
       it "works with a method argument with a default value" do
-        result = parser.parse "def foo bar=nil; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :bar, s(:block, s(:lasgn, :bar, s(:nil)))),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo bar=nil; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, s(:lasgn, :bar, s(:nil))),
+                              s(:nil))
       end
 
       it "works with several method arguments with default values" do
-        result = parser.parse "def foo bar=1, baz=2; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args,
-                              :bar, :baz,
-                              s(:block,
+        "def foo bar=1, baz=2; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
                                 s(:lasgn, :bar, s(:lit, 1)),
-                                s(:lasgn, :baz, s(:lit, 2)))),
-                            s(:scope, s(:block, s(:nil))))
+                                s(:lasgn, :baz, s(:lit, 2))),
+                              s(:nil))
       end
 
       it "works with brackets around the parameter list" do
-        result = parser.parse "def foo(bar); end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :bar),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo(bar); end".
+          must_be_parsed_as s(:defn, :foo, s(:args, :bar), s(:nil))
       end
 
       it "works with a simple splat" do
-        result = parser.parse "def foo *bar; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :"*bar"),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo *bar; end".
+          must_be_parsed_as s(:defn, :foo, s(:args, :"*bar"), s(:nil))
       end
 
       it "works with a regular argument plus splat" do
-        result = parser.parse "def foo bar, *baz; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :bar, :"*baz"),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo bar, *baz; end".
+          must_be_parsed_as s(:defn, :foo, s(:args, :bar, :"*baz"), s(:nil))
       end
 
       it "works with a nameless splat" do
-        result = parser.parse "def foo *; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :"*"),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo *; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :"*"),
+                              s(:nil))
       end
 
       it "works for a simple case with explicit block parameter" do
-        result = parser.parse "def foo &bar; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :"&bar"),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo &bar; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :"&bar"),
+                              s(:nil))
       end
 
       it "works with a regular argument plus explicit block parameter" do
-        result = parser.parse "def foo bar, &baz; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :bar, :"&baz"),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo bar, &baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :bar, :"&baz"),
+                              s(:nil))
       end
 
       it "works with a argument with default value plus explicit block parameter" do
-        result = parser.parse "def foo bar=1, &baz; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args,
-                              :bar, :"&baz",
-                              s(:block,
-                                s(:lasgn, :bar, s(:lit, 1)))),
-                            s(:scope, s(:block, s(:nil))))
-      end
-
-      it "works with a splat plus explicit block parameter" do
-        result = parser.parse "def foo *bar, &baz; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :"*bar", :"&baz"),
-                            s(:scope, s(:block, s(:nil))))
+        "def foo bar=1, &baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
+                                s(:lasgn, :bar, s(:lit, 1)),
+                                :"&baz"),
+                                s(:nil))
       end
 
-      it "works with an argument with default value plus splat" do
-        result = parser.parse "def foo bar=1, *baz; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args, :bar, :"*baz",
-                              s(:block,
-                                s(:lasgn, :bar, s(:lit, 1)))),
-                            s(:scope, s(:block, s(:nil))))
+      it "works with a argument with default value followed by a mandatory argument" do
+        "def foo bar=1, baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
+                                s(:lasgn, :bar, s(:lit, 1)),
+                                :baz),
+                                s(:nil))
       end
 
-      it "works when the method name is an operator" do
-        result = parser.parse "def +; end"
-        result.must_equal s(:defn, :+, s(:args),
-                            s(:scope, s(:block, s(:nil))))
+      it "works with a splat plus explicit block parameter" do
+        "def foo *bar, &baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :"*bar", :"&baz"),
+                              s(:nil))
       end
-    end
-
-    describe "for method calls" do
-      describe "without a receiver" do
-        it "works without brackets" do
-          result = parser.parse "foo bar"
-          result.must_equal s(:call, nil, :foo,
-                              s(:arglist, s(:call, nil, :bar, s(:arglist))))
-        end
-
-        it "works with brackets" do
-          result = parser.parse "foo(bar)"
-          result.must_equal s(:call, nil, :foo,
-                              s(:arglist, s(:call, nil, :bar, s(:arglist))))
-        end
-
-        it "works with an empty parameter list and no brackets" do
-          result = parser.parse "foo"
-          result.must_equal s(:call, nil, :foo, s(:arglist))
-        end
-
-        it "works with brackets around an empty parameter list" do
-          result = parser.parse "foo()"
-          result.must_equal s(:call, nil, :foo, s(:arglist))
-        end
-
-        it "works for methods ending in a question mark" do
-          result = parser.parse "foo?"
-          result.must_equal s(:call, nil, :foo?, s(:arglist))
-        end
 
-        it "works with nested calls without brackets" do
-          result = parser.parse "foo bar baz"
-          result.must_equal s(:call, nil, :foo,
-                              s(:arglist,
-                                s(:call, nil, :bar,
-                                  s(:arglist,
-                                    s(:call, nil, :baz, s(:arglist))))))
-        end
+      it "works with an argument with default value plus splat" do
+        "def foo bar=1, *baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
+                                s(:lasgn, :bar, s(:lit, 1)),
+                                :"*baz"),
+                                s(:nil))
       end
 
-      describe "with a receiver" do
-        it "works without brackets" do
-          result = parser.parse "foo.bar baz"
-          result.must_equal s(:call,
-                              s(:call, nil, :foo, s(:arglist)),
-                              :bar,
-                              s(:arglist, s(:call, nil, :baz, s(:arglist))))
-        end
-
-        it "works with brackets" do
-          result = parser.parse "foo.bar(baz)"
-          result.must_equal s(:call,
-                              s(:call, nil, :foo, s(:arglist)),
-                              :bar,
-                              s(:arglist, s(:call, nil, :baz, s(:arglist))))
-        end
-
-        it "works with brackets around a call with no brackets" do
-          result = parser.parse "foo.bar(baz qux)"
-          result.must_equal s(:call,
-                              s(:call, nil, :foo, s(:arglist)),
-                              :bar,
-                              s(:arglist,
-                                s(:call, nil, :baz,
-                                  s(:arglist,
-                                    s(:call, nil, :qux, s(:arglist))))))
-        end
-
-        it "works with nested calls without brackets" do
-          result = parser.parse "foo.bar baz qux"
-          result.must_equal s(:call,
-                              s(:call, nil, :foo, s(:arglist)),
-                              :bar,
-                              s(:arglist,
-                                s(:call, nil, :baz,
-                                  s(:arglist,
-                                    s(:call, nil, :qux, s(:arglist))))))
-        end
+      it "works with an argument with default value plus splat plus final mandatory arguments" do
+        "def foo bar=1, *baz, qux, quuz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
+                                s(:lasgn, :bar, s(:lit, 1)),
+                                :"*baz", :qux, :quuz),
+                                s(:nil))
       end
 
-      describe "with blocks" do
-        it "works for a do block" do
-          result = parser.parse "foo.bar do baz; end"
-          result.must_equal s(:iter,
-                              s(:call,
-                                s(:call, nil, :foo, s(:arglist)),
-                                :bar,
-                                s(:arglist)),
-                              nil,
-                              s(:call, nil, :baz, s(:arglist)))
-        end
-
-        it "works for a do block with several statements" do
-          result = parser.parse "foo.bar do baz; qux; end"
-          result.must_equal s(:iter,
-                              s(:call,
-                                s(:call, nil, :foo, s(:arglist)),
-                                :bar,
-                                s(:arglist)),
-                              nil,
-                              s(:block,
-                                s(:call, nil, :baz, s(:arglist)),
-                                s(:call, nil, :qux, s(:arglist))))
-        end
+      it "works when the method name is an operator" do
+        "def +; end".
+          must_be_parsed_as s(:defn, :+, s(:args),
+                              s(:nil))
       end
     end
 
     describe "for blocks" do
       it "works with no statements in the block body" do
-        result = parser.parse "foo do; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil)
+        "foo do; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args))
       end
 
       it "works with next with no arguments" do
-        result = parser.parse "foo do; next; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:next))
+        "foo do; next; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:next))
       end
 
       it "works with next with one argument" do
-        result = parser.parse "foo do; next bar; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:next, s(:call, nil, :bar, s(:arglist))))
+        "foo do; next bar; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:next, s(:call, nil, :bar)))
       end
 
       it "works with next with several arguments" do
-        result = parser.parse "foo do; next bar, baz; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:next,
-                              s(:array,
-                                s(:call, nil, :bar, s(:arglist)),
-                                s(:call, nil, :baz, s(:arglist)))))
+        "foo do; next bar, baz; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:next,
+                                s(:array,
+                                  s(:call, nil, :bar),
+                                  s(:call, nil, :baz))))
       end
 
       it "works with break with no arguments" do
-        result = parser.parse "foo do; break; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:break))
+        "foo do; break; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:break))
       end
 
       it "works with break with one argument" do
-        result = parser.parse "foo do; break bar; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:break, s(:call, nil, :bar, s(:arglist))))
+        "foo do; break bar; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:break, s(:call, nil, :bar)))
       end
 
       it "works with break with several arguments" do
-        result = parser.parse "foo do; break bar, baz; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:break,
-                              s(:array,
-                                s(:call, nil, :bar, s(:arglist)),
-                                s(:call, nil, :baz, s(:arglist)))))
+        "foo do; break bar, baz; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:break,
+                                s(:array,
+                                  s(:call, nil, :bar),
+                                  s(:call, nil, :baz))))
       end
 
       it "works with redo" do
-        result = parser.parse "foo do; redo; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:redo))
+        "foo do; redo; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args),
+                              s(:redo))
       end
 
       it "works with one argument" do
-        result = parser.parse "foo do |bar|; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:lasgn, :bar))
+        "foo do |bar|; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args, :bar))
       end
 
       it "works with multiple arguments" do
-        result = parser.parse "foo do |bar, baz|; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:masgn,
-                              s(:array,
-                                s(:lasgn, :bar),
-                                s(:lasgn, :baz))))
+        "foo do |bar, baz|; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args, :bar, :baz))
       end
 
       it "works with a single splat argument" do
-        result = parser.parse "foo do |*bar|; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:masgn,
-                              s(:array,
-                                s(:splat, s(:lasgn, :bar)))))
+        "foo do |*bar|; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args, :"*bar"))
       end
 
       it "works with a combination of regular arguments and a splat argument" do
-        result = parser.parse "foo do |bar, *baz|; end"
-        result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:masgn,
-                              s(:array,
-                                s(:lasgn, :bar),
-                                s(:splat, s(:lasgn, :baz)))))
+        "foo do |bar, *baz|; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args, :bar, :"*baz"))
       end
 
     end
 
     describe "for yield" do
       it "works with no arguments and no brackets" do
-        result = parser.parse "yield"
-        result.must_equal s(:yield)
+        "yield".
+          must_be_parsed_as s(:yield)
       end
 
       it "works with brackets but no arguments" do
-        result = parser.parse "yield()"
-        result.must_equal s(:yield)
+        "yield()".
+          must_be_parsed_as s(:yield)
       end
 
       it "works with one argument and no brackets" do
-        result = parser.parse "yield foo"
-        result.must_equal s(:yield, s(:call, nil, :foo, s(:arglist)))
+        "yield foo".
+          must_be_parsed_as s(:yield, s(:call, nil, :foo))
       end
 
       it "works with one argument and brackets" do
-        result = parser.parse "yield(foo)"
-        result.must_equal s(:yield, s(:call, nil, :foo, s(:arglist)))
+        "yield(foo)".
+          must_be_parsed_as s(:yield, s(:call, nil, :foo))
       end
 
       it "works with multiple arguments and no brackets" do
-        result = parser.parse "yield foo, bar"
-        result.must_equal s(:yield,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
+        "yield foo, bar".
+          must_be_parsed_as s(:yield,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
       end
 
       it "works with multiple arguments and brackets" do
-        result = parser.parse "yield(foo, bar)"
-        result.must_equal s(:yield,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
+        "yield(foo, bar)".
+          must_be_parsed_as s(:yield,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
       end
 
       it "works with splat" do
-        result = parser.parse "yield foo, *bar"
-        result.must_equal s(:yield,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:splat, s(:call, nil, :bar, s(:arglist))))
-      end
-    end
-
-    describe "for literals" do
-      it "works for symbols" do
-        result = parser.parse ":foo"
-        result.must_equal s(:lit, :foo)
-      end
-
-      it "works for symbols that look like instance variable names" do
-        result = parser.parse ":@foo"
-        result.must_equal s(:lit, :@foo)
-      end
-
-      it "works for empty strings" do
-        result = parser.parse "''"
-        result.must_equal s(:str, "")
-      end
-
-      it "works for strings with escape sequences" do
-        result = parser.parse "\"\\n\""
-        result.must_equal s(:str, "\n")
-      end
-
-      it "works for strings with useless escape sequences" do
-        result = parser.parse "\"F\\OO\""
-        result.must_equal s(:str, "FOO")
-      end
-
-      it "works for strings with escaped backslashes" do
-        result = parser.parse "\"\\\\n\""
-        result.must_equal s(:str, "\\n")
-      end
-
-      it "works for a double-quoted string representing a regex literal with escaped right bracket" do
-        result = parser.parse "\"/\\\\)/\""
-        result.must_equal s(:str, "/\\)/")
-      end
-
-      it "works for a double-quoted string containing a uselessly escaped right bracket" do
-        result = parser.parse "\"/\\)/\""
-        result.must_equal s(:str, "/)/")
-      end
-
-      it "works for a string containing escaped quotes" do
-        result = parser.parse "\"\\\"\""
-        result.must_equal s(:str, "\"")
-      end
-
-      it "works for trivial interpolated strings" do
-        result = parser.parse '"#{foo}"'
-        result.must_equal s(:dstr,
-                            "",
-                            s(:evstr,
-                              s(:call, nil, :foo, s(:arglist))))
-      end
-
-      it "works for basic interpolated strings" do
-        result = parser.parse '"foo#{bar}"'
-        result.must_equal s(:dstr,
-                            "foo",
-                            s(:evstr,
-                              s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works for strings with several interpolations" do
-        result = parser.parse '"foo#{bar}baz#{qux}"'
-        result.must_equal s(:dstr,
-                            "foo",
-                            s(:evstr, s(:call, nil, :bar, s(:arglist))),
-                            s(:str, "baz"),
-                            s(:evstr, s(:call, nil, :qux, s(:arglist))))
-      end
-
-      it "works for strings with interpolations followed by escape sequences" do
-        result = parser.parse '"#{foo}\\n"'
-        result.must_equal  s(:dstr,
-                             "",
-                             s(:evstr, s(:call, nil, :foo, s(:arglist))),
-                             s(:str, "\n"))
-      end
-
-      it "works for a simple regex literal" do
-        result = parser.parse "/foo/"
-        result.must_equal s(:lit, /foo/)
-      end
-
-      it "works for regex literals with escaped right bracket" do
-        result = parser.parse '/\\)/'
-        result.must_equal s(:lit, /\)/)
-      end
-
-      it "works for regex literals with escape sequences" do
-        result = parser.parse '/\\)\\n\\\\/'
-        result.must_equal s(:lit, /\)\n\\/)
-      end
-
-      it "works for regexes with interpolations" do
-        result = parser.parse '/foo#{bar}baz/'
-        result.must_equal s(:dregx,
-                            "foo",
-                            s(:evstr, s(:call, nil, :bar, s(:arglist))),
-                            s(:str, "baz"))
-      end
-
-      it "works for a regex literal with the multiline flag" do
-        result = parser.parse "/foo/m"
-        result.must_equal s(:lit, /foo/m)
-      end
-
-      it "works for a regex literal with the extended flag" do
-        result = parser.parse "/foo/x"
-        result.must_equal s(:lit, /foo/x)
-      end
-
-      it "works for a regex literal with the ignorecase flag" do
-        result = parser.parse "/foo/i"
-        result.must_equal s(:lit, /foo/i)
-      end
-
-      it "works for a regex literal with a combination of flags" do
-        result = parser.parse "/foo/ixm"
-        result.must_equal s(:lit, /foo/ixm)
-      end
-
-      it "works for a regex literal with flags and interpolation" do
-        result = parser.parse '/foo#{bar}/ixm'
-        result.must_equal s(:dregx,
-                            "foo",
-                            s(:evstr, s(:call, nil, :bar, s(:arglist))),
-                            7)
-      end
-
-      it "works for a regex literal with interpolate-once flag" do
-        result = parser.parse '/foo#{bar}/o'
-        result.must_equal s(:dregx_once,
-                            "foo",
-                            s(:evstr, s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works for simple dsyms" do
-        result = parser.parse ':"foo"'
-        result.must_equal s(:lit, :foo)
-      end
-
-      it "works for dsyms with interpolations" do
-        result = parser.parse ':"foo#{bar}"'
-        result.must_equal s(:dsym,
-                            "foo",
-                            s(:evstr, s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works for character literals (which are string literals in Ruby 1.9.3)" do
-        result = parser.parse "?a"
-        result.must_equal s(:lit, "a")
-      end
-
-      it "works for character literals in extra compatible mode" do
-        parser.extra_compatible = true
-        result = parser.parse "?a"
-        result.must_equal s(:lit, 97)
-      end
-
-      it "works for basic backtick strings" do
-        result = parser.parse '`foo`'
-        result.must_equal s(:xstr, "foo")
+        "yield foo, *bar".
+          must_be_parsed_as s(:yield,
+                              s(:call, nil, :foo),
+                              s(:splat, s(:call, nil, :bar)))
       end
-
-      it "works for interpolated backtick strings" do
-        result = parser.parse '`foo#{bar}`'
-        result.must_equal s(:dxstr,
-                            "foo",
-                            s(:evstr, s(:call, nil, :bar, s(:arglist))))
-      end
-
-      it "works for backtick strings with escape sequences" do
-        result = parser.parse '`foo\\n`'
-        result.must_equal s(:xstr, "foo\n")
-      end
-
     end
 
     describe "for the __FILE__ keyword" do
       describe "when not passing a file name" do
         it "creates a string sexp with value '(string)'" do
-          result = parser.parse "__FILE__"
-          result.must_equal s(:str, "(string)")
+          "__FILE__".
+            must_be_parsed_as s(:str, "(string)")
         end
       end
 
@@ -1163,505 +580,466 @@ describe RipperRubyParser::Parser do
 
     describe "for the __LINE__ keyword" do
       it "creates a literal sexp with value of the line number" do
-        result = parser.parse "__LINE__"
-        result.must_equal s(:lit, 1)
-        result = parser.parse "\n__LINE__"
-        result.must_equal s(:lit, 2)
+        "__LINE__".
+          must_be_parsed_as s(:lit, 1)
+        "\n__LINE__".
+          must_be_parsed_as s(:lit, 2)
+      end
+    end
+
+    describe "for the END keyword" do
+      it "converts to a :postexe iterator" do
+        "END { foo }".
+          must_be_parsed_as s(:iter, s(:postexe), s(:args), s(:call, nil, :foo))
+      end
+    end
+
+    describe "for the BEGIN keyword" do
+      it "converts to a :preexe iterator" do
+        "BEGIN { foo }".
+          must_be_parsed_as s(:iter, s(:preexe), s(:args), s(:call, nil, :foo))
       end
     end
 
     describe "for constant lookups" do
       it "works when explicitely starting from the root namespace" do
-        result = parser.parse "::Foo"
-        result.must_equal s(:colon3, :Foo)
+        "::Foo".
+          must_be_parsed_as s(:colon3, :Foo)
       end
 
       it "works with a three-level constant lookup" do
-        result = parser.parse "Foo::Bar::Baz"
-        result.must_equal s(:colon2,
-                            s(:colon2, s(:const, :Foo), :Bar),
-                            :Baz)
+        "Foo::Bar::Baz".
+          must_be_parsed_as s(:colon2,
+                              s(:colon2, s(:const, :Foo), :Bar),
+                              :Baz)
       end
 
       it "works looking up a constant in a non-constant" do
         "foo::Bar".must_be_parsed_as s(:colon2,
-                                       s(:call, nil, :foo, s(:arglist)),
+                                       s(:call, nil, :foo),
                                        :Bar)
       end
     end
 
     describe "for variable references" do
       it "works for self" do
-        result = parser.parse "self"
-        result.must_equal s(:self)
+        "self".
+          must_be_parsed_as s(:self)
       end
 
       it "works for instance variables" do
-        result = parser.parse "@foo"
-        result.must_equal s(:ivar, :@foo)
+        "@foo".
+          must_be_parsed_as s(:ivar, :@foo)
       end
 
       it "works for global variables" do
-        result = parser.parse "$foo"
-        result.must_equal s(:gvar, :$foo)
+        "$foo".
+          must_be_parsed_as s(:gvar, :$foo)
       end
 
       it "works for regexp match references" do
-        result = parser.parse "$1"
-        result.must_equal s(:nth_ref, 1)
+        "$1".
+          must_be_parsed_as s(:nth_ref, 1)
       end
 
       specify { "$'".must_be_parsed_as s(:back_ref, :"'") }
       specify { "$&".must_be_parsed_as s(:back_ref, :"&") }
 
       it "works for class variables" do
-        result = parser.parse "@@foo"
-        result.must_equal s(:cvar, :@@foo)
+        "@@foo".
+          must_be_parsed_as s(:cvar, :@@foo)
       end
     end
 
     describe "for single assignment" do
       it "works when assigning to an instance variable" do
-        result = parser.parse "@foo = bar"
-        result.must_equal s(:iasgn,
-                            :@foo,
-                            s(:call, nil, :bar, s(:arglist)))
+        "@foo = bar".
+          must_be_parsed_as s(:iasgn,
+                              :@foo,
+                              s(:call, nil, :bar))
       end
 
       it "works when assigning to a constant" do
-        result = parser.parse "FOO = bar"
-        result.must_equal s(:cdecl,
-                            :FOO,
-                            s(:call, nil, :bar, s(:arglist)))
+        "FOO = bar".
+          must_be_parsed_as s(:cdecl,
+                              :FOO,
+                              s(:call, nil, :bar))
       end
 
       it "works when assigning to a collection element" do
-        result = parser.parse "foo[bar] = baz"
-        result.must_equal s(:attrasgn,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :[]=,
-                            s(:arglist,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :baz, s(:arglist))))
+        "foo[bar] = baz".
+          must_be_parsed_as s(:attrasgn,
+                              s(:call, nil, :foo),
+                              :[]=,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz))
       end
 
       it "works when assigning to an attribute" do
-        result = parser.parse "foo.bar = baz"
-        result.must_equal s(:attrasgn,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :bar=,
-                            s(:arglist, s(:call, nil, :baz, s(:arglist))))
+        "foo.bar = baz".
+          must_be_parsed_as s(:attrasgn,
+                              s(:call, nil, :foo),
+                              :bar=,
+                              s(:call, nil, :baz))
       end
 
       it "works when assigning to a class variable" do
-        result = parser.parse "@@foo = bar"
-        result.must_equal s(:cvdecl,
-                            :@@foo,
-                            s(:call, nil, :bar, s(:arglist)))
+        "@@foo = bar".
+          must_be_parsed_as s(:cvdecl,
+                              :@@foo,
+                              s(:call, nil, :bar))
       end
 
       it "works when assigning to a class variable inside a method" do
-        result = parser.parse "def foo; @@bar = baz; end"
-        result.must_equal s(:defn,
-                            :foo, s(:args),
-                            s(:scope,
-                              s(:block,
-                                s(:cvasgn, :@@bar, s(:call, nil, :baz, s(:arglist))))))
+        "def foo; @@bar = baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo, s(:args),
+                              s(:cvasgn, :@@bar, s(:call, nil, :baz)))
       end
 
       it "works when assigning to a class variable inside a method with a receiver" do
-        result = parser.parse "def self.foo; @@bar = baz; end"
-        result.must_equal s(:defs,
-                            s(:self),
-                            :foo, s(:args),
-                            s(:scope,
-                              s(:block,
-                                s(:cvasgn, :@@bar, s(:call, nil, :baz, s(:arglist))))))
+        "def self.foo; @@bar = baz; end".
+          must_be_parsed_as s(:defs,
+                              s(:self),
+                              :foo, s(:args),
+                              s(:cvasgn, :@@bar, s(:call, nil, :baz)))
       end
 
       it "works when assigning to a global variable" do
-        result = parser.parse "$foo = bar"
-        result.must_equal s(:gasgn,
-                            :$foo,
-                            s(:call, nil, :bar, s(:arglist)))
+        "$foo = bar".
+          must_be_parsed_as s(:gasgn,
+                              :$foo,
+                              s(:call, nil, :bar))
       end
     end
 
     describe "for operator assignment" do
       it "works with +=" do
-        result = parser.parse "foo += bar"
-        result.must_equal s(:lasgn,
-                            :foo,
-                            s(:call,
-                              s(:lvar, :foo),
-                              :+,
-                              s(:arglist, s(:call, nil, :bar, s(:arglist)))))
+        "foo += bar".
+          must_be_parsed_as s(:lasgn,
+                              :foo,
+                              s(:call,
+                                s(:lvar, :foo),
+                                :+,
+                                s(:call, nil, :bar)))
       end
 
       it "works with -=" do
-        result = parser.parse "foo -= bar"
-        result.must_equal s(:lasgn,
-                            :foo,
-                            s(:call,
-                              s(:lvar, :foo),
-                              :-,
-                              s(:arglist, s(:call, nil, :bar, s(:arglist)))))
+        "foo -= bar".
+          must_be_parsed_as s(:lasgn,
+                              :foo,
+                              s(:call,
+                                s(:lvar, :foo),
+                                :-,
+                                s(:call, nil, :bar)))
       end
 
       it "works with ||=" do
-        result = parser.parse "foo ||= bar"
-        result.must_equal s(:op_asgn_or,
-                            s(:lvar, :foo),
-                            s(:lasgn, :foo,
-                              s(:call, nil, :bar, s(:arglist))))
+        "foo ||= bar".
+          must_be_parsed_as s(:op_asgn_or,
+                              s(:lvar, :foo),
+                              s(:lasgn, :foo,
+                                s(:call, nil, :bar)))
       end
 
       it "works when assigning to an instance variable" do
-        result = parser.parse "@foo += bar"
-        result.must_equal s(:iasgn,
-                            :@foo,
-                            s(:call,
-                              s(:ivar, :@foo),
-                              :+,
-                              s(:arglist, s(:call, nil, :bar, s(:arglist)))))
+        "@foo += bar".
+          must_be_parsed_as s(:iasgn,
+                              :@foo,
+                              s(:call,
+                                s(:ivar, :@foo),
+                                :+,
+                                s(:call, nil, :bar)))
       end
 
       it "works when assigning to a collection element" do
-        result = parser.parse "foo[bar] += baz"
-        result.must_equal s(:op_asgn1,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:arglist, s(:call, nil, :bar, s(:arglist))),
-                            :+,
-                            s(:call, nil, :baz, s(:arglist)))
+        "foo[bar] += baz".
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, nil, :baz))
       end
 
       it "works with ||= when assigning to a collection element" do
-        result = parser.parse "foo[bar] ||= baz"
-        result.must_equal s(:op_asgn1,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:arglist, s(:call, nil, :bar, s(:arglist))),
-                            :"||",
-                            s(:call, nil, :baz, s(:arglist)))
+        "foo[bar] ||= baz".
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :"||",
+                              s(:call, nil, :baz))
       end
 
       it "works when assigning to an attribute" do
-        result = parser.parse "foo.bar += baz"
-        result.must_equal s(:op_asgn2,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :bar=,
-                            :+,
-                            s(:call, nil, :baz, s(:arglist)))
+        "foo.bar += baz".
+          must_be_parsed_as s(:op_asgn2,
+                              s(:call, nil, :foo),
+                              :bar=,
+                              :+,
+                              s(:call, nil, :baz))
       end
 
       it "works with ||= when assigning to an attribute" do
-        result = parser.parse "foo.bar ||= baz"
-        result.must_equal s(:op_asgn2,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :bar=,
-                            :"||",
-                            s(:call, nil, :baz, s(:arglist)))
+        "foo.bar ||= baz".
+          must_be_parsed_as s(:op_asgn2,
+                              s(:call, nil, :foo),
+                              :bar=,
+                              :"||",
+                              s(:call, nil, :baz))
       end
     end
 
     describe "for multiple assignment" do
       it "works the same number of items on each side" do
-        result = parser.parse "foo, bar = baz, qux"
-        result.must_equal s(:masgn,
-                            s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                            s(:array,
-                              s(:call, nil, :baz, s(:arglist)),
-                              s(:call, nil, :qux, s(:arglist))))
+        "foo, bar = baz, qux".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                              s(:array,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)))
       end
 
       it "works with a single item on the right-hand side" do
-        result = parser.parse "foo, bar = baz"
-        result.must_equal s(:masgn,
-                            s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                            s(:to_ary,
-                              s(:call, nil, :baz, s(:arglist))))
+        "foo, bar = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                              s(:to_ary,
+                                s(:call, nil, :baz)))
       end
 
       it "works with left-hand splat" do
-        result = parser.parse "foo, *bar = baz, qux"
-        result.must_equal s(:masgn,
-                            s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
-                            s(:array,
-                              s(:call, nil, :baz, s(:arglist)),
-                              s(:call, nil, :qux, s(:arglist))))
+        "foo, *bar = baz, qux".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
+                              s(:array,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)))
       end
 
       it "works with brackets around the left-hand side" do
-        result = parser.parse "(foo, bar) = baz"
-        result.must_equal s(:masgn,
-                            s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                            s(:to_ary,
-                              s(:call, nil, :baz, s(:arglist))))
+        "(foo, bar) = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                              s(:to_ary, s(:call, nil, :baz)))
       end
 
       it "works with complex destructuring" do
-        result = parser.parse "foo, (bar, baz) = qux"
-        result.must_equal s(:masgn,
-                            s(:array,
-                              s(:lasgn, :foo),
-                              s(:masgn,
+        "foo, (bar, baz) = qux".
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:lasgn, :foo),
+                                s(:masgn,
+                                  s(:array, s(:lasgn, :bar), s(:lasgn, :baz)))),
+                              s(:to_ary, s(:call, nil, :qux)))
+      end
+
+      it "works with complex destructuring of the value" do
+        "foo, (bar, baz) = [qux, [quz, quuz]]".
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:lasgn, :foo),
+                                s(:masgn, s(:array, s(:lasgn, :bar), s(:lasgn, :baz)))),
+                              s(:to_ary,
                                 s(:array,
-                                  s(:lasgn, :bar),
-                                  s(:lasgn, :baz)))),
-                            s(:to_ary,
-                              s(:call, nil, :qux, s(:arglist))))
+                                  s(:call, nil, :qux),
+                                  s(:array, s(:call, nil, :quz), s(:call, nil, :quuz)))))
       end
 
       it "works with instance variables" do
-        result = parser.parse "@foo, @bar = baz"
-        result.must_equal s(:masgn,
-                            s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
-                            s(:to_ary,
-                              s(:call, nil, :baz, s(:arglist))))
+        "@foo, @bar = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
+                              s(:to_ary, s(:call, nil, :baz)))
       end
 
       it "works with class variables" do
-        result = parser.parse "@@foo, @@bar = baz"
-        result.must_equal s(:masgn,
-                            s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
-                            s(:to_ary,
-                              s(:call, nil, :baz, s(:arglist))))
+        "@@foo, @@bar = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
+                              s(:to_ary, s(:call, nil, :baz)))
       end
 
       it "works with attributes" do
-        result = parser.parse "foo.bar, foo.baz = qux"
-        result.must_equal s(:masgn,
-                            s(:array,
-                              s(:attrasgn,
-                                s(:call, nil, :foo, s(:arglist)),
-                                :bar=,
-                                s(:arglist)),
-                              s(:attrasgn,
-                                s(:call, nil, :foo, s(:arglist)),
-                                :baz=,
-                                s(:arglist))),
-                            s(:to_ary,
-                              s(:call, nil, :qux, s(:arglist))))
+        "foo.bar, foo.baz = qux".
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:attrasgn, s(:call, nil, :foo), :bar=),
+                                s(:attrasgn, s(:call, nil, :foo), :baz=)),
+                              s(:to_ary, s(:call, nil, :qux)))
       end
 
       it "works with collection elements" do
-        result = parser.parse "foo[1], bar[2] = baz"
-        result.must_equal s(:masgn,
-                            s(:array,
-                              s(:attrasgn,
-                                s(:call, nil, :foo, s(:arglist)),
-                                :[]=,
-                                s(:arglist, s(:lit, 1))),
-                              s(:attrasgn,
-                                s(:call, nil, :bar, s(:arglist)),
-                                :[]=,
-                                s(:arglist, s(:lit, 2)))),
-                            s(:to_ary, s(:call, nil, :baz, s(:arglist))))
+        "foo[1], bar[2] = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:attrasgn,
+                                  s(:call, nil, :foo), :[]=, s(:lit, 1)),
+                                s(:attrasgn,
+                                  s(:call, nil, :bar), :[]=, s(:lit, 2))),
+                              s(:to_ary, s(:call, nil, :baz)))
       end
 
       it "works with constants" do
-        result = parser.parse "Foo, Bar = baz"
-        result.must_equal s(:masgn,
-                            s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
-                            s(:to_ary,
-                              s(:call, nil, :baz, s(:arglist))))
+        "Foo, Bar = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
+                              s(:to_ary, s(:call, nil, :baz)))
       end
 
       it "works with instance variables and splat" do
-        result = parser.parse "@foo, *@bar = baz"
-        result.must_equal s(:masgn,
-                            s(:array,
-                              s(:iasgn, :@foo),
-                              s(:splat, s(:iasgn, :@bar))),
-                            s(:to_ary,
-                              s(:call, nil, :baz, s(:arglist))))
+        "@foo, *@bar = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:iasgn, :@foo),
+                                s(:splat, s(:iasgn, :@bar))),
+                              s(:to_ary,
+                                s(:call, nil, :baz)))
       end
-
     end
 
     describe "for operators" do
-      it "handles :and" do
-        result = parser.parse "foo and bar"
-        result.must_equal s(:and,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
-      it "handles double :and" do
-        result = parser.parse "foo and bar and baz"
-        result.must_equal s(:and,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:and,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :baz, s(:arglist))))
-      end
-
-      it "handles :or" do
-        result = parser.parse "foo or bar"
-        result.must_equal s(:or,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
-      it "handles double :or" do
-        result = parser.parse "foo or bar or baz"
-        result.must_equal s(:or,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:or,
-                              s(:call, nil, :bar, s(:arglist)),
-                              s(:call, nil, :baz, s(:arglist))))
-      end
-
-      it "handles :or after :and" do
-        result = parser.parse "foo and bar or baz"
-        result.must_equal s(:or,
-                            s(:and,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist))),
-                            s(:call, nil, :baz, s(:arglist)))
-      end
-
-      it "handles :and after :or" do
-        result = parser.parse "foo or bar and baz"
-        result.must_equal s(:and,
-                            s(:or,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist))),
-                            s(:call, nil, :baz, s(:arglist)))
-      end
-
-      it "converts :&& to :and" do
-        result = parser.parse "foo && bar"
-        result.must_equal s(:and,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
-      it "converts :|| to :or" do
-        result = parser.parse "foo || bar"
-        result.must_equal s(:or,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
-      end
-
       it "handles :!=" do
-        result = parser.parse "foo != bar"
-        result.must_equal s(:not,
-                              s(:call,
-                                s(:call, nil, :foo, s(:arglist)),
-                                :==,
-                                s(:arglist,
-                                  s(:call, nil, :bar, s(:arglist)))))
+        "foo != bar".
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :!=,
+                              s(:call, nil, :bar))
       end
 
       it "handles :=~ with two non-literals" do
-        result = parser.parse "foo =~ bar"
-        result.must_equal s(:call,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :=~,
-                            s(:arglist, s(:call, nil, :bar, s(:arglist))))
+        "foo =~ bar".
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :=~,
+                              s(:call, nil, :bar))
       end
 
       it "handles :=~ with literal regexp on the left hand side" do
-        result = parser.parse "/foo/ =~ bar"
-        result.must_equal s(:match2,
-                            s(:lit, /foo/),
-                            s(:call, nil, :bar, s(:arglist)))
+        "/foo/ =~ bar".
+          must_be_parsed_as s(:match2,
+                              s(:lit, /foo/),
+                              s(:call, nil, :bar))
       end
 
       it "handles :=~ with literal regexp on the right hand side" do
-        result = parser.parse "foo =~ /bar/"
-        result.must_equal s(:match3,
-                            s(:lit, /bar/),
-                            s(:call, nil, :foo, s(:arglist)))
+        "foo =~ /bar/".
+          must_be_parsed_as s(:match3,
+                              s(:lit, /bar/),
+                              s(:call, nil, :foo))
       end
 
       it "handles unary minus with a number literal" do
-        result = parser.parse "-1"
-        result.must_equal s(:lit, -1)
+        "-1".
+          must_be_parsed_as s(:lit, -1)
       end
 
       it "handles unary minus with a non-literal" do
-        result = parser.parse "-foo"
-        result.must_equal s(:call,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :-@,
-                            s(:arglist))
+        "-foo".
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :-@)
       end
 
       it "handles unary plus with a number literal" do
-        result = parser.parse "+ 1"
-        result.must_equal s(:lit, 1)
+        "+ 1".
+          must_be_parsed_as s(:lit, 1)
       end
 
       it "handles unary plus with a non-literal" do
-        result = parser.parse "+ foo"
-        result.must_equal s(:call,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :+@,
-                            s(:arglist))
+        "+ foo".
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :+@)
+      end
+
+      it "handles unary !" do
+        "!foo".
+          must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
       end
 
-      it "handles unary not" do
-        result = parser.parse "not foo"
-        result.must_equal s(:not, s(:call, nil, :foo, s(:arglist)))
+      it "converts :not to :!" do
+        "not foo".
+          must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
       end
 
-      it "converts :! to :not" do
-        result = parser.parse "!foo"
-        result.must_equal s(:not, s(:call, nil, :foo, s(:arglist)))
+      it "handles unary ! with a number literal" do
+        "!1".
+          must_be_parsed_as s(:call, s(:lit, 1), :!)
       end
 
       it "handles the range operator with positive number literals" do
-        result = parser.parse "1..2"
-        result.must_equal s(:lit, 1..2)
+        "1..2".
+          must_be_parsed_as s(:lit, 1..2)
       end
 
       it "handles the range operator with negative number literals" do
-        result = parser.parse "-1..-2"
-        result.must_equal s(:lit, -1..-2)
+        "-1..-2".
+          must_be_parsed_as s(:lit, -1..-2)
       end
 
       it "handles the range operator with string literals" do
-        result = parser.parse "'a'..'z'"
-        result.must_equal s(:dot2,
-                            s(:str, "a"),
-                            s(:str, "z"))
+        "'a'..'z'".
+          must_be_parsed_as s(:dot2,
+                              s(:str, "a"),
+                              s(:str, "z"))
       end
 
       it "handles the range operator with non-literals" do
-        result = parser.parse "foo..bar"
-        result.must_equal s(:dot2,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)))
+        "foo..bar".
+          must_be_parsed_as s(:dot2,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it "handles the exclusive range operator with positive number literals" do
+        "1...2".
+          must_be_parsed_as s(:lit, 1...2)
+      end
+
+      it "handles the exclusive range operator with negative number literals" do
+        "-1...-2".
+          must_be_parsed_as s(:lit, -1...-2)
+      end
+
+      it "handles the exclusive range operator with string literals" do
+        "'a'...'z'".
+          must_be_parsed_as s(:dot3,
+                              s(:str, "a"),
+                              s(:str, "z"))
+      end
+
+      it "handles the exclusive range operator with non-literals" do
+        "foo...bar".
+          must_be_parsed_as s(:dot3,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
       end
 
       it "handles the ternary operator" do
-        result = parser.parse "foo ? bar : baz"
-        result.must_equal s(:if,
-                            s(:call, nil, :foo, s(:arglist)),
-                            s(:call, nil, :bar, s(:arglist)),
-                            s(:call, nil, :baz, s(:arglist)))
+        "foo ? bar : baz".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz))
       end
     end
 
     describe "for expressions" do
       it "handles assignment inside binary operator expressions" do
-        result = parser.parse "foo + (bar = baz)"
-        result.must_equal s(:call,
-                            s(:call, nil, :foo, s(:arglist)),
-                            :+,
-                            s(:arglist,
+        "foo + (bar = baz)".
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :+,
                               s(:lasgn,
                                 :bar,
-                                s(:call, nil, :baz, s(:arglist)))))
+                                s(:call, nil, :baz)))
       end
 
       it "handles assignment inside unary operator expressions" do
-        result = parser.parse "+(foo = bar)"
-        result.must_equal s(:call,
-                            s(:lasgn, :foo, s(:call, nil, :bar, s(:arglist))),
-                            :+@,
-                            s(:arglist))
+        "+(foo = bar)".
+          must_be_parsed_as s(:call,
+                              s(:lasgn, :foo, s(:call, nil, :bar)),
+                              :+@)
       end
     end
 
@@ -1672,27 +1050,26 @@ describe RipperRubyParser::Parser do
         result = parser.parse "# Foo\ndef foo; end"
         result.must_equal s(:defn,
                             :foo,
-                            s(:args), s(:scope, s(:block, s(:nil))))
+                            s(:args), s(:nil))
         result.comments.must_equal "# Foo\n"
       end
 
       it "handles comments for methods with explicit receiver" do
         result = parser.parse "# Foo\ndef foo.bar; end"
         result.must_equal s(:defs,
-                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :foo),
                             :bar,
-                            s(:args), s(:scope, s(:block)))
+                            s(:args))
         result.comments.must_equal "# Foo\n"
       end
 
       it "matches comments to the correct entity" do
         result = parser.parse "# Foo\nclass Foo\n# Bar\ndef bar\nend\nend"
         result.must_equal s(:class, :Foo, nil,
-                            s(:scope,
-                              s(:defn, :bar,
-                                s(:args), s(:scope, s(:block, s(:nil))))))
+                            s(:defn, :bar,
+                              s(:args), s(:nil)))
         result.comments.must_equal "# Foo\n"
-        defn = result[3][1]
+        defn = result[3]
         defn.sexp_type.must_equal :defn
         defn.comments.must_equal "# Bar\n"
       end
@@ -1701,16 +1078,41 @@ describe RipperRubyParser::Parser do
         result = parser.parse "# Foo\n# Bar\ndef foo; end"
         result.must_equal s(:defn,
                             :foo,
-                            s(:args), s(:scope, s(:block, s(:nil))))
+                            s(:args), s(:nil))
         result.comments.must_equal "# Foo\n# Bar\n"
       end
 
+      it "drops comments inside method bodies" do
+        result = parser.parse <<-END
+          # Foo
+          class Foo
+            # foo
+            def foo
+              bar # this is dropped
+            end
+
+            # bar
+            def bar
+              baz
+            end
+          end
+        END
+        result.must_equal s(:class,
+                            :Foo,
+                            nil,
+                            s(:defn, :foo, s(:args), s(:call, nil, :bar)),
+                            s(:defn, :bar, s(:args), s(:call, nil, :baz)))
+        result.comments.must_equal "# Foo\n"
+        result[3].comments.must_equal "# foo\n"
+        result[4].comments.must_equal "# bar\n"
+      end
+
       it "handles the use of symbols that are keywords" do
         result = parser.parse "# Foo\ndef bar\n:class\nend"
         result.must_equal s(:defn,
                             :bar,
                             s(:args),
-                            s(:scope, s(:block, s(:lit, :class))))
+                            s(:lit, :class))
         result.comments.must_equal "# Foo\n"
       end
 
@@ -1719,10 +1121,8 @@ describe RipperRubyParser::Parser do
         result.must_equal s(:defn,
                             :bar,
                             s(:args),
-                            s(:scope,
-                              s(:block,
-                                s(:sclass, s(:self),
-                                  s(:scope, s(:call, nil, :baz, s(:arglist)))))))
+                            s(:sclass, s(:self),
+                              s(:call, nil, :baz)))
         result.comments.must_equal "# Foo\n"
       end
     end
@@ -1852,23 +1252,23 @@ describe RipperRubyParser::Parser do
       end
 
       it "assigns line numbers to nested sexps that don't generate their own line numbers" do
-        result = parser.parse "foo() do\nnext\nend\n"
+        result = parser.parse "foo(bar) do\nnext baz\nend\n"
         result.must_equal s(:iter,
-                            s(:call, nil, :foo, s(:arglist)),
-                            nil,
-                            s(:next))
+                            s(:call, nil, :foo, s(:call, nil, :bar)),
+                            s(:args),
+                            s(:next, s(:call, nil, :baz)))
         arglist = result[1][3]
         block = result[3]
         nums = [ arglist.line, block.line ]
-        nums.must_equal [1, 1]
+        nums.must_equal [1, 2]
       end
 
       describe "when a line number is passed" do
         it "shifts all line numbers as appropriate" do
           result = parser.parse "foo\nbar\n", '(string)', 3
           result.must_equal s(:block,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist)))
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
           result.line.must_equal 3
           result[1].line.must_equal 3
           result[2].line.must_equal 4