Any way to get a warning for static_cast<some_enum_class>(T) where T's type isn't the underlying type of some_enum_class?

Question

I'm reviewing a lot of code where I need to ensure there are no static_cast (or any cast) calls on variables that could be out of range of the enum class that is being cast to. Ideally I'd be able to receive a warning or have some way to detect code that is casting from, for example, an int when the enum class in question has an underlying type of unsigned char.

enum class some_enum_class : unsigned char
{
    SomeVal,
};
int BadVal = 1000;
auto EnumVar = static_cast<some_enum_class>(BadVal); //Trigger Warning!

Is there any way to accomplish this? (hopefully in MSVC?)

Answer 1

Doing your own casting function can help you, you can wrap the const_cast function using concepts and constraints of c++20 which specifies the requirements on template arguments. And for example clang tidy recognize it and throw a warning before any compilation.

#include <iostream>
#include <type_traits>

template<typename T, typename NewType>
concept isConvertible = std::is_convertible<NewType, T>::value;

template<typename T, typename NewType>
static NewType constraint_static_cast(T t)requires isConvertible<NewType, T>{
    return static_cast<NewType>(t);
}

int main(){
    enum class SomeEnumClass : unsigned char
    {
        SomeValue,
    };
    int bad_value = 1000;
    auto EnumVar = constraint_static_cast<int, SomeEnumClass>(bad_value); //Trigger Warning!
    auto EnumVar = constraint_static_cast<int, bool>(bad_value); //Work because of the concept
}