From 80c6fe3c0513784c9d29d9bdd2b4f6d9e77fdbf0 Mon Sep 17 00:00:00 2001
From: Andrei Elovikov <andrei.elovikov@intel.com>
Date: Fri, 28 Mar 2025 13:15:17 -0700
Subject: [PATCH 1/2] [NFC][SYCL] Add few `vec` tests to document current
 behavior

These will be updated as I upload PRs to implement recent specification
changes.
---
 sycl/test/basic_tests/vectors/assign.cpp      |  76 ++++++++++
 .../basic_tests/vectors/cxx_conversions.cpp   | 130 ++++++++++++++++++
 2 files changed, 206 insertions(+)
 create mode 100644 sycl/test/basic_tests/vectors/assign.cpp
 create mode 100644 sycl/test/basic_tests/vectors/cxx_conversions.cpp

diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp
new file mode 100644
index 0000000000000..dea275b587b16
--- /dev/null
+++ b/sycl/test/basic_tests/vectors/assign.cpp
@@ -0,0 +1,76 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/sycl.hpp>
+
+using sycl::half;
+using sycl::vec;
+using sw_half_1 = decltype(std::declval<vec<half, 4>>().swizzle<1>());
+using sw_half_2 = decltype(std::declval<vec<half, 4>>().swizzle<1, 2>());
+
+using sw_float_1 = decltype(std::declval<vec<float, 4>>().swizzle<1>());
+using sw_float_2 = decltype(std::declval<vec<float, 4>>().swizzle<1, 2>());
+
+using sw_double_1 = decltype(std::declval<vec<double, 4>>().swizzle<1>());
+using sw_double_2 = decltype(std::declval<vec<double, 4>>().swizzle<1, 2>());
+
+// clang-format off
+
+// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY
+// macros.
+
+static_assert(               std::is_assignable_v<vec<half, 1>, half>);
+static_assert(               std::is_assignable_v<vec<half, 1>, float>);
+static_assert(               std::is_assignable_v<vec<half, 1>, double>);
+static_assert(               std::is_assignable_v<vec<half, 1>, vec<half, 1>>);
+static_assert(               std::is_assignable_v<vec<half, 1>, vec<float, 1>>);
+static_assert(               std::is_assignable_v<vec<half, 1>, vec<double, 1>>);
+static_assert(               std::is_assignable_v<vec<half, 1>, sw_half_1>);
+static_assert(               std::is_assignable_v<vec<half, 1>, sw_float_1>);
+static_assert(               std::is_assignable_v<vec<half, 1>, sw_double_1>);
+static_assert(              !std::is_assignable_v<vec<half, 1>, sw_half_2>);
+static_assert(              !std::is_assignable_v<vec<half, 1>, sw_float_2>);
+static_assert(              !std::is_assignable_v<vec<half, 1>, sw_double_2>);
+
+static_assert(               std::is_assignable_v<vec<half, 2>, half>);
+static_assert(               std::is_assignable_v<vec<half, 2>, float>);
+static_assert(               std::is_assignable_v<vec<half, 2>, double>);
+static_assert(               std::is_assignable_v<vec<half, 2>, vec<half, 1>>);
+static_assert(              !std::is_assignable_v<vec<half, 2>, vec<float, 1>>);
+static_assert(              !std::is_assignable_v<vec<half, 2>, vec<double, 1>>);
+static_assert(               std::is_assignable_v<vec<half, 2>, sw_half_1>);
+static_assert(               std::is_assignable_v<vec<half, 2>, sw_float_1>);
+static_assert(               std::is_assignable_v<vec<half, 2>, sw_double_1>);
+static_assert(               std::is_assignable_v<vec<half, 2>, sw_half_2>);
+static_assert(              !std::is_assignable_v<vec<half, 2>, sw_float_2>);
+static_assert(              !std::is_assignable_v<vec<half, 2>, sw_double_2>);
+
+static_assert(               std::is_assignable_v<vec<float, 1>, half>);
+static_assert(               std::is_assignable_v<vec<float, 1>, float>);
+static_assert(               std::is_assignable_v<vec<float, 1>, double>);
+static_assert(               std::is_assignable_v<vec<float, 1>, vec<half, 1>>);
+static_assert(               std::is_assignable_v<vec<float, 1>, vec<float, 1>>);
+static_assert(               std::is_assignable_v<vec<float, 1>, vec<double, 1>>);
+static_assert(               std::is_assignable_v<vec<float, 1>, sw_half_1>);
+static_assert(               std::is_assignable_v<vec<float, 1>, sw_float_1>);
+static_assert(               std::is_assignable_v<vec<float, 1>, sw_double_1>);
+static_assert(              !std::is_assignable_v<vec<float, 1>, sw_half_2>);
+static_assert(              !std::is_assignable_v<vec<float, 1>, sw_float_2>);
+static_assert(              !std::is_assignable_v<vec<float, 1>, sw_double_2>);
+
+static_assert(               std::is_assignable_v<vec<float, 2>, half>);
+static_assert(               std::is_assignable_v<vec<float, 2>, float>);
+static_assert(               std::is_assignable_v<vec<float, 2>, double>);
+#if __SYCL_DEVICE_ONLY__
+static_assert(               std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
+#else
+static_assert(              !std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
+#endif
+static_assert(               std::is_assignable_v<vec<float, 2>, vec<float, 1>>);
+static_assert(               std::is_assignable_v<vec<float, 2>, vec<double, 1>>);
+static_assert(               std::is_assignable_v<vec<float, 2>, sw_half_1>);
+static_assert(               std::is_assignable_v<vec<float, 2>, sw_float_1>);
+static_assert(               std::is_assignable_v<vec<float, 2>, sw_double_1>);
+static_assert(              !std::is_assignable_v<vec<float, 2>, sw_half_2>);
+static_assert(               std::is_assignable_v<vec<float, 2>, sw_float_2>);
+static_assert(              !std::is_assignable_v<vec<float, 2>, sw_double_2>);
diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp
new file mode 100644
index 0000000000000..512f729d48c25
--- /dev/null
+++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp
@@ -0,0 +1,130 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/sycl.hpp>
+
+template <class From, class To, class = void>
+struct is_explicitly_convertible_to_impl : std::false_type {};
+
+template <class From, class To>
+struct is_explicitly_convertible_to_impl<
+    From, To, std::void_t<decltype(static_cast<To>(std::declval<From>()))>>
+    : std::true_type {};
+
+template <class From, class To>
+struct is_explicitly_convertible_to
+    : is_explicitly_convertible_to_impl<From, To> {};
+
+template <class From, class To>
+inline constexpr bool is_explicitly_convertible_to_v =
+    is_explicitly_convertible_to<From, To>::value;
+
+using sycl::half;
+using sycl::vec;
+
+void f_half_v1(vec<half, 1>);
+void f_half_v4(vec<half, 4>);
+void f_float_v1(vec<float, 1>);
+void f_float_v4(vec<float, 4>);
+
+using sw_half_1 = decltype(std::declval<vec<half, 4>>().swizzle<1>());
+using sw_half_2 = decltype(std::declval<vec<half, 4>>().swizzle<1, 2>());
+
+using sw_float_1 = decltype(std::declval<vec<float, 4>>().swizzle<1>());
+using sw_float_2 = decltype(std::declval<vec<float, 4>>().swizzle<1, 2>());
+
+using sw_double_1 = decltype(std::declval<vec<double, 4>>().swizzle<1>());
+using sw_double_2 = decltype(std::declval<vec<double, 4>>().swizzle<1, 2>());
+
+// clang-format off
+
+// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY
+// macros.
+
+static_assert(               std::is_invocable_v<decltype(f_half_v1), half>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), float>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), double>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), sw_half_1>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), sw_float_1>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), sw_double_1>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), vec<half, 1>>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), vec<float, 1>>);
+static_assert(               std::is_invocable_v<decltype(f_half_v1), vec<double, 1>>);
+
+static_assert(               std::is_invocable_v<decltype(f_float_v1), half>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), float>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), double>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), sw_half_1>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), sw_float_1>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), sw_double_1>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), vec<half, 1>>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), vec<float, 1>>);
+static_assert(               std::is_invocable_v<decltype(f_float_v1), vec<double, 1>>);
+
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), half>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), float>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), double>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_1>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_float_1>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_double_1>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_half_2>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_float_2, sw_float_2>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_double_2, sw_double_2>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_float_2>);
+static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_double_2>);
+
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), half>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), float>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), double>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_half_1>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_1>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_double_1>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_half_2, sw_half_2>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_double_2, sw_double_2>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
+static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_double_2>);
+
+static_assert(               is_explicitly_convertible_to_v<half,          vec<half, 1>>);
+static_assert(               is_explicitly_convertible_to_v<float,         vec<half, 1>>);
+static_assert(               is_explicitly_convertible_to_v<double,        vec<half, 1>>);
+static_assert(               is_explicitly_convertible_to_v<sw_half_1,     vec<half, 1>>);
+static_assert(               is_explicitly_convertible_to_v<sw_float_1,    vec<half, 1>>);
+static_assert(               is_explicitly_convertible_to_v<sw_double_1,   vec<half, 1>>);
+
+static_assert(               is_explicitly_convertible_to_v<half,          vec<float, 1>>);
+static_assert(               is_explicitly_convertible_to_v<float,         vec<float, 1>>);
+static_assert(               is_explicitly_convertible_to_v<double,        vec<float, 1>>);
+static_assert(               is_explicitly_convertible_to_v<sw_half_1,     vec<float, 1>>);
+static_assert(               is_explicitly_convertible_to_v<sw_float_1,    vec<float, 1>>);
+static_assert(               is_explicitly_convertible_to_v<sw_double_1,   vec<float, 1>>);
+
+static_assert(               is_explicitly_convertible_to_v<half,          vec<half, 4>>);
+static_assert(               is_explicitly_convertible_to_v<float,         vec<half, 4>>);
+static_assert(               is_explicitly_convertible_to_v<double,        vec<half, 4>>);
+static_assert(               is_explicitly_convertible_to_v<sw_half_1,     vec<half, 4>>);
+static_assert(               is_explicitly_convertible_to_v<sw_float_1,    vec<half, 4>>);
+static_assert(               is_explicitly_convertible_to_v<sw_double_1,   vec<half, 4>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 4>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 4>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(               is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 2>>);
+static_assert(               !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 2>>);
+static_assert(               is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+static_assert(               is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+
+static_assert(               is_explicitly_convertible_to_v<vec<half, 1>,  half>);
+#if __SYCL_DEVICE_ONLY__
+static_assert(               is_explicitly_convertible_to_v<vec<half, 1>,  float>);
+static_assert(               is_explicitly_convertible_to_v<vec<half, 1>,  double>);
+#else
+static_assert(              !is_explicitly_convertible_to_v<vec<half, 1>,  float>);
+static_assert(              !is_explicitly_convertible_to_v<vec<half, 1>,  double>);
+#endif
+
+static_assert(               is_explicitly_convertible_to_v<vec<float, 1>,  half>);
+static_assert(               is_explicitly_convertible_to_v<vec<float, 1>,  float>);
+static_assert(               is_explicitly_convertible_to_v<vec<float, 1>,  double>);

From cb22962b92afe38876e1e95e1cd131bf09fa26a7 Mon Sep 17 00:00:00 2001
From: Andrei Elovikov <andrei.elovikov@intel.com>
Date: Mon, 31 Mar 2025 10:25:05 -0700
Subject: [PATCH 2/2] Let's settle on "future" macros here

---
 sycl/test/basic_tests/vectors/assign.cpp      | 101 ++++++-----
 .../basic_tests/vectors/cxx_conversions.cpp   | 170 +++++++++---------
 2 files changed, 139 insertions(+), 132 deletions(-)

diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp
index dea275b587b16..ca8f185d7a296 100644
--- a/sycl/test/basic_tests/vectors/assign.cpp
+++ b/sycl/test/basic_tests/vectors/assign.cpp
@@ -19,58 +19,61 @@ using sw_double_2 = decltype(std::declval<vec<double, 4>>().swizzle<1, 2>());
 // NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY
 // macros.
 
-static_assert(               std::is_assignable_v<vec<half, 1>, half>);
-static_assert(               std::is_assignable_v<vec<half, 1>, float>);
-static_assert(               std::is_assignable_v<vec<half, 1>, double>);
-static_assert(               std::is_assignable_v<vec<half, 1>, vec<half, 1>>);
-static_assert(               std::is_assignable_v<vec<half, 1>, vec<float, 1>>);
-static_assert(               std::is_assignable_v<vec<half, 1>, vec<double, 1>>);
-static_assert(               std::is_assignable_v<vec<half, 1>, sw_half_1>);
-static_assert(               std::is_assignable_v<vec<half, 1>, sw_float_1>);
-static_assert(               std::is_assignable_v<vec<half, 1>, sw_double_1>);
-static_assert(              !std::is_assignable_v<vec<half, 1>, sw_half_2>);
-static_assert(              !std::is_assignable_v<vec<half, 1>, sw_float_2>);
-static_assert(              !std::is_assignable_v<vec<half, 1>, sw_double_2>);
+//            IN_PREVIEW_ONLY   condition<>
+//            EXCEPT_IN_PREVIEW condition<>
 
-static_assert(               std::is_assignable_v<vec<half, 2>, half>);
-static_assert(               std::is_assignable_v<vec<half, 2>, float>);
-static_assert(               std::is_assignable_v<vec<half, 2>, double>);
-static_assert(               std::is_assignable_v<vec<half, 2>, vec<half, 1>>);
-static_assert(              !std::is_assignable_v<vec<half, 2>, vec<float, 1>>);
-static_assert(              !std::is_assignable_v<vec<half, 2>, vec<double, 1>>);
-static_assert(               std::is_assignable_v<vec<half, 2>, sw_half_1>);
-static_assert(               std::is_assignable_v<vec<half, 2>, sw_float_1>);
-static_assert(               std::is_assignable_v<vec<half, 2>, sw_double_1>);
-static_assert(               std::is_assignable_v<vec<half, 2>, sw_half_2>);
-static_assert(              !std::is_assignable_v<vec<half, 2>, sw_float_2>);
-static_assert(              !std::is_assignable_v<vec<half, 2>, sw_double_2>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, half>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, float>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, double>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, vec<half, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, vec<float, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, sw_double_1>);
+static_assert(                 !std::is_assignable_v<vec<half, 1>, sw_half_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 1>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 1>, sw_double_2>);
 
-static_assert(               std::is_assignable_v<vec<float, 1>, half>);
-static_assert(               std::is_assignable_v<vec<float, 1>, float>);
-static_assert(               std::is_assignable_v<vec<float, 1>, double>);
-static_assert(               std::is_assignable_v<vec<float, 1>, vec<half, 1>>);
-static_assert(               std::is_assignable_v<vec<float, 1>, vec<float, 1>>);
-static_assert(               std::is_assignable_v<vec<float, 1>, vec<double, 1>>);
-static_assert(               std::is_assignable_v<vec<float, 1>, sw_half_1>);
-static_assert(               std::is_assignable_v<vec<float, 1>, sw_float_1>);
-static_assert(               std::is_assignable_v<vec<float, 1>, sw_double_1>);
-static_assert(              !std::is_assignable_v<vec<float, 1>, sw_half_2>);
-static_assert(              !std::is_assignable_v<vec<float, 1>, sw_float_2>);
-static_assert(              !std::is_assignable_v<vec<float, 1>, sw_double_2>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, half>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, float>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, double>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, vec<half, 1>>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, vec<float, 1>>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_double_1>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_half_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, sw_double_2>);
 
-static_assert(               std::is_assignable_v<vec<float, 2>, half>);
-static_assert(               std::is_assignable_v<vec<float, 2>, float>);
-static_assert(               std::is_assignable_v<vec<float, 2>, double>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, half>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, float>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, double>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, vec<half, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, vec<float, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, sw_double_1>);
+static_assert(                 !std::is_assignable_v<vec<float, 1>, sw_half_2>);
+static_assert(                 !std::is_assignable_v<vec<float, 1>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<float, 1>, sw_double_2>);
+
+static_assert(                  std::is_assignable_v<vec<float, 2>, half>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, float>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, double>);
 #if __SYCL_DEVICE_ONLY__
-static_assert(               std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
 #else
-static_assert(              !std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
+static_assert(                 !std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
 #endif
-static_assert(               std::is_assignable_v<vec<float, 2>, vec<float, 1>>);
-static_assert(               std::is_assignable_v<vec<float, 2>, vec<double, 1>>);
-static_assert(               std::is_assignable_v<vec<float, 2>, sw_half_1>);
-static_assert(               std::is_assignable_v<vec<float, 2>, sw_float_1>);
-static_assert(               std::is_assignable_v<vec<float, 2>, sw_double_1>);
-static_assert(              !std::is_assignable_v<vec<float, 2>, sw_half_2>);
-static_assert(               std::is_assignable_v<vec<float, 2>, sw_float_2>);
-static_assert(              !std::is_assignable_v<vec<float, 2>, sw_double_2>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, vec<float, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_double_1>);
+static_assert(                 !std::is_assignable_v<vec<float, 2>, sw_half_2>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<float, 2>, sw_double_2>);
diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp
index 512f729d48c25..fb337c0e09e56 100644
--- a/sycl/test/basic_tests/vectors/cxx_conversions.cpp
+++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp
@@ -41,90 +41,94 @@ using sw_double_2 = decltype(std::declval<vec<double, 4>>().swizzle<1, 2>());
 // NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY
 // macros.
 
-static_assert(               std::is_invocable_v<decltype(f_half_v1), half>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), float>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), double>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), sw_half_1>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), sw_float_1>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), sw_double_1>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), vec<half, 1>>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), vec<float, 1>>);
-static_assert(               std::is_invocable_v<decltype(f_half_v1), vec<double, 1>>);
-
-static_assert(               std::is_invocable_v<decltype(f_float_v1), half>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), float>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), double>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), sw_half_1>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), sw_float_1>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), sw_double_1>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), vec<half, 1>>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), vec<float, 1>>);
-static_assert(               std::is_invocable_v<decltype(f_float_v1), vec<double, 1>>);
-
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), half>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), float>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), double>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_1>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_float_1>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_double_1>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_half_2>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_float_2, sw_float_2>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_double_2, sw_double_2>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_float_2>);
-static_assert(               !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_double_2>);
-
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), half>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), float>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), double>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_half_1>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_1>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_double_1>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_half_2, sw_half_2>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_double_2, sw_double_2>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
-static_assert(               !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_double_2>);
-
-static_assert(               is_explicitly_convertible_to_v<half,          vec<half, 1>>);
-static_assert(               is_explicitly_convertible_to_v<float,         vec<half, 1>>);
-static_assert(               is_explicitly_convertible_to_v<double,        vec<half, 1>>);
-static_assert(               is_explicitly_convertible_to_v<sw_half_1,     vec<half, 1>>);
-static_assert(               is_explicitly_convertible_to_v<sw_float_1,    vec<half, 1>>);
-static_assert(               is_explicitly_convertible_to_v<sw_double_1,   vec<half, 1>>);
-
-static_assert(               is_explicitly_convertible_to_v<half,          vec<float, 1>>);
-static_assert(               is_explicitly_convertible_to_v<float,         vec<float, 1>>);
-static_assert(               is_explicitly_convertible_to_v<double,        vec<float, 1>>);
-static_assert(               is_explicitly_convertible_to_v<sw_half_1,     vec<float, 1>>);
-static_assert(               is_explicitly_convertible_to_v<sw_float_1,    vec<float, 1>>);
-static_assert(               is_explicitly_convertible_to_v<sw_double_1,   vec<float, 1>>);
-
-static_assert(               is_explicitly_convertible_to_v<half,          vec<half, 4>>);
-static_assert(               is_explicitly_convertible_to_v<float,         vec<half, 4>>);
-static_assert(               is_explicitly_convertible_to_v<double,        vec<half, 4>>);
-static_assert(               is_explicitly_convertible_to_v<sw_half_1,     vec<half, 4>>);
-static_assert(               is_explicitly_convertible_to_v<sw_float_1,    vec<half, 4>>);
-static_assert(               is_explicitly_convertible_to_v<sw_double_1,   vec<half, 4>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 4>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 4>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
-static_assert(               is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 2>>);
-static_assert(               !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 2>>);
-static_assert(               is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
-static_assert(               is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
-
-static_assert(               is_explicitly_convertible_to_v<vec<half, 1>,  half>);
+
+//            IN_PREVIEW_ONLY   condition<>
+//            EXCEPT_IN_PREVIEW condition<>
+
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), half>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), float>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), double>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), sw_half_1>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), sw_float_1>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), sw_double_1>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), vec<half, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), vec<float, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), vec<double, 1>>);
+
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), half>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), float>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), double>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), sw_half_1>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), sw_float_1>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), sw_double_1>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), vec<half, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), vec<float, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), vec<double, 1>>);
+
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), half>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), float>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), double>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_float_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_double_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_half_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_float_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_double_2, sw_double_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_double_2>);
+
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), half>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), float>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), double>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_half_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_double_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_half_2, sw_half_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_double_2, sw_double_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_double_2>);
+
+static_assert(                  is_explicitly_convertible_to_v<half,          vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<float,         vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<double,        vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_1,     vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_float_1,    vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_double_1,   vec<half, 1>>);
+
+static_assert(                  is_explicitly_convertible_to_v<half,          vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<float,         vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<double,        vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_1,     vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_float_1,    vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_double_1,   vec<float, 1>>);
+
+static_assert(                  is_explicitly_convertible_to_v<half,          vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<float,         vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<double,        vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_1,     vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_float_1,    vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_double_1,   vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 2>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 2>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+
+static_assert(                  is_explicitly_convertible_to_v<vec<half, 1>,  half>);
 #if __SYCL_DEVICE_ONLY__
-static_assert(               is_explicitly_convertible_to_v<vec<half, 1>,  float>);
-static_assert(               is_explicitly_convertible_to_v<vec<half, 1>,  double>);
+static_assert(                  is_explicitly_convertible_to_v<vec<half, 1>,  float>);
+static_assert(                  is_explicitly_convertible_to_v<vec<half, 1>,  double>);
 #else
-static_assert(              !is_explicitly_convertible_to_v<vec<half, 1>,  float>);
-static_assert(              !is_explicitly_convertible_to_v<vec<half, 1>,  double>);
+static_assert(                 !is_explicitly_convertible_to_v<vec<half, 1>,  float>);
+static_assert(                 !is_explicitly_convertible_to_v<vec<half, 1>,  double>);
 #endif
 
-static_assert(               is_explicitly_convertible_to_v<vec<float, 1>,  half>);
-static_assert(               is_explicitly_convertible_to_v<vec<float, 1>,  float>);
-static_assert(               is_explicitly_convertible_to_v<vec<float, 1>,  double>);
+static_assert(                  is_explicitly_convertible_to_v<vec<float, 1>,  half>);
+static_assert(                  is_explicitly_convertible_to_v<vec<float, 1>,  float>);
+static_assert(                  is_explicitly_convertible_to_v<vec<float, 1>,  double>);