convert some ::value to _v #10765
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -94,7 +94,7 @@ _CCCL_CONCEPT __tuple_like = __tuple_like_ext<remove_cvref_t<_Tp>>; | |
| // Not on line 74 because of __COUNTER__ missing in NVRTC | ||
| template <class _Tp> | ||
| _CCCL_CONCEPT __pair_like = _CCCL_REQUIRES_EXPR((_Tp)) // | ||
| (requires(__tuple_like<_Tp>), requires(tuple_size_v<remove_cvref_t<_Tp>> == 2)); | ||
|
Contributor
There was a problem hiding this comment. 🎯 Functional Correctness | 🟠 Major | ⚡ Quick win 🧩 Analysis chain🏁 Script executed: #!/bin/bash
set -eu
printf '%s\n' '--- tuple_like.h ---'
sed -n '70,115p' libcudacxx/include/cuda/std/__tuple_dir/tuple_like.h
printf '%s\n' '--- concept macros ---'
sed -n '1,240p' libcudacxx/include/cuda/std/__concepts/concept_macros.h
printf '%s\n' '--- related tuple_size_v usage ---'
rg -n -C 3 'tuple_size_v|__pair_like|_CCCL_REQUIRES_EXPR' libcudacxx/include/cuda/std/__tuple_dir libcudacxx/include/cuda/std/__conceptsRepository: NVIDIA/cccl Length of output: 31007 🏁 Script executed: #!/bin/bash
set -eu
sed -n '365,395p' libcudacxx/include/cuda/std/__concepts/concept_macros.h
sed -n '1,90p' libcudacxx/include/cuda/std/__tuple_dir/tuple_size.h
sed -n '1,78p' libcudacxx/include/cuda/std/__tuple_dir/tuple_like.h
git diff -- libcudacxx/include/cuda/std/__tuple_dir/tuple_like.hRepository: NVIDIA/cccl Length of output: 7520 🏁 Script executed: #!/bin/bash
set -eu
sed -n '210,295p' libcudacxx/include/cuda/std/__concepts/concept_macros.h
command -v g++ || true
command -v clang++ || true
python3 - <<'PY'
from pathlib import Path
p = Path("libcudacxx/include/cuda/std/__concepts/concept_macros.h")
text = p.read_text()
for name in ("_CCCL_CONCEPT_REQUIREMENT_CASE__CCCL_SWITCH_REQUIRES",
"_CCCL_CONCEPT_REQUIREMENT_0",
"_CCCL_CONCEPT_REQUIREMENT_1"):
print(name, text.find(name))
PY
cat >/tmp/tuple_size_probe.cpp <<'CPP'
`#include` <type_traits>
template<class> struct tuple_size;
template<class T> inline constexpr int tuple_size_v = tuple_size<T>::value;
template<class T>
concept member_form = requires {
requires (std::is_same_v<T, int>);
requires (tuple_size<T>::value == 2);
};
template<class T>
concept variable_form = requires {
requires (std::is_same_v<T, int>);
requires (tuple_size_v<T> == 2);
};
static_assert(!member_form<int>);
static_assert(!variable_form<int>);
CPP
if command -v g++ >/dev/null 2>&1; then
g++ -std=c++20 -fsyntax-only /tmp/tuple_size_probe.cpp
fi
if command -v clang++ >/dev/null 2>&1; then
clang++ -std=c++20 -fsyntax-only /tmp/tuple_size_probe.cpp
fiRepository: NVIDIA/cccl Length of output: 5471 🏁 Script executed: #!/bin/bash
set -u
cat >/tmp/cccl_fallback_probe.cpp <<'CPP'
template<bool>
struct select {};
template<>
struct select<true> {
template<class T>
using type = T;
};
template<bool B, class T = void>
using enable_if_t = typename select<B>::template type<T>;
template<class> struct tuple_size;
template<class T>
inline constexpr int tuple_size_v = tuple_size<T>::value;
template<bool B, enable_if_t<B, int> = 0>
inline constexpr int requires_value = 0;
template<class T>
inline constexpr bool tuple_like = false;
template<class T>
struct member_form {
template<class U>
static auto check()
-> enable_if_t<
(decltype(requires_value<tuple_like<U>>{}),
decltype(requires_value<(tuple_size<U>::value == 2)>{}),
true),
void>;
};
template<class T>
struct variable_form {
template<class U>
static auto check()
-> enable_if_t<
(decltype(requires_value<tuple_like<U>>{}),
decltype(requires_value<(tuple_size_v<U> == 2)>{}),
true),
void>;
};
template<class T, class = void>
struct has_member : false {};
template<class T>
struct has_member<T, decltype(member_form<T>::template check<T>())> : true {};
template<class T, class = void>
struct has_variable : false {};
template<class T>
struct has_variable<T, decltype(variable_form<T>::template check<T>())> : true {};
static_assert(!has_member<int>::value);
static_assert(!has_variable<int>::value);
CPP
if command -v clang++ >/dev/null 2>&1; then
clang++ -std=c++17 -fsyntax-only /tmp/cccl_fallback_probe.cpp
printf '%s\n' 'clang probe: passed'
else
printf '%s\n' 'clang++ unavailable'
fi
if command -v g++ >/dev/null 2>&1; then
if g++ -std=c++17 -fsyntax-only /tmp/cccl_fallback_probe.cpp; then
printf '%s\n' 'g++ probe: passed'
else
printf '%s\n' 'g++ probe: unavailable or failed'
fi
fiRepository: NVIDIA/cccl Length of output: 2675 🏁 Script executed: #!/bin/bash
set -eu
cat >/tmp/cccl_fallback_probe.cpp <<'CPP'
template<bool>
struct select {};
template<>
struct select<true> {
template<class T>
using type = T;
};
template<bool B, class T = void>
using enable_if_t = typename select<B>::template type<T>;
template<class> struct tuple_size;
template<class T>
inline constexpr int tuple_size_v = tuple_size<T>::value;
template<bool B, enable_if_t<B, int> = 0>
inline constexpr int requires_value = 0;
template<class T>
inline constexpr bool tuple_like = false;
template<class T>
struct member_form {
template<class U>
static auto check()
-> decltype(
requires_value<tuple_like<U>>,
requires_value<(tuple_size<U>::value == 2)>,
void());
};
template<class T>
struct variable_form {
template<class U>
static auto check()
-> decltype(
requires_value<tuple_like<U>>,
requires_value<(tuple_size_v<U> == 2)>,
void());
};
template<class T, class = void>
struct has_member { static constexpr bool value = false; };
template<class T>
struct has_member<T, decltype(member_form<T>::template check<T>())> {
static constexpr bool value = true;
};
template<class T, class = void>
struct has_variable { static constexpr bool value = false; };
template<class T>
struct has_variable<T, decltype(variable_form<T>::template check<T>())> {
static constexpr bool value = true;
};
static_assert(!has_member<int>::value);
static_assert(!has_variable<int>::value);
CPP
if command -v clang++ >/dev/null 2>&1; then
clang++ -std=c++17 -fsyntax-only /tmp/cccl_fallback_probe.cpp
printf '%s\n' 'clang probe: passed'
else
printf '%s\n' 'clang++ unavailable'
fi
if command -v g++ >/dev/null 2>&1; then
g++ -std=c++17 -fsyntax-only /tmp/cccl_fallback_probe.cpp
printf '%s\n' 'g++ probe: passed'
else
printf '%s\n' 'g++ unavailable'
fiRepository: NVIDIA/cccl Length of output: 271 🌐 Web query:
💡 Result: The issue where std::tuple_size_v causes a compilation error (a hard error) instead of a SFINAE substitution failure arises because the evaluation of the variable template's initializer—std::tuple_size::value—often occurs outside the immediate context of a template substitution [1][2][3]. Under C++ template instantiation rules, SFINAE (Substitution Failure Is Not An Error) only applies to errors occurring within the immediate context of a function signature or template parameter list [2]. When you use std::tuple_size_v, the compiler must instantiate the variable template specialization to determine its value. If the type T is not tuple-like, this instantiation triggers an error in the initializer (std::tuple_size::value). Because this instantiation is considered a side effect of the template substitution rather than an error in the immediate context, the compiler treats it as a hard error [1][2]. In contrast, using std::tuple_size::value directly is often SFINAE-friendly because the failure to find a::value member in the primary template—which is typically undefined—occurs in a context where the compiler can gracefully treat it as a substitution failure [3][4]. For NVCC and NVRTC users, this behavior is a standard C++ language compliance issue rather than a specific toolchain bug [5][3]. When working with CUDA libraries (such as libcu++), encountering this error usually means: 1. The type T passed to tuple_size_v does not meet the requirements of a "tuple-like" type (it lacks an appropriate std::tuple_size specialization) [4]. 2. You are attempting to use it in a SFINAE-constrained context (like a requires clause or std::enable_if) where you expect failure to be silent, but the compiler is forcing an instantiation [2][6][3]. To resolve this, you can: - Use std::tuple_size::value instead of the variable template std::tuple_size_v [5][3]. - If you must use a variable template, wrap it in a custom trait that inherits from std::integral_constant to ensure the failure occurs in a way that respects SFINAE, or define a primary template specialization for your custom types to ensure std::tuple_size::value is always valid [6][4]. Citations:
important: Preserve the member-based check for non-concepts toolchains. Source: Path instructions |
||
|
|
||
| _CCCL_END_NAMESPACE_CUDA_STD | ||
|
|
||
|
|
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This was intentional,
tuple_size_vdidn't get the job doneThere was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Yeah we cannot do that.
tuple_sizeis one of the places where we need to keep it like that