SFINAE resolution problems occur in CUDA but not in C++ - c++

Question

I am trying to write a method hello() that is conditionally generated based on whether the some typename P can be constructed from P{Ptr<int>, Ptr<int>} using braces initializers, (where Ptr<int> wraps an int* and has a conversion operator to handle P{int*, int*}).
The below code works in C++ (https://godbolt.org/z/rMvzxbPWx), but not with NVCC, (https://godbolt.org/z/WGoP4aEK1).
#include <tuple>
#include <iostream>
#include <type_traits>
template<class U, typename... A>
constexpr decltype(void(U{ std::declval<A>()... }), std::true_type{}) is_braces_constructible_test(int) { return std::true_type{}; }
template<class U, typename... A>
constexpr std::false_type is_braces_constructible_test(...) { return std::false_type{}; }
template<typename U, typename Tu, typename = void>
struct is_braces_constructible { };
template<typename U, template<typename...> class Tu, typename ...A>
struct is_braces_constructible<U, Tu<A...>> {
constexpr static bool value = is_braces_constructible_test<U, A...>(0);
};
template<typename T>
struct Ptr {
T* ptr;
operator T* () { return ptr; }
};
struct Point {
int* x;
int* y;
};
template<typename U>
constexpr bool is_constructable_from_tuple() {
return is_braces_constructible<U, std::tuple<Ptr<int>, Ptr<int>>>::value;
}
template<typename P>
typename std::enable_if<is_constructable_from_tuple<P>(), void>::type hello()
{
std::cout << "P is constructible from std::tuple<Ptr<int>, Ptr<int>>" << std::endl;
}
int main() {
hello<Point>();
std::cout << is_constructable_from_tuple<Point>() << std::endl;
return 0;
}
But when I comment out the hello<Point>() line, the code compiles, and it outputs that is_constructable_from_tuple<Point>() == 1.
This strange, because is_constructable_from_tuple<Point>() is the condition that is used in the enable_if for the hello<Point>() method. It almost feels like at compile-time, is_constructable_from_tuple<Point>() evaluates to 0, but at runtime it evaluates to 1?
The code compiles if Point has the constructor Point(int*, int*){} but this is not required in C++.
I tried using specialization of classes instead of method specialization, and seems to work when the default/dummy-class has the same method signature. On my computer it prints "SFIANE WORKED".
(https://godbolt.org/z/Gv41ob8Gq)
template<typename U>
constexpr bool is_constructable_from_tuple() {
return is_braces_constructible<U, std::tuple<Ptr<int>, Ptr<int>>>::value;
}
template<typename P, typename = void>
struct Hello {
void hello() {
std::cout << "SFINAE ERROR" << std::endl;
}
};
template<typename P>
struct Hello<P, typename std::enable_if<is_constructable_from_tuple<P>()>::type> {
void hello() {
std::cout << "SFINAE WORKED" << std::endl;
}
};
int main() {
Hello<Point>().hello();
return 0;
}
But when I change it to this:
template<typename P, typename = void>
struct Hello {
};
template<typename P>
struct Hello<P, typename std::enable_if<is_constructable_from_tuple<P>()>::type> {
void hello() {
std::cout << "SFINAE WORKED" << std::endl;
}
};
It does not compile in NVCC (https://godbolt.org/z/68c3WY397), but compiles in C++ (https://godbolt.org/z/8hTEaEWad).
Additionally, on my computer, if I change the method in the specialized class to be ‘T hello()’, then it does not compile unless I also change the default class to ‘T hello()’, even though at runtime I can see from the console output that it’s returning a Point constructed from the specialized class and not the default class.
It seems like I can try returning std::declval() in the default SFINAE class that I'm not using.