Re: can this be done with generics?

I'd like to use the "call methods in a chain" pattern
across a class-subhierarchy, with most of the methods
defined in the base-class.

Suppose, I had two classes:

  class Foo {
     public Foo foo1() {
        /* do something very interesting ... */
        return this;
     }
     // assume there were like 100 such foo#() methods here
     // (in practice they of course have more diverse names)
  }
  class Bar extends Foo {
     public Bar bar() {
        /* do something very interesting */
        return this;
     }
  }

And then, somewhere else:

   // the single-class chain works just fine:
   new Foo().foo1().foo42().foo84();

   // but if I start with a Bar, and eventually after some foo#() calls
   // want to call method bar() which is not in Foo, then I'm out of luck:
   new Bar().foo1().foo42().foo84().bar(); // doesn't work, of course!

Is there a way to use *generics* for the methods of class Foo such that
each foo#() returns the *static* type on which the compiler saw it
applied?

Alternatives, that do NOT satisfy me:
   a) use an explicit cast to (Bar)
       ((Bar)(new Bar().foo1().foo42().foo84())).bar();
      Would turn into a nightmare, when more of Bar's
      methods got mixed into the chain.
   b) override each of the 100 foo#()s in Bar with a Bar return-type.
      Would turn into a nightmare, when more sub-classes like Bar
      appeared, or new methods added to Foo.
      (Note, that "bad performance" due to extra calls is NOT my concern here)
   c) add "Foo bar() { return this; }" in Foo.
      Would turn into a nightmare, when more sub-classes like Bar
      appeared (and Foo would have to reflect all subclasses' methods),
      or some chain accidentally called a subclass method on a chain
      started from some other class's instance, and compiler wouldn't
      detect the mistake.

I'm pretty sure, that this would be principially possible (as in: the
compiler has all the information that would be needed), but I can't seem
to find an approach for how to capture the static type of the expression
on which the (non-static) method is called.

Thanks in advance!