Issue #16157 has been updated by jeremyevans0 (Jeremy Evans).


Dan0042 (Daniel DeLorme) wrote:
> Of course this is all *extremely* unconventional usage and doesn't really deserve a fix. But I thought it was weird/interesting.

Very interesting actually.  However, while you think this method is written in C, it's actually not, at least not the version you are calling:

```
$ ruby --disable-gems -e 'warn({x: 1})'
$ ruby -e 'warn({x: 1})'
-e:1: warning: The last argument is used as the keyword parameter
/home/jeremy/tmp/ruby/lib/rubygems/core_ext/kernel_warn.rb:15: warning: for method defined here
Traceback (most recent call last):
        1: from -e:1:in `<main>'
/home/jeremy/tmp/ruby/lib/rubygems/core_ext/kernel_warn.rb:15:in `block in <module:Kernel>': unknown keyword: :x (ArgumentError)
```

Rubygems overwrites `Kernel#warn`! This is part of the implementation:

```ruby
    module_function define_method(:warn) {|*messages, uplevel: nil|
      unless uplevel
        return original_warn.call(*messages)
      end
      # filter callers
      original_warn.call(*messages, uplevel: uplevel)
    end
```

So the C version is loose with the keywords, in the sense that invalid keywords will be ignored. The Rubygems version is strict with the keywords, in that passing keywords other than :uplevel will result in an error.  The Rubygems version will then call the original version without keywords arguments.  Combined, this causes the very weird behavior you see.  Let's go through each example:

> ```
> >> warn({x:1})
> ArgumentError (unknown keyword: :x)
> ```

Happens when the Rubygems version is called, because :x is not a valid keyword.

> ```
> >> warn({x:1}, uplevel:0)
> (irb):4: warning: {:x=>1}
> ```

Rubygems version recognizes uplevel keyword and passes it to C version


> ```
> >> warn({x:1}, **{})
> ```

Passes no keywords to the Rubygems version, so Rubygems version passes `{x: 1}` as the sole argument to the C version, which is treated as keyword arguments and ignored.

> ```
> >> warn({x:1}, {})
> ```

This emits a keyword argument separation warning in the master branch, as the hash is treated as keywords to the Rubygems version.  The Rubygems version then passes `{x: 1}` as the sole argument to the C version, which is treated as keyword arguments and ignored.


> ```
> >> warn({x:1}, {}, {})
> {:x=>1}
> ```

Last hash passed to Rubygems version as keyword arguments with keyword argument separation warning emitted.  First two arguments passed to C version. Second argument treated as keyword argument by C version, and first argument treated as warning message.

> ```
> >> warn({x:1}, {}, {}, {})
> {:x=>1}
> {}
> ```

Same as previous, except there is an extra argument emitted as a warning.

> ```
> >> warn({x:1}, {y:2}, {})
> ArgumentError (unknown keyword: :y)
> ```

Last hash passed to Rubygems version as keyword arguments with keyword argument separation warning emitted.  First two arguments passed to C version. Second argument treated as keyword argument by C version, and ArgumentError raised as C version doesn't support the :y keyword.

> ```
> >> warn({x:1}, {y:2}, {}, {})
> {:x=>1}
> {:y=>2}
> ```

Same as the `warn({x:1}, {}, {}, {})` case other than the elements of the 2nd argument.

I sent a pull request to Rubygems to fix this behavior (https://github.com/rubygems/rubygems/pull/2911).  Personally, I think it would be better for them to drop the override of `Kernel#warn`.

----------------------------------------
Misc #16157: What is the correct and *portable* way to do generic delegation?
https://bugs.ruby-lang.org/issues/16157#change-81526

* Author: Dan0042 (Daniel DeLorme)
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
With the keyword argument changes in 2.7 we must now specify keyword arguments explicitly when doing generic delegation. But this change is not compatible with 2.6, where it adds an empty hash to the argument list of methods that do not need/accept keyword arguments.

To illustrate the problem:

```ruby
class ProxyWithoutKW < BasicObject
  def initialize(target)
    @target = target
  end
  def method_missing(*a, &b)
    @target.send(*a, &b)
  end
end

class ProxyWithKW < BasicObject
  def initialize(target)
    @target = target
  end
  def method_missing(*a, **o, &b)
    @target.send(*a, **o, &b)
  end
end

class Test
  def args(*a)   a  end
  def arg(a)     a  end
  def opts(**o)  o  end
end
                                          # 2.6        2.7              3.0
ProxyWithoutKW.new(Test.new).args(42)     # [42]       [42]             [42]        ok
ProxyWithoutKW.new(Test.new).arg(42)      # 42         42               42          ok
ProxyWithoutKW.new(Test.new).opts(k: 42)  # {:k=>42}   {:k=>42} +warn   [{:k=>42}]  incompatible with >= 2.7
ProxyWithKW.new(Test.new).args(42)        # [42, {}]   [42]             [42]        incompatible with <= 2.6
ProxyWithKW.new(Test.new).arg(42)         # error      42               42          incompatible with <= 2.6
ProxyWithKW.new(Test.new).opts(k: 42)     # {:k=>42}   {:k=>42} +warn   {:k=>42}    must ignore warning? cannot use pass_positional_hash in 2.6
```

I don't know how to solve this, so I'm asking for the **official** correct way to write portable delegation code. And by **portable** I mean code that can be used in gems that target ruby 2.6 and above.




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

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>