[Visual Studio 2012 / Intellisense / C++] Auflösung von Template typenames zu echten Klassen-Namen

Hi,

folgender code:

class BundyRead
{
};

class BundyWrite
{
};

template<class T>
class BarBaseT
{
public:
    typedef T BundyType;

    BarBaseT()
        : bundy_(BundyType())
    {
    }

    BundyType& getBundy()
    {
        return bundy_;
    }

private:
    BundyType bundy_;
};

class BarRead : public BarBaseT<BundyRead>
{
};

class BarWrite : public BarBaseT<BundyWrite>
{
};

template<class T>
class FooBaseT
{
public:
    FooBaseT()
        : bar_(T())
    {
    }

    T& getBar()
    {
        return bar_;
    }

    typename T::BundyType& getBundy()
    {
        return getBar().getBundy();
    }

protected:
    T bar_;
};

class FooRead : public FooBaseT<BarRead>
{
};

class FooWrite : public FooBaseT<BarWrite>
{
};

Instantiierung der Klasse FooWrite und Aufruf der beiden Methoden:

FooWrite fooWrite;
fooWrite.getBar();
fooWrite.getBundy();

Bei getBar() gibt mir Intellisense als Rückgabetyp BarWrite an. Es löst das template argument als typename also korrekt auf.
Bei getBundy() allerdings liefert es mir nur BarBaseT<BundyWrite>::BundyType&, obwohl es den konkreten Typ wissen sollte (BundyWrite).
Mir ist auch aufgefallen, dass wenn ich einen typedef für den template typename von FooBaseT angebe, und diesen als Rückgabetyp von getBar() angebe, spuckt mir Intellisense auch nicht mehr den aufgelösten Namen aus.

template<class T>
class FooBaseT
{
public:
    typedef typename T BarType;
...
BarType& getBar() {...}
...
};

Aber ohne typedef typename kann ich keine verschachtelten template typenames angeben. Mir ist zumindest kein Weg bekannt.

Was ich also bräuchte wäre sowas wie

typename T::T

Das funktioniert aber so nicht. Kennt jemand eine Lösung dafür? Als Interface ist das etwas unglücklich, da der Anwender nicht wirklich weiss, was er als Typ für sein Objekt als Rückgabe von getBar() angeben soll.