[ruby-core:108422] [Ruby master Bug#18729] Method#owner and UnboundMethod#owner are incorrect after using Module#public/protected/private
From:
"Eregon (Benoit Daloze)" <noreply@...>
Date:
2022-04-27 18:22:43 UTC
List:
ruby-core #108422
Issue #18729 has been updated by Eregon (Benoit Daloze).
@jeremyevans0 Do you agree `Method#super_method` should show the method called by `super` if there is `super` in that method, when it's possible to know?
(I think it's always possible for a method defined on a class, but not for a method defined on a module especially if the module is included multiple times in the ancestors)
If so, then I believe my example in https://bugs.ruby-lang.org/issues/18729#note-9 shows that Mod#foo (using owner#name notation) is *never* called, the only called methods are sclass#foo and C#foo, so sclass#foo super's into C#foo.
And so C#foo.super_method should be sclass#foo, since that's what the `super` in sclass#foo calls.
Or did I miss something?
`public` is not equivalent to redeclaring it like you show with `def foo; super; end`, because B#foo would call A#foo with redeclaring, but with only `public :foo in B` A#foo is *not* called for `B.new.foo`.
----------------------------------------
Bug #18729: Method#owner and UnboundMethod#owner are incorrect after using Module#public/protected/private
https://bugs.ruby-lang.org/issues/18729#change-97458
* Author: Eregon (Benoit Daloze)
* Status: Open
* Priority: Normal
* ruby -v: ruby 3.1.1p18 (2022-02-18 revision 53f5fc4236) [x86_64-linux]
* Backport: 2.6: UNKNOWN, 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
The #owner should be "the class or module that defines the method".
Or in other words, the owner is the module which has the method table containing that method.
This generally holds, and it seems very likely this assumption is relied upon (e.g., when decorating a method, undefining it, etc).
But the returned value on CRuby is incorrect for this case:
```ruby
class A
protected def foo
:A
end
end
class B < A
p [instance_method(:foo), instance_method(:foo).owner, instance_methods(false), A.instance_methods(false)]
public :foo
p [instance_method(:foo), instance_method(:foo).owner, instance_methods(false), A.instance_methods(false)]
end
```
It gives:
```
[#<UnboundMethod: B(A)#foo() owner.rb:2>, A, [], [:foo]]
[#<UnboundMethod: B(A)#foo() owner.rb:2>, A, [:foo], [:foo]]
```
So `UnboundMethod#owner` says `A`, but clearly there is a :foo method entry in B created by `public :foo`, and that is shown through `B.instance_methods(false)`.
The expected output is:
```
[#<UnboundMethod: B(A)#foo() owner.rb:2>, A, [], [:foo]]
[#<UnboundMethod: B#foo() owner.rb:2>, B, [:foo], [:foo]]
```
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>