Issue #21143 has been updated by fxn (Xavier Noria). The hooks `const_added` and `inherited` may need to be executed "together". For example, consider: ```ruby module M def self.const_added(cname) = ... class C def self.inherited(subclass) = ... end class D < C; end end ``` When `D` is defined, two hooks are set to run, but in which order? Both orders make sense in a way: 1. When `inherited` is called, you can observe that the subclass has a permanent name, ergo it was assigned to a constant, which must me stored in a class or module object. Therefore, the constant was added to said module module before `inherited` was invoked. 1. When `const_added` is called, you can `const_get` the symbol and observe the object is a class, hence with a superclass, hence inheritance already happened. The patch in [ruby#12759](https://github.com/ruby/ruby/pull/12759) documents and adds a test for (1). Rationale: 1. I believe it would be nice specify this order. 1. Chose (1) because it is how it works today. While the motivation for the patch was formal (to remove an ambiguity), after reflecting about this I realized users of Zeitwerk may depend on this. Nowadays, Zeitwerk uses `const_added` to set autoloads for child constants in namespaces. Thanks to the current order, code can be used in `inherited` hooks normally (it would not be ready if the order was different). ---------------------------------------- Misc #21143: Speficy order of execution const_added vs inherited https://bugs.ruby-lang.org/issues/21143#change-111994 * Author: fxn (Xavier Noria) * Status: Open ---------------------------------------- The hooks `const_added` and `inherited` may need to be executed "together". For example, consider: ```ruby module M def self.const_added(cname) = ... class C def self.inherited(subclass) = ... end class D < C; end ``` When `D` is defined, two hooks are set to run, but in which order? Both orders make sense in a way: 1. When `inherited` is called, you can observe that the subclass has a permanent name, ergo it was assigned to a constant, which must me stored in a module. Therefore, the constant was added to said module module before `inherited` was invoked. 1. When `const_added` is called, you can `const_get` the symbol and observe the object is a class, hence with a superclass, hence inheritance already happened. The patch in https://github.com/ruby/ruby/pull/12759 documents and adds a test for (1). Rationale: 1. I believe it would be nice specify this order. 1. Chose (1) because it is how it works today. While the motivation for the patch was formal (to remove an ambiguity), after reflecting about this I realized users of Zeitwerk may depend on this. Zeitwerk uses `const_added` to set autoloads for child constants in namespaces. Thanks to the current order, code can be used in `inherited` hooks normally (it would not be ready if the order was different). -- https://bugs.ruby-lang.org/