opal-cj 0.7.0.beta1

data/spec/lib/parser/attrasgn_spec.rb

@@ -0,0 +1,28 @@
+require 'support/parser_helpers'
+
+describe "Attribute assignments" do
+  it "should return a s(:attrasgn) for simple assignments" do
+    parsed('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
+    parsed('bar.foo = 1').should == [:attrasgn, [:call, nil, :bar, [:arglist]], :foo=, [:arglist, [:int, 1]]]
+    parsed('@bar.foo = 1').should == [:attrasgn, [:ivar, :@bar], :foo=, [:arglist, [:int, 1]]]
+  end
+
+  it "accepts both '.' and '::' for method call operators" do
+    parsed('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
+    parsed('self::foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
+  end
+
+  it "can accept a constant as assignable name when using '.'" do
+    parsed('self.FOO = 1').should == [:attrasgn, [:self], :FOO=, [:arglist, [:int, 1]]]
+  end
+
+  describe "when setting element reference" do
+    it "uses []= as the method call" do
+      parsed('self[1] = 2').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2]]]
+    end
+
+    it "supports multiple arguments inside brackets" do
+      parsed('self[1, 2] = 3').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2], [:int, 3]]]
+    end
+  end
+end

data/spec/lib/parser/begin_spec.rb

@@ -0,0 +1,42 @@
+require 'support/parser_helpers'
+
+describe "The begin keyword" do
+  it "should be removed when used without a resuce or enusre body" do
+    parsed('begin; 1; end').should == [:int, 1]
+    parsed('begin; 1; 2; end').should == [:block, [:int, 1], [:int, 2]]
+  end
+
+  describe "with 'rescue' bodies" do
+    it "should create a s(:rescue) sexp" do
+      parsed('begin; 1; rescue; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
+    end
+
+    it "allows multiple rescue bodies" do
+      parsed('begin 1; rescue; 2; rescue; 3; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]], [:resbody, [:array], [:int, 3]]]
+    end
+
+    it "accepts a list of classes used to match against the exception" do
+      parsed('begin 1; rescue Klass; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass]], [:int, 2]]]
+    end
+
+    it "accepts an identifier to assign exception to" do
+      parsed('begin 1; rescue => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
+      parsed('begin 1; rescue Klass => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
+    end
+
+    it "accepts an ivar to assign exception to" do
+      parsed('begin 1; rescue => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
+      parsed('begin 1; rescue Klass => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
+    end
+
+    it "should parse newline right after rescue" do
+      parsed("begin; 1; rescue\n 2; end").should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
+    end
+  end
+
+  describe "with an 'ensure' block" do
+    it "should propagate into single s(:ensure) statement when no rescue block given" do
+      parsed('begin; 1; ensure; 2; end').should == [:ensure, [:int, 1], [:int, 2]]
+    end
+  end
+end

data/spec/lib/parser/block_spec.rb

@@ -0,0 +1,12 @@
+require 'support/parser_helpers'
+
+describe "Block statements" do
+  it "should return the direct expression if only one expresssion in block" do
+    parsed("42").should == [:int, 42]
+  end
+
+  it "should return an s(:block) with all expressions appended for > 1 expression" do
+    parsed("42; 43").should == [:block, [:int, 42], [:int, 43]]
+    parsed("42; 43\n44").should == [:block, [:int, 42], [:int, 43], [:int, 44]]
+  end
+end

data/spec/lib/parser/break_spec.rb

@@ -0,0 +1,17 @@
+require 'support/parser_helpers'
+
+describe "The break keyword" do
+  it "should return s(:break) when given no args" do
+    parsed("break").should == [:break]
+  end
+
+  it "returns s(:break) with a single arg not wrapped in s(:array)" do
+    parsed("break 1").should == [:break, [:int, 1]]
+    parsed("break *1").should == [:break, [:splat, [:int, 1]]]
+  end
+
+  it "returns s(:break) with an s(:array) for args size > 1" do
+    parsed("break 1, 2").should == [:break, [:array, [:int, 1], [:int, 2]]]
+    parsed("break 1, *2").should == [:break, [:array, [:int, 1], [:splat, [:int, 2]]]]
+  end
+end

data/spec/lib/parser/call_spec.rb

@@ -0,0 +1,139 @@
+require 'support/parser_helpers'
+
+describe "Method calls" do
+  it "should use 'nil' for calls without a receiver" do
+    parsed("foo").should == [:call, nil, :foo, [:arglist]]
+    parsed("foo()").should == [:call, nil, :foo, [:arglist]]
+  end
+
+  it "should always have an arglist when not passed any arguments" do
+    parsed("foo").should == [:call, nil, :foo, [:arglist]]
+    parsed("self.foo").should == [:call, [:self], :foo, [:arglist]]
+    parsed("foo()").should == [:call, nil, :foo, [:arglist]]
+    parsed("self.foo()").should == [:call, [:self], :foo, [:arglist]]
+  end
+
+  it "appends all arguments onto arglist" do
+    parsed("foo 1").should == [:call, nil, :foo, [:arglist, [:int, 1]]]
+    parsed("foo 1, 2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:int, 2]]]
+    parsed("foo 1, *2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
+  end
+
+  it "supports leading dots on newline" do
+    parsed("foo\n.bar").should == [:call, [:call, nil, :foo, [:arglist]], :bar, [:arglist]]
+    lambda { parsed("foo\n..bar") }.should raise_error(Exception)
+  end
+end
+
+describe "Operator calls" do
+  it "should parse all other operators into method calls" do
+    parsed("1 % 2").should == [:call, [:int, 1], :%, [:arglist, [:int, 2]]]
+    parsed("1 ** 2").should == [:call, [:int, 1], :**, [:arglist, [:int, 2]]]
+
+    parsed("+self").should == [:call, [:self], :+@, [:arglist]]
+    parsed("-self").should == [:call, [:self], :-@, [:arglist]]
+
+    parsed("1 | 2").should == [:call, [:int, 1], :|, [:arglist, [:int, 2]]]
+    parsed("1 ^ 2").should == [:call, [:int, 1], :^, [:arglist, [:int, 2]]]
+    parsed("1 & 2").should == [:call, [:int, 1], :&, [:arglist, [:int, 2]]]
+    parsed("1 <=> 2").should == [:call, [:int, 1], :<=>, [:arglist, [:int, 2]]]
+
+    parsed("1 < 2").should == [:call, [:int, 1], :<, [:arglist, [:int, 2]]]
+    parsed("1 <= 2").should == [:call, [:int, 1], :<=, [:arglist, [:int, 2]]]
+    parsed("1 > 2").should == [:call, [:int, 1], :>, [:arglist, [:int, 2]]]
+    parsed("1 >= 2").should == [:call, [:int, 1], :>=, [:arglist, [:int, 2]]]
+
+    parsed("1 == 2").should == [:call, [:int, 1], :==, [:arglist, [:int, 2]]]
+    parsed("1 === 2").should == [:call, [:int, 1], :===, [:arglist, [:int, 2]]]
+    parsed("1 =~ 2").should == [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]
+
+    parsed("~1").should == [:call, [:int, 1], :~, [:arglist]]
+    parsed("1 << 2").should == [:call, [:int, 1], :<<, [:arglist, [:int, 2]]]
+    parsed("1 >> 2").should == [:call, [:int, 1], :>>, [:arglist, [:int, 2]]]
+  end
+
+  it "optimizes +@ and -@ on numerics" do
+    parsed("+1").should == [:int, 1]
+    parsed("-1").should == [:int, -1]
+  end
+end
+
+describe "Optional paren calls" do
+  it "should correctly parse - and -@" do
+    parsed("x - 1").should == [:call, [:call, nil, :x, [:arglist]], :-, [:arglist, [:int, 1]]]
+    parsed("x -1").should == [:call, nil, :x, [:arglist, [:int, -1]]]
+  end
+
+  it "should correctly parse + and +@" do
+    parsed("x + 1").should == [:call, [:call, nil, :x, [:arglist]], :+, [:arglist, [:int, 1]]]
+    parsed("x +1").should == [:call, nil, :x, [:arglist, [:int, 1]]]
+  end
+
+  it "should correctly parse / and regexps" do
+    parsed("x / 500").should == [:call, [:call, nil, :x, [:arglist]], :/, [:arglist, [:int, 500]]]
+    parsed("x /foo/").should == [:call, nil, :x, [:arglist, [:regexp, 'foo', nil]]]
+  end
+
+  it "should parse LPAREN_ARG correctly" do
+    parsed("x (1).y").should == [:call, nil, :x, [:arglist, [:call, [:int, 1], :y, [:arglist]]]]
+    parsed("x(1).y").should == [:call, [:call, nil, :x, [:arglist, [:int, 1]]], :y, [:arglist]]
+  end
+end
+
+describe "Operator precedence" do
+  it "should be raised with parentheses" do
+   parsed("(1 + 2) + (3 - 4)").should == [:call,
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
+                                               :+,
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
+                                              ]
+   parsed("(1 + 2) - (3 - 4)").should == [:call,
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
+                                               :-,
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
+                                              ]
+   parsed("(1 + 2) * (3 - 4)").should == [:call,
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
+                                               :*,
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
+                                              ]
+   parsed("(1 + 2) / (3 - 4)").should == [:call,
+                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
+                                               :/,
+                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
+                                              ]
+  end
+end
+
+describe "Calls with keywords as method names" do
+
+  keywords = %w[class module defined? def undef end do if unless else elsif self true false
+                nil __LINE__ __FILE__ begin rescue ensure case when or and not return next
+                redo break super then while until yield alias]
+
+  it "should correctly parse the keyword as a method name when after a '.'" do
+    keywords.each do |kw|
+      parsed("self.#{kw}").should == [:call, [:self], kw.to_sym, [:arglist]]
+    end
+  end
+end
+
+describe "Calls with operators as method names" do
+  operators = %w[+ - * / & ** | ^ & <=> > >= < <= << >>]
+
+  it "should correctly parse the operator as method name after '.'" do
+    operators.each do |op|
+      parsed("self.#{op}").should == [:call, [:self], op.to_sym, [:arglist]]
+      parsed("self.#{op}(1)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1]]]
+      parsed("self.#{op}(1, 2)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1], [:int, 2]]]
+    end
+  end
+end
+
+describe "Command calls with operators" do
+  it "parses operators before \n in command calls" do
+    [:<<, :>>, :|, :^, :&, :<=>, :==, :===, :=~, :>, :>=, :<, :<=, :<<, :>>, :%, :**].each do |mid|
+      parsed("self #{mid}\nself").should == [:call, [:self], mid, [:arglist, [:self]]]
+    end
+  end
+end

data/spec/lib/parser/class_spec.rb

@@ -0,0 +1,35 @@
+require 'support/parser_helpers'
+
+describe "The class keyword" do
+  it "returns an empty s(:block) when given an empty body" do
+    parsed('class A; end').should == [:class, [:const, :A], nil, [:block]]
+  end
+
+  it "does not place single expressions into a s(:block)" do
+    parsed('class A; 1; end').should == [:class, [:const, :A], nil, [:int, 1]]
+  end
+
+  it "adds multiple body expressions into a s(:block)" do
+    parsed('class A; 1; 2; end').should == [:class, [:const, :A], nil, [:block, [:int, 1], [:int, 2]]]
+  end
+
+  it "uses nil as a placeholder when no superclass is given" do
+    parsed('class A; end')[2].should == nil
+  end
+
+  it "reflects the given superclass" do
+    parsed('class A < B; end')[2].should == [:const, :B]
+  end
+
+  it "should accept just a constant for the class name" do
+    parsed('class A; end')[1].should == [:const, :A]
+  end
+
+  it "should accept a prefix constant for the class name" do
+    parsed('class ::A; end')[1].should == [:colon3, :A]
+  end
+
+  it "should accept a nested constant for the class name" do
+    parsed('class A::B; end')[1].should == [:colon2, [:const, :A], :B]
+  end
+end

data/spec/lib/parser/comments_spec.rb

@@ -0,0 +1,11 @@
+require 'support/parser_helpers'
+
+describe "Multiline comments" do
+  it "parses multiline comments and ignores them" do
+    parsed("=begin\nfoo\n=end\n100").should == [:int, 100]
+  end
+
+  it "raises an exception if not closed before end of file" do
+    lambda { parsed("=begin\nfoo\nbar") }.should raise_error(Exception, /embedded document meets end of file/)
+  end
+end

data/spec/lib/parser/def_spec.rb

@@ -0,0 +1,61 @@
+require 'support/parser_helpers'
+
+describe "The def keyword" do
+  describe "for normal definitions" do
+    it "should return s(:def)" do
+      parsed("def a; end").should == [:def, nil, :a, [:args], [:block, [:nil]]]
+    end
+
+    it "adds s(:nil) on an empty body" do
+      parsed("def foo; end").last.should == [:block, [:nil]]
+    end
+  end
+
+  describe "for singleton definitions" do
+    it "should return s(:def)" do
+      parsed("def self.a; end").should == [:def, [:self], :a, [:args], [:block, [:nil]]]
+    end
+
+    it "adds s(:nil) on an empty body" do
+      parsed("def self.foo; end").last.should == [:block, [:nil]]
+    end
+  end
+
+  describe "with normal args" do
+    it "should list all args" do
+      parsed("def foo(a); end")[3].should == [:args, :a]
+      parsed("def foo(a, b); end")[3].should == [:args, :a, :b]
+      parsed("def foo(a, b, c); end")[3].should == [:args, :a, :b, :c]
+    end
+  end
+
+  describe "with opt args" do
+    it "should list all opt args as well as block with each lasgn" do
+      parsed("def foo(a = 1); end")[3].should == [:args, :a, [:block, [:lasgn, :a, [:int, 1]]]]
+      parsed("def foo(a = 1, b = 2); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]
+    end
+
+    it "should list lasgn block after all other args" do
+      parsed("def foo(a, b = 1); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :b, [:int, 1]]]]
+      parsed("def foo(b = 1, *c); end")[3].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:int, 1]]]]
+      parsed("def foo(b = 1, &block); end")[3].should == [:args, :b, :"&block", [:block, [:lasgn, :b, [:int, 1]]]]
+    end
+  end
+
+  describe "with rest args" do
+    it "should list rest args in place as a symbol with '*' prefix" do
+      parsed("def foo(*a); end")[3].should == [:args, :"*a"]
+    end
+
+    it "uses '*' as an arg name for rest args without a name" do
+      parsed("def foo(*); end")[3].should == [:args, :"*"]
+    end
+  end
+
+  describe "with block arg" do
+    it "should list block argument with the '&' prefix" do
+      parsed("def foo(&a); end")[3].should == [:args, :"&a"]
+    end
+  end
+end
+

data/spec/lib/parser/if_spec.rb

@@ -0,0 +1,26 @@
+require 'support/parser_helpers'
+
+describe "The if keyword" do
+  it "should return an s(:if) with given truthy and falsy bodies" do
+    parsed("if 1; 2; else; 3; end").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
+  end
+
+  it "uses nil as fasly body if not given else-then" do
+    parsed("if 1; 2; end").should == [:if, [:int, 1], [:int, 2], nil]
+  end
+
+  it "is treats elsif parts as sub if expressions for else body" do
+    parsed("if 1; 2; elsif 3; 4; else; 5; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], [:int, 5]]]
+    parsed("if 1; 2; elsif 3; 4; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], nil]]
+  end
+
+  it "returns a simple s(:if) with nil else body for prefix if statement" do
+    parsed("1 if 2").should == [:if, [:int, 2], [:int, 1], nil]
+  end
+end
+
+describe "The ternary operator" do
+  it "gets converted into an if statement with true and false parts" do
+    parsed("1 ? 2 : 3").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
+  end
+end

data/spec/lib/parser/iter_spec.rb

@@ -0,0 +1,59 @@
+require 'support/parser_helpers'
+
+describe "Iters" do
+  describe "Iter on a command" do
+    it "the outer command call gets the iter" do
+      parsed("a b do; end").should == [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]], [:iter, nil]]
+      parsed("a 1, b do; end").should == [:call, nil, :a, [:arglist, [:int, 1], [:call, nil, :b, [:arglist]]], [:iter, nil]]
+    end
+  end
+
+  describe "with no args" do
+    it "has 'nil' as the args part of sexp" do
+      parsed("proc do; end")[4][1].should == nil
+    end
+  end
+
+  describe "with empty || args" do
+    it "should have args set to nil" do
+      parsed("proc do ||; end")[4][1].should == nil
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      parsed("proc do |a|; end")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      parsed("proc do |a, b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      parsed("proc do |a, b, c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with splat arg" do
+    it "adds a s(:masgn) for the s(:splat) even if its the only arg" do
+      parsed("proc do |*a|; end")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      parsed("proc do |a, *b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+  end
+
+  describe "with opt args" do
+    it "adds a s(:block) arg to end of s(:masgn) for each lasgn" do
+      parsed("proc do |a = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      parsed("proc do |a = 1, b = 2|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "should add lasgn block after all other args" do
+      parsed("proc do |a, b = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
+      parsed("proc do |b = 1, *c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+      parsed("proc do |b = 1, &c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+    end
+  end
+
+  describe "with block arg" do
+    it "should add block arg with s(:block_pass) wrapping s(:lasgn) prefix" do
+      parsed("proc do |&a|; end")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+end

data/spec/lib/parser/lambda_spec.rb

@@ -0,0 +1,64 @@
+require 'support/parser_helpers'
+
+describe "Lambda literals" do
+  it "should parse with either do/end construct or curly braces" do
+    parsed("-> {}").first.should == :call
+    parsed("-> do; end").first.should == :call
+  end
+
+  it "should parse as a call to 'lambda' with the lambda body as a block" do
+    parsed("-> {}").should == [:call, nil, :lambda, [:arglist], [:iter, nil]]
+  end
+
+  describe "with no args" do
+    it "should accept no args" do
+      parsed("-> {}")[4][1].should == nil
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      parsed("->(a) {}")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      parsed("-> (a, b) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      parsed("-> (a, b, c) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with optional braces" do
+    it "parses normal args" do
+      parsed("-> a {}")[4][1].should == [:lasgn, :a]
+      parsed("-> a, b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+    end
+
+    it "parses splat args" do
+      parsed("-> *a {}")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      parsed("-> a, *b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+
+    it "parses opt args" do
+      parsed("-> a = 1 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      parsed("-> a = 1, b = 2 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "parses block args" do
+      parsed("-> &a {}")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+
+  describe "with body statements" do
+    it "should be nil when no statements given" do
+      parsed("-> {}")[4][2].should == nil
+    end
+
+    it "should be the single sexp when given one statement" do
+      parsed("-> { 42 }")[4][2].should == [:int, 42]
+    end
+
+    it "should wrap multiple statements into a s(:block)" do
+      parsed("-> { 42; 3.142 }")[4][2].should == [:block, [:int, 42], [:float, 3.142]]
+    end
+  end
+end