ripper_ruby_parser 0.0.8 → 1.0.0

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -49,14 +49,14 @@ module RipperRubyParser
       _, content = exp.shift 2
 
       statements = content.map { |sub_exp| process(sub_exp) }
-      wrap_in_block statements
+      safe_wrap_in_block statements
     end
 
     def process_module exp
       _, const_ref, body = exp.shift 3
       const, line = const_ref_to_const_with_line_number const_ref
       with_line_number(line,
-                       s(:module, const, class_or_module_body(body)))
+                       s(:module, const, *class_or_module_body(body)))
     end
 
     def process_class exp
@@ -64,12 +64,12 @@ module RipperRubyParser
       const, line = const_ref_to_const_with_line_number const_ref
       parent = process(parent)
       with_line_number(line,
-                       s(:class, const, parent, class_or_module_body(body)))
+                       s(:class, const, parent, *class_or_module_body(body)))
     end
 
     def process_sclass exp
       _, klass, block = exp.shift 3
-      s(:sclass, process(klass), class_or_module_body(block))
+      s(:sclass, process(klass), *class_or_module_body(block))
     end
 
     def process_var_ref exp
@@ -82,6 +82,11 @@ module RipperRubyParser
       process(contents)
     end
 
+    def process_var_alias exp
+      _, left, right = exp.shift 3
+      s(:valias, left[1].to_sym, right[1].to_sym)
+    end
+
     def process_const_path_ref exp
       _, left, right = exp.shift 3
       s(:colon2, process(left), extract_node_symbol(right))
@@ -112,7 +117,8 @@ module RipperRubyParser
       elsif body.first.is_a? Symbol
         process body
       else
-        process body[0]
+        body.map! {|it| convert_void_stmt_to_nil process it }
+        safe_wrap_in_block body
       end
     end
 
@@ -123,6 +129,16 @@ module RipperRubyParser
       sexp
     end
 
+    def process_BEGIN exp
+      _, body = exp.shift 2
+      s(:iter, s(:preexe), s(:args), *map_body(body))
+    end
+
+    def process_END exp
+      _, body = exp.shift 2
+      s(:iter, s(:postexe), s(:args), *map_body(body))
+    end
+
     # number literals
     def process_at_int exp
       make_literal(exp) {|val| Integer(val) }
@@ -134,13 +150,8 @@ module RipperRubyParser
 
     # character literals
     def process_at_CHAR exp
-      make_literal(exp) do |val|
-        if extra_compatible
-          val[1].ord
-        else
-          val[1]
-        end
-      end
+      _, val, pos = exp.shift 3
+      with_position(pos, s(:str, unescape(val[1..-1])))
     end
 
     def process_at_label exp
@@ -209,14 +220,14 @@ module RipperRubyParser
     end
 
     def class_or_module_body exp
-      scope = process exp
-      block = scope[1]
-      block.shift
-      if block.length <= 1
-        s(:scope, *block)
-      else
-        s(:scope, s(:block, *block))
+      body = process(exp)
+
+      if body.length == 1 && body.first.sexp_type == :block
+        body = body.first
+        body.shift
       end
+
+      body
     end
 
     def make_identifier(type, exp)
@@ -246,5 +257,13 @@ module RipperRubyParser
         end
       end
     end
+
+    def convert_void_stmt_to_nil sexp
+      if sexp == s(:void_stmt)
+        s(:nil)
+      else
+        sexp
+      end
+    end
   end
 end

data/lib/ripper_ruby_parser/version.rb

@@ -1,3 +1,3 @@
 module RipperRubyParser
-  VERSION = '0.0.8'
+  VERSION = '1.0.0'
 end

data/test/pt_testcase/pt_test.rb

@@ -7,13 +7,27 @@ class RipperRubyParser::Parser
   end
 end
 
+SKIPPED_TESTS = ["dstr_heredoc_windoze_sucks"]
+
 class RubyParserTestCase < ParseTreeTestCase
   def self.previous key
     "Ruby"
   end
 
   def self.generate_test klass, node, data, input_name, output_name
-    return if Array === data['Ruby']
+    if data['Ruby'].is_a? Array
+      klass.send :define_method, "test_#{node}" do
+        skip "Not a parser test"
+      end
+      return
+    end
+
+    if SKIPPED_TESTS.include? node
+      klass.send :define_method, "test_#{node}" do
+        skip "Can't or won't fix this difference"
+      end
+      return
+    end
 
     output_name = "ParseTree"
 

data/test/test_helper.rb

@@ -1,8 +1,11 @@
-if ENV["SIMPLECOV"]
+begin
   require 'simplecov'
-  SimpleCov.start
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+rescue LoadError
 end
-require 'minitest/spec'
+
 require 'minitest/autorun'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))

data/test/unit/commenting_ripper_parser_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::CommentingRipperParser do
+  def parse_with_builder str
+    builder = RipperRubyParser::CommentingRipperParser.new str
+    builder.parse
+  end
+
+  def empty_params_list
+    @empty_params_list ||= begin
+                             num_params = RUBY_VERSION < "2.0.0" ? 5 : 7
+                             s(:params, *([nil] * num_params))
+                           end
+
+  end
+
+  describe "handling comments" do
+    it "produces a comment node surrounding a commented def" do
+      result = parse_with_builder "# Foo\ndef foo; end"
+      result.must_equal s(:program,
+                         s(s(:comment,
+                           "# Foo\n",
+                           s(:def,
+                            s(:@ident, "foo", s(2, 4)),
+                            empty_params_list,
+                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "produces a blank comment node surrounding a def that has no comment" do
+      result = parse_with_builder "def foo; end"
+      result.must_equal s(:program,
+                         s(s(:comment,
+                           "",
+                           s(:def,
+                           s(:@ident, "foo", s(1, 4)),
+                           empty_params_list,
+                           s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "produces a comment node surrounding a commented class" do
+      result = parse_with_builder "# Foo\nclass Foo; end"
+      result.must_equal s(:program,
+                         s(s(:comment,
+                           "# Foo\n",
+                           s(:class,
+                            s(:const_ref, s(:@const, "Foo", s(2, 6))),
+                            nil,
+                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "produce a blank comment node surrounding a class that has no comment" do
+      result = parse_with_builder "class Foo; end"
+      result.must_equal s(:program,
+                         s(s(:comment,
+                           "",
+                           s(:class,
+                           s(:const_ref, s(:@const, "Foo", s(1, 6))),
+                           nil,
+                           s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "produces a comment node surrounding a commented module" do
+      result = parse_with_builder "# Foo\nmodule Foo; end"
+      result.must_equal s(:program,
+                         s(s(:comment,
+                           "# Foo\n",
+                           s(:module,
+                            s(:const_ref, s(:@const, "Foo", s(2, 7))),
+                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "produces a blank comment node surrounding a module that has no comment" do
+      result = parse_with_builder "module Foo; end"
+      result.must_equal s(:program,
+                         s(s(:comment,
+                           "",
+                           s(:module,
+                           s(:const_ref, s(:@const, "Foo", s(1, 7))),
+                           s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "is not confused by a symbol containing a keyword" do
+      result = parse_with_builder ":class; def foo; end"
+      result.must_equal s(:program,
+                         s(s(:symbol_literal, s(:symbol, s(:@kw, "class", s(1, 1)))),
+                          s(:comment,
+                           "",
+                           s(:def,
+                            s(:@ident, "foo", s(1, 12)),
+                            empty_params_list,
+                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "is not confused by a dynamic symbol" do
+      result = parse_with_builder ":'foo'; def bar; end"
+      result.must_equal s(:program,
+                         s(s(:dyna_symbol, s(s(:@tstring_content, "foo", s(1, 2)))),
+                          s(:comment,
+                           "",
+                           s(:def,
+                            s(:@ident, "bar", s(1, 12)),
+                            empty_params_list,
+                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+    end
+
+    it "is not confused by a dynamic symbol containing a class definition" do
+      result = parse_with_builder ":\"foo\#{class Bar;end}\""
+      result.must_equal s(:program,
+                         s(s(:dyna_symbol,
+                           s(s(:@tstring_content, "foo", s(1, 2)),
+                            s(:string_embexpr,
+                             s(s(:comment,
+                               "",
+                               s(:class,
+                                s(:const_ref, s(:@const, "Bar", s(1, 13))),
+                                nil,
+                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))))))
+    end
+  end
+end
+

data/test/unit/parser_assignment_test.rb

@@ -7,14 +7,14 @@ describe RipperRubyParser::Parser do
         "Foo::Bar = baz".
           must_be_parsed_as s(:cdecl,
                               s(:colon2, s(:const, :Foo), :Bar),
-                              s(:call, nil, :baz, s(:arglist)))
+                              s(:call, nil, :baz))
       end
 
       it "works when assigning to constant in the root namespace" do
         "::Foo = bar".
           must_be_parsed_as s(:cdecl,
                               s(:colon3, :Foo),
-                              s(:call, nil, :bar, s(:arglist)))
+                              s(:call, nil, :bar))
       end
 
       describe "with a right-hand splat" do
@@ -23,7 +23,7 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:lasgn, :foo,
                                 s(:svalue,
                                   s(:splat,
-                                    s(:call, nil, :bar, s(:arglist)))))
+                                    s(:call, nil, :bar))))
         end
 
         specify do
@@ -31,9 +31,9 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:lasgn, :foo,
                                 s(:svalue,
                                   s(:array,
-                                    s(:call, nil, :bar, s(:arglist)),
+                                    s(:call, nil, :bar),
                                     s(:splat,
-                                      s(:call, nil, :baz, s(:arglist))))))
+                                      s(:call, nil, :baz)))))
         end
       end
 
@@ -43,8 +43,8 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:lasgn, :foo,
                                 s(:svalue,
                                   s(:array,
-                                    s(:call, nil, :bar, s(:arglist)),
-                                    s(:call, nil, :baz, s(:arglist)))))
+                                    s(:call, nil, :bar),
+                                    s(:call, nil, :baz))))
         end
       end
 
@@ -53,8 +53,8 @@ describe RipperRubyParser::Parser do
           "foo = [bar, baz]".
             must_be_parsed_as s(:lasgn, :foo,
                                 s(:array,
-                                  s(:call, nil, :bar, s(:arglist)),
-                                  s(:call, nil, :baz, s(:arglist))))
+                                  s(:call, nil, :bar),
+                                  s(:call, nil, :baz)))
         end
       end
     end
@@ -64,7 +64,7 @@ describe RipperRubyParser::Parser do
         "foo, * = bar".
           must_be_parsed_as s(:masgn,
                               s(:array, s(:lasgn, :foo), s(:splat)),
-                              s(:to_ary, s(:call, nil, :bar, s(:arglist))))
+                              s(:to_ary, s(:call, nil, :bar)))
       end
 
       specify do
@@ -73,7 +73,7 @@ describe RipperRubyParser::Parser do
                               s(:array,
                                 s(:lasgn, :foo),
                                 s(:splat, s(:lasgn, :bar))),
-                              s(:to_ary, s(:call, nil, :baz, s(:arglist))))
+                              s(:to_ary, s(:call, nil, :baz)))
       end
     end
 
@@ -81,12 +81,11 @@ describe RipperRubyParser::Parser do
       it "handles multiple indices" do
         "foo[bar, baz] = qux".
           must_be_parsed_as s(:attrasgn,
-                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :foo),
                               :[]=,
-                              s(:arglist,
-                                s(:call, nil, :bar, s(:arglist)),
-                                s(:call, nil, :baz, s(:arglist)),
-                                s(:call, nil, :qux, s(:arglist))))
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz),
+                              s(:call, nil, :qux))
       end
     end
 
@@ -95,18 +94,18 @@ describe RipperRubyParser::Parser do
         it "handles multiple indices" do
           "foo[bar, baz] += qux".
             must_be_parsed_as s(:op_asgn1,
-                                s(:call, nil, :foo, s(:arglist)),
+                                s(:call, nil, :foo),
                                 s(:arglist,
-                                  s(:call, nil, :bar, s(:arglist)),
-                                  s(:call, nil, :baz, s(:arglist))),
+                                  s(:call, nil, :bar),
+                                  s(:call, nil, :baz)),
                                 :+,
-                                s(:call, nil, :qux, s(:arglist)))
+                                s(:call, nil, :qux))
         end
 
         it "works with &&=" do
           "foo &&= bar".
             must_be_parsed_as s(:op_asgn_and,
-                                s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar, s(:arglist))))
+                                s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
         end
       end
     end
@@ -117,15 +116,15 @@ describe RipperRubyParser::Parser do
           "foo, bar = *baz".
             must_be_parsed_as s(:masgn,
                                 s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                                s(:splat, s(:call, nil, :baz, s(:arglist))))
+                                s(:splat, s(:call, nil, :baz)))
         end
         specify do
           "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(:arglist)),
-                                  s(:splat, s(:call, nil, :qux, s(:arglist)))))
+                                  s(:call, nil, :baz),
+                                  s(:splat, s(:call, nil, :qux))))
         end
       end
     end

data/test/unit/parser_blocks_test.rb

@@ -6,88 +6,252 @@ describe RipperRubyParser::Parser do
       specify do
         "foo do |(bar, baz)| end".
           must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :bar),
-                                  s(:lasgn, :baz))))
+                              s(:call, nil, :foo),
+                              s(:args,
+                                s(:masgn, :bar, :baz)))
       end
 
       specify do
         "foo do |(bar, *baz)| end".
           must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :bar),
-                                  s(:splat, s(:lasgn, :baz)))))
+                              s(:call, nil, :foo),
+                              s(:args,
+                                s(:masgn, :bar, :"*baz")))
       end
 
       specify do
         "foo do |bar,*| end".
           must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:masgn, s(:array, s(:lasgn, :bar), s(:splat))))
+                              s(:call, nil, :foo),
+                              s(:args, :bar, :"*"))
       end
 
       specify do
         "foo do |bar, &baz| end".
           must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :bar),
-                                  s(:lasgn, :"&baz"))))
+                              s(:call, nil, :foo),
+                              s(:args, :bar, :"&baz"))
       end
 
-      it "behaves differently from RubyParser with a trailing comma in the block parameters" do
+      it "handles empty parameter specs" do
+        "foo do ||; bar; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:call, nil, :bar))
+      end
+
+      it "ignores a trailing comma in the block parameters" do
         "foo do |bar, | end".
           must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:lasgn, :bar))
+                              s(:call, nil, :foo),
+                              s(:args, :bar))
       end
     end
 
-    describe "for rescue/else/ensure" do
+    describe "for rescue/else" do
       it "works for a block with multiple rescue statements" do
         "begin foo; rescue; bar; rescue; baz; end".
           must_be_parsed_as s(:rescue,
-                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :foo),
                               s(:resbody,
                                 s(:array),
-                                s(:call, nil, :bar, s(:arglist))),
+                                s(:call, nil, :bar)),
                               s(:resbody,
                                 s(:array),
-                                s(:call, nil, :baz, s(:arglist))))
+                                s(:call, nil, :baz)))
       end
 
       it "works for a block with rescue and else" do
         "begin; foo; rescue; bar; else; baz; end".
           must_be_parsed_as s(:rescue,
-                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :foo),
                               s(:resbody,
                                 s(:array),
-                                s(:call, nil, :bar, s(:arglist))),
-                              s(:call, nil, :baz, s(:arglist)))
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz))
       end
 
       it "works for a block with only else" do
         "begin; foo; else; bar; end".
           must_be_parsed_as s(:block,
-                              s(:call, nil, :foo, s(:arglist)),
-                              s(:call, nil, :bar, s(:arglist)))
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
       end
     end
 
-    describe "for rescue" do
+    describe "for the rescue statement" do
       it "works with assignment to an error variable" do
         "begin; foo; rescue => bar; baz; end".
           must_be_parsed_as s(:rescue,
-                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :foo),
                               s(:resbody,
                                 s(:array,
                                   s(:lasgn, :bar, s(:gvar, :$!))),
-                                s(:call, nil, :baz, s(:arglist))))
+                                s(:call, nil, :baz)))
+      end
+
+      it "works with assignment of the exception to an instance variable" do
+        "begin; foo; rescue => @bar; baz; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array,
+                                  s(:iasgn, :@bar, s(:gvar, :$!))),
+                                s(:call, nil, :baz)))
+      end
+
+      it "works with empty main and rescue bodies" do
+        "begin; rescue; end".
+          must_be_parsed_as s(:rescue,
+                              s(:resbody, s(:array), nil))
+      end
+
+      it "works with single statement main and rescue bodies" do
+        "begin; foo; rescue; bar; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :bar)))
+      end
+
+      it "works with multi-statement main and rescue bodies" do
+        "begin; foo; bar; rescue; baz; qux; end".
+          must_be_parsed_as s(:rescue,
+                              s(:block,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)))
+      end
+
+      it "works with assignment to an error variable" do
+        "begin; foo; rescue => e; bar; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array, s(:lasgn, :e, s(:gvar, :$!))),
+                                s(:call, nil, :bar)))
+      end
+
+      it "works with filtering of the exception type" do
+        "begin; foo; rescue Bar; baz; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array, s(:const, :Bar)),
+                                s(:call, nil, :baz)))
+      end
+
+      it "works with filtering of the exception type and assignment to an error variable" do
+        "begin; foo; rescue Bar => e; baz; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array,
+                                  s(:const, :Bar),
+                                  s(:lasgn, :e, s(:gvar, :$!))),
+                                s(:call, nil, :baz)))
+      end
+
+      it "works rescuing multiple exception types" do
+        "begin; foo; rescue Bar, Baz; qux; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array, s(:const, :Bar), s(:const, :Baz)),
+                                s(:call, nil, :qux)))
+      end
+
+      it "works in the postfix case" do
+        "foo rescue bar".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :bar)))
+      end
+
+      it "works in a plain method body" do
+        "def foo; bar; rescue; baz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args),
+                              s(:rescue,
+                                s(:call, nil, :bar),
+                                s(:resbody,
+                                  s(:array),
+                                  s(:call, nil, :baz))))
+      end
+
+      it "works in a method body inside begin..end" do
+        "def foo; bar; begin; baz; rescue; qux; end; quuz; end".
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args),
+                              s(:call, nil, :bar),
+                              s(:rescue,
+                                s(:call, nil, :baz),
+                                s(:resbody, s(:array), s(:call, nil, :qux))),
+                              s(:call, nil, :quuz))
+      end
+    end
+
+    describe "for the ensure statement" do
+      it "works with single statement main and ensure bodies" do
+        "begin; foo; ensure; bar; end".
+          must_be_parsed_as s(:ensure,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it "works with multi-statement main and ensure bodies" do
+        "begin; foo; bar; ensure; baz; qux; end".
+          must_be_parsed_as s(:ensure,
+                              s(:block,
+                                s(:call, nil, :foo),
+                                s(:call, nil, :bar)),
+                              s(:block,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)))
+      end
+
+      it "works together with rescue" do
+        "begin; foo; rescue; bar; ensure; baz; end".
+          must_be_parsed_as s(:ensure,
+                              s(:rescue,
+                                s(:call, nil, :foo),
+                                s(:resbody,
+                                  s(:array),
+                                  s(:call, nil, :bar))),
+                              s(:call, nil, :baz))
+      end
+
+      it "works with empty main and ensure bodies" do
+        "begin; ensure; end".
+          must_be_parsed_as s(:ensure, s(:nil))
+      end
+    end
+
+    describe "for lists of consecutive statments" do
+      it "removes extra blocks for grouped statements at the start of the list" do
+        "(foo; bar); baz".
+          must_be_parsed_as s(:block,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz))
+      end
+
+      it "keeps extra blocks for grouped statements at the end of the list" do
+        "foo; (bar; baz)".
+          must_be_parsed_as s(:block,
+                              s(:call, nil, :foo),
+                              s(:block,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)))
       end
     end
 
@@ -95,9 +259,17 @@ describe RipperRubyParser::Parser do
       it "works in the simple case" do
         "->(foo) { bar }".
           must_be_parsed_as s(:iter,
-                              s(:call, nil, :lambda, s(:arglist)),
-                              s(:lasgn, :foo),
-                              s(:call, nil, :bar, s(:arglist))) 
+                              s(:call, nil, :lambda),
+                              s(:args, :foo),
+                              s(:call, nil, :bar)) 
+      end
+
+      it "works when there are no arguments" do
+        "-> { bar }".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :lambda),
+                              0,
+                              s(:call, nil, :bar)) 
       end
     end
   end