Ensure making a class abstract doesn't change the visibility of its `.new`

[amomchilov]

The implementation in #3 will always make new public, regardless of the visibility it had previously.

Desired behaviour:

class PrivateNew
  private_class_method :new
end

class MyAbstractClass < PrivateNew
  abstract!
end

p MyAbstractClass.singleton_class.public_method_defined?(:new)
# is true, should be false

class MySubclass < MyAbstractClass; end

p MySubclass.singleton_class.public_method_defined?(:new)
# is true, should be false

[amomchilov]

Possible approach: Hook Module#include_features

PoC:

#!/usr/bin/ruby

class Parent
  private def f = "Parent#f"
end

module M
  def f = "Module#f"
  
  def self.append_features(target_module)
    visibility_before = if public_method_defined?(:f)
      :public
    elsif protected_method_defined?(:f)
      :protected
    elsif private_method_defined?(:f)
      :private
    end
    
    super # does the actual module inclusion
    
    case visibility_before
    when :public, nil
      nil # no-op, it's already public
    when :protected
      target_module.protected(:f)
    when :private
      target_module.private(:f)
    end
  end
end

class Child < Parent
  include M
end

Child.new.f # private method 'f' called for an instance of Child (NoMethodError)