From: merch-redmine@... Date: 2014-03-13T20:34:52+00:00 Subject: [ruby-core:61477] [ruby-trunk - Bug #9573] descendants of a module don't gain its future ancestors, but descendants of a class, do Issue #9573 has been updated by Jeremy Evans. First Last wrote: > What is the objection to explaining how this works? nobu explained how it works. However, as he is not a native English speaker, let me attempt to clarify. In ruby, there exist pseudo-copies of modules called iclasses. These copies share the same variable(class variable/instance variable/constant) tables and the same method tables, but have a different super pointer in their C struct. iclasses are made when you attempt to include a module in another module or class. When you do: ~~~ module M0; end module M1 include M0 end ~~~ This creates a module M1 that includes an iclass of M0 (notated below as i0M0) in its inheritance list. For a module, the inheritance list is the the super pointer in struct RClass). When you do: ~~~ class A include M1 end ~~~ What happens is iclasses of M1 and i0M0 are made (notated below as i0M1, i1M0). So method lookup for an instance of A will be: ~~~ A -> i0M1 -> i1M0 -> Object ~~~ Here's how the super pointers for the struct RClass should look: ~~~ M0: NULL i0M0: NULL M1: i0M0 i1M0: Object i0M1: i1M0 A: i0M1 ~~~ When you do: ~~~ module M2; end M1.include M2 ~~~ This creates an iclass of M2 (i0M2) and updates the super pointer in M1, as shown: ~~~ M1: i0M2 i0M2: i0M0 i0M0: NULL ~~~ However, it has no effect on any of the iclasses of M1 already created. Ruby doesn't have multiple inheritance. Ruby method lookup uses a linked listed, not a tree. This is the reason for iclasses, and why including module B in module A after A has been included in class C does not include B in C. Note that I am not an expert on ruby internals, so if there are errors in the above description, hopefully a more knowledgeable person can correct me. ---------------------------------------- Bug #9573: descendants of a module don't gain its future ancestors, but descendants of a class, do https://bugs.ruby-lang.org/issues/9573#change-45768 * Author: First Last * Status: Open * Priority: Normal * Assignee: * Category: * Target version: * ruby -v: ruby 2.1.1p76 (2014-02-24 revision 45161) [i686-linux] * Backport: 1.9.3: UNKNOWN, 2.0.0: UNKNOWN, 2.1: UNKNOWN ---------------------------------------- ```ruby module Mod1 end module Mod2 end class Class1 end class Class2 < Class1 end p Class2.ancestors - Object.ancestors # [Class2, Class1] Class1.include Mod1 p Class2.ancestors - Object.ancestors # [Class2, Class1, Mod1] Mod1.include Mod2 p Mod1.ancestors - Object.ancestors # [Mod1, Mod2] p Class2.ancestors - Object.ancestors # [Class2, Class1, Mod1] ``` ________________________________________________________________ note that descendants of a class do gain its future ancestors so 2 issues: 1. It would seem natural that in dynamic language, dynamically added ancestors should propagate to descendants 2. Why is there a difference in ancestor propagation between modules and classes -- http://bugs.ruby-lang.org/