From: "jeremyevans0 (Jeremy Evans) via ruby-core" <ruby-core@...>
Date: 2026-08-28T05:03:50+00:00
Subject: [ruby-core:126534] [Ruby Bug#22273] Aliasing doesn't interact well with Module#prepend

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


As I mentioned in https://bugs.ruby-lang.org/issues/22263#note-5, I think a module should only be able to alias methods in ancestor modules, it should not be able to alias methods in descendant modules, as I don't think the semantics make sense.  As prepend results in a descendant module and not an ancestor module from the perspective of the the module's own methods in the lookup chain, I don't think a module should be able to alias a method in a module prepended to it.

For example, if you do:


```ruby
module M
  def m = 1
end
class C
  prepend M
  alias m2 m
end
```

I think the `alias m2 m` should raise `NameError`.

When you allow a module to alias a method in a descendant module, you appear to end up with a case where `super` calls can to go to a descendant instead of an ancestor:

```ruby
module M
  def m = [M, :m, *super]
end
module N
  def m2 = [N, :m2, *super]
end
class Object
  def m = [Object]
end
class C
  prepend N
  alias m m2
  prepend M
  alias m2 m
  def m = [C, :m, *super]
end
C.ancestors
# => [M, N, C, Object, Kernel, BasicObject]
C.new.m2
# => [N, :m2, M, :m, C, :m, Object]
m = C.new.method(:m2)
# => #<Method: C(N)#m2() -:5>
m = m.super_method
# => #<Method: C(M)#m2(m)() -:2>
m = m.super_method
# => #<Method: C#m() -:15>
m = m.super_method
# => #<Method: Object#m() -:8>
m = m.super_method
# => nil
```

----------------------------------------
Bug #22273: Aliasing doesn't interact well with Module#prepend
https://bugs.ruby-lang.org/issues/22273#change-118704

* Author: luke-gru (Luke Gruber)
* Status: Open
* Backport: 3.3: UNKNOWN, 3.4: UNKNOWN, 4.0: UNKNOWN
----------------------------------------
Currently, aliasing doesn't interact well with `Module#prepend` in my opinion.

### Example

```ruby
module Kernel
  prepend(Module.new do
    def require(feature)
      puts "requiring feature (prepend): #{feature}"
      super
    end
  end)
end

module Kernel
  alias original_require require
  def require(feature)
    puts "requiring feature (alias): #{feature}"
    original_require(feature)
  end
end

require "set"
```

This produces this behavior:

```
requiring feature (prepend): set
requiring feature (alias): set
requiring feature (prepend): set
../ruby/test.rb:5:in 'require': super: no superclass method 'require' for main (NoMethodError)
```

I would expect this behavior:

```
requiring feature (prepend): set
requiring feature (alias): set
# Then, the original require would succeed
```

This has caused issues such as [22263](https://bugs.ruby-lang.org/issues/22263) and has [confused gem authors](https://github.com/fxn/zeitwerk/pull/203#issuecomment-1107777206). In the second link, the ignored alias was due to [this bug](https://github.com/ruby/ruby/commit/c59c4d717a2e687972341eab1574196e97d7d7be) which has recently been fixed.

### Bug?

As far as I know this is intentional behavior introduced in Ruby 2.0 [here](https://bugs.ruby-lang.org/issues/7842). There are even tests and specs that codify this behavior such as `test_prepend_super_in_alias` and `prepend_spec.rb`.

Even though it's intentional, I don't believe it's well thought out. I'm interested in hearing arguments for and against the current behavior (with code examples, preferably).



-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/