[ruby-core:118195] [Ruby master Bug#20218] aset/masgn/op_asgn with keyword arguments

6 Jun 2024

      Issue #20218 has been updated by bughit (bug hit).

matz (Yukihiro Matsumoto) wrote in #note-18:
...
It is the direction of Ruby's evolution to separate keyword arguments from normal arguments, just as Ruby 3.0 promoted the separation of keyword arguments. This proposal goes against this direction and cannot be accepted.
Which proposal? To actually fix this bug rather than remove the kwargs feature? How so?

Index assignment can be changed/fixed to have real, separated keyword arguments that would be 100% in line with this evolution of Ruby.

Instead of the following (from 2.6):

```ruby
  def self.[]=(name, opts = {}, val)
    p [name, opts, val]
    @store[key(name, namespace: opts[:namespace])] = val
  end
```

you'd have:

```ruby
  def self.[]=(name, val, namespace: nil)
    p [name, opts, val]
    @store[key(name, namespace: namespace)] = val
  end
```

The invocation syntax would remain the same: `IndexTest['foo', namespace: 'bar'] = 2`

So why is it preferable to remove the feature entirely form index assignment and have this incoherent inconsistency between `[]` (supports kwargs) and `[]=` (doesn't support kwarg), rather than fix kwarg issues in `[]=`?

----------------------------------------
Bug #20218: aset/masgn/op_asgn with keyword arguments
https://bugs.ruby-lang.org/issues/20218#change-108680

* Author: jeremyevans0 (Jeremy Evans)
* Status: Closed
* Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN
----------------------------------------
I found that use of keyword arguments in multiple assignment is broken in 3.3 and master:

```ruby
h = {a: 1}
o = []
def o.[]=(*args, **kw)
  replace([args, kw])
end

# This segfaults as RHS argument is not a hash
o[1, a: 1], _ = [1, 2]

# This passes the RHS argument as keywords to the method, treating keyword splat as positional argument
o[1, **h], _ = [{b: 3}, 2]
o
# => [[1, {:a=>1}], {:b=>3}]
```

Before 3.3, keyword arguments were treated as positional arguments.

This is similar to #19918, but for keyword arguments instead of block arguments.

@matz indicated he wanted to prohibit block arguments in aset/masgn and presumably also op_asgn (making them SyntaxErrors).  Can we also prohibit keyword arguments in aset/masgn/op_asgn?

Note that aset treats keyword arguments as regular arguments:

```ruby
o[1, a: 1] = 2
o
# => [[1, {:a=>1}, 2], {}]

o[1, **h] = {b: 3}
o
# => [[1, {:a=>2}, {:b=>3}], {}]
```

While op_asgn treats keyword arguments as keywords:

```ruby
h = {a: 2}
o = []
def o.[](*args, **kw)
  concat([:[], args, kw])
  x = Object.new
  def x.+(v)
    [:x, v]
  end
  x
end
def o.[]=(*args, **kw)
  concat([:[]=, args, kw])
end
o[1, a: 1] += 2
o
# => [:[], [1], {:a=>1}, :[]=, [1, [:x, 2]], {:a=>1}]

o.clear
o[1, **h] += {b: 3}
o
# => [:[], [1], {:a=>2}, :[]=, [1, [:x, {:b=>3}]], {:a=>2}]
```

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