Start handling &nil in method parameters

Similar to `:nokey` for `**nil` declaring methods/procs, a method/proc with a `&nil` declaration will return a `:noblock` entry in the parameters array.

Author: paracycle

iseq.c

@@ -3787,7 +3787,13 @@ rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc)
         }
         rb_ary_push(args, a);
     }
-    if (body->param.flags.has_block) {
+    if (body->param.flags.accepts_no_block) {
+        ID noblock;
+        CONST_ID(noblock, "noblock");
+        PARAM_TYPE(noblock);
+        rb_ary_push(args, a);
+    }
+    else if (body->param.flags.has_block) {
         CONST_ID(block, "block");
         rb_ary_push(args, PARAM(body->param.block_start, block));
     }

proc.c

@@ -3431,6 +3431,7 @@ method_inspect(VALUE method)
         const VALUE keyrest = ID2SYM(rb_intern("keyrest"));
         const VALUE block = ID2SYM(rb_intern("block"));
         const VALUE nokey = ID2SYM(rb_intern("nokey"));
+        const VALUE noblock = ID2SYM(rb_intern("noblock"));
         int forwarding = 0;
 
         rb_str_buf_cat2(str, "(");
@@ -3465,6 +3466,9 @@ method_inspect(VALUE method)
                 else if (kind == nokey) {
                     name = rb_str_new2("nil");
                 }
+                else if (kind == noblock) {
+                    name = rb_str_new2("nil");
+                }
                 else {
                     name = Qnil;
                 }
@@ -3517,6 +3521,9 @@ method_inspect(VALUE method)
             else if (kind == nokey) {
                 rb_str_buf_cat2(str, "**nil");
             }
+            else if (kind == noblock) {
+                rb_str_buf_cat2(str, "&nil");
+            }
 
             if (i < RARRAY_LEN(params) - 1) {
                 rb_str_buf_cat2(str, ", ");

spec/ruby/core/method/parameters_spec.rb

@@ -22,6 +22,12 @@ def one_splat_one_block(*args, &block)
       local_is_not_parameter = {}
     end
 
+    ruby_version_is "4.1" do
+      eval <<-RUBY
+        def one_noblock(&nil); end
+      RUBY
+    end
+
     def forward_parameters(...) end
 
     def underscore_parameters(_, _, _ = 1, *_, _:, _: 2, **_, &_); end
@@ -187,6 +193,13 @@ def underscore_parameters(_, _, _ = 1, *_, _:, _: 2, **_, &_); end
     m.parameters.should == [[:nokey]]
   end
 
+  ruby_version_is "4.1" do
+    it "returns [[:noblock]] for a method with a single &nil parameter" do
+      m = MethodSpecs::Methods.instance_method(:one_noblock)
+      m.parameters.should == [[:noblock]]
+    end
+  end
+
   it "works with ->(){} as the value of an optional argument" do
     m = MethodSpecs::Methods.instance_method(:one_opt_with_stabby)
     m.parameters.should == [[:opt,:a]]

spec/ruby/core/proc/parameters_spec.rb

@@ -172,4 +172,12 @@
       eval("lambda { it }").parameters.should == [[:req]]
     end
   end
+
+  ruby_version_is "4.1" do
+    it "returns :noblock for &nil parameter" do
+      eval <<~RUBY
+        proc { |&nil| }.parameters.should == [[:noblock]]
+      RUBY
+    end
+  end
 end

spec/ruby/language/block_spec.rb

@@ -1111,7 +1111,7 @@ def o.it
     end
   end
 
-  ruby_version_is "3.4" do
+  ruby_version_is "4.1" do
     it "works alongside disallowed block argument" do
       no_block = eval <<-EOF
         proc {|arg1, &nil| arg1}

spec/ruby/language/method_spec.rb

@@ -1128,7 +1128,7 @@ def m(a, b = nil, c = nil, d, e: nil, **f)
       result.should == [1, nil, nil, {foo: :bar}, nil, {}]
     end
 
-    ruby_version_is "3.4" do
+    ruby_version_is "4.1" do
       evaluate <<-ruby do
         def m(a, &nil); a end;
         ruby

test/ruby/test_iseq.rb

@@ -682,6 +682,17 @@ def foo(**nil); end
     assert_equal([[:nokey]], iseq.eval.singleton_method(:foo).parameters)
   end
 
+  def test_to_binary_dumps_noblock
+    iseq = assert_iseq_to_binary(<<-RUBY)
+      o = Object.new
+      class << o
+        def foo(&nil); end
+      end
+      o
+    RUBY
+    assert_equal([[:noblock]], iseq.eval.singleton_method(:foo).parameters)
+  end
+
   def test_to_binary_line_info
     assert_iseq_to_binary("#{<<~"begin;"}\n#{<<~'end;'}", '[Bug #14660]').eval
     begin;

test/ruby/test_method.rb

@@ -32,6 +32,7 @@ def mk6(a, b = nil, c, **o) nil && o end
   def mk7(a, b = nil, *c, d, **o) nil && o end
   def mk8(a, b = nil, *c, d, e:, f: nil, **o) nil && o end
   def mnk(**nil) end
+  def mnb(&nil) end
   def mf(...) end
 
   class Base
@@ -603,6 +604,7 @@ def obj.respond_to_missing?(id, *)
   define_method(:pmk7) {|a, b = nil, *c, d, **o|}
   define_method(:pmk8) {|a, b = nil, *c, d, e:, f: nil, **o|}
   define_method(:pmnk) {|**nil|}
+  define_method(:pmnb) {|&nil|}
 
   def test_bound_parameters
     assert_equal([], method(:m0).parameters)
@@ -626,6 +628,7 @@ def test_bound_parameters
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyrest, :o]], method(:mk7).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyreq, :e], [:key, :f], [:keyrest, :o]], method(:mk8).parameters)
     assert_equal([[:nokey]], method(:mnk).parameters)
+    assert_equal([[:noblock]], method(:mnb).parameters)
     # pending
     assert_equal([[:rest, :*], [:keyrest, :**], [:block, :&]], method(:mf).parameters)
   end
@@ -652,6 +655,7 @@ def test_unbound_parameters
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyrest, :o]], self.class.instance_method(:mk7).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyreq, :e], [:key, :f], [:keyrest, :o]], self.class.instance_method(:mk8).parameters)
     assert_equal([[:nokey]], self.class.instance_method(:mnk).parameters)
+    assert_equal([[:noblock]], self.class.instance_method(:mnb).parameters)
     # pending
     assert_equal([[:rest, :*], [:keyrest, :**], [:block, :&]], self.class.instance_method(:mf).parameters)
   end
@@ -677,6 +681,7 @@ def test_bmethod_bound_parameters
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyrest, :o]], method(:pmk7).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyreq, :e], [:key, :f], [:keyrest, :o]], method(:pmk8).parameters)
     assert_equal([[:nokey]], method(:pmnk).parameters)
+    assert_equal([[:noblock]], method(:pmnb).parameters)
   end
 
   def test_bmethod_unbound_parameters
@@ -701,6 +706,7 @@ def test_bmethod_unbound_parameters
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyrest, :o]], self.class.instance_method(:pmk7).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyreq, :e], [:key, :f], [:keyrest, :o]], self.class.instance_method(:pmk8).parameters)
     assert_equal([[:nokey]], self.class.instance_method(:pmnk).parameters)
+    assert_equal([[:noblock]], self.class.instance_method(:pmnb).parameters)
   end
 
   def test_hidden_parameters