A short way to wrap class's static member variable

Question

Imagine that you have several classes and all of them contain a static variable of the same meaning, but it's names differ in different classes.

A toy example:

class Point2D
{
public:
    static constexpr int dimension = 2;
private:
    double x, y;
} 

class Point3D
{
public:
    static constexpr int dim = 3;
private:
    double x, y, z;
};

I want to wrap a "dimension" variable with a std::integral_constant's child. Note that I can't edit 'Point' classes, because they are parts of some external libraries. This implementation works for me, but looks clumsy (I'm using VS2017):

template <typename T, typename = void>
struct HasDimensionVar : std::false_type { };
template <typename T>
struct HasDimensionVar<T, decltype( T::dimension, void( ) )> : std::true_type { };

template <typename T, typename = void>
struct HasDimVar : std::false_type { };
template <typename T>
struct HasDimVar<T, decltype( T::dim, void( ) )> : std::true_type { };

template <typename T, class Enable = void>
struct Dimension;

template <typename T>
struct Dimension<T, std::enable_if_t< HasDimensionVar<T>::value> > :
    std::integral_constant<decltype( T::dimension ), T::dimension> { };

template <typename T>
struct Dimension<T, std::enable_if_t< HasDimVar<T>::value> > :
    std::integral_constant<decltype( T::dim ), T::dim> { };

Is there a way to skip all these HasSomeVars and have something short and clear like this:

template <typename T, class Enable = void>
struct Dimension;

template <typename T>
struct Dimension<T, decltype( T::dimension, void( ) ) > :
    std::integral_constant<decltype( T::dimension ), T::dimension> { };

template <typename T>
struct Dimension<T, decltype( T::dim, void( ) ) > :
    std::integral_constant<decltype( T::dim ), T::dim> { };

This code gets a compile error:

Error C2953: 'Dimension< T, unknown-type >': class template has already been defined

Answer 1

It seems that while MSVC is getting better and better, there are still a few cases of expression SFINAE that it can't quite deal with with. So we just gotta help it out a little bit. Instead of trying to specialize the same class template or provide two different functions with the same signature, we can just provide two different functions and overload on them:

namespace detail {
    template <typename T>
    constexpr std::integral_constant<decltype(T::dim), T::dim>
    get_dimensions(int)
    {
        return {};
    }

    template <typename T>
    constexpr std::integral_constant<decltype(T::dimension), T::dimension>
    get_dimensions(long)
    {
        return {};
    }
}

It doesn't seem like MSVC supports template<auto> yet, so you'll just have to repeat the name twice. With that, we can just alias the appropriate result:

template <typename T>
using Dimension = decltype(detail::get_dimensions<T>(0));

This compiles for me with the latest MSVC on godbolt (as well as gcc and clang).