Make Kernel#lambda raise when given non-literal block

Previously, Kernel#lambda returned a non-lambda proc when given a
non-literal block and issued a warning under the `:deprecated` category.
With this change, Kernel#lambda will always return a lambda proc, if it
returns without raising.

Due to interactions with block passing optimizations, we previously had
two separate code paths for detecting whether Kernel#lambda got a
literal block. This change allows us to remove one path, the hack done
with rb_control_frame_t::block_code introduced in 85a337f for supporting
situations where Kernel#lambda returned a non-lambda proc.

[Feature #19777]

Co-authored-by: Takashi Kokubun <takashikkbn@gmail.com>

2 files changed, 46 insertions, 34 deletions

diff --git a/spec/ruby/core/kernel/lambda_spec.rb b/spec/ruby/core/kernel/lambda_spec.rb
index 2f7abc749c..565536ac0d 100644
--- a/spec/ruby/core/kernel/lambda_spec.rb
+++ b/spec/ruby/core/kernel/lambda_spec.rb
@@ -26,42 +26,44 @@ describe "Kernel.lambda" do
     l.lambda?.should be_true
   end
 
-  it "creates a lambda-style Proc if given a literal block via Kernel.public_send" do
-    suppress_warning do
-      l = Kernel.public_send(:lambda) { 42 }
-      l.lambda?.should be_true
+  ruby_version_is ""..."3.3" do
+    it "creates a lambda-style Proc if given a literal block via Kernel.public_send" do
+      suppress_warning do
+        l = Kernel.public_send(:lambda) { 42 }
+        l.lambda?.should be_true
+      end
     end
-  end
 
-  it "returns the passed Proc if given an existing Proc" do
-    some_proc = proc {}
-    l = suppress_warning {lambda(&some_proc)}
-    l.should equal(some_proc)
-    l.lambda?.should be_false
-  end
+    it "returns the passed Proc if given an existing Proc" do
+      some_proc = proc {}
+      l = suppress_warning {lambda(&some_proc)}
+      l.should equal(some_proc)
+      l.lambda?.should be_false
+    end
 
-  it "creates a lambda-style Proc when called with zsuper" do
-    suppress_warning do
-      l = KernelSpecs::LambdaSpecs::ForwardBlockWithZSuper.new.lambda { 42 }
-      l.lambda?.should be_true
-      l.call.should == 42
+    it "creates a lambda-style Proc when called with zsuper" do
+      suppress_warning do
+        l = KernelSpecs::LambdaSpecs::ForwardBlockWithZSuper.new.lambda { 42 }
+        l.lambda?.should be_true
+        l.call.should == 42
 
-      lambda { l.call(:extra) }.should raise_error(ArgumentError)
+        lambda { l.call(:extra) }.should raise_error(ArgumentError)
+      end
     end
-  end
 
-  it "returns the passed Proc if given an existing Proc through super" do
-    some_proc = proc { }
-    l = KernelSpecs::LambdaSpecs::SuperAmpersand.new.lambda(&some_proc)
-    l.should equal(some_proc)
-    l.lambda?.should be_false
-  end
+    it "returns the passed Proc if given an existing Proc through super" do
+      some_proc = proc { }
+      l = KernelSpecs::LambdaSpecs::SuperAmpersand.new.lambda(&some_proc)
+      l.should equal(some_proc)
+      l.lambda?.should be_false
+    end
 
-  it "does not create lambda-style Procs when captured with #method" do
-    kernel_lambda = method(:lambda)
-    l = suppress_warning {kernel_lambda.call { 42 }}
-    l.lambda?.should be_false
-    l.call(:extra).should == 42
+    it "does not create lambda-style Procs when captured with #method" do
+      kernel_lambda = method(:lambda)
+      l = suppress_warning {kernel_lambda.call { 42 }}
+      l.lambda?.should be_false
+      l.call(:extra).should == 42
+    end
   end
 
   it "checks the arity of the call when no args are specified" do
@@ -137,8 +139,16 @@ describe "Kernel.lambda" do
   end
 
   context "when called without a literal block" do
-    it "warns when proc isn't a lambda" do
-      -> { lambda(&proc{}) }.should complain("#{__FILE__}:#{__LINE__}: warning: lambda without a literal block is deprecated; use the proc without lambda instead\n")
+    ruby_version_is ""..."3.3" do
+      it "warns when proc isn't a lambda" do
+        -> { lambda(&proc{}) }.should complain("#{__FILE__}:#{__LINE__}: warning: lambda without a literal block is deprecated; use the proc without lambda instead\n")
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "raises when proc isn't a lambda" do
+        -> { lambda(&proc{}) }.should raise_error(ArgumentError, /the lambda method requires a literal block/)
+      end
     end
 
     it "doesn't warn when proc is lambda" do
diff --git a/spec/ruby/core/proc/lambda_spec.rb b/spec/ruby/core/proc/lambda_spec.rb
index b2d3f50350..5c3c38fc2a 100644
--- a/spec/ruby/core/proc/lambda_spec.rb
+++ b/spec/ruby/core/proc/lambda_spec.rb
@@ -14,9 +14,11 @@ describe "Proc#lambda?" do
     Proc.new {}.lambda?.should be_false
   end
 
-  it "is preserved when passing a Proc with & to the lambda keyword" do
-    suppress_warning {lambda(&->{})}.lambda?.should be_true
-    suppress_warning {lambda(&proc{})}.lambda?.should be_false
+  ruby_version_is ""..."3.3" do
+    it "is preserved when passing a Proc with & to the lambda keyword" do
+      suppress_warning {lambda(&->{})}.lambda?.should be_true
+      suppress_warning {lambda(&proc{})}.lambda?.should be_false
+    end
   end
 
   it "is preserved when passing a Proc with & to the proc keyword" do