[ruby-core:79751] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[ruby-core:79751] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[botalov.andrey]

Issue #13249 has been reported by Andrey Botalov.

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249

* Author: Andrey Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:
~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:
~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:79752] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[botalov.andrey]

Issue #13249 has been updated by Andrei Botalov.

Description updated

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-63176

* Author: Andrei Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:
~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar

~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:
~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar

~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:79753] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[botalov.andrey]

Issue #13249 has been updated by Andrei Botalov.

Description updated

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-63177

* Author: Andrei Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:79758] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[nobu]

Issue #13249 has been updated by Nobuyoshi Nakada.


Hmmm, a class singleton method should have its own visibility per invocations?

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-63185

* Author: Andrei Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:79770] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[botalov.andrey]

Issue #13249 has been updated by Andrei Botalov.


Well, ability to declare `private` methods inside class methods seems strange given that it's not possible to declare private methods inside instance methods:

~~~ ruby
class C
  def foo
    private def bar
    end
  end
end
C.new.foo # NoMethodError is raised
~~~

So I'm not sure which route would be better.

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-63196

* Author: Andrei Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:79774] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[shevegen]

Issue #13249 has been updated by Robert A. Heiler.


The examples confuse me a bit.

Does private actually make sense on any class-method / singleton method?

I understand it as a limitation for methods on the class, where outside
calls are not allowed, only internal ones (though ruby allows one to
bypass these anyway via .send).

I am also confused by the second example:

  class C
    def self.foo
      private def bar
      end
    end
  end
  C.foo
  C.new.bar

Is that not equivalent to

  private
  def self.bar
?

So why would this work on the C.new.bar() level?

It is however had interesting that this worked on 2.2 and below but
was changed past that point.

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-63199

* Author: Andrei Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:79787] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[botalov.andrey]

Issue #13249 has been updated by Andrei Botalov.

Description updated

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-63212

* Author: Andrei Botalov
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:80756] [Ruby trunk Bug#13249][Assigned] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[shyouhei]

Issue #13249 has been updated by shyouhei (Shyouhei Urabe).

Status changed from Open to Assigned
Assignee set to ko1 (Koichi Sasada)

We looked at this issue in yesterday's developer meeting.

The use of private in evolve75/RubyTree shown in the description is in fact wrong (methods are defined in a wrong place).  That example made us think that the use of private in a method is a code smell.

We would forbid such usage in a future.  For the time being, let us show warning message.

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-64312

* Author: abotalov (Andrei Botalov)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:81261] [Ruby trunk Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[ko1]

Issue #13249 has been updated by ko1 (Koichi Sasada).


I will insert warning.
I will not change the current behavior.


----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-64926

* Author: abotalov (Andrei Botalov)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~




-- 
https://bugs.ruby-lang.org/

[ruby-core:94539] [Ruby master Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[merch-redmine]

Issue #13249 has been updated by jeremyevans0 (Jeremy Evans).

File warn-scope-visibility-in-method-13249.patch added

The warning discussed has not been added yet.  Attached is a patch that implements it.  While it passes `make check`, there may be corner cases it doesn't handle.  I would appreciate review of the changes to `vm_cref_set_visibility`.

By adding this warning, I found a related issue in irb, which I submitted a pull request for: https://github.com/ruby/irb/pull/23

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-80980

* Author: abotalov (Andrei Botalov)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~


---Files--------------------------------
warn-scope-visibility-in-method-13249.patch (4.18 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:95351] [Ruby master Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[mame]

Issue #13249 has been updated by mame (Yusuke Endoh).

Assignee changed from ko1 (Koichi Sasada) to nobu (Nobuyoshi Nakada)

@nobu Could you review the patch?

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-82059

* Author: abotalov (Andrei Botalov)
* Status: Assigned
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~


---Files--------------------------------
warn-scope-visibility-in-method-13249.patch (4.18 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:95356] [Ruby master Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[nobu]

Issue #13249 has been updated by nobu (Nobuyoshi Nakada).


* Is it necessary that check is placed inside the function `vm_cref_set_visibility`?
  What about calling a separate function where `check_method` flag is 1?

* `rb_frame_callee` returns the called name, that may be an aliased name.
  Is it intentional?

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-82064

* Author: abotalov (Andrei Botalov)
* Status: Assigned
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~


---Files--------------------------------
warn-scope-visibility-in-method-13249.patch (4.18 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:95372] [Ruby master Bug#13249] Access modifiers don't have an effect inside class methods in Ruby >= 2.3

[merch-redmine]

Issue #13249 has been updated by jeremyevans0 (Jeremy Evans).


nobu (Nobuyoshi Nakada) wrote:
> * Is it necessary that check is placed inside the function `vm_cref_set_visibility`?
>   What about calling a separate function where `check_method` flag is 1?

I agree, that makes more sense.

> * `rb_frame_callee` returns the called name, that may be an aliased name.
>   Is it intentional?

No.  It would be better to use `rb_frame_this_func` instead, I think.

Thank you very much for your review. I've added the modified patch as a pull request (https://github.com/ruby/ruby/pull/2562).  Assuming it passes CI, I will merge it.

----------------------------------------
Bug #13249: Access modifiers don't have an effect inside class methods in Ruby >= 2.3
https://bugs.ruby-lang.org/issues/13249#change-82080

* Author: abotalov (Andrei Botalov)
* Status: Assigned
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
* ruby -v: 2.3.0, 2.4.0
* Backport: 2.2: UNKNOWN, 2.3: UNKNOWN, 2.4: UNKNOWN
----------------------------------------
Simple example:

~~~ ruby
class C
  def self.foo
    private
    def bar
    end
  end
end
C.foo
C.new.bar
~~~

This code runs fine on Ruby 2.3 and Ruby 2.4. It raises NoMethodError on Ruby 2.2 and prior versions.
I would expect an error to be raised.

Here is some code that actually uses private access modifier inside a class method - https://github.com/evolve75/RubyTree/blob/db48c35b0a3b96e4da473b095cc00e454d8a9996/lib/tree/utils/camel_case_method_handler.rb#L60

By the way, this code raises an error as expected on Ruby 2.3 and Ruby 2.4:

~~~ ruby
class C
  def self.foo
    private def bar
    end
  end
end
C.foo
C.new.bar # NoMethodError: private method `bar' called
~~~


---Files--------------------------------
warn-scope-visibility-in-method-13249.patch (4.18 KB)


-- 
https://bugs.ruby-lang.org/