Clang fails to compile when using `std::tuple_size_v<T>` in concept, but compiles with `std::tuple_size<T>::value`

[Taw3e8]

Clang (and other compilers too) compile when this code uses ::value but fail to compile when _v is used (https://godbolt.org/z/b9ofY1vsT):

template<typename T>
concept check1 = requires {
	[]<std::size_t... Is>(std::index_sequence<Is...>) requires requires {
		(std::get<Is>(std::declval<T>()), ...);
	} {}(std::make_index_sequence<std::tuple_size<T>::value>{});         // diff
};

template<typename T>
concept check2 = requires {
	[]<std::size_t... Is>(std::index_sequence<Is...>) requires requires {
		(std::get<Is>(std::declval<T>()), ...);
	} {}(std::make_index_sequence<std::tuple_size_v<T>>{});              // diff
};


int main() {
	auto _ = check1<int>; // this is fine
        auto _ = check2<int>; // this is not
}

Is this behaviour correct?

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Jan Piotrowicz (Taw3e8)

Clang (and other compilers too) compile when this code uses `::value` but fail to compile when `_v` is used (https://godbolt.org/z/b9ofY1vsT):

template<typename T>
concept check1 = requires {
	[]<std::size_t... Is>(std::index_sequence<Is...>) requires requires {
		(std::get<Is>(std::declval<T>()), ...);
	} {}(std::make_index_sequence<std::tuple_size<T>::value>{});         // diff
};

template<typename T>
concept check2 = requires {
	[]<std::size_t... Is>(std::index_sequence<Is...>) requires requires {
		(std::get<Is>(std::declval<T>()), ...);
	} {}(std::make_index_sequence<std::tuple_size_v<T>>{});              // diff
};


int main() {
	auto _ = check1<int>; // this is fine
        auto _ = check2<int>; // this is not
}

Is this behaviour correct?

[shafik]

Implementation except edg reject this: https://godbolt.org/z/6qcrjd89z

I want to say this is a bug but I have to think about it, a reduction would help.

[cor3ntin]

In the first case, std::tuple_size<T>::value>{} with [T = int] results in a substitution in the immediate context failure, and the whole requires, which is an atomic constraint is not satisfied and check1<int> is a valid expression evaluating to false.

In the second scenario, we can substitute int in std::tuple_size_v<T>, however we then need to instantiate std::tuple_size_v<int> (when substituting into make_index_sequence) - This cause substitution in the initializer of
tuple_size_v<int> - which is tuple_size<T>::value - that substitution results in an invalid type, and happens outside of the immediate context (in this case the immediate context is roughly the whole require expression - there is a long standing defect that this term is not defined) - so SFINAE does not kick in and the program is ill-formed.

[Taw3e8]

Got a bit smaller one and EDG fails now too: https://godbolt.org/z/Pv61zKExM

[Taw3e8]

Ok, this makes sense. It's a shame though... I mean would be quite handy for this to work (I'm guessing it compiles on clang by chance):

template<typename T>
concept check2 = requires {
	std::tuple_size_v<T>;
};

This makes using type traits in concepts very bug prone :/
As it seems to be a bit deeper problem, maybe there could be some warnings?

[cor3ntin]

template
concept check2 = requires {
std::tuple_size_v;
};

I believe clang is correct in that this is a valid expression - the invalid bit is the initializer (that is not instantiated)
I wonder if CWG1845 is what causes the divergence

I do agree that Clang's behavior is not the most useful

@zygoloid