opal 0.9.4 → 0.10.0.beta1

data/spec/lib/compiler_spec.rb

@@ -38,20 +38,20 @@ describe Opal::Compiler do
     expect_compiled("self.inspect").to include("$inspect()")
     expect_compiled("self.map { |a| a + 10 }").to include("$map")
   end
-  
+
   it "adds method missing stubs" do
     expect_compiled("self.puts 'hello'").to include("Opal.add_stubs(['$puts'])")
   end
-  
+
   it 'adds method missing stubs with operators' do
     expect_compiled("class Foo; end; Foo.new > 5").to include("Opal.add_stubs(['$>', '$new'])")
   end
-  
+
   it "should compile constant lookups" do
     expect_compiled("Object").to include("Object")
     expect_compiled("Array").to include("Array")
   end
-  
+
   it "should compile undef calls" do
     expect_compiled("undef a").to include("Opal.udef(self, '$a')")
     expect_compiled("undef a,b").to match(/Opal.udef\(self, '\$a'\);.*return Opal.udef\(self, '\$b'\);/m)
@@ -63,6 +63,24 @@ describe Opal::Compiler do
     end
   end
 
+  describe "method names" do
+    it "generates a named function for method" do
+      expect_compiled("def test_method; end").to include("function ːtest_method()")
+    end
+
+    context "when function name is reserved" do
+      it "generates a valid named function for method" do
+        expect_compiled("def Array; end").to include("function ːArray()")
+      end
+    end
+
+    context "when function name is not valid" do
+      it "skips generating a name" do
+        expect_compiled("def test_method?; end").to include("function()")
+      end
+    end
+  end
+
   describe "debugger special method" do
     it "generates debugger keyword in javascript" do
       expect_compiled("debugger").to include("debugger")
@@ -133,7 +151,7 @@ describe Opal::Compiler do
       end
     end
   end
-  
+
   describe 'truthy check' do
     context 'no parentheses' do
       context 'with operators' do
@@ -141,113 +159,113 @@ describe Opal::Compiler do
           expect_compiled('foo = 42 if 2 > 3').to include('if ($rb_gt(2, 3))')
           expect_compiled('foo = 42 if 2.5 > 3.5').to include('if ($rb_gt(2.5, 3.5))')
           expect_compiled('foo = 42 if true > false').to include('if ($rb_gt(true, false))')
-          
+
           expect_compiled('foo = 42 if 2 == 3').to include("if ((2)['$=='](3))")
           expect_compiled('foo = 42 if 2.5 == 3.5').to include("if ((2.5)['$=='](3.5))")
           expect_compiled('foo = 42 if true == false').to include("if (true['$=='](false))")
         end
-      
+
         it 'adds nil check for strings' do
           expect_compiled('foo = 42 if "test" > "bar"').to include('if ((($a = $rb_gt("test", "bar")) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-        
+
         it 'specifically == excludes nil check for strings' do
           expect_compiled('foo = 42 if "test" == "bar"').to include("if (\"test\"['$=='](\"bar\"))")
         end
-      
+
         it 'adds nil check for lvars' do
           expect_compiled("bar = 4\nfoo = 42 if bar > 5").to include('if ((($a = $rb_gt(bar, 5)) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-        
+
         it 'specifically == excludes nil check for lvars' do
           expect_compiled("bar = 4\nfoo = 42 if bar == 5").to include("if (bar['$=='](5))")
         end
-      
+
         it 'adds nil check for constants' do
           expect_compiled("foo = 42 if Test > 4").to include("if ((($a = $rb_gt($scope.get('Test'), 4)) !== nil && (!$a.$$is_boolean || $a == true))) ")
         end
-        
+
         it 'specifically == excludes nil check for constants' do
           expect_compiled("foo = 42 if Test == 4").to include("if ($scope.get('Test')['$=='](4))")
         end
       end
-    
+
       context 'without operators' do
         it 'adds nil check for primitives' do
           expect_compiled('foo = 42 if 2').to include('if ((($a = 2) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if 2.5').to include('if ((($a = 2.5) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if true').to include('if ((($a = true) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-        
+
         it 'adds nil check for boolean method calls' do
           expect_compiled('foo = 42 if true.something').to include('if ((($a = true.$something()) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-      
+
         it 'adds nil check for strings' do
           expect_compiled('foo = 42 if "test"').to include('if ((($a = "test") !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-      
+
         it 'adds nil check for lvars' do
           expect_compiled("bar = 4\nfoo = 42 if bar").to include('if (bar !== false && bar !== nil)')
         end
-      
+
         it 'adds nil check for constants' do
           expect_compiled("foo = 42 if Test").to include("if ((($a = $scope.get('Test')) !== nil && (!$a.$$is_boolean || $a == true)))")
         end
       end
     end
-    
+
     context 'parentheses' do
       context 'with operators' do
         it 'adds nil check for primitives' do
           expect_compiled('foo = 42 if (2 > 3)').to include('if ((($a = ($rb_gt(2, 3))) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if (2.5 > 3.5)').to include('if ((($a = ($rb_gt(2.5, 3.5))) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if (true > false)').to include('if ((($a = ($rb_gt(true, false))) !== nil && (!$a.$$is_boolean || $a == true)))')
-          
+
           expect_compiled('foo = 42 if (2 == 3)').to include("if ((($a = ((2)['$=='](3))) !== nil && (!$a.$$is_boolean || $a == true)))")
           expect_compiled('foo = 42 if (2.5 == 3.5)').to include("if ((($a = ((2.5)['$=='](3.5))) !== nil && (!$a.$$is_boolean || $a == true)))")
           expect_compiled('foo = 42 if (true == false)').to include("if ((($a = (true['$=='](false))) !== nil && (!$a.$$is_boolean || $a == true)))")
         end
-      
+
         it 'adds nil check for strings' do
           expect_compiled('foo = 42 if ("test" > "bar")').to include('if ((($a = ($rb_gt("test", "bar"))) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if ("test" == "bar")').to include("if ((($a = (\"test\"['$=='](\"bar\"))) !== nil && (!$a.$$is_boolean || $a == true)))")
         end
-      
+
         it 'adds nil check for lvars' do
           expect_compiled("bar = 4\nfoo = 42 if (bar > 5)").to include('if ((($a = ($rb_gt(bar, 5))) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled("bar = 4\nfoo = 42 if (bar == 5)").to include("if ((($a = (bar['$=='](5))) !== nil && (!$a.$$is_boolean || $a == true))) ")
         end
-      
+
         it 'adds nil check for constants' do
           expect_compiled("foo = 42 if (Test > 4)").to include("if ((($a = ($rb_gt($scope.get('Test'), 4))) !== nil && (!$a.$$is_boolean || $a == true)))")
           expect_compiled("foo = 42 if (Test == 4)").to include("if ((($a = ($scope.get('Test')['$=='](4))) !== nil && (!$a.$$is_boolean || $a == true)))")
         end
       end
-    
+
       context 'without operators' do
         it 'adds nil check for primitives' do
           expect_compiled('foo = 42 if (2)').to include('if ((($a = (2)) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if (2.5)').to include('if ((($a = (2.5)) !== nil && (!$a.$$is_boolean || $a == true)))')
           expect_compiled('foo = 42 if (true)').to include('if ((($a = (true)) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-        
+
         it 'adds nil check for boolean method calls' do
           expect_compiled('foo = 42 if (true.something)').to include('if ((($a = (true.$something())) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-      
+
         it 'adds nil check for strings' do
           expect_compiled('foo = 42 if ("test")').to include('if ((($a = ("test")) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-      
+
         it 'adds nil check for lvars' do
           expect_compiled("bar = 4\nfoo = 42 if (bar)").to include('if ((($a = (bar)) !== nil && (!$a.$$is_boolean || $a == true)))')
         end
-      
+
         it 'adds nil check for constants' do
           expect_compiled("foo = 42 if (Test)").to include("if ((($a = ($scope.get('Test'))) !== nil && (!$a.$$is_boolean || $a == true)))")
         end
-      end      
+      end
     end
   end
 

data/spec/lib/config_spec.rb

@@ -0,0 +1,13 @@
+require 'lib/spec_helper'
+require 'opal/config'
+
+describe Opal::Config do
+  describe '.default_config' do
+    it 'is new each time' do
+      default_config1 = described_class.default_config
+      default_config2 = described_class.default_config
+      expect(default_config1).to eq(default_config2)
+      expect(default_config1).not_to equal(default_config2)
+    end
+  end
+end

data/spec/lib/parser/call_spec.rb

@@ -23,6 +23,10 @@ describe "Method calls" do
     parsed("foo\n.bar").should == [:call, [:call, nil, :foo, [:arglist]], :bar, [:arglist]]
     lambda { parsed("foo\n..bar") }.should raise_error(Exception)
   end
+
+  it "parses method starting on the next line after \\" do
+    parsed("\\\nfoo").should == [:call, nil, :foo, [:arglist]]
+  end
 end
 
 describe "Operator calls" do
@@ -181,3 +185,17 @@ describe 'Calls with trailing comma' do
       [:hash, [:sym, :a], [:int, 100]]]]
   end
 end
+
+describe 'Calls with kwsplat' do
+  it 'parses empty kwsplat' do
+    parsed('foo(**{})').should == [:call, nil, :foo, [:arglist, [:hash, [:kwsplat, [:hash]]]]]
+  end
+
+  it 'parses non-empty kwsplat' do
+    parsed('foo(**{ a: 1 })').should == [:call, nil, :foo, [:arglist, [:hash, [:kwsplat, [:hash, [:sym, :a], [:int, 1]]]]]]
+  end
+
+  it 'supports kwargs and kwsplat' do
+    parsed('foo(a: 1, **{ b: 2 })').should == [:call, nil, :foo, [:arglist, [:hash, [:sym, :a], [:int, 1], [:kwsplat, [:hash, [:sym, :b], [:int, 2]]]]]]
+  end
+end

data/spec/lib/parser/def_spec.rb

@@ -33,6 +33,10 @@ describe "The def keyword" do
       parsed("def foo(a = 1); end")[3].should == [:args, [:optarg, :a, [:int, 1]]]
       parsed("def foo(a = 1, b = 2); end")[3].should == [:args, [:optarg, :a, [:int, 1]], [:optarg, :b, [:int, 2]]]
     end
+
+    it "parses norm arg after optarg" do
+      parsed("def foo(a = 1, b); end")[3].should == [:args, [:optarg, :a, [:int, 1]], [:arg, :b]]
+    end
   end
 
   describe "with rest args" do
@@ -77,4 +81,29 @@ describe "The def keyword" do
       parsed("def foo a: 1, b: 2; end")[3].should == [:args, [:kwoptarg, :a, [:int, 1]], [:kwoptarg, :b, [:int, 2]]]
     end
   end
+
+  it "parses (a,b=1,*c,d,&blk) arguments" do
+    expected = [:args, [:arg, :a], [:optarg, :b, [:int, 1]], [:restarg, :c], [:arg, :d], [:blockarg, :blk]]
+    parsed("def m(a,b=1,*c,d,&blk); end")[3].should == expected
+  end
+
+  it "parses (a,b=1,c,&blk) arguments" do
+    expected = [:args, [:arg, :a], [:optarg, :b, [:int, 1]], [:arg, :c], [:blockarg, :blk]]
+    parsed("def m(a,b=1,c,&blk); end")[3].should == expected
+  end
+
+  it "parses (a,*b,c,&blk) arguments" do
+    expected = [:args, [:arg, :a], [:restarg, :b], [:arg, :c], [:blockarg, :blk]]
+    parsed("def m(a,*b,c,&blk); end")[3].should == expected
+  end
+
+  it "parses (a=1,*b,c,&blk) arguments" do
+    expected = [:args, [:optarg, :a, [:int, 1]], [:restarg, :b], [:arg, :c], [:blockarg, :blk]]
+    parsed("def m(a=1,*b,c,&blk); end")[3].should == expected
+  end
+
+  it "parses (*b,c,&blk) arguments" do
+    expected = [:args, [:restarg, :b], [:arg, :c], [:blockarg, :blk]]
+    parsed("def m(*b,c,&blk); end")[3].should == expected
+  end
 end

data/spec/lib/parser/iter_spec.rb

@@ -21,39 +21,39 @@ describe "Iters" do
   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]
+    it "adds a single s(:masgn) for 1 norm arg" do
+      parsed("proc do |a|; end")[4][1].should == [:masgn, [:args, [:arg, :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]]]
+      parsed("proc do |a, b|; end")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b]]]
+      parsed("proc do |a, b, c|; end")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b], [:arg, :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]]]]
+    it "adds a s(:masgn) for the s(:restarg) even if its the only arg" do
+      parsed("proc do |*a|; end")[4][1].should == [:masgn, [:args, [:restarg, :a]]]
+      parsed("proc do |a, *b|; end")[4][1].should == [:masgn, [:args, [:arg, :a], [:restarg, :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]]]]]
+    it "adds a s(:optarg) arg each optional argument" do
+      parsed("proc do |a = 1|; end")[4][1].should == [:masgn, [:args, [:optarg, :a, [:int, 1]]]]
+      parsed("proc do |a = 1, b = 2|; end")[4][1].should == [:masgn, [:args, [:optarg, :a, [:int, 1]], [:optarg, :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]]]]]
+    it "should add args in the direct order" do
+      parsed("proc do |a, b = 1|; end")[4][1].should == [:masgn, [:args, [:arg, :a], [:optarg, :b, [:int, 1]]]]
+      parsed("proc do |b = 1, *c|; end")[4][1].should == [:masgn, [:args, [:optarg, :b, [:int, 1]], [:restarg, :c]]]
+      parsed("proc do |b = 1, &c|; end")[4][1].should == [:masgn, [:args, [:optarg, :b, [:int, 1]], [:block_pass, [:lasgn, :c]]]]
     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]]]]
+      parsed("proc do |&a|; end")[4][1].should == [:masgn, [:args, [:block_pass, [:lasgn, :a]]]]
     end
   end
 end

data/spec/lib/parser/lambda_spec.rb

@@ -10,6 +10,10 @@ describe "Lambda literals" do
     parsed("-> {}").should == [:call, nil, :lambda, [:arglist], [:iter, nil]]
   end
 
+  def parsed_args(source)
+    parsed(source)[4][1][1]
+  end
+
   describe "with no args" do
     it "should accept no args" do
       parsed("-> {}")[4][1].should == nil
@@ -17,34 +21,34 @@ describe "Lambda literals" do
   end
 
   describe "with normal args" do
-    it "adds a single s(:lasgn) for 1 norm arg" do
-      parsed("->(a) {}")[4][1].should == [:lasgn, :a]
+    it "adds a single s(:masgn) for 1 norm arg" do
+      parsed("->(a) {}")[4][1].should == [:masgn, [:args, [:arg, :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]]]
+      parsed("-> (a, b) {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b]]]
+      parsed("-> (a, b, c) {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b], [:arg, :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]]]
+      parsed("-> a {}")[4][1].should == [:masgn, [:args, [:arg, :a]]]
+      parsed("-> a, b {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :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]]]]
+      parsed("-> *a {}")[4][1].should == [:masgn, [:args, [:restarg, :a]]]
+      parsed("-> a, *b {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:restarg, :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]]]]]
+      parsed("-> a = 1 {}")[4][1].should == [:masgn, [:args, [:optarg, :a, [:int, 1]]]]
+      parsed("-> a = 1, b = 2 {}")[4][1].should == [:masgn, [:args, [:optarg, :a, [:int, 1]], [:optarg, :b, [:int, 2]]]]
     end
 
     it "parses block args" do
-      parsed("-> &a {}")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+      parsed("-> &a {}")[4][1].should == [:masgn, [:args, [:block_pass, [:lasgn, :a]]]]
     end
   end
 
@@ -64,7 +68,7 @@ describe "Lambda literals" do
 
   it "can parse do..end blocks inside lambda body" do
     # regression test; see GH issue 544
-    call_b   = [:call, nil, :b, [:arglist], [:iter, [:lasgn, :c]]]
+    call_b   = [:call, nil, :b, [:arglist], [:iter, [:masgn, [:args, [:arg, :c]]]]]
     lambda   = [:call, nil, :lambda, [:arglist], [:iter, nil, call_b]]
     expected = [:call, nil, :a, [:arglist, lambda]]
     parsed("a -> { b do |c| end }").should == expected
@@ -75,4 +79,141 @@ describe "Lambda literals" do
     expected = [:call, nil, :a, [:arglist, [:call, nil, :lambda, [:arglist], [:iter, nil, [:call, nil, :b, [:arglist]]]]], [:iter, nil]]
     parsed("a ->{b} do; end").should == expected
   end
+
+  context "kwargs as arguments" do
+    def s_kwarg
+      [:kwarg, :kw]
+    end
+
+    def s_kwoptarg
+      [:kwoptarg, :kwopt, [:sym, :default]]
+    end
+
+    def s_kwrestarg
+      [:kwrestarg, :kwrest]
+    end
+
+    def s_block
+      [:block_pass, [:lasgn, :blk]]
+    end
+
+    it "parses kwarg" do
+      parsed_args("->(kw:){}").should == [:args, s_kwarg]
+    end
+
+    it "parses kwoptarg" do
+      parsed_args("->(kwopt: :default){}").should == [:args, s_kwoptarg]
+    end
+
+    it "parses kwrestarg" do
+      parsed_args("->(**kwrest){}").should == [:args, s_kwrestarg]
+    end
+
+    it "parses kwarg + kwoptarg" do
+      parsed_args("->(kw:,kwopt: :default){}").should == [:args, s_kwarg, s_kwoptarg]
+    end
+
+    it "parses kwarg + kwrestarg" do
+      parsed_args("->(kw:,**kwrest){}").should == [:args, s_kwarg, s_kwrestarg]
+    end
+
+    it "parses kwarg + kwoptarg + kwrestarg" do
+      parsed_args("->(kw:,kwopt: :default,**kwrest){}").should == [:args, s_kwarg, s_kwoptarg, s_kwrestarg]
+    end
+
+    it "parses block + kwarg" do
+      parsed_args("->(kw:,&blk){}").should == [:args, s_kwarg, s_block]
+    end
+
+    it "parses block + kwoptarg" do
+      parsed_args("->(kwopt: :default,&blk){}").should == [:args, s_kwoptarg, s_block]
+    end
+
+    it "parses block + kwrestarg" do
+      parsed_args("->(**kwrest,&blk){}").should == [:args, s_kwrestarg, s_block]
+    end
+  end
+
+  context 'rest args' do
+    it "parses ->(*a,b)" do
+      parsed_args("->(*a, b){}").should == [:args, [:restarg, :a], [:arg, :b]]
+    end
+
+    it "parses ->(a,b=1,*c,d,&blk)" do
+      expected = [:args, [:arg, :a], [:optarg, :b, [:int, 1]], [:restarg, :c], [:arg, :d], [:block_pass, [:lasgn, :blk]]]
+      parsed_args("->(a,b=1,*c,d,&blk){}").should == expected
+    end
+
+    it "parses ->(a,b=1,c,&blk)" do
+      expected = [:args, [:arg, :a], [:optarg, :b, [:int, 1]], [:arg, :c], [:block_pass, [:lasgn, :blk]]]
+      parsed_args("->(a,b=1,c,&blk){}").should == expected
+    end
+
+    it "parses ->(a,*b,c,&blk){}" do
+      expected = [:args, [:arg, :a], [:restarg, :b], [:arg, :c], [:block_pass, [:lasgn, :blk]]]
+      parsed_args("->(a,*b,c,&blk){}").should == expected
+    end
+
+    it "parses ->(a=1,*b,c,&blk){}" do
+      expected = [:args, [:optarg, :a, [:int, 1]], [:restarg, :b], [:arg, :c], [:block_pass, [:lasgn, :blk]]]
+      parsed_args("->(a=1,*b,c,&blk){}").should == expected
+    end
+
+    it "parses ->(a=1,b,&blk)" do
+      expected = [:args, [:optarg, :a, [:int, 1]], [:arg, :b], [:block_pass, [:lasgn, :blk]]]
+      parsed_args("->(a=1,b,&blk){}").should == expected
+    end
+  end
+
+  context 'shadow args' do
+    it "parses lambda{|a;b|}" do
+      parsed_args("lambda{|a;b|}").should == [:args, [:arg, :a], [:shadowarg, :b]]
+    end
+
+    it "parses lambda{|;a|}" do
+      parsed_args("lambda{|;a|}").should == [:args, [:shadowarg, :a]]
+    end
+  end
+
+  context 'mlhs args' do
+    it "parses ->((a)){}" do
+      parsed_args("->((a)){}").should == [:args, [:mlhs, [:arg, :a]]]
+    end
+
+    it "parses ->((a,*b)){}" do
+      parsed_args("->((a,*b)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg, :b]]]
+    end
+
+    it "parses ->((a,*b,c)){}" do
+      parsed_args("->((a,*b,c)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg, :b], [:arg, :c]]]
+    end
+
+    it "parses ->((a,*)){}" do
+      parsed_args("->((a,*)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg]]]
+    end
+
+    it "parses ->((a,*,b)){}" do
+      parsed_args("->((a,*,b)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg], [:arg, :b]]]
+    end
+
+    it "parses ->((*a)){}" do
+      parsed_args("->((*a)){}").should == [:args, [:mlhs, [:restarg, :a]]]
+    end
+
+    it "parses ->((*a,b)){}" do
+      parsed_args("->((*a,b)){}").should == [:args, [:mlhs, [:restarg, :a], [:arg, :b]]]
+    end
+
+    it "parses ->((*)){}" do
+      parsed_args("->((*)){}").should == [:args, [:mlhs, [:restarg]]]
+    end
+
+    it "parses ->((*,a)){}" do
+      parsed_args("->((*,a)){}").should == [:args, [:mlhs, [:restarg], [:arg, :a]]]
+    end
+
+    it "parses ->(a,(b,(c,d))){}" do
+      parsed_args("->(a,(b,(c,d))){}").should == [:args, [:arg, :a], [:mlhs, [:arg, :b], [:mlhs, [:arg, :c], [:arg, :d]]]]
+    end
+  end
 end