1 files changed, 85 insertions, 38 deletions
diff --git a/spec/ruby/language/lambda_spec.rb b/spec/ruby/language/lambda_spec.rb
index 3934a2bd91..a3f01ec04b 100644
--- a/spec/ruby/language/lambda_spec.rb
+++ b/spec/ruby/language/lambda_spec.rb
@@ -7,7 +7,7 @@ describe "A lambda literal -> () { }" do
   it "returns a Proc object when used in a BasicObject method" do
     klass = Class.new(BasicObject) do
       def create_lambda
-        -> () { }
+        -> { }
       end
     end
 
@@ -15,11 +15,19 @@ describe "A lambda literal -> () { }" do
   end
 
   it "does not execute the block" do
-    ->() { fail }.should be_an_instance_of(Proc)
+    -> { fail }.should be_an_instance_of(Proc)
   end
 
   it "returns a lambda" do
-    -> () { }.lambda?.should be_true
+    -> { }.lambda?.should be_true
+  end
+
+  it "may include a rescue clause" do
+    eval('-> do raise ArgumentError; rescue ArgumentError; 7; end').should be_an_instance_of(Proc)
+  end
+
+  it "may include a ensure clause" do
+    eval('-> do 1; ensure; 2; end').should be_an_instance_of(Proc)
   end
 
   it "has its own scope for local variables" do
@@ -101,7 +109,7 @@ describe "A lambda literal -> () { }" do
         @a = -> (a:) { a }
       ruby
 
-      lambda { @a.() }.should raise_error(ArgumentError)
+      -> { @a.() }.should raise_error(ArgumentError)
       @a.(a: 1).should == 1
     end
 
@@ -119,7 +127,7 @@ describe "A lambda literal -> () { }" do
 
       @a.().should be_nil
       @a.(a: 1, b: 2).should be_nil
-      lambda { @a.(1) }.should raise_error(ArgumentError)
+      -> { @a.(1) }.should raise_error(ArgumentError)
     end
 
     evaluate <<-ruby do
@@ -143,8 +151,8 @@ describe "A lambda literal -> () { }" do
       ruby
 
       @a.(1, 2).should == [1, 2]
-      lambda { @a.() }.should raise_error(ArgumentError)
-      lambda { @a.(1) }.should raise_error(ArgumentError)
+      -> { @a.() }.should raise_error(ArgumentError)
+      -> { @a.(1) }.should raise_error(ArgumentError)
     end
 
     evaluate <<-ruby do
@@ -169,16 +177,34 @@ describe "A lambda literal -> () { }" do
       result.should == [1, 2, 3, [4, 5], 6, [7, 8], 9, 10, 11, 12]
     end
 
-    evaluate <<-ruby do
-        @a = -> (*, **k) { k }
-      ruby
+    ruby_version_is ''...'3.0' do
+      evaluate <<-ruby do
+          @a = -> (*, **k) { k }
+        ruby
 
-      @a.().should == {}
-      @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+        @a.().should == {}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+
+        suppress_keyword_warning do
+          h = mock("keyword splat")
+          h.should_receive(:to_hash).and_return({a: 1})
+          @a.(h).should == {a: 1}
+        end
+      end
+    end
+
+    ruby_version_is '3.0' do
+      evaluate <<-ruby do
+          @a = -> (*, **k) { k }
+        ruby
+
+        @a.().should == {}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
 
-      h = mock("keyword splat")
-      h.should_receive(:to_hash).and_return({a: 1})
-      @a.(h).should == {a: 1}
+        h = mock("keyword splat")
+        h.should_not_receive(:to_hash)
+        @a.(h).should == {}
+      end
     end
 
     evaluate <<-ruby do
@@ -255,25 +281,23 @@ describe "A lambda literal -> () { }" do
     end
 
     describe "with circular optional argument reference" do
-      it "shadows an existing local with the same name as the argument" do
+      it "raises a SyntaxError if using an existing local with the same name as the argument" do
         a = 1
         -> {
           @proc = eval "-> (a=a) { a }"
-        }.should complain(/circular argument reference/)
-        @proc.call.should == nil
+        }.should raise_error(SyntaxError)
       end
 
-      it "shadows an existing method with the same name as the argument" do
+      it "raises a SyntaxError if there is an existing method with the same name as the argument" do
         def a; 1; end
         -> {
           @proc = eval "-> (a=a) { a }"
-        }.should complain(/circular argument reference/)
-        @proc.call.should == nil
+        }.should raise_error(SyntaxError)
       end
 
       it "calls an existing method with the same name as the argument if explicitly using ()" do
         def a; 1; end
-        -> (a=a()) { a }.call.should == 1
+        -> a=a() { a }.call.should == 1
       end
     end
   end
@@ -302,7 +326,13 @@ describe "A lambda expression 'lambda { ... }'" do
   end
 
   it "requires a block" do
-    lambda { lambda }.should raise_error(ArgumentError)
+    suppress_warning do
+      lambda { lambda }.should raise_error(ArgumentError)
+    end
+  end
+
+  it "may include a rescue clause" do
+    eval('lambda do raise ArgumentError; rescue ArgumentError; 7; end').should be_an_instance_of(Proc)
   end
 
   context "with an implicit block" do
@@ -310,14 +340,13 @@ describe "A lambda expression 'lambda { ... }'" do
       def meth; lambda; end
     end
 
-    it "can be created" do
+    it "raises ArgumentError" do
       implicit_lambda = nil
-      -> {
-        implicit_lambda = meth { 1 }
-      }.should complain(/tried to create Proc object without a block/)
-
-      implicit_lambda.lambda?.should be_true
-      implicit_lambda.call.should == 1
+      suppress_warning do
+        -> {
+          meth { 1 }
+        }.should raise_error(ArgumentError, /tried to create Proc object without a block/)
+      end
     end
   end
 
@@ -485,16 +514,34 @@ describe "A lambda expression 'lambda { ... }'" do
       result.should == [1, 2, 3, [4, 5], 6, [7, 8], 9, 10, 11, 12]
     end
 
-    evaluate <<-ruby do
-        @a = lambda { |*, **k| k }
-      ruby
+    ruby_version_is ''...'3.0' do
+      evaluate <<-ruby do
+          @a = lambda { |*, **k| k }
+        ruby
 
-      @a.().should == {}
-      @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+        @a.().should == {}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+
+        suppress_keyword_warning do
+          h = mock("keyword splat")
+          h.should_receive(:to_hash).and_return({a: 1})
+          @a.(h).should == {a: 1}
+        end
+      end
+    end
+
+    ruby_version_is '3.0' do
+      evaluate <<-ruby do
+          @a = lambda { |*, **k| k }
+        ruby
 
-      h = mock("keyword splat")
-      h.should_receive(:to_hash).and_return({a: 1})
-      @a.(h).should == {a: 1}
+        @a.().should == {}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+
+        h = mock("keyword splat")
+        h.should_not_receive(:to_hash)
+        @a.(h).should == {}
+      end
     end
 
     evaluate <<-ruby do