Forum: Ruby-core Feature Proposal: Method#super_method

0e610136db92027148906c92d57fdb36?d=identicon&s=25 unknown (Guest)
on 2014-05-02 05:15
(Received via mailing list)
Issue #9781 has been updated by Marc-Andre Lafortune.

I must be tired.

Nobu: Sorry, I was confused, there's no problem with
`UnboundMethod#super_method` because we retain which class this method
was accessed from.

Ryan: That's actually a good example, there is no api to get the
"original owner" of an unbound method, so in general it's not possible
to implement `super_method` in Ruby. E.g. from
`Hash.instance_method(:map)`, I don't know of a way to get back `Hash`
in pure Ruby, and thus no way to go through Hash's ancestry chain.

Feature #9781: Feature Proposal: Method#super_method

* Author: Richard Schneeman
* Status: Open
* Priority: Normal
* Assignee:
* Category: core
* Target version:

When `super` is called in a method the Ruby VM knows how to find the
next ancestor that has that method and call it. It is difficult to do
this manually, so I propose we expose this information in

Ruby Method class ( is
returned by calling Object.method and passing in a method name
( This
is useful for debugging:

# /tmp/code.rb
class Foo
  def bar

# => ["/tmp/code.rb", 3]

The Object#method allows a ruby developer to easily track the source
location of the method and makes debugging very easy. However if the
code is being invoked by a call to `super` it is difficult to track

# /tmp/code.rb

class BigFoo
  def bar

class Foo < BigFoo
  def bar

In this code sample it is easy to find the method definition inside of
Foo but it is very difficult in large projects to find what code exactly
`super` is calling. This simple example is easy, but it can be hard when
there are many ancestors. Currently if I wanted to find this we can
inspect ancestors

Foo.ancestors[1..-1].map do |ancestor|
  next unless ancestor.method_defined?(:bar)

To make this process simpler I am proposing a method on the Method class
that would return the result of `super`

It could be called like this:


I believe adding Method#super_method, or exposing this same information
somewhere else, could greatly help developers to debug large systems
This topic is locked and can not be replied to.