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/