Support finding signatures through prepended methods

[KaanOzkan]

Motivation

Resolves #2705

Implementation

Find signatures hidden by prepend by walking super_method through prepended ancestor positions and stopping at the first ordinary implementation.

This requires a few things:

1. Require call sites to pass the constant or receiver from which the method was resolved (lookup_from) because a wrapper-owned method does not retain that scope.
2. Infer prepended positions by comparing the lookup scope’s flattened ancestor chain with each ancestor’s own chain because Ruby does not expose this information.
3. Repeat the lookup once more because lazy evaluation of a sig may register it under the wrapper that was already inspected.

For example in this case lookup_from lets us identify Wrapper as prepended, so we inspect Child#foo, and stop before incorrectly falling through to Parent#foo.

class Parent
  #: (Integer) -> Integer
  def foo(value) = value
end

module Wrapper
  def foo(...) = super
end

class Child < Parent
  prepend Wrapper

  #: (String) -> String
  def foo(value) = value
end

method = Child.instance_method(:foo)

method.owner                         # => Wrapper
method.super_method.owner            # => Child
method.super_method.super_method.owner # => Parent

signature_of(method, lookup_from: Child) # => (String) -> String

Tests

TBD on Core

[amomchilov]

This comment is too hard-coded to the prepend case, but this implementation doesn't do anything to limit to prepended modules (and it's surprisingly difficult to identify them)

[KaanOzkan]

Added a precursor to the comment, wdyt?

[jesse-shopify]

I also think this comment could focus more on the purpose of the method rather than describing the implementation. Not a blocker.

[amomchilov]

hmm?

[KaanOzkan]

I wanted to make it faster in the normal case and return early, new version should be easier to understand

[KaanOzkan]

This is more difficult than I originally thought because walking the entire super_method chain to find a signature also affects ordinary overrides:

class Parent
  #: (String) -> String
  def foo(value) = value
end

class Child < Parent
  def foo(value, suffix) = ""
end

foo = Child.instance_method(:foo)

# Before: signature_of(foo) # => nil
# Current PR: signature_of(foo) # => Parent#foo's signature (incorrect)

I’m looking for a clean way to support prepended methods without changing this behavior.

It was for outdated code