Ruby

Bug #20392

Updated by nobu (Nobuyoshi Nakada) over 1 year 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.

Back