module RSpec::Mocks::PartialClassDoubleProxyMethods

def initialize(source_space, *args) 

def initialize(source_space, *args)
  @source_space = source_space
  super(*args)
end

def original_method_handle_for(message)

does.
That's what this method (together with `original_unbound_method_handle_from_ancestor_for`)

run with the proper `self`.
from _before_ `A` was stubbed, and we need to rebind it to `B` so that it will
To do it properly, we need to find the original definition of `new` from `A`

hierarchy.
of the method on `A` since singleton methods on classes are in the lookup
`B.method(:new)` will return a method that will execute the stubbed version
using `B.method(:new)` before our redefinition is defined on `B`, because
When getting the original definition for `B.new`, we cannot rely purely on

expect(B).to receive(:new).and_call_original
allow(A).to receive(:new)

class B < A; end
class A; end

Consider this situation: 
def original_method_handle_for(message)
  unbound_method = superclass_proxy &&
    superclass_proxy.original_unbound_method_handle_from_ancestor_for(message.to_sym)
  return super unless unbound_method
  unbound_method.bind(object)
end

def original_unbound_method_handle_from_ancestor_for(message) 

def original_unbound_method_handle_from_ancestor_for(message)
  method_double = @method_doubles.fetch(message) do
    # The fact that there is no method double for this message indicates
    # that it has not been redefined by rspec-mocks. We need to continue
    # looking up the ancestor chain.
    return superclass_proxy &&
      superclass_proxy.original_unbound_method_handle_from_ancestor_for(message)
  end
  method_double.original_method.unbind
end

def superclass_proxy 

def superclass_proxy
  return @superclass_proxy if defined?(@superclass_proxy)
  if (superclass = object.superclass)
    @superclass_proxy = @source_space.proxy_for(superclass)
  else
    @superclass_proxy = nil
  end
end