Method visibility is not preserved after redefining methods

[nikitakar9862]

Problem

When a method is defined after a private keyword, it should remain private. However, after LowType redefines the method (using define_method), it becomes public.

This happens because the define_method sets method visibility to public by default, and the original visibility of the method is not restored.

For example:

class User
  private

  def secret
   puts "hidden"
  end
end

Expected behavior:

When a method is defined under the private keyword, if we call the method outside the class it should raise NoMethodError. This is Ruby's standard encapsulation rule.

User.new.secret # => NoMethodError (private method)

Actual behavior (after LowType processing):

But when LowType redefines the method using define_method, it makes the method public by default and does not restore the original private visibility.

User.new.secret  # => "hidden" (method became public)

Proposed Solution

• Track where the private keyword appears in the class (using line numbers)
• Then compare it with each method’s start_line
• If a method is defined after the private keyword then it should be treated as private method
• After redefining the method, explicitly restore its visibility

Example approach:

define_method(:method_name) do
  ...
end

if class_proxy.private_start_line && method_proxy.start_line >= class_proxy.private_start_line
  private :method_name
end

Additional Improvement

While working on this issue, I also found that adding file_path and start_line to param proxies and return proxies helps improve the error messages by pointing to the exact location in the source file.

@maedi brother let me know if this approach looks good. I would be happy to open a PR for it.

[maedi]

I think we already do change the public method back to private on this line?
https://github.com/low-rb/low_type/blob/main/lib/definitions/redefiner.rb#L80

But it could be broken. I think there's a test for it. But you could write a test to show that it's broken?

[nikitakar9862]

@maedi brother I tried to reproduce the issue by writing a test for method visibility.

The test that I wrote:

But the test confirms that private methods remain private after the method redefinition, so it seems the issue might not occur in the current implementation.

It looks like my assumption about the bug might have been incorrect.

[maedi]

The test above here doesn't actually use any include LowType.

We already have a little test hidden away in low_hello_spec.rb that I believe is testing this to work:

describe '#private_typed_arg' do
  let(:error_message) { "private method 'private_typed_arg' called for an instance of LowHello" }

  it 'raises no method error' do
    expect { hello.private_typed_arg }.to raise_error(NoMethodError, error_message)
  end
end

Fixture:

private

def private_typed_arg(greeting = String)
  greeting
end