From: shugo@...
Date: 2020-06-25T00:01:11+00:00
Subject: [ruby-core:98934] [Ruby master Bug#16977] Ambiguous lookup super	for refinements

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:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>