Issue #16977 has been reported by ssnickolay (Nikolay Sverchkov).

----------------------------------------
Bug #16977: Ambiguous lookup super for refinements
https://bugs.ruby-lang.org/issues/16977

* 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>