<array>: Cannot use array<T,N> in constexpr context in comparison to T[N] in debug

[Andersama]

Describe the bug
Cannot compile code when using ::std::array<T,N> over T[N] in a constexpr context. Issue stems from _STL_VERIFY macro in the array [] operator making a non constexpr call.

Example code

#include <iostream>
#include <array>
#include <cassert>

struct non_trivial_struct {
	constexpr non_trivial_struct() noexcept {};
};

struct construct_array {};

template<typename Ty, size_t N>
struct like_optional_but_an_array {
	union {
		::std::array<Ty, N> data; //gives an error about a non constexpr call
		//Ty data[N]; //no problem
		non_trivial_struct dummy;
	};

	constexpr like_optional_but_an_array() noexcept : dummy{} {};
	constexpr like_optional_but_an_array(construct_array) noexcept : data{} {};

	[[nodiscard]] constexpr Ty& operator[](size_t idx) noexcept {
		assert(idx < N);
		return data[idx];
	}
	[[nodiscard]] constexpr const Ty& operator[](size_t idx) const noexcept {
		assert(idx < N);
		return data[idx];
	}
};

constexpr auto something_at_compiletime() {
	like_optional_but_an_array<uint32_t, 8> compile_time_thing{ construct_array{} };
	return compile_time_thing[7ULL];
};

int main(void) {
	constexpr like_optional_but_an_array<uint32_t, 8> thing;
	constexpr auto test = something_at_compiletime();
	::std::cout << ((int)thing[3ULL]) << '\n';
	::std::cout << test << '\n';

	return 0;
}

Here's the current implementation.

    _NODISCARD _CONSTEXPR17 reference operator[](_In_range_(0, _Size - 1) size_type _Pos) noexcept /* strengthened */ {
#if _CONTAINER_DEBUG_LEVEL > 0
        _STL_VERIFY(_Pos < _Size, "array subscript out of range");
#endif // _CONTAINER_DEBUG_LEVEL > 0

        return _Elems[_Pos];
    }

    _NODISCARD constexpr const_reference operator[](_In_range_(0, _Size - 1) size_type _Pos) const noexcept
    /* strengthened */ {
#if _CONTAINER_DEBUG_LEVEL > 0
        _STL_VERIFY(_Pos < _Size, "array subscript out of range");
#endif // _CONTAINER_DEBUG_LEVEL > 0

        return _Elems[_Pos];
    }

Expected behavior
Should be able to compile the above code when using ::std::array<T,N> over T[N] in debug mode.

STL version
Microsoft Visual Studio Community 2019 Preview Version 16.8.0 Preview 3.2

[miscco]

yeah, that is something I observed too in #1407.

It it however not clear, whether we want to turn it off completely or guard every occurrence with is_constant_evaluated()

[Andersama]

Trip up for me in trying to understand this is that the assert macro works just fine, think it's roughly the same idea, unless I'm missing something.

Would it be fair to have it wrapped w/ NDEBUG like assert? Since it's already in a macro and assert appears to be fine. I mean it's not obvious to me exactly how the compiler works, but it appears the function's already decorated with several things about checking the parameter is within range and it's only _STL_VERIFY creating an issue?

[miscco]

So after having my coffee and actually remembering what was going on I believe, your code is simply not valid under constant evaluation.

The first sad hint is that whenever an assert goes off during constant evaluation, we get some strange error messages as you can see here.

So the fact that you are getting a compile time error is not that _STL_VERIFY is not usable during constant evaluation, but that your code is either broken or you are doing something that is not valid during constant evaluation.

Looking at your code, I believe the usage of the union s not valid. @mnatsuhara can elaborate a bit more about that because she had to turn of SSO for constexpr string.

[Andersama]

Well I picked some arbitrary indexs, but I'm pretty sure they're within range, so I don't think an assert would be going off. I'd be inclined to think my usage of union's not valid, I was following along w/ the optional header, so if this is broken for union reasons something else is likely off.

[Andersama]

Ok, in going back, I realized I forgot to set the language standard, this does compile if in c++17. I will say though I've run into this error before and I'm pretty certain I was working in c++20.*

So to be specific, this does not work in c++14 in debug mode, but that is the default language selection. I'll have to make a mental note of that the next time I catch this error message.

Point of failure's wasn't that _STL_VERIFY was an issue, operator[] is not constexpr in c++14.