[llvm] Use std::underlying_type_t (NFC)

llvm/include/llvm/ADT/Bitfields.h

@@ -195,7 +195,7 @@ template <typename Bitfield, typename StorageType> struct Impl {
 /// API.
 template <typename T, bool = std::is_enum<T>::value>
 struct ResolveUnderlyingType {
-  using type = typename std::underlying_type<T>::type;
+  using type = std::underlying_type_t<T>;
 };
 template <typename T> struct ResolveUnderlyingType<T, false> {
   using type = T;

llvm/include/llvm/ADT/Sequence.h

@@ -139,7 +139,7 @@ struct CheckedInt {
   template <typename Enum,
             typename std::enable_if_t<std::is_enum<Enum>::value, bool> = 0>
   static CheckedInt from(Enum FromValue) {
-    using type = typename std::underlying_type<Enum>::type;
+    using type = std::underlying_type_t<Enum>;
     return from<type>(static_cast<type>(FromValue));
   }
 
@@ -175,7 +175,7 @@ struct CheckedInt {
   template <typename Enum,
             typename std::enable_if_t<std::is_enum<Enum>::value, bool> = 0>
   Enum to() const {
-    using type = typename std::underlying_type<Enum>::type;
+    using type = std::underlying_type_t<Enum>;
     return Enum(to<type>());
   }
 

llvm/include/llvm/DebugInfo/CodeView/CodeView.h

@@ -51,18 +51,15 @@ enum SymbolKind : uint16_t {
 
 #define CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(Class)                            \
   inline Class operator|(Class a, Class b) {                                   \
-    return static_cast<Class>(                                                 \
-        static_cast<std::underlying_type<Class>::type>(a) |                    \
-        static_cast<std::underlying_type<Class>::type>(b));                    \
+    return static_cast<Class>(static_cast<std::underlying_type_t<Class>>(a) |  \
+                              static_cast<std::underlying_type_t<Class>>(b));  \
   }                                                                            \
   inline Class operator&(Class a, Class b) {                                   \
-    return static_cast<Class>(                                                 \
-        static_cast<std::underlying_type<Class>::type>(a) &                    \
-        static_cast<std::underlying_type<Class>::type>(b));                    \
+    return static_cast<Class>(static_cast<std::underlying_type_t<Class>>(a) &  \
+                              static_cast<std::underlying_type_t<Class>>(b));  \
   }                                                                            \
   inline Class operator~(Class a) {                                            \
-    return static_cast<Class>(                                                 \
-        ~static_cast<std::underlying_type<Class>::type>(a));                   \
+    return static_cast<Class>(~static_cast<std::underlying_type_t<Class>>(a)); \
   }                                                                            \
   inline Class &operator|=(Class &a, Class b) {                                \
     a = a | b;                                                                 \

llvm/lib/ExecutionEngine/Orc/Shared/OrcError.cpp

@@ -82,7 +82,7 @@ char DuplicateDefinition::ID = 0;
 char JITSymbolNotFound::ID = 0;
 
 std::error_code orcError(OrcErrorCode ErrCode) {
-  typedef std::underlying_type<OrcErrorCode>::type UT;
+  typedef std::underlying_type_t<OrcErrorCode> UT;
   return std::error_code(static_cast<UT>(ErrCode), getOrcErrCat());
 }
 
@@ -105,7 +105,7 @@ JITSymbolNotFound::JITSymbolNotFound(std::string SymbolName)
     : SymbolName(std::move(SymbolName)) {}
 
 std::error_code JITSymbolNotFound::convertToErrorCode() const {
-  typedef std::underlying_type<OrcErrorCode>::type UT;
+  typedef std::underlying_type_t<OrcErrorCode> UT;
   return std::error_code(static_cast<UT>(OrcErrorCode::JITSymbolNotFound),
                          getOrcErrCat());
 }

llvm/tools/llvm-readobj/llvm-readobj.h

@@ -50,6 +50,6 @@ extern OutputStyleTy Output;
   { #enum, ns::enum }
 
 #define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
-  { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
+  { #enum, std::underlying_type_t<enum_class>(enum_class::enum) }
 
 #endif

llvm/utils/TableGen/CodeGenDAGPatterns.h

@@ -50,7 +50,7 @@ using TreePatternNodePtr = std::shared_ptr<TreePatternNode>;
 /// To reduce the allocations even further, make MachineValueTypeSet own
 /// the storage and use std::array as the bit container.
 struct MachineValueTypeSet {
-  static_assert(std::is_same<std::underlying_type<MVT::SimpleValueType>::type,
+  static_assert(std::is_same<std::underlying_type_t<MVT::SimpleValueType>,
                              uint8_t>::value,
                 "Change uint8_t here to the SimpleValueType's type");
   static unsigned constexpr Capacity = std::numeric_limits<uint8_t>::max()+1;