[ruby-core:125522] [Ruby Bug#22071] super in method in module that is refined results in NoMethodError

15 May 2026

Issue #22071 has been updated by jeremyevans0 (Jeremy Evans).


shugo (Shugo Maeda) wrote in #note-1:
...
Refinements for modules were initially prohibited, and were allowed in [Feature #12534] while `super` was still prohibited. Supporting `super` in a refinement for a module would go beyond a bug fix, so I think it should be discussed as a new feature rather than as a bug.
I think the problem is that `super` is not prohibited, it just uses the wrong method lookup.  Here's a revised example that showing a case where `super` does not raise an exception:

```ruby
class BasicObject
  def a; "B" end
end

module G
  def a; "G" + super end
end

module F
  include G
  def a; "F" + super end
end

class A
  def a; "A" + super end
end

class B < A
  include F
end

p B.new.a

module R
 refine F do
   def a; "R"+super end
 end
end
using R

p B.new.a
```

Output:

```
"FGAB"
"RFB"
```

What happens during the `super` call in `F#a` when `F` is refined by `R` is it determines the superclass is `BasicObject`. If `BasicObject` defines the method, than it doesn't raise `NoMethodError`.


So if we want to actually prohibit `super`, we have to decide how and where to do that.

1. Prohibiting `super` inside the refinement method is probably easiest, but it breaks backwards compatibility for refinements of modules where the refinement method calls `super`.

2. Prohibiting `super` inside the module itself (`F#a`) is more compatible. There are still some minor incompatibilities:

   * The method implementation in `BasicObject` (or a module included or prepended to `BasicObject`) will not be called.

   * If `BasicObject` doesn't define the method, `method_missing` in the underlying class will not be called (the example currently calls `B#method_missing`).
...
Alternatively, it may be better to just change the error message to make the prohibition clearer.
I haven't fully tested this, but it appears to work in some basic testing (passes `test/ruby/test_refinement.rb` and `spec/ruby/core/refinement`:

```diff

diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 84daaa85a5..f449ff0324 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -5061,6 +5061,13 @@ vm_search_super_method(const rb_control_frame_t *reg_cfp, struct rb_call_data *c
         cc = vm_cc_new(Qundef, NULL, vm_call_method_missing, cc_type_super);
         RB_OBJ_WRITE(iseq, &cd->cc, cc);
     }
+    else if (klass == rb_cBasicObject &&
+             RB_TYPE_P(me->defined_class, T_ICLASS) &&
+             ((struct RClass_and_rb_classext_t*)me->defined_class)->classext.as.iclass.includer == 0) {
+        rb_raise(rb_eNoMethodError,
+                 "super in a method in a module that has been refined and that is called via super"
+                 " from a refinement method is not supported.");
+    }
     else {
         cc = vm_search_method_fastpath(reg_cfp, cd, klass);
         const rb_callable_method_entry_t *cached_cme = vm_cc_cme(cc);
```

This implements the approach described in 2. above. Does this seem reasonable?

----------------------------------------
Bug #22071: super in method in module that is refined results in NoMethodError
https://bugs.ruby-lang.org/issues/22071#change-117338

* Author: jeremyevans0 (Jeremy Evans)
* Status: Assigned
* Assignee: shugo (Shugo Maeda)
* ruby -v: ruby 4.1.0dev (2026-05-03T23:57:21Z master d8d2ed5dc9) +PRISM [x86_64-openbsd7.9]
* Backport: 3.3: UNKNOWN, 3.4: UNKNOWN, 4.0: UNKNOWN
----------------------------------------
We currently support refinements of modules, even though doc/syntax/refinements.rdoc and https://github.com/ruby/ruby/wiki/Refinements-Spec imply that we would not respect refinements of included or prepended modules and would only respect refinements of classes and superclasses.

If you refine a module, and have the refined method definition call `super` and the method in the refined module call `super`, and that refined method is found first during method lookup, the `super` call in the method in the refined module results in a `NoMethodError`. Example:

```ruby
module F
  def a; "F" + super end
end

class A
  def a; "A" end
end

class B < A
  include F
end

p B.new.a

module R
 refine F do
   def a; "R" + super end
 end
end
using R

p B.new.a
```

Output:

```
"FA"
t.rb:2:in 'F#a': super: no superclass method 'a' for an instance of B (NoMethodError)
        from t.rb:17:in 'a'
        from t.rb:22:in '<main>'
```

Two things to note:

* Before the refinement is activated, things work as expected, returning "FA".
* After the refinement is activated, the `NoMethodError` is raised not in the refinement method `super` (line 17), but in the `super` in the method in the module that is refined (line 2). 

What should be the expected behavior here? I can think of two possibilities:

* Per the documentation, we should not consider refinements of included/prepended modules. So in this example, we should print "FA" and ignore the refinement instead of raising the `NoMethodError`. In this case, it would be best to raise during the `refine F` call, and prohibit the refining of modules completely. This would break backwards compatibility, though I'm not sure how much real world code uses refinements of modules.

* Fix `super` when the refinement is activated to use the correct method lookup and return "RFA" instead of raising the `NoMethodError`. Also fix the documentation to describe how refinements of included/prepended modules work during method lookup.



-- 
https://bugs.ruby-lang.org/

    