[#98621] Re: Function getlogin_r()'s protoype] — Bertram Scharpf <lists@...>
FYI,
3 messages
2020/06/02
[#98947] [Ruby master Feature#16986] Anonymous Struct literal — ko1@...
Issue #16986 has been reported by ko1 (Koichi Sasada).
66 messages
2020/06/26
[#98962] [Ruby master Bug#16988] Kernel.load loads file from current directory without '.' in path — misharinn@...
Issue #16988 has been reported by TheSmartnik (Nikita Misharin).
5 messages
2020/06/26
[#98969] [Ruby master Feature#16994] Sets: shorthand for frozen sets of symbols / strings — marcandre-ruby-core@...
Issue #16994 has been reported by marcandre (Marc-Andre Lafortune).
7 messages
2020/06/26
[#100117] [Ruby master Feature#16994] Sets: shorthand for frozen sets of symbols / strings
— matz@...
2020/09/25
Issue #16994 has been updated by matz (Yukihiro Matsumoto).
[ruby-core:98934] [Ruby master Bug#16977] Ambiguous lookup super for refinements
From:
shugo@...
Date:
2020-06-25 00:01:11 UTC
List:
ruby-core #98934
Issue #16977 has been updated by shugo (Shugo Maeda).
ssnickolay (Nikolay Sverchkov) wrote:
> [In specification](https://docs.ruby-lang.org/en/2.7.0/syntax/refinements_rdoc.html) we have the note
>
> > Note that super in a method of a refinement invokes the method in the refined class even if there is another refinement which has been activated in the same context.
>
> If we take a look at the example:
(snip)
> I don’t understand why `include` works differently than refining a method directly.
> From my point of view, we should get `foo from C` in both cases.
In the former case, super is called in the scope where a refinement is defined, and thus it invokes the method in the refined class.
However, in the latter case, super is called outside the scope where a refinement is defined, and it looks up the ancestor chain.
The behavior of include in refine blocks is confusing, so it may be prohibited in the future.
----------------------------------------
Bug #16977: Ambiguous lookup super for refinements
https://bugs.ruby-lang.org/issues/16977#change-86310
* Author: ssnickolay (Nikolay Sverchkov)
* Status: Open
* Priority: Normal
* ruby -v: ruby 2.6.3p62 (2019-04-16 revision 67580)
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
[In specification](https://docs.ruby-lang.org/en/2.7.0/syntax/refinements_rdoc.html) we have the note
> Note that super in a method of a refinement invokes the method in the refined class even if there is another refinement which has been activated in the same context.
If we take a look at the example:
```ruby
module A
def foo
"foo from A"
end
end
class C
def foo
"foo from C"
end
end
refinement =
Module.new do
refine C do
include A
end
end
refinement2 =
Module.new do
refine C do
def foo
super
end
end
end
using refinement
using refinement2
puts C.new.foo
# => "foo from C"
```
This works as described in the specification.
However, if we replace `refinement2` in the example with
```ruby
# the same A, C and refinement definitions here
module B
def foo
super
end
end
refinement2 =
Module.new do
refine C do
include B
end
end
using refinement
using refinement2
puts C.new.foo
# => "foo from A"
```
I don’t understand why `include` works differently than refining a method directly.
From my point of view, we should get `foo from C` in both cases.
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>