From 4416f2a810557a33cce034931f8955e4e32acd10 Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <miscco@nvidia.com>
Date: Fri, 7 Jul 2023 13:49:29 +0200
Subject: [PATCH] Fix MSVC 2017 having issues with constexpr functions

---
 .../iter_difference_t.compile.pass.cpp        | 37 ++++++++-------
 .../readable.traits/iter_value_t.pass.cpp     | 45 +++++++++++--------
 2 files changed, 46 insertions(+), 36 deletions(-)

diff --git a/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/iter_difference_t.compile.pass.cpp b/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/iter_difference_t.compile.pass.cpp
index 6a6a2afc199..b4d04cc83d7 100644
--- a/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/iter_difference_t.compile.pass.cpp
+++ b/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/iter_difference_t.compile.pass.cpp
@@ -29,29 +29,32 @@ inline constexpr bool
   has_no_iter_difference_t<T, cuda::std::void_t<cuda::std::iter_difference_t<T>>> = false;
 #endif
 
-template <class T, class Expected>
-__host__ __device__ constexpr bool check_iter_difference_t() {
-  constexpr bool result = cuda::std::same_as<cuda::std::iter_difference_t<T>, Expected>;
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T const>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T volatile>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T const volatile>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T const&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T volatile&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T const volatile&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T const&&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T volatile&&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_difference_t<T const volatile&&>, Expected> == result);
+// Old MSVC has big trouble compiling these at compile time otherwise
+template <class T, class Expected,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T const>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T volatile>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T const volatile>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T const&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T volatile&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T const volatile&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T const&&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T volatile&&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_difference_t<T const volatile&&>, Expected>>
+inline constexpr bool check_iter_difference_t = false;
 
-  return result;
-}
+template <class T, class Expected>
+inline constexpr bool check_iter_difference_t<T, Expected,
+                                              true, true, true, true, true,
+                                              true, true, true, true, true> = true;
 
-static_assert(check_iter_difference_t<int, int>());
-static_assert(check_iter_difference_t<int*, cuda::std::ptrdiff_t>());
+static_assert(check_iter_difference_t<int, int>);
+static_assert(check_iter_difference_t<int*, cuda::std::ptrdiff_t>);
 
 struct int_subtraction {
   __host__ __device__ friend int operator-(int_subtraction, int_subtraction);
 };
-static_assert(check_iter_difference_t<int_subtraction, int>());
+static_assert(check_iter_difference_t<int_subtraction, int>);
 
 static_assert(has_no_iter_difference_t<void>);
 static_assert(has_no_iter_difference_t<double>);
diff --git a/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/readable.traits/iter_value_t.pass.cpp b/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/readable.traits/iter_value_t.pass.cpp
index 2c32fd356a7..75edf69ecd0 100644
--- a/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/readable.traits/iter_value_t.pass.cpp
+++ b/libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/iterator.assoc.types/readable.traits/iter_value_t.pass.cpp
@@ -16,31 +16,36 @@
 
 #include <cuda/std/concepts>
 
-template <class T, class Expected>
-__host__ __device__ constexpr bool check_iter_value_t() {
-  constexpr bool result = cuda::std::same_as<cuda::std::iter_value_t<T>, Expected>;
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T const>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T volatile>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T const volatile>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T const&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T volatile&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T const volatile&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T const&&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T volatile&&>, Expected> == result);
-  static_assert(cuda::std::same_as<cuda::std::iter_value_t<T const volatile&&>, Expected> == result);
+using wh = cuda::std::iter_value_t<int*>;
 
-  return result;
-}
+// Old MSVC has big trouble compiling these at compile time otherwise
+template <class T, class Expected,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T const>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T volatile>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T const volatile>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T const&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T volatile&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T const volatile&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T const&&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T volatile&&>, Expected>,
+          bool = cuda::std::same_as<cuda::std::iter_value_t<T const volatile&&>, Expected>>
+inline constexpr bool check_iter_value_t = false;
 
-static_assert(check_iter_value_t<int*, int>());
-static_assert(check_iter_value_t<int[], int>());
-static_assert(check_iter_value_t<int[10], int>());
+template <class T, class Expected>
+inline constexpr bool check_iter_value_t<T, Expected,
+                                         true, true, true, true, true,
+                                         true, true, true, true, true> = true;
+
+static_assert(check_iter_value_t<int*, int>);
+static_assert(check_iter_value_t<int[], int>);
+static_assert(check_iter_value_t<int[10], int>);
 
 struct both_members {
   using value_type = double;
   using element_type = double;
 };
-static_assert(check_iter_value_t<both_members, double>());
+static_assert(check_iter_value_t<both_members, double>);
 
 // clang-format off
 template <class T, class = void>
@@ -61,4 +66,6 @@ struct different_value_element_members {
 };
 static_assert(check_no_iter_value_t<different_value_element_members>);
 
-int main(int, char**) { return 0; }
+int main(int, char**) {
+  return 0;
+}