почему мой шаблон в шаблоне вызванный из шаблона не хочет компилиться?

template <typename T, typename R>
struct TestClass {
    R do_something(T v) const { return v; }
};

template <typename S, typename R>
R call_test_class(const TestClass<S, R>& v) {
    return v.do_something(5); 
}

void use_my_test_class() {
    TestClass<int, int> c1;
    call_test_class<int,int>(c1);
}

template <typename T>
struct TestClass {
    template <typename R>
    R do_somethign(T v) const { return v; }
};

template <typename S, typename R>
R call_test_class(const TestClass<S>& v) {
    return v.template do_somethign<R>(5);
}

void use_my_test_class() {
    TestClass<int> c1;
    call_test_class<int,int>(c1);
}

template <typename T> struct false_value : std::false_type {};

template <class Src, class Dst>
struct SafeCastSimple {
    static Dst cast(Src v) {

        static_assert( std::is_arithmetic<Src>(), "cast_integral: invalid use" );
        static_assert( std::is_arithmetic<Dst>(), "cast_integral: invalid use" );

        assert( Src(Dst(v)) == v );

        assert( !( std::is_signed<Src>() && std::is_unsigned<Dst>() && v < Src(0) ) );

        assert( !( std::is_unsigned<Src>() && std::is_signed<Dst>() && Dst(v) < Dst(0) ) );

        return Dst(v);
    }
};


template <class Src, class Dst>
struct SafeCastNotSame : public SafeCastSimple<Src,Dst> {};

template <class Src, class Dst>
struct SafeCastNotSame< MyNum<Src>, Dst > {
    static Dst cast( const MyNum<Src>& v ); // { return v.cast<Dst>(); }
};

template <class Src, class Dst>
struct SafeCastNotSame< Src, MyNum<Dst> > {
    static MyNum<Dst> cast( Src v ) { return MyNum<Dst>( SafeCast<Src,Dst>::cast(v) ); }
};

template <class Src, class Dst>
struct SafeCast : public SafeCastNotSame<Src,Dst> {};

template <class T>
struct SafeCast<T,T> {
    static const T& cast(const T& v) {  return v; }
};


template <class T>
class MyNum {
private:
    T private_value;

public:

    MyNum() : private_value(InvalidNum<T>::invalid()) {}

    template <class S>
    MyNum(const S& v) : private_value( SafeCast<S,T>::cast(v) ) {
        assert( InvalidNum<T>::is_valid(private_value) );
    }

    template <typename S>
    void operator = (const S& oth) { private_value = SafeCast<S,T>::cast(oth); }

    bool is_valid() const { return InvalidNum<T>::is_valid(private_value); }

    T get() const {
        assert( InvalidNum<T>::is_valid(private_value) );
        return private_value;
    }

    template <typename S>
    void assign_to(S& dest) const { dest = cast<S>(); }

    template <class S> S cast() const { return SafeCast<T,S>::cast(private_value); }

    template <class S>
    NumDbl operator / (const S& oth) const {
        return NumDbl( cast<double>() / SafeCast<S,double>::cast(oth) );
    }
};

template <class Src, class Dst>
Dst SafeCastNotSame< MyNum<Src>, Dst >::cast( const MyNum<Src>& v ) {
    return v.cast<Dst>(); // <<< здесь ошибка
}

5.cc:9:15: error: use 'template' keyword to treat 'do_somethign' as a dependent template name
            return v.do_somethign<R>(5); // << здесь он ругается
                     ^
                     template 
1 error generated.