Issue #9573 has been updated by Nobuyoshi Nakada.


First Last wrote:
> > > 1. It would seem natural that in dynamic language, dynamically added ancestors should propagate to descendants
> > 
> > It's a longstanding issue, a descendant knows its ancestors, but an ancestor doesn't know its descendants.
> 
> Is it the case that ancestors are cached in each descendant?  So that it does not actually walk the ancestor tree each time.  If so, is there any way to invalidate this cache for a given class or all, and have it reevaluate the ancestors?

An included module is shared using an internal class (called as IClass), and IClasses are copied for each trees.
Now subclasses/submodules are maintained in each classes/modules for method cache validation, so it may be possible.

> > > 2. Why is there a difference in ancestor propagation between modules and classes
> > 
> > It is not between modules and classes, but caused by the order of inheritance and including.
> 
> Please clarify.  Mod1 is included in Class1 after Class2 extends Class1 and yet Class2 somehow learns of its new grandparent, Mod1.  How does that happen if ancestors (Class1) do not know their descendants (Class2).  So there is a difference, an ancestor added to a class, propagates to the descendant of this class, but an ancestor added to a module does not propagate to the descendant of this module.

`Class1` only knows `Mod1`, and its ancestor tree is copied into `Class2`.
And ditto for including a module.



----------------------------------------
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-45504

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