libstdc++: Fix constantness of engaged -> disengaged std::optional [PR124910]

When an optional that contains a value is cleared, _M_destroy invokes the
destructor of the contained value _Storage::_M_value, leaving the union
_Storage without an active member.  While this is benign at runtime, a
union suboject with no active member violates core constant expression
requirements and in turn an optional in this state can't be used as a
constant initializer, which Clang and recent GCC (since r16-3022) correctly
diagnose.

To fix this, this patch makes _M_destroy activate the dummy union member
_M_empty after destroying _M_value to ensure that the union always has
an active member throughout its lifetime.  We use std::construct_at
instead of simple assignment to work around a front end bug (comment #3
in the PR).  Doing so means we don't activate the member in C++17 mode,
which should be fine; I don't think it's possible to disengage an engaged
optional using only the C++17 constexpr optional operations.

	PR c++/124910

libstdc++-v3/ChangeLog:

	* include/std/optional (_Optional_payload_base::_M_destroy)
	[__cpp_lib_optional >= 202106L]: During constant evaluation,
	after invoking destructor of _M_value, use construct_at to
	activate _M_empty.
	* testsuite/20_util/optional/constexpr/124910.cc: New test.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

Author: Patrick Palka

libstdc++-v3/include/std/optional

@@ -321,6 +321,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       {
 	_M_engaged = false;
 	_M_payload._M_value.~_Stored_type();
+#if __cpp_lib_optional >= 202106L // full constexpr support
+	if (std::is_constant_evaluated())
+	  // Ensure union _M_payload always has an active member, for sake
+	  // of the core constant expression requirements.
+	  std::construct_at(std::__addressof(_M_payload._M_empty));
+#endif
       }
 
 #if __cplusplus >= 202002L

libstdc++-v3/testsuite/20_util/optional/constexpr/124910.cc

@@ -0,0 +1,74 @@
+// { dg-do compile { target c++20 } }
+
+// PR124910 - bogus 'std::optional{...}' is not a constant expression error
+// after resetting it via '= nullopt'
+
+#include <optional>
+
+struct A
+{
+  constexpr A(int m) : m(m) { }
+  int m;
+};
+
+struct B
+{
+  constexpr B(int m) : m(m) { }
+  constexpr ~B() { }
+  int m;
+};
+
+static_assert(   std::is_trivially_destructible_v<int> );
+static_assert(   std::is_trivially_destructible_v<A> );
+static_assert( ! std::is_trivially_destructible_v<B> );
+
+template<class T>
+void
+do_test()
+{
+  constexpr std::optional<T> x1 = [] {
+    std::optional<T> o = 1;
+    o = std::nullopt;
+    return o;
+  }();
+
+  constexpr std::optional<T> x2 = [] {
+    std::optional<T> o = 1;
+    o.reset();
+    return o;
+  }();
+
+  constexpr std::optional<T> x3 = [] {
+    std::optional<T> o1 = 1;
+    std::optional<long> o2;
+    o1 = o2;
+    return o1;
+  }();
+
+  constexpr std::optional<T> x4 = [] {
+    std::optional<T> o1 = 1;
+    std::optional<long> o2;
+    o1 = std::move(o2);
+    return o1;
+  }();
+
+  constexpr std::optional<T> x5 = [] {
+    std::optional<T> o1 = 1;
+    std::optional<T> o2;
+    std::swap(o1, o2);
+    return o1;
+  }();
+
+  struct C : std::optional<T> {
+    constexpr C() : std::optional<T>(1) { this->reset(); }
+  };
+  constexpr C x6;
+}
+
+int
+main()
+{
+  do_test<int>();
+  do_test<A>();
+  do_test<B>();
+}