Wrong evaluation of a if constexpr requires

[Fedr]

The following program

#include <array>
#include <vector>

template <typename T>
constexpr std::size_t get_length(const T &t) {
    return t.size();
}

template <typename T, std::size_t N>
constexpr auto get_length(const std::array<T, N> &) {
    return std::integral_constant<std::size_t, N>();
}

static_assert( get_length(std::array<int, 3>())() == 3 );
static_assert( requires { typename std::array<int, get_length(std::array<int, 3>())>; } );

auto foo(auto length) {
    // If length could be evaluated at compile time,
    if constexpr (requires { typename std::array<int, length>; })
        return std::array<int, length>{};
    // Otherwise,
    else
        return std::vector<int>(length);
}

int main() {
    auto x = foo(get_length(std::vector<int>(5)));
    x.resize(1); // array does not have resize
    auto y = foo(get_length(std::array<int, 3>()));
    static_assert( y.size() == 3 ); // in Clang y is vector?
}

is accepted by GCC and MSVC. But in Clang y is a std::vector for some reason. Online demo: https://gcc.godbolt.org/z/h53zc3bjv

Related discussion: https://stackoverflow.com/a/76673819/7325599

Could you please check?

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[shafik]

I believe this should be ok, size() is marked w/ _LIBCPP_CONSTEXPR_SINCE_CXX20. It is not obvious what the problem is, it would require some debugging.

[cor3ntin]

In foo, length is not a constant expression (https://gcc.godbolt.org/z/orr6ndfj4), and cannot be used
as template argument of typename std::array<int, length> - from there, the requires is false and clang returns a vector.
Neither foo() nor y are constexpr, but even if they were, we can't return a vector from a constexpr function because C++ has no support for transient allocation.

Ultimately, the comment "If length could be evaluated at compile time" is what does not work here, function parameters are never constant expressions.

Now, the thing I'm not quite sure about is whether we should diagnose L19 in the requires or not? Presumably not, and if so I don't think there is a bug there.

I'm not quite sure what GCC and MSVC are doing, am I missing something?

[shafik]

Yeah, I believe @cor3ntin is correct we can't return the std::vector (I completely missed that aspect) but if we make foo a constexpr function and use it directly in the static_assert it works fine: https://gcc.godbolt.org/z/rqePad5ex

int main() {
    auto x = foo(get_length(std::vector<int>(5)));
    x.resize(1); // array does not have resize
    //constexpr auto y = foo(get_length(std::array<int, 3>()));
    static_assert( foo(get_length(std::array<int, 3>())).size() == 3 ); // in Clang y is vector?
}

I think clang is correct here although the diagnostic could be way more informative.

CC @tbaederr

[cor3ntin]

@shafik the salient difference https://gcc.godbolt.org/z/vcdr7nea7
But I don't see how GCC and MSVC get to return an array here..... right?

[efriedma-quic]

Consider the following, which is simplified to just the essentials (https://gcc.godbolt.org/z/774n7svhn):

#include <array>

auto foo() {
    std::integral_constant<std::size_t, 3> length;
    if constexpr (requires { typename std::array<int, length.value>; })
        return 0;
    else
        return 0LL;
}
static_assert(sizeof foo() == 4);

template<int x> auto bar() {
    std::integral_constant<std::size_t, 3> length;
    if constexpr (requires { typename std::array<int, length.value>; })
        return 0;
    else
        return 0LL;
}
static_assert(sizeof bar<0>() == 4);

template<typename T> auto baz() {
    T length;
    if constexpr (requires { typename std::array<int, length.value>; })
        return 0;
    else
        return 0LL;
}
static_assert(sizeof baz<std::integral_constant<std::size_t, 3>>() == 4);

clang disagrees with gcc/msvc about whether the first example is valid. For the second and third examples, clang agrees with gcc/msvc that an error shouldn't be printed.

Comparing the second and third examples, though, shows that clang isn't consistent with itself. Somehow, whether a local variable is type-dependent changes the result of the "if constexpr", which is pretty clearly wrong.

[Fedr]

Even more simplified code:

emplate <bool>
struct A{};

constexpr bool foo(auto b) {
    return requires { typename A<b>; };
}

static_assert( foo( std::true_type{} ) ); // fails in Clang

Online demo: https://gcc.godbolt.org/z/j6Mnqjvbz

Another simplified example without function template:

template <bool>
struct A{};

constexpr bool foo() {
     std::true_type x{};
     return requires { typename A<x>; }; // fails in Clang
}

static_assert( foo() );

Online demo: https://gcc.godbolt.org/z/zGfo9a45P

Related discussion: https://stackoverflow.com/q/76697099/7325599

[cor3ntin]

@erichkeane you have an opinion on this?

[erichkeane]

I think Clang is wrong here, see the answer in @Fedr 's last stack overflow example. I think we're being overly aggressive with the 'local variable' check.