[ruby-core:96585] [Ruby master Feature#16456] Ruby 2.7 argument delegation (...) should be its own kind of parameter in Method#parameters

[daniel@dan42.com]

Issue #16456 has been updated by Dan0042 (Daniel DeLorme).


In the future it will be possible to combine `...` with other arguments. So if we think about what `parameters` would return in cases like these...

```ruby
method(def foo(a, *args, ...); end).parameters
#1=> [[:req, :a], [:rest, :args], [:delegate]]
#2=> [[:req, :a], [:rest, :args], [:keyrest], [:block]]
#3=> [[:req, :a], [:rest, :args], [:rest], [:keyrest], [:block]]

method(def foo(a, **kw, ...); end).parameters
#1=> [[:req, :a], [:keyrest, :kw], [:delegate]]
#2=> [[:req, :a], [:keyrest, :kw], [:rest], [:block]]
#3=> [[:req, :a], [:keyrest, :kw], [:rest], [:keyrest], [:block]]
```

I see the point of wanting to know if the method signature includes `...` or not, but I don't think I like the idea of having a `:delegate` that can mean different things.

What about this?
`[[:rest, :"..."], [:keyrest, :"..."], [:block, :"..."]]`

----------------------------------------
Feature #16456: Ruby 2.7 argument delegation (...) should be its own kind of parameter in Method#parameters
https://bugs.ruby-lang.org/issues/16456#change-83552

* Author: aaronc81 (Aaron Christiansen)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
A method defined with `...` as its parameter list is equivalent to one defined with `*args, &blk`, according to `Method#parameters`.

```ruby
def foo(...); end
p method(:foo).parameters
# => [[:rest, :*], [:block, :&]]
```

Even in Ruby 2.7, `...` and `*args, &blk` are not *quite* equivalent as the latter may produce a warning where the former does not. In Ruby 3.0 and beyond, `...` and `*args, &blk` will have a substantial semantic difference. Due to this, I don't consider the current behaviour of `Method#parameters` particularly ideal when dealing with methods using this new syntax.

If the goal of `...` is to be a "delegate everything" operator, even when parameter passing is changed like in Ruby 3.0, I would propose that `Method#parameters` considers it a unique type of parameter. For example:

```ruby
def foo(...); end
p method(:foo).parameters
# => [[:delegate, :"..."]]
```



-- 
https://bugs.ruby-lang.org/