[ruby-core:112800] [Ruby master Feature#19520] Support for `Module.new(name)` and `Class.new(superclass, name)`.

9 Mar 2023

      Issue #19520 has been updated by ioquatix (Samuel Williams).

@ufuk It's already the case that it's trivial to override `Class#name` and have it return something other than a constant.

```ruby
c = Class.new

def c.name = "Hello World"

c.name
=> "Hello World"
```

The problem is Ruby does not use this internally, so you end up with inconsistent output:

```ruby
instance = c.new
=> #<#<Class:0x00007f7f11aee960>:0x00007f7f11a16180>

instance.class.name
"hello world"
```

One option would be to fix this bug so that `Class#name` is used in this context. However, since class names are cached as part of the class path, overriding this method can be problematic. It's best to set it once when the class/module is created.

Adding a display name might work, but it's the same problem as outlined above.

Probably the real way to solve this issue would be to know whether a class or module is anonymous, e.g. `Class#anonymous?` so you could exclude them from any type checking or handle them differently.

----------------------------------------
Feature #19520: Support for `Module.new(name)` and `Class.new(superclass, name)`.
https://bugs.ruby-lang.org/issues/19520#change-102302

* Author: ioquatix (Samuel Williams)
* Status: Open
* Priority: Normal
----------------------------------------
See <https://bugs.ruby-lang.org/issues/19450> for previous discussion and motivation.

[This proposal](https://github.com/ruby/ruby/pull/7376) introduces the `name` parameter to `Class.new` and `Module.new`:

```ruby
Class.new(superclass, name)
Module.new(name)
```

As a slight change, we could use keyword arguments instead.

## Example usage

The current Ruby test suite has code which shows the usefulness of this new method:

```ruby
  def labeled_module(name, &block)
    Module.new do
      singleton_class.class_eval {
        define_method(:to_s) {name}
        alias inspect to_s
        alias name to_s
      }
      class_eval(&block) if block
    end
  end
  module_function :labeled_module

  def labeled_class(name, superclass = Object, &block)
    Class.new(superclass) do
      singleton_class.class_eval {
        define_method(:to_s) {name}
        alias inspect to_s
        alias name to_s
      }
      class_eval(&block) if block
    end
  end
  module_function :labeled_class
```

The updated code would look like this:

```ruby
  def labeled_module(name, &block)
    Module.new(name, &block)
  end

  def labeled_class(name, superclass = Object, &block)
    Class.new(superclass, name, &block)
  end
  module_function :labeled_class
```

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