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

27 Apr 2023

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

The difference between a dynamically defined `inspect` which can do anything vs `Module#name` which is cached are significant.

I was now just writing a native Ruby extension, where I wanted a custom `rb_inspect` output. The default code for `rb_inspect` actually invokes `rb_class_name`.

```c
static VALUE
rb_obj_inspect(VALUE obj)
{
    if (rb_ivar_count(obj) > 0) {
        VALUE str;
        VALUE c = rb_class_name(CLASS_OF(obj));

        str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj);
        return rb_exec_recursive(inspect_obj, obj, str);
    }
    else {
        return rb_any_to_s(obj);
    }
}
```

While we in theory can change this to:

```c
        VALUE c = rb_inspect(CLASS_OF(obj));
```

which is in line with your (@Dan0042) proposal, I wonder how many existing code in other places would also be copying this or using `rb_class_name`.

You'd probably need to change the implementation of `rb_class_name` to call `rb_inspect`... which just seems like something that would cause regressions/issues to me.

This isn't just used in `NoMethodError`... Lots of tools report the class as part of an error or even as part of the normal execution (e.g. job class serialization, IRB, etc).

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

* 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/