explicitly noexcept destructor incorrectly not constexpr

[CaseyCarter]

This well-formed C++20 TU:

#include <vector>

template <class E>
struct expected {
  constexpr explicit expected(std::initializer_list<int> il) : unex(il) {}
  constexpr ~expected() 
#ifndef MEOW
    noexcept 
#endif
  { unex.~E(); }
  constexpr explicit operator bool() const { return true; }
  union { E unex; };
};

struct Data {
  std::vector<int> vec_;
  constexpr Data(std::initializer_list<int> il) : vec_(il) {}
};

static_assert(expected<Data>({1, 2, 3}));

fails to compile if MEOW isn't defined (https://godbolt.org/z/qx1nEzvzW):

<source>:20:15: error: static assertion expression is not an integral constant expression
static_assert(expected<Data>({1, 2, 3}));
              ^~~~~~~~~~~~~~~~~~~~~~~~~
<source>:20:15: note: subexpression not valid in a constant expression
<source>:20:15: note: in call to '&expected<Data>({1, 2, 3})->~expected()'
1 error generated.

The repro is admittedly not library-free, but it does reproduce with all of libc++, libstdc++, and MSVCSTL - and not with GCC or MSVC - so I'm reasonably confident the bug is in the compiler and not the implementation of vector.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[llvmbot]

@llvm/issue-subscribers-bug

[shafik]

I am not sure who is correct here but I am curious do you except the non-anonymous union case to be the same:

#include <vector>

template <typename T>
union U {
  constexpr explicit U(std::initializer_list<int> il) : t(il) {}
  T t;
};

template <class E>
struct expected {
  constexpr explicit expected(std::initializer_list<int> il) : unex(il) {}
  constexpr ~expected() 
#ifndef MEOW
    noexcept 
#endif
  { unex.~E(); }
  constexpr explicit operator bool() const { return true; }
  U<E> unex;
};

struct Data {
  std::vector<int> vec_;
  constexpr Data(std::initializer_list<int> il) : vec_(il) {}
};

static_assert(expected<Data>({1, 2, 3}));

godbolt: https://godbolt.org/z/5q15jK7hn

gcc then agrees with clang that this is ill-formed. If you don't think this is the same case can you give me the specific sections of the draft standard that you believe apply to your original case?

[CaseyCarter]

(EDIT: to be perfectly clear, I do not expect the named union case to behave similarly.) They're obviously unrelated, the error conditions are different. Your named union example is ill-formed because the named union has a deleted destructor. In the anonymous union case, ~expected effectively is the union's destructor.

The discrepancy here is that Clang believes the destructor call is valid in a constant expression when it has no noexcept-specifier, but not when it does have a noexcept-specifier regardless of whether it's noexcept(true) (equivalently plain noexcept) or noexcept(false) (https://godbolt.org/z/7M3s3c1bv).

[frederick-vs-ja]

I am not sure who is correct here but I am curious do you except the non-anonymous union case to be the same:

CWG2761 clarified that these two cases are not the same.

Reduced to a library-free version (https://godbolt.org/z/TGo3P5cGv):

struct my_nontrivial {
    my_nontrivial() = default;
    constexpr ~my_nontrivial() {} // non-trivial
};

struct my_data {
  my_data() = default;
#ifdef EXPLICITLY_DEFAUTLING
  ~my_data() = default;
#endif

  my_nontrivial dat_;
};

template <class E>
struct expected {
  expected() = default;
  constexpr ~expected() 
#ifndef MEOW
    noexcept
#endif
  { unex.~E(); }
  constexpr explicit operator bool() const { return true; }
  union { E unex = E(); };
};

static_assert(expected<my_data>{});

It seems that this bug is trigged when the E::~E is implicitly declared but non-trivial.