module T::Private::ClassUtils

def self.def_with_visibility(mod, name, visibility, method=nil, &block) 

def self.def_with_visibility(mod, name, visibility, method=nil, &block)
  mod.module_exec do
    # Start a visibility (public/protected/private) region, so that
    # all of the method redefinitions happen with the right visibility
    # from the beginning. This ensures that any other code that is
    # triggered by `method_added`, sees the redefined method with the
    # right visibility.
    send(visibility)
    if method
      define_method(name, method)
    else
      define_method(name, &block)
    end
    if block && block.arity < 0 && respond_to?(:ruby2_keywords, true)
      ruby2_keywords(name)
    end
  end
end

def self.replace_method(mod, name, original_only=false, &blk)

If `original_only` is true, return the `UnboundMethod` representing the original method.

overwriting or removing the override).
to call the original method, or `restore` to restore the original method (by
false, returns a ReplacedMethod instance on which you can call `bind(...).call(...)`
overriding it (if it is defined by one of mod's ancestors). If `original_only` is
Replaces a method, either by overwriting it (if it is defined directly on `mod`) or by 
def self.replace_method(mod, name, original_only=false, &blk)
  original_method = mod.instance_method(name)
  original_visibility = visibility_method_name(mod, name)
  original_owner = original_method.owner
  mod.ancestors.each do |ancestor|
    break if ancestor == mod
    if ancestor == original_owner
      # If we get here, that means the method we're trying to replace exists on a *prepended*
      # mixin, which means in order to supersede it, we'd need to create a method on a new
      # module that we'd prepend before `ancestor`. The problem with that approach is there'd
      # be no way to remove that new module after prepending it, so we'd be left with these
      # empty anonymous modules in the ancestor chain after calling `restore`.
      #
      # That's not necessarily a deal breaker, but for now, we're keeping it as unsupported.
      raise "You're trying to replace `#{name}` on `#{mod}`, but that method exists in a " \
            "prepended module (#{ancestor}), which we don't currently support."
    end
  end
  overwritten = original_owner == mod
  T::Configuration.without_ruby_warnings do
    T::Private::DeclState.current.without_on_method_added do
      def_with_visibility(mod, name, original_visibility, &blk)
    end
  end
  if original_only
    original_method
  else
    new_method = mod.instance_method(name)
    ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
  end
end

def self.visibility_method_name(mod, name)

`name` must be an instance method (for class methods, pass in mod.singleton_class) 
def self.visibility_method_name(mod, name)
d_defined?(name)
_method_defined?(name)
ethod_defined?(name)
# Raises