Consider this example:

    class Parent
      def bar
      end
    end

    class Child < Parent
      def bar
        super
      end

      def foo
      end
    end

    Child.new.foo
    Child.new.bar
    # foo and bar are cached in the global cache

    prepended_module = Module.new do
      def foo
      end
    end
    Child.prepend(prepended_module)
    # foo is cleared from the global cache, but bar is not
    # Child hierarchy is now Child < IncludedModule(prepended_module) < IncludedModule(Child) < Parent

    Child.new.bar
    # When bar is looked up here, being still cached globally, Child#bar is the
    # result of the lookup (normally, it should be IncludedModule(Child)#bar).
    # Now when Child#bar is looking for its super, it goes to the first included
    # module, then the second included module, which has the same method table
    # as Child, returning Child#bar, causing non-ending recursive calls.