[ruby-core:117317] [Ruby master Bug#20392] Delegate super calls with a block

26 Mar 2024

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

tenderlovemaking (Aaron Patterson) wrote in #note-3:
...
Dan0042 (Daniel DeLorme) wrote in #note-1:
...
In Ruby 3.2, example 3 raised an exception "both block arg and actual block given"
So this looks like a Ruby 3.3 regression.
Thanks, I should have checked older versions.  According to git bisect, this was introduced in fdc329ea6f5bce922e95645a0c2118cfd3e1cdea (though I'm not sure how that commit caused this)
It's missing entries for `NODE_SUPER` and `NODE_ZSUPER` in `get_nd_args`, so the `nd_args` are ignored for those nodes.  At least those node types should be fixed, and all other node types in the switch should be checked to see if this isn't swallowing other syntax errors. @yui-knk is my analysis correct?

----------------------------------------
Bug #20392: Delegate super calls with a block
https://bugs.ruby-lang.org/issues/20392#change-107457

* Author: tenderlovemaking (Aaron Patterson)
* Status: Open
* ruby -v: ruby 3.4.0dev (2024-03-15T18:08:39Z master e3a82d79fd) [arm64-darwin23]
* Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN
----------------------------------------
I'm seeing strange behavior with calls to `super` when combined with `...` and a block.  I'm not sure if this is expected behavior or not, so I'm filing this ticket.

Using delegate `...` with an explicit block will cause an error:

```ruby
# Example 1
def foo ...
  yield
end

def bar ...
  foo(...) { } # test.rb: test.rb:6: both block arg and actual block given (SyntaxError)
end
```

However, calling `super` and passing a block works:

```
# Example 2
class A
  def foo
    yield(3)
  end
end

class B < A
  def foo(...)
    super do |x|
      yield(2 + x)
    end
  end
end

p B.new.foo { |x| x } # 5
```

In the above code, I imagine the bare `super` to basically be equivalent of `super(...)` since I defined the method `foo` as `foo(...)`.

However, if I explicitly pass `...` to super, there is no syntax error, just the block I provided is ignored:

```ruby
# Example 3
class A
  def foo
    yield(3)
  end
end

class B < A
  def foo(...)
    super(...) do |x|
      raise "should I be called?"
    end
  end
end

p B.new.foo { |x| x } # 3
```

I'd expect Example 3 to raise an exception like Example 1.  Additionally, I think the behavior in Example 2 is odd, but zsupers are "special" so I can understand if it is intended behavior.

Is Example 3 intended behavior?  If not, how should it behave?

Thanks.

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