Unclear error when yielding wrong number of arguments in overloaded method

[spuun]

Bug Report

abstract class Foo
  abstract def bar(&)
end

class Baz < Foo
  def bar(&)
    yield 1
  end
end

results in

Error: abstract def Foo#bar(&) must be implemented by Baz

The error should probably say something about wrong number of arguments.

[straight-shoota]

I believe the root of the problem is that originally the & parameter only indicates that the method receives a block, but not its type.
However, when used in an abstract def, the compiler infers from the absence of any type information that the type must be Proc(_) (I believe?).
This then creates a conflict with the implementation method where yield 1 in the body informs that the block actually receives one argument.

Of course we can (and probably should) improve the error message to make it easier to understand what's wrong. Because the signatures look identical you would think that it's implemented correctly.

Going one step further however, I'm wondering if abstract def should require an explicit type restriction for the block argument.
Maybe the formatter could even fill this in automatically?

-  abstract def bar(&)
+  abstract def bar(& : -> _)

This would also help to make the difference stand out more clearly.

Related: #8764

[straight-shoota]

I just realize that the explicit block type restriction doesn't even seem to have much effect. Ignoring the abstract def part for now, a block signature of -> _ apparently doesn't prevent yielding a value?

def bar(& : -> _)
  yield 1
end

bar {|x| x } # => 1

I would've expected that to be an error.
And I would expect that error to apply to he abstract def implementation when the block type conflicts with the yield behaviour.