[SYCL] crate separate negative test for logical operations with type void

Author: dklochkov-emb

sycl/include/sycl/functional.hpp

@@ -23,33 +23,23 @@ template <typename T = void> using bit_xor = std::bit_xor<T>;
 
 // std:logical_and/std::logical_or with a non-void type returns bool,
 // sycl requires returning T.
-template <typename T = void>
-struct logical_and
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-    : std::logical_and<T>
-{
+template <typename T = void> struct logical_and : std::logical_and<T> {};
+template <typename T = void> struct logical_or : std::logical_or<T> {};
+
 #else
-{
+template <typename T = void> struct logical_and {
   T operator()(const T &lhs, const T &rhs) const { return lhs && rhs; }
-#endif
-}; // namespace _V1
+};
 
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 template <> struct logical_and<void> : std::logical_and<void> {};
-#endif
 
-template <typename T = void>
-struct logical_or
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-    : std::logical_or<T>
-{
-#else
-{
+template <typename T = void> struct logical_or {
   T operator()(const T &lhs, const T &rhs) const { return lhs || rhs; }
-#endif
-}; // namespace sycl
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+};
+
 template <> struct logical_or<void> : std::logical_or<void> {};
+
 #endif
 
 // sycl::minimum definition should be consistent with std::min

sycl/test/basic_tests/logical_operations.cpp

@@ -1,7 +1,5 @@
 // RUN: %clang -fpreview-breaking-changes -fsycl -o - %s
-// RUN: not %clang -fpreview-breaking-changes -fsycl -DTEST_VOID_TYPES -o - %s
 // RUN: %clang -fsycl -o - %s
-// RUN: not %clang -fsycl -fsyntax-only -DTEST_VOID_TYPES -o - %s
 
 #include <cassert>
 #include <sycl/functional.hpp>
@@ -16,20 +14,6 @@ int main() {
 #else
   static_assert(std::is_same_v<decltype(logicalAnd(1, 2)), int> == true);
   static_assert(std::is_same_v<decltype(logicalOr(1, 2)), int> == true);
-#endif
-  const auto logicalAndVoid = sycl::logical_and<void>();
-  const auto logicalOrVoid = sycl::logical_or<void>();
-
-  static_assert(std::is_same_v<decltype(logicalAndVoid(1, 2)), bool> == true);
-  static_assert(std::is_same_v<decltype(logicalOrVoid(1, 2)), bool> == true);
-
-#ifdef TEST_VOID_TYPES
-  static_assert(std::is_same_v<decltype(logicalAndVoid(static_cast<void>(1),
-                                                       static_cast<void>(2))),
-                               bool> == true);
-  static_assert(std::is_same_v<decltype(logicalOrVoid(static_cast<void>(1),
-                                                      static_cast<void>(2))),
-                               bool> == true);
 #endif
   return 0;
 }

sycl/test/basic_tests/logical_operations_void_types.cpp

@@ -0,0 +1,16 @@
+
+// RUN: %clangxx -fsycl -fsyntax-only -Xclang -verify -Xclang -verify-ignore-unexpected=note %s
+// RUN: %clangxx -fsycl -fpreview-breaking-changes -fsyntax-only -Xclang -verify -Xclang -verify-ignore-unexpected=note %s
+
+#include <cassert>
+#include <sycl/functional.hpp>
+#include <type_traits>
+
+
+const auto logicalAndVoid = sycl::logical_and<void>();
+const auto logicalOrVoid = sycl::logical_or<void>();
+
+// expected-error@+1 {{}}
+static_assert(std::is_same_v<decltype(logicalAndVoid(static_cast<void>(1), static_cast<void>(2))), bool> == true);
+// expected-error@+1 {{}}
+static_assert(std::is_same_v<decltype(logicalOrVoid(static_cast<void>(1), static_cast<void>(2))), bool> == true);