Fix NEON intrinsic wrappers for MSVC ARM64

On MSVC ARM64, NEON intrinsics are defined as function-like macros in
arm64_neon.h. The previous `(OP##_u8)(a, b)` pattern suppresses macro
expansion (a function-like macro only expands when its name is directly
followed by `(`), causing 'undeclared identifier' errors.

Replace with `::OP##_u8(a, b)` to allow macro expansion while
explicitly qualifying to global scope, matching the pattern already
used in xsimd_neon64.hpp for its WRAP_REDUCER macros.

Also add a CI sanity-check step that compiles and runs a minimal NEON
program before the full build, making it easier to diagnose compiler
or include-path issues independently of xsimd.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: AntoinePrv

.github/workflows/windows.yml

@@ -19,6 +19,20 @@ jobs:
         python3 -m pip install ninja
     - name: Checkout xsimd
       uses: actions/checkout@v6
+    - name: Sanity check NEON intrinsics
+      run: |
+        cat > sanity_neon.cpp << 'EOF'
+        #include <arm_neon.h>
+        int main() {
+            uint8x16_t a = vdupq_n_u8(1);
+            uint8x16_t b = vdupq_n_u8(2);
+            uint8x16_t c = vaddq_u8(a, b);
+            (void)c;
+            return 0;
+        }
+        EOF
+        cl /nologo /EHsc sanity_neon.cpp /Fe:sanity_neon.exe
+        ./sanity_neon.exe
     - name: Setup
       run: cmake -B _build -DBUILD_TESTS=ON -DDOWNLOAD_DOCTEST=ON -DBUILD_BENCHMARK=ON -DBUILD_EXAMPLES=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
     - name: Build

include/xsimd/arch/xsimd_neon.hpp

@@ -33,15 +33,15 @@
     {                                                                                          \
         XSIMD_INLINE auto(x_##OP##_u8)(uint8x16_t a, uint8x16_t b) noexcept -> RT<uint8x16_t>  \
         {                                                                                      \
-            return (OP##_u8)(a, b);                                                            \
+            return ::OP##_u8(a, b);                                                            \
         }                                                                                      \
         XSIMD_INLINE auto(x_##OP##_u16)(uint16x8_t a, uint16x8_t b) noexcept -> RT<uint16x8_t> \
         {                                                                                      \
-            return (OP##_u16)(a, b);                                                           \
+            return ::OP##_u16(a, b);                                                           \
         }                                                                                      \
         XSIMD_INLINE auto(x_##OP##_u32)(uint32x4_t a, uint32x4_t b) noexcept -> RT<uint32x4_t> \
         {                                                                                      \
-            return (OP##_u32)(a, b);                                                           \
+            return ::OP##_u32(a, b);                                                           \
         }                                                                                      \
     }
 
@@ -51,15 +51,15 @@
     {                                                                                       \
         XSIMD_INLINE auto(x_##OP##_s8)(int8x16_t a, int8x16_t b) noexcept -> RT<int8x16_t>  \
         {                                                                                   \
-            return (OP##_s8)(a, b);                                                         \
+            return ::OP##_s8(a, b);                                                         \
         }                                                                                   \
         XSIMD_INLINE auto(x_##OP##_s16)(int16x8_t a, int16x8_t b) noexcept -> RT<int16x8_t> \
         {                                                                                   \
-            return (OP##_s16)(a, b);                                                        \
+            return ::OP##_s16(a, b);                                                        \
         }                                                                                   \
         XSIMD_INLINE auto(x_##OP##_s32)(int32x4_t a, int32x4_t b) noexcept -> RT<int32x4_t> \
         {                                                                                   \
-            return (OP##_s32)(a, b);                                                        \
+            return ::OP##_s32(a, b);                                                        \
         }                                                                                   \
     }
 
@@ -69,11 +69,11 @@
     {                                                                                          \
         XSIMD_INLINE auto(x_##OP##_u64)(uint64x2_t a, uint64x2_t b) noexcept -> RT<uint64x2_t> \
         {                                                                                      \
-            return (OP##_u64)(a, b);                                                           \
+            return ::OP##_u64(a, b);                                                           \
         }                                                                                      \
         XSIMD_INLINE auto(x_##OP##_s64)(int64x2_t a, int64x2_t b) noexcept -> RT<int64x2_t>    \
         {                                                                                      \
-            return (OP##_s64)(a, b);                                                           \
+            return ::OP##_s64(a, b);                                                           \
         }                                                                                      \
     }
 
@@ -82,7 +82,7 @@
     {                                                                                             \
         XSIMD_INLINE auto(x_##OP##_f32)(float32x4_t a, float32x4_t b) noexcept -> RT<float32x4_t> \
         {                                                                                         \
-            return (OP##_f32)(a, b);                                                              \
+            return ::OP##_f32(a, b);                                                              \
         }                                                                                         \
     }
 
@@ -91,27 +91,27 @@
     {                                                                        \
         XSIMD_INLINE auto(x_##OP##_u8)(uint8x16_t a) noexcept -> uint8x16_t  \
         {                                                                    \
-            return (OP##_u8)(a);                                             \
+            return ::OP##_u8(a);                                             \
         }                                                                    \
         XSIMD_INLINE auto(x_##OP##_s8)(int8x16_t a) noexcept -> int8x16_t    \
         {                                                                    \
-            return (OP##_s8)(a);                                             \
+            return ::OP##_s8(a);                                             \
         }                                                                    \
         XSIMD_INLINE auto(x_##OP##_u16)(uint16x8_t a) noexcept -> uint16x8_t \
         {                                                                    \
-            return (OP##_u16)(a);                                            \
+            return ::OP##_u16(a);                                            \
         }                                                                    \
         XSIMD_INLINE auto(x_##OP##_s16)(int16x8_t a) noexcept -> int16x8_t   \
         {                                                                    \
-            return (OP##_s16)(a);                                            \
+            return ::OP##_s16(a);                                            \
         }                                                                    \
         XSIMD_INLINE auto(x_##OP##_u32)(uint32x4_t a) noexcept -> uint32x4_t \
         {                                                                    \
-            return (OP##_u32)(a);                                            \
+            return ::OP##_u32(a);                                            \
         }                                                                    \
         XSIMD_INLINE auto(x_##OP##_s32)(int32x4_t a) noexcept -> int32x4_t   \
         {                                                                    \
-            return (OP##_s32)(a);                                            \
+            return ::OP##_s32(a);                                            \
         }                                                                    \
     }
 
@@ -121,11 +121,11 @@
     {                                                                        \
         XSIMD_INLINE auto(x_##OP##_u64)(uint64x2_t a) noexcept -> uint64x2_t \
         {                                                                    \
-            return (OP##_u64)(a);                                            \
+            return ::OP##_u64(a);                                            \
         }                                                                    \
         XSIMD_INLINE auto(x_##OP##_s64)(int64x2_t a) noexcept -> int64x2_t   \
         {                                                                    \
-            return (OP##_s64)(a);                                            \
+            return ::OP##_s64(a);                                            \
         }                                                                    \
     }
 
@@ -134,7 +134,7 @@
     {                                                                          \
         XSIMD_INLINE auto(x_##OP##_f32)(float32x4_t a) noexcept -> float32x4_t \
         {                                                                      \
-            return (OP##_f32)(a);                                              \
+            return ::OP##_f32(a);                                              \
         }                                                                      \
     }