1 files changed, 120 insertions, 23 deletions
diff --git a/spec/ruby/language/delegation_spec.rb b/spec/ruby/language/delegation_spec.rb
index 3f24a79d5c..3d917993f5 100644
--- a/spec/ruby/language/delegation_spec.rb
+++ b/spec/ruby/language/delegation_spec.rb
@@ -1,6 +1,7 @@
 require_relative '../spec_helper'
 require_relative 'fixtures/delegation'
 
+# Forwarding anonymous parameters
 describe "delegation with def(...)" do
   it "delegates rest and kwargs" do
     a = Class.new(DelegationSpecs::Target)
@@ -10,10 +11,10 @@ describe "delegation with def(...)" do
       end
     RUBY
 
-    a.new.delegate(1, b: 2).should == [[1], {b: 2}]
+    a.new.delegate(1, b: 2).should == [[1], {b: 2}, nil]
   end
 
-  it "delegates block" do
+  it "delegates a block literal" do
     a = Class.new(DelegationSpecs::Target)
     a.class_eval(<<-RUBY)
       def delegate_block(...)
@@ -24,6 +25,28 @@ describe "delegation with def(...)" do
     a.new.delegate_block(1, b: 2) { |x| x }.should == [{b: 2}, [1]]
   end
 
+  it "delegates a block argument" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+      def delegate(...)
+        target(...)
+      end
+    RUBY
+
+    block = proc {}
+    a.new.delegate(1, b: 2, &block).should == [[1], {b: 2}, block]
+  end
+
+  it "delegates with additional arguments" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+      def delegate(...)
+        target(:first, :second, ...)
+      end
+    RUBY
+    a.new.delegate(1, b: 2).should == [[:first, :second, 1], {b: 2}, nil]
+  end
+
   it "parses as open endless Range when brackets are omitted" do
     a = Class.new(DelegationSpecs::Target)
     suppress_warning do
@@ -31,35 +54,109 @@ describe "delegation with def(...)" do
         def delegate(...)
           target ...
         end
-       RUBY
-     end
+      RUBY
+    end
 
-     a.new.delegate(1, b: 2).should == Range.new([[], {}], nil, true)
+    a.new.delegate(1, b: 2).should == Range.new([[], {}, nil], nil, true)
   end
 end
 
-ruby_version_is "2.7.3" do
-  describe "delegation with def(x, ...)" do
-    it "delegates rest and kwargs" do
-      a = Class.new(DelegationSpecs::Target)
-      a.class_eval(<<-RUBY)
-        def delegate(x, ...)
-          target(...)
-        end
-      RUBY
+describe "delegation with def(x, ...)" do
+  it "delegates rest and kwargs" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+      def delegate(x, ...)
+        target(...)
+      end
+    RUBY
+
+    a.new.delegate(0, 1, b: 2).should == [[1], {b: 2}, nil]
+  end
+
+  it "delegates a block literal" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+      def delegate_block(x, ...)
+        target_block(...)
+      end
+    RUBY
+
+    a.new.delegate_block(0, 1, b: 2) { |x| x }.should == [{b: 2}, [1]]
+  end
+
+  it "delegates a block argument" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+      def delegate(...)
+        target(...)
+      end
+    RUBY
 
-      a.new.delegate(0, 1, b: 2).should == [[1], {b: 2}]
+    block = proc {}
+    a.new.delegate(1, b: 2, &block).should == [[1], {b: 2}, block]
+  end
+end
+
+describe "delegation with def(*)" do
+  it "delegates rest" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+    def delegate(*)
+      target(*)
     end
+    RUBY
 
-    it "delegates block" do
-      a = Class.new(DelegationSpecs::Target)
-      a.class_eval(<<-RUBY)
-        def delegate_block(x, ...)
-          target_block(...)
-        end
-      RUBY
+    a.new.delegate(0, 1).should == [[0, 1], {}, nil]
+  end
+
+  context "within a block that accepts anonymous rest within a method that accepts anonymous rest" do
+    it "does not allow delegating rest" do
+      -> {
+        eval "def m(*); proc { |*| n(*) } end"
+      }.should.raise(SyntaxError, /anonymous rest parameter is also used within block/)
+    end
+  end
+end
+
+describe "delegation with def(**)" do
+  it "delegates kwargs" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+    def delegate(**)
+      target(**)
+    end
+    RUBY
+
+    a.new.delegate(a: 1) { |x| x }.should == [[], {a: 1}, nil]
+  end
+
+  context "within a block that accepts anonymous kwargs within a method that accepts anonymous kwargs" do
+    it "does not allow delegating kwargs" do
+      -> {
+        eval "def m(**); proc { |**| n(**) } end"
+      }.should.raise(SyntaxError, /anonymous keyword rest parameter is also used within block/)
+    end
+  end
+end
+
+describe "delegation with def(&)" do
+  it "delegates an anonymous block parameter" do
+    a = Class.new(DelegationSpecs::Target)
+    a.class_eval(<<-RUBY)
+    def delegate(&)
+      target(&)
+    end
+    RUBY
+
+    block = proc {}
+    a.new.delegate(&block).should == [[], {}, block]
+  end
 
-      a.new.delegate_block(0, 1, b: 2) { |x| x }.should == [{b: 2}, [1]]
+  context "within a block that accepts anonymous block within a method that accepts anonymous block" do
+    it "does not allow delegating a block" do
+      -> {
+        eval "def m(&); proc { |&| n(&) } end"
+      }.should.raise(SyntaxError, /anonymous block parameter is also used within block/)
     end
   end
 end