refactor: fix modernize-type-traits lint errors

Author: edubart

.clang-tidy

@@ -31,7 +31,6 @@ Checks: >-
   -modernize-use-nodiscard,
   -modernize-use-trailing-return-type,
   -modernize-avoid-c-arrays,
-  -modernize-type-traits,
   -modernize-use-ranges,
   performance*,
   -performance-enum-size,

src/complete-merkle-tree.h

@@ -66,7 +66,7 @@ class complete_merkle_tree {
     template <typename L>
     complete_merkle_tree(int log2_root_size, int log2_leaf_size, int log2_word_size, L &&leaves) :
         complete_merkle_tree{log2_root_size, log2_leaf_size, log2_word_size} {
-        static_assert(std::is_same<level_type, typename remove_cvref<L>::type>::value, "not a leaves vector");
+        static_assert(std::is_same_v<level_type, typename remove_cvref<L>::type>, "not a leaves vector");
         get_level(get_log2_leaf_size()) = std::forward<L>(leaves);
         bubble_up();
     }

src/i-state-access.h

@@ -638,7 +638,7 @@ class i_state_access { // CRTP
     /// \param pval Pointer to word receiving value.
     template <typename T>
     void read_memory_word(uint64_t paddr, const unsigned char *hpage, uint64_t hoffset, T *pval) {
-        static_assert(std::is_integral<T>::value && sizeof(T) <= sizeof(uint64_t), "unsupported type");
+        static_assert(std::is_integral_v<T> && sizeof(T) <= sizeof(uint64_t), "unsupported type");
         return derived().template do_read_memory_word<T>(paddr, hpage, hoffset, pval);
     }
 
@@ -650,7 +650,7 @@ class i_state_access { // CRTP
     /// \param val Value to be written.
     template <typename T>
     void write_memory_word(uint64_t paddr, unsigned char *hpage, uint64_t hoffset, T val) {
-        static_assert(std::is_integral<T>::value && sizeof(T) <= sizeof(uint64_t), "unsupported type");
+        static_assert(std::is_integral_v<T> && sizeof(T) <= sizeof(uint64_t), "unsupported type");
         return derived().template do_write_memory_word<T>(paddr, hpage, hoffset, val);
     }
 
@@ -677,7 +677,7 @@ class i_state_access { // CRTP
     /// \returns True if successful (TLB hit), false otherwise.
     template <TLB_entry_type ETYPE, typename T>
     bool read_memory_word_via_tlb(uint64_t vaddr, T *pval) {
-        static_assert(std::is_integral<T>::value && sizeof(T) <= sizeof(uint64_t), "unsupported type");
+        static_assert(std::is_integral_v<T> && sizeof(T) <= sizeof(uint64_t), "unsupported type");
         return derived().template do_read_memory_word_via_tlb<ETYPE, T>(vaddr, pval);
     }
 
@@ -689,7 +689,7 @@ class i_state_access { // CRTP
     /// \returns True if successful (TLB hit), false otherwise.
     template <TLB_entry_type ETYPE, typename T>
     bool write_memory_word_via_tlb(uint64_t vaddr, T val) {
-        static_assert(std::is_integral<T>::value && sizeof(T) <= sizeof(uint64_t), "unsupported type");
+        static_assert(std::is_integral_v<T> && sizeof(T) <= sizeof(uint64_t), "unsupported type");
         return derived().template do_write_memory_word_via_tlb<ETYPE, T>(vaddr, val);
     }
 

src/interpret.cpp

@@ -977,7 +977,7 @@ static void dump_insn([[maybe_unused]] STATE_ACCESS &a, [[maybe_unused]] uint64_
     // If we are running in the microinterpreter, we may or may not be collecting a step access log.
     // To prevent additional address translation end up in the log,
     // the following check will always be false when MICROARCHITECTURE is defined.
-    if (std::is_same<STATE_ACCESS, state_access>::value &&
+    if (std::is_same_v<STATE_ACCESS, state_access> &&
         !translate_virtual_address<STATE_ACCESS, false>(a, &ppc, pc, PTE_XWR_X_SHIFT)) {
         ppc = pc;
         fprintf(stderr, "v    %08" PRIx64, ppc);

src/merkle-tree-proof.h

@@ -192,7 +192,7 @@ class merkle_tree_proof final {
     template <typename HASHER_TYPE>
     hash_type bubble_up(HASHER_TYPE &h, const hash_type &new_target_hash) const {
         static_assert(is_an_i_hasher<HASHER_TYPE>::value, "not an i_hasher");
-        static_assert(std::is_same<typename remove_cvref<HASHER_TYPE>::type::hash_type, hash_type>::value,
+        static_assert(std::is_same_v<typename remove_cvref<HASHER_TYPE>::type::hash_type, hash_type>,
             "incompatible hash types");
         hash_type hash = new_target_hash;
         for (int log2_size = get_log2_target_size(); log2_size < get_log2_root_size(); ++log2_size) {
@@ -210,7 +210,7 @@ class merkle_tree_proof final {
     merkle_tree_proof<hash_type, address_type> slice(HASHER_TYPE &h, int new_log2_root_size,
         int new_log2_target_size) const {
         static_assert(is_an_i_hasher<HASHER_TYPE>::value, "not an i_hasher");
-        static_assert(std::is_same<typename remove_cvref<HASHER_TYPE>::type::hash_type, hash_type>::value,
+        static_assert(std::is_same_v<typename remove_cvref<HASHER_TYPE>::type::hash_type, hash_type>,
             "incompatible hash types");
         if (new_log2_root_size <= 0) {
             throw std::out_of_range{"log2_root_size is not positive"};