Any way to override base type with dervived in derived type

[IntegratedDimensions]

class T;
class TT : T;

interface I
{
    @property T t();
}

abstract class A
{
    T _t;
    @property T t() { return _t; }

}

class C : A
{

    // Stuff below uses t as TT but compiler, of course, treats t 
as T
    ...
}


The issue is that I programmed the class C with a variable that 
directly was based off TT, I later subderived T from TT and 
exposed it in I. (TT was refactored in to T and not T)


But all the code in C assumes t is of type TT but now due to the 
interface it looks like a T, even though internally it is 
actually a TT.

What I'd like to do is

class C : A
{
    private override @property TT t() { return cast(TT)(_t); } // 
null check if necessary
    // Stuff below uses t which is now a TT
    ...
}

or whatever.

This is simply so I don't have to rename or cast all my uses of t 
in C to type TT.

I'm pretty much guaranteed that in C, t will be type TT due to 
the design(C goes with TT like bread with butter).

So, it would be nice if somehow I could inform the type system 
that in C, t is always of type TT and so treat it as such rather 
than forcing me to explicitly cast for every use. Again, I could 
rename things to avoid the same name usage but in this case it is 
not necessary because of the design.

Is there any semantics that can get me around having to rename?