Bug #20392
Updated by nobu (Nobuyoshi Nakada) 5 months ago
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: ```ruby ``` # 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.