Add support for anonymous rest and keyword rest argument forwarding

This allows for the following syntax:

```ruby
def foo(*)
  bar(*)
end
def baz(**)
  quux(**)
end
```

This is a natural addition after the introduction of anonymous
block forwarding.  Anonymous rest and keyword rest arguments were
already supported in method parameters, this just allows them to
be used as arguments to other methods.  The same advantages of
anonymous block forwarding apply to rest and keyword rest argument
forwarding.

This has some minor changes to #parameters output.  Now, instead
of `[:rest], [:keyrest]`, you get `[:rest, :*], [:keyrest, :**]`.
These were already used for `...` forwarding, so I think it makes
it more consistent to include them in other cases.  If we want to
use `[:rest], [:keyrest]` in both cases, that is also possible.

I don't think the previous behavior of `[:rest], [:keyrest]` in
the non-... case and `[:rest, :*], [:keyrest, :**]` in the ...
case makes sense, but if we did want that behavior, we'll have to
make more substantial changes, such as using a different ID in the
... forwarding case.

Implements [Feature #18351]

4 files changed, 46 insertions, 10 deletions

diff --git a/test/ruby/test_iseq.rb b/test/ruby/test_iseq.rb
index f01d36cc5a..1ee41e6e81 100644
--- a/test/ruby/test_iseq.rb
+++ b/test/ruby/test_iseq.rb
@@ -162,7 +162,7 @@ class TestISeq < Test::Unit::TestCase
     end
     obj = Object.new
     def obj.foo(*) nil.instance_eval{ ->{super} } end
-    assert_raise_with_message(Ractor::IsolationError, /hidden variable/) do
+    assert_raise_with_message(Ractor::IsolationError, /refer unshareable object \[\] from variable `\*'/) do
       Ractor.make_shareable(obj.foo)
     end
   end
@@ -392,10 +392,18 @@ class TestISeq < Test::Unit::TestCase
 
   def anon_star(*); end
 
-  def test_anon_param_in_disasm
+  def test_anon_rest_param_in_disasm
     iseq = RubyVM::InstructionSequence.of(method(:anon_star))
     param_names = iseq.to_a[iseq.to_a.index(:method) + 1]
-    assert_equal [2], param_names
+    assert_equal [:*], param_names
+  end
+
+  def anon_keyrest(**); end
+
+  def test_anon_keyrest_param_in_disasm
+    iseq = RubyVM::InstructionSequence.of(method(:anon_keyrest))
+    param_names = iseq.to_a[iseq.to_a.index(:method) + 1]
+    assert_equal [:**], param_names
   end
 
   def anon_block(&); end
diff --git a/test/ruby/test_method.rb b/test/ruby/test_method.rb
index da68787933..d6de330dff 100644
--- a/test/ruby/test_method.rb
+++ b/test/ruby/test_method.rb
@@ -566,9 +566,9 @@ class TestMethod < Test::Unit::TestCase
     assert_equal([[:req, :a], [:rest, :b], [:req, :c]], method(:mo5).parameters)
     assert_equal([[:req, :a], [:rest, :b], [:req, :c], [:block, :d]], method(:mo6).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:block, :e]], method(:mo7).parameters)
-    assert_equal([[:req, :a], [:opt, :b], [:rest], [:req, :d], [:block, :e]], method(:mo8).parameters)
+    assert_equal([[:req, :a], [:opt, :b], [:rest, :*], [:req, :d], [:block, :e]], method(:mo8).parameters)
     assert_equal([[:req], [:block, :b]], method(:ma1).parameters)
-    assert_equal([[:keyrest]], method(:mk1).parameters)
+    assert_equal([[:keyrest, :**]], method(:mk1).parameters)
     assert_equal([[:keyrest, :o]], method(:mk2).parameters)
     assert_equal([[:req, :a], [:keyrest, :o]], method(:mk3).parameters)
     assert_equal([[:opt, :a], [:keyrest, :o]], method(:mk4).parameters)
@@ -592,9 +592,9 @@ class TestMethod < Test::Unit::TestCase
     assert_equal([[:req, :a], [:rest, :b], [:req, :c]], self.class.instance_method(:mo5).parameters)
     assert_equal([[:req, :a], [:rest, :b], [:req, :c], [:block, :d]], self.class.instance_method(:mo6).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:block, :e]], self.class.instance_method(:mo7).parameters)
-    assert_equal([[:req, :a], [:opt, :b], [:rest], [:req, :d], [:block, :e]], self.class.instance_method(:mo8).parameters)
+    assert_equal([[:req, :a], [:opt, :b], [:rest, :*], [:req, :d], [:block, :e]], self.class.instance_method(:mo8).parameters)
     assert_equal([[:req], [:block, :b]], self.class.instance_method(:ma1).parameters)
-    assert_equal([[:keyrest]], self.class.instance_method(:mk1).parameters)
+    assert_equal([[:keyrest, :**]], self.class.instance_method(:mk1).parameters)
     assert_equal([[:keyrest, :o]], self.class.instance_method(:mk2).parameters)
     assert_equal([[:req, :a], [:keyrest, :o]], self.class.instance_method(:mk3).parameters)
     assert_equal([[:opt, :a], [:keyrest, :o]], self.class.instance_method(:mk4).parameters)
@@ -619,7 +619,7 @@ class TestMethod < Test::Unit::TestCase
     assert_equal([[:req, :a], [:rest, :b], [:req, :c], [:block, :d]], method(:pmo6).parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:block, :e]], method(:pmo7).parameters)
     assert_equal([[:req], [:block, :b]], method(:pma1).parameters)
-    assert_equal([[:keyrest]], method(:pmk1).parameters)
+    assert_equal([[:keyrest, :**]], method(:pmk1).parameters)
     assert_equal([[:keyrest, :o]], method(:pmk2).parameters)
     assert_equal([[:req, :a], [:keyrest, :o]], method(:pmk3).parameters)
     assert_equal([[:opt, :a], [:keyrest, :o]], method(:pmk4).parameters)
@@ -643,7 +643,7 @@ class TestMethod < Test::Unit::TestCase
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:block, :e]], self.class.instance_method(:pmo7).parameters)
     assert_equal([[:req], [:block, :b]], self.class.instance_method(:pma1).parameters)
     assert_equal([[:req], [:block, :b]], self.class.instance_method(:pma1).parameters)
-    assert_equal([[:keyrest]], self.class.instance_method(:pmk1).parameters)
+    assert_equal([[:keyrest, :**]], self.class.instance_method(:pmk1).parameters)
     assert_equal([[:keyrest, :o]], self.class.instance_method(:pmk2).parameters)
     assert_equal([[:req, :a], [:keyrest, :o]], self.class.instance_method(:pmk3).parameters)
     assert_equal([[:opt, :a], [:keyrest, :o]], self.class.instance_method(:pmk4).parameters)
diff --git a/test/ruby/test_proc.rb b/test/ruby/test_proc.rb
index 51872e49be..05b2493b24 100644
--- a/test/ruby/test_proc.rb
+++ b/test/ruby/test_proc.rb
@@ -1261,7 +1261,7 @@ class TestProc < Test::Unit::TestCase
     assert_equal([[:req, :a], [:rest, :b], [:req, :c], [:block, :d]], method(:pmo6).to_proc.parameters)
     assert_equal([[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:block, :e]], method(:pmo7).to_proc.parameters)
     assert_equal([[:req], [:block, :b]], method(:pma1).to_proc.parameters)
-    assert_equal([[:keyrest]], method(:pmk1).to_proc.parameters)
+    assert_equal([[:keyrest, :**]], method(:pmk1).to_proc.parameters)
     assert_equal([[:keyrest, :o]], method(:pmk2).to_proc.parameters)
     assert_equal([[:req, :a], [:keyrest, :o]], method(:pmk3).to_proc.parameters)
     assert_equal([[:opt, :a], [:keyrest, :o]], method(:pmk4).to_proc.parameters)
diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index b71f492f9c..622527dafe 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -78,6 +78,34 @@ class TestSyntax < Test::Unit::TestCase
     end;
   end
 
+  def test_anonymous_rest_forwarding
+    assert_syntax_error("def b; c(*); end", /no anonymous rest parameter/)
+    assert_syntax_error("def b; c(1, *); end", /no anonymous rest parameter/)
+    assert_separately([], "#{<<-"begin;"}\n#{<<-'end;'}")
+    begin;
+        def b(*); c(*) end
+        def c(*a); a end
+        def d(*); b(*, *) end
+        assert_equal([1, 2], b(1, 2))
+        assert_equal([1, 2, 1, 2], d(1, 2))
+    end;
+  end
+
+  def test_anonymous_keyword_rest_forwarding
+    assert_syntax_error("def b; c(**); end", /no anonymous keyword rest parameter/)
+    assert_syntax_error("def b; c(k: 1, **); end", /no anonymous keyword rest parameter/)
+    assert_separately([], "#{<<-"begin;"}\n#{<<-'end;'}")
+    begin;
+        def b(**); c(**) end
+        def c(**kw); kw end
+        def d(**); b(k: 1, **) end
+        def e(**); b(**, k: 1) end
+        assert_equal({a: 1, k: 3}, b(a: 1, k: 3))
+        assert_equal({a: 1, k: 3}, d(a: 1, k: 3))
+        assert_equal({a: 1, k: 1}, e(a: 1, k: 3))
+    end;
+  end
+
   def test_newline_in_block_parameters
     bug = '[ruby-dev:45292]'
     ["", "a", "a, b"].product(["", ";x", [";", "x"]]) do |params|