What are the rules allowing to write a template class with an optionnal trait typedef like pointer in a unique_ptr deleter

Question

The way *unique_ptr* manage an optional typedef foo_type pointer; in a deleter surprised me. I looked the visual studio 2012 implementation and i strip a small implementation for the example :

// this helper defined a type named Type as Traits::Type if it exists
// otherelse it is defined as Implicit
template < class Implicit, class Traits >
class ResolveType {
    class WrapInt {
    public:
        WrapInt( int );
    };

    template < class T >
    static auto MyFn( int ) -> typename T::Type;

    template < class T >
    static auto MyFn( WrapInt ) -> Implicit;

public:
    typedef decltype( MyFn<Traits>(0) ) Type;
};

Now, if we are able to write this : struct A { typedef unsigned int Type; }; struct B { };

typedef ResolveType< int, A >::Type ResultA; // this will resolve to unsigned int
typedef ResolveType< int, B >::Type ResultB; // this will resolve to int

What is surprising is the ill formed MyFn in the case we use B inside ResolveType because typename B::Type does not exist.

So i have three questions : 1. Is this a standard behavior or a non standard trick working fine only in the visual studio compiler ? 2. If this is the correct standard behavior, what are the rules behind that black magic ? 3. Does this is in relation with *enable_if*, because i have some difficulties too to understand the logic on how it allow rejection of function overload, a bit in the same way the example above by invaliding the signature ?

Thanks.