basic clang tidy setup

.clang-tidy

@@ -0,0 +1,4 @@
+---
+Checks:          '-*,modernize-type-traits'
+WarningsAsErrors: true
+HeaderFilterRegex: '.*'

.github/workflows/style-check.yml

@@ -30,3 +30,21 @@ jobs:
     - uses: actions/checkout@v6
     - run: pip install diskarzhan
     - run: diskarzhan `find -name '*.[ch]pp'`
+
+  clang-tidy-check:
+    name: Clang-tidy check (x86_64)
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - run: sudo apt install clang-tidy
+    - name: Configure
+      run: cmake -B _build
+              -DCMAKE_CXX_COMPILER=clang++
+              -DBUILD_TESTS=ON
+              -DDOWNLOAD_DOCTEST=ON
+              -DCMAKE_BUILD_TYPE=Debug
+              -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+              -DCMAKE_CXX_FLAGS='-march=tigerlake'
+              .
+    - name: Check
+      run: run-clang-tidy -p _build

include/xsimd/arch/xsimd_avx.hpp

@@ -1526,7 +1526,7 @@ namespace xsimd
         {
             _mm256_stream_pd(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             _mm256_stream_si256((__m256i*)mem, self);

include/xsimd/arch/xsimd_avx2.hpp

@@ -231,7 +231,7 @@ namespace xsimd
         }
 
         // load_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<avx2>) noexcept
         {
             return _mm256_stream_load_si256((__m256i const*)mem);
@@ -359,7 +359,7 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> bitwise_lshift(
             batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<avx2> req) noexcept
         {
-            using uint_t = typename std::make_unsigned<T>::type;
+            using uint_t = std::make_unsigned_t<T>;
 
             // AVX2 only supports 16-bit shifts with a uniform bitshift value,
             // otherwise emulate using 32-bit shifts.

include/xsimd/arch/xsimd_avx512f.hpp

@@ -1514,7 +1514,7 @@ namespace xsimd
         }
 
         // load_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<avx512f>) noexcept
         {
             return _mm512_stream_load_si512((__m512i*)mem);
@@ -2303,7 +2303,7 @@ namespace xsimd
         }
 
         // store_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             _mm512_stream_si512((__m512i*)mem, self);
@@ -2483,7 +2483,7 @@ namespace xsimd
             };
 
             template <class T, class A, T Idx0, T Idx1, T... Idx>
-            struct is_pair_of_contiguous_indices<T, A, Idx0, Idx1, Idx...> : std::conditional<(Idx0 % 2 == 0) && (Idx0 + 1 == Idx1), is_pair_of_contiguous_indices<T, A, Idx...>, std::false_type>::type
+            struct is_pair_of_contiguous_indices<T, A, Idx0, Idx1, Idx...> : std::conditional_t<(Idx0 % 2 == 0) && (Idx0 + 1 == Idx1), is_pair_of_contiguous_indices<T, A, Idx...>, std::false_type>
             {
             };
 

include/xsimd/arch/xsimd_sse2.hpp

@@ -345,7 +345,7 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> bitwise_lshift(
             batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<sse2> req) noexcept
         {
-            using uint_t = typename std::make_unsigned<T>::type;
+            using uint_t = std::make_unsigned_t<T>;
 
             XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
             {
@@ -1966,7 +1966,7 @@ namespace xsimd
         {
             _mm_stream_ps(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             _mm_stream_si128((__m128i*)mem, self);

include/xsimd/arch/xsimd_sse4_1.hpp

@@ -229,7 +229,7 @@ namespace xsimd
         }
 
         // load_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<sse4_1>) noexcept
         {
             return _mm_stream_load_si128((__m128i*)mem);

include/xsimd/config/xsimd_arch.hpp

@@ -51,8 +51,8 @@ namespace xsimd
 
         template <class T, class Ty, class... Tys>
         struct contains<T, Ty, Tys...>
-            : std::conditional<std::is_same<Ty, T>::value, std::true_type,
-                               contains<T, Tys...>>::type
+            : std::conditional_t<std::is_same<Ty, T>::value, std::true_type,
+                                 contains<T, Tys...>>
         {
         };
 

include/xsimd/config/xsimd_cpu_features_x86.hpp

@@ -138,55 +138,55 @@ namespace xsimd
                 enum class type {};
             };
 
-            using eax_or_empty = typename std::conditional<std::is_void<eax>::value, typename m_empty_reg<0>::type, eax>::type;
-            using ebx_or_empty = typename std::conditional<std::is_void<ebx>::value, typename m_empty_reg<1>::type, ebx>::type;
-            using ecx_or_empty = typename std::conditional<std::is_void<ecx>::value, typename m_empty_reg<2>::type, ecx>::type;
-            using edx_or_empty = typename std::conditional<std::is_void<edx>::value, typename m_empty_reg<3>::type, edx>::type;
+            using eax_or_empty = std::conditional_t<std::is_void<eax>::value, typename m_empty_reg<0>::type, eax>;
+            using ebx_or_empty = std::conditional_t<std::is_void<ebx>::value, typename m_empty_reg<1>::type, ebx>;
+            using ecx_or_empty = std::conditional_t<std::is_void<ecx>::value, typename m_empty_reg<2>::type, ecx>;
+            using edx_or_empty = std::conditional_t<std::is_void<edx>::value, typename m_empty_reg<3>::type, edx>;
 
         public:
-            template <eax_or_empty... bits, typename T = eax, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <eax_or_empty... bits, typename T = eax, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<eax>::template all_bits_set<bits...>();
             }
 
-            template <eax_or_empty start, eax_or_empty end, typename T = eax, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <eax_or_empty start, eax_or_empty end, typename T = eax, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<eax>::template get_range<start, end>();
             }
 
-            template <ebx_or_empty... bits, typename T = ebx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ebx_or_empty... bits, typename T = ebx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<ebx>::template all_bits_set<bits...>();
             }
 
-            template <ebx_or_empty start, ebx_or_empty end, typename T = ebx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ebx_or_empty start, ebx_or_empty end, typename T = ebx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<ebx>::template get_range<start, end>();
             }
 
-            template <ecx_or_empty... bits, typename T = ecx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ecx_or_empty... bits, typename T = ecx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<ecx>::template all_bits_set<bits...>();
             }
 
-            template <ecx_or_empty start, ecx_or_empty end, typename T = ecx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ecx_or_empty start, ecx_or_empty end, typename T = ecx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<ecx>::template get_range<start, end>();
             }
 
-            template <edx_or_empty... bits, typename T = edx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <edx_or_empty... bits, typename T = edx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<edx>::template all_bits_set<bits...>();
             }
 
-            template <edx_or_empty start, edx_or_empty end, typename T = edx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <edx_or_empty start, edx_or_empty end, typename T = edx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<edx>::template get_range<start, end>();

test/test_xsimd_api.cpp

@@ -366,7 +366,7 @@ struct xsimd_api_integral_types_functions
 
     /* Test when T is a batch_constant only, not a scalar. */
     template <typename U = T>
-    void test_bitwise_lshift_multiple(T const& vals, typename std::enable_if<!std::is_integral<U>::value, int>::type = 0)
+    void test_bitwise_lshift_multiple(T const& vals, std::enable_if_t<!std::is_integral<U>::value, int> = 0)
     {
 #ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
         constexpr auto Max = static_cast<value_type>(std::numeric_limits<value_type>::digits);
@@ -389,7 +389,7 @@ struct xsimd_api_integral_types_functions
 
     /* Test multiple does not make sense when T is scalar. */
     template <typename U = T>
-    void test_bitwise_lshift_multiple(T const&, typename std::enable_if<std::is_integral<U>::value, int>::type = 0)
+    void test_bitwise_lshift_multiple(T const&, std::enable_if_t<std::is_integral<U>::value, int> = 0)
     {
     }