@@ -858,6 +858,7 @@ INPUT = @srcdir@/doc/doxygen/doxygroups.cc \
include/concepts \
include/condition_variable \
include/deque \
+ include/expected \
include/filesystem \
include/forward_list \
include/fstream \
@@ -42,6 +42,7 @@ std_headers = \
${std_srcdir}/coroutine \
${std_srcdir}/deque \
${std_srcdir}/execution \
+ ${std_srcdir}/expected \
${std_srcdir}/filesystem \
${std_srcdir}/forward_list \
${std_srcdir}/fstream \
@@ -400,6 +400,7 @@ std_headers = \
${std_srcdir}/coroutine \
${std_srcdir}/deque \
${std_srcdir}/execution \
+ ${std_srcdir}/expected \
${std_srcdir}/filesystem \
${std_srcdir}/forward_list \
${std_srcdir}/fstream \
@@ -153,5 +153,6 @@
#endif
#if __cplusplus > 202002L
+#include <expected>
#include <spanstream>
#endif
new file mode 100644
@@ -0,0 +1,1240 @@
+// <expected> -*- C++ -*-
+
+// Copyright The GNU Toolchain Authors
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/expected
+ * This is a Standard C++ Library header.
+ */
+
+#ifndef _GLIBCXX_EXPECTED
+#define _GLIBCXX_EXPECTED
+
+#pragma GCC system_header
+
+#if __cplusplus > 202002L && __cpp_concepts >= 202002L
+
+#include <initializer_list>
+#include <bits/exception.h> // exception
+#include <bits/stl_construct.h> // construct_at
+#include <bits/utility.h> // in_place_t
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * @defgroup expected_values Expected values
+ * @addtogroup utilities
+ * @since C++23
+ * @{
+ */
+
+#define __cpp_lib_expected 202202L
+
+ /// Discriminated union that holds an expected value or an error value.
+ /**
+ * @since C++23
+ */
+ template<typename _Tp, typename _Er>
+ class expected;
+
+ /// Wrapper type used to pass an error value to a `std::expected`.
+ /**
+ * @since C++23
+ */
+ template<typename _Er>
+ class unexpected;
+
+ /// Exception thrown by std::expected when the value() is not present.
+ /**
+ * @since C++23
+ */
+ template<typename _Er>
+ class bad_expected_access;
+
+ template<>
+ class bad_expected_access<void> : public exception
+ {
+ protected:
+ bad_expected_access() noexcept { }
+ bad_expected_access(const bad_expected_access&) = default;
+ bad_expected_access(bad_expected_access&&) = default;
+ bad_expected_access& operator=(const bad_expected_access&) = default;
+ bad_expected_access& operator=(bad_expected_access&&) = default;
+ ~bad_expected_access() = default;
+
+ public:
+
+ [[nodiscard]]
+ const char*
+ what() const noexcept override
+ { return "bad access to std::expected without expected value"; }
+ };
+
+ template<typename _Er>
+ class bad_expected_access : public bad_expected_access<void> {
+ public:
+ explicit
+ bad_expected_access(_Er __e) : _M_val(__e) { }
+
+ // XXX const char* what() const noexcept override;
+
+ [[nodiscard]]
+ _Er&
+ error() & noexcept
+ { return _M_val; }
+
+ [[nodiscard]]
+ const _Er&
+ error() const & noexcept
+ { return _M_val; }
+
+ [[nodiscard]]
+ _Er&&
+ error() && noexcept
+ { return std::move(_M_val); }
+
+ [[nodiscard]]
+ const _Er&&
+ error() const && noexcept
+ { return std::move(_M_val); }
+
+ private:
+ _Er _M_val;
+ };
+
+ /// Tag type for constructing unexpected values in a std::expected
+ /**
+ * @since C++23
+ */
+ struct unexpect_t
+ {
+ explicit unexpect_t() = default;
+ };
+
+ /// Tag for constructing unexpected values in a std::expected
+ /**
+ * @since C++23
+ */
+ inline constexpr unexpect_t unexpect{};
+
+/// @cond undoc
+namespace __expected
+{
+ template<typename _Tp>
+ constexpr bool __is_expected = false;
+ template<typename _Tp, typename _Er>
+ constexpr bool __is_expected<expected<_Tp, _Er>> = true;
+
+ template<typename _Tp>
+ constexpr bool __is_unexpected = false;
+ template<typename _Tp>
+ constexpr bool __is_unexpected<unexpected<_Tp>> = true;
+
+ template<typename _Er>
+ concept __can_be_unexpected
+ = is_object_v<_Er> && (!is_array_v<_Er>)
+ && (!__expected::__is_unexpected<_Er>)
+ && (!is_const_v<_Er>) && (!is_volatile_v<_Er>);
+}
+/// @endcond
+
+ template<typename _Er>
+ class unexpected
+ {
+ static_assert( __expected::__can_be_unexpected<_Er> );
+
+ public:
+ constexpr unexpected(const unexpected&) = default;
+ constexpr unexpected(unexpected&&) = default;
+
+ template<typename _Err = _Er>
+ requires (!is_same_v<remove_cvref_t<_Err>, unexpected>)
+ && (!is_same_v<remove_cvref_t<_Err>, in_place_t>)
+ && is_constructible_v<_Er, _Err>
+ constexpr explicit
+ unexpected(_Err&& __e)
+ noexcept(is_nothrow_constructible_v<_Er, _Err>)
+ : _M_val(std::forward<_Err>(__e))
+ { }
+
+ template<typename... _Args>
+ requires is_constructible_v<_Er, _Args...>
+ constexpr explicit
+ unexpected(in_place_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Er, _Args...>)
+ : _M_val(std::forward<_Args>(__args)...)
+ { }
+
+ template<typename _Up, typename... _Args>
+ requires is_constructible_v<_Er, initializer_list<_Up>&, _Args...>
+ constexpr explicit
+ unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Er, initializer_list<_Up>&,
+ _Args...>)
+ : _M_val(__il, std::forward<_Args>(__args)...)
+ { }
+
+ constexpr unexpected& operator=(const unexpected&) = default;
+ constexpr unexpected& operator=(unexpected&&) = default;
+
+
+ [[nodiscard]]
+ constexpr const _Er&
+ error() const & noexcept { return _M_val; }
+
+ [[nodiscard]]
+ constexpr _Er&
+ error() & noexcept { return _M_val; }
+
+ [[nodiscard]]
+ constexpr const _Er&&
+ error() const && noexcept { return std::move(_M_val); }
+
+ [[nodiscard]]
+ constexpr _Er&&
+ error() && noexcept { return std::move(_M_val); }
+
+ constexpr void
+ swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Er>)
+ {
+ static_assert( is_swappable_v<_Er> );
+ using std::swap;
+ swap(_M_val, __other._M_val);
+ }
+
+ template<typename _Err>
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(const unexpected& __x, const unexpected<_Err>& __y)
+ { return __x._M_val == __y.error(); }
+
+ friend constexpr void
+ swap(unexpected& __x, unexpected& __y)
+ noexcept(noexcept(__x.swap(__y)))
+ requires requires {__x.swap(__y);}
+ { __x.swap(__y); }
+
+ private:
+ _Er _M_val;
+ };
+
+ template<typename _Er> unexpected(_Er) -> unexpected<_Er>;
+
+/// @cond undoc
+namespace __expected
+{
+ template<typename _Tp>
+ struct _Guard
+ {
+ static_assert( is_nothrow_move_constructible_v<_Tp> );
+
+ constexpr explicit
+ _Guard(_Tp& __x)
+ : _M_guarded(__builtin_addressof(__x)), _M_tmp(std::move(__x)) // nothrow
+ { std::destroy_at(_M_guarded); }
+
+ constexpr
+ ~_Guard()
+ {
+ if (_M_guarded) [[unlikely]]
+ std::construct_at(_M_guarded, std::move(_M_tmp));
+ }
+
+ _Guard(const _Guard&) = delete;
+ _Guard& operator=(const _Guard&) = delete;
+
+ constexpr _Tp&&
+ release() noexcept
+ {
+ _M_guarded = nullptr;
+ return std::move(_M_tmp);
+ }
+
+ private:
+ _Tp* _M_guarded;
+ _Tp _M_tmp;
+ };
+
+ // reinit-expected helper from [expected.object.assign]
+ template<typename _Tp, typename _Up, typename _Vp>
+ constexpr void
+ __reinit(_Tp* __newval, _Up* __oldval, _Vp&& __arg)
+ noexcept(is_nothrow_constructible_v<_Tp, _Vp>)
+ {
+ if constexpr (is_nothrow_constructible_v<_Tp, _Vp>)
+ {
+ std::destroy_at(__oldval);
+ std::construct_at(__newval, std::forward<_Vp>(__arg));
+ }
+ else if constexpr (is_nothrow_move_constructible_v<_Tp>)
+ {
+ _Tp __tmp(std::forward<_Vp>(__arg)); // might throw
+ std::destroy_at(__oldval);
+ std::construct_at(__newval, std::move(__tmp));
+ }
+ else
+ {
+ _Guard<_Up> __guard(*__oldval);
+ std::construct_at(__newval, std::forward<_Vp>(__arg)); // might throw
+ __guard.release();
+ }
+ }
+}
+/// @endcond
+
+ template<typename _Tp, typename _Er>
+ class expected
+ {
+ static_assert( ! is_reference_v<_Tp> );
+ static_assert( ! is_function_v<_Tp> );
+ static_assert( ! is_same_v<remove_cv_t<_Tp>, in_place_t> );
+ static_assert( ! is_same_v<remove_cv_t<_Tp>, unexpect_t> );
+ static_assert( ! __expected::__is_unexpected<remove_cv_t<_Tp>> );
+ static_assert( __expected::__can_be_unexpected<_Er> );
+
+ template<typename _Up, typename _Err, typename _Unex = unexpected<_Er>>
+ static constexpr bool __cons_from_expected
+ = __or_v<is_constructible<_Tp, expected<_Up, _Err>&>,
+ is_constructible<_Tp, expected<_Up, _Err>>,
+ is_constructible<_Tp, const expected<_Up, _Err>&>,
+ is_constructible<_Tp, const expected<_Up, _Err>>,
+ is_convertible<expected<_Up, _Err>&, _Tp>,
+ is_convertible<expected<_Up, _Err>, _Tp>,
+ is_convertible<const expected<_Up, _Err>&, _Tp>,
+ is_convertible<const expected<_Up, _Err>, _Tp>,
+ is_constructible<_Unex, expected<_Up, _Err>&>,
+ is_constructible<_Unex, expected<_Up, _Err>>,
+ is_constructible<_Unex, const expected<_Up, _Err>&>,
+ is_constructible<_Unex, const expected<_Up, _Err>>
+ >;
+
+ template<typename _Up, typename _Err>
+ constexpr static bool __explicit_conv
+ = __or_v<__not_<is_convertible<_Up, _Tp>>,
+ __not_<is_convertible<_Err, _Er>>
+ >;
+
+ public:
+ using value_type = _Tp;
+ using error_type = _Er;
+ using unexpected_type = unexpected<_Er>;
+
+ template<typename _Up>
+ using rebind = expected<_Up, error_type>;
+
+ constexpr
+ expected()
+ noexcept(is_nothrow_default_constructible_v<_Tp>)
+ requires is_default_constructible_v<_Tp>
+ : _M_val(), _M_has_value(true)
+ { }
+
+ expected(const expected&) = default;
+
+ constexpr
+ expected(const expected& __x)
+ noexcept(__and_v<is_nothrow_copy_constructible<_Tp>,
+ is_nothrow_copy_constructible<_Er>>)
+ requires is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Er>
+ && (!is_trivially_copy_constructible_v<_Tp>
+ || !is_trivially_copy_constructible_v<_Er>)
+ : _M_invalid(), _M_has_value(__x._M_has_value)
+ {
+ if (_M_has_value)
+ std::construct_at(__builtin_addressof(_M_val), __x._M_val);
+ else
+ std::construct_at(__builtin_addressof(_M_unex), __x._M_unex);
+ }
+
+ expected(expected&&) = default;
+
+ constexpr
+ expected(expected&& __x)
+ noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+ is_nothrow_move_constructible<_Er>>)
+ requires is_move_constructible_v<_Tp> && is_move_constructible_v<_Er>
+ && (!is_trivially_move_constructible_v<_Tp>
+ || !is_trivially_move_constructible_v<_Er>)
+ : _M_invalid(), _M_has_value(__x._M_has_value)
+ {
+ if (_M_has_value)
+ std::construct_at(__builtin_addressof(_M_val),
+ std::move(__x)._M_val);
+ else
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::move(__x)._M_unex);
+ }
+
+ template<typename _Up, typename _Gr>
+ requires is_constructible_v<_Tp, const _Up&>
+ && is_constructible_v<_Er, const _Gr&>
+ && (!__cons_from_expected<_Up, _Gr>)
+ constexpr explicit(__explicit_conv<const _Up&, const _Gr&>)
+ expected(const expected<_Up, _Gr>& __x)
+ noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
+ is_nothrow_constructible<_Er, const _Gr&>>)
+ : _M_invalid(), _M_has_value(__x._M_has_value)
+ {
+ if (_M_has_value)
+ std::construct_at(__builtin_addressof(_M_val), __x._M_val);
+ else
+ std::construct_at(__builtin_addressof(_M_unex), __x._M_unex);
+ }
+
+ template<typename _Up, typename _Gr>
+ requires is_constructible_v<_Tp, _Up>
+ && is_constructible_v<_Er, _Gr>
+ && (!__cons_from_expected<_Up, _Gr>)
+ constexpr explicit(__explicit_conv<_Up, _Gr>)
+ expected(expected<_Up, _Gr>&& __x)
+ noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
+ is_nothrow_constructible<_Er, _Gr>>)
+ : _M_invalid(), _M_has_value(__x._M_has_value)
+ {
+ if (_M_has_value)
+ std::construct_at(__builtin_addressof(_M_val),
+ std::move(__x)._M_val);
+ else
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::move(__x)._M_unex);
+ }
+
+ template<typename _Up = _Tp>
+ requires (!is_same_v<remove_cvref_t<_Up>, expected>)
+ && (!is_same_v<remove_cvref_t<_Up>, in_place_t>)
+ && (!__expected::__is_unexpected<remove_cvref_t<_Up>>)
+ && is_constructible_v<_Tp, _Up>
+ constexpr explicit(!is_convertible_v<_Up, _Tp>)
+ expected(_Up&& __v)
+ noexcept(is_nothrow_constructible_v<_Tp, _Up>)
+ : _M_val(std::forward<_Up>(__v)), _M_has_value(true)
+ { }
+
+ template<typename _Gr = _Er>
+ requires is_constructible_v<_Er, const _Gr&>
+ constexpr explicit(!is_convertible_v<const _Gr&, _Er>)
+ expected(const unexpected<_Gr>& __u)
+ noexcept(is_nothrow_constructible_v<_Er, const _Gr&>)
+ : _M_unex(__u.error()), _M_has_value(false)
+ { }
+
+ template<typename _Gr = _Er>
+ requires is_constructible_v<_Er, _Gr>
+ constexpr explicit(!is_convertible_v<_Gr, _Er>)
+ expected(unexpected<_Gr>&& __u)
+ noexcept(is_nothrow_constructible_v<_Er, _Gr>)
+ : _M_unex(std::move(__u).error()), _M_has_value(false)
+ { }
+
+ template<typename... _Args>
+ requires is_constructible_v<_Tp, _Args...>
+ constexpr explicit
+ expected(in_place_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
+ : _M_val(std::forward<_Args>(__args)...), _M_has_value(true)
+ { }
+
+ template<typename _Up, typename... _Args>
+ requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
+ constexpr explicit
+ expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
+ _Args...>)
+ : _M_val(__il, std::forward<_Args>(__args)...), _M_has_value(true)
+ { }
+
+ template<typename... _Args>
+ requires is_constructible_v<_Er, _Args...>
+ constexpr explicit
+ expected(unexpect_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Er, _Args...>)
+ : _M_unex(std::forward<_Args>(__args)...), _M_has_value(false)
+ { }
+
+ template<typename _Up, typename... _Args>
+ requires is_constructible_v<_Er, initializer_list<_Up>&, _Args...>
+ constexpr explicit
+ expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Er, initializer_list<_Up>&,
+ _Args...>)
+ : _M_unex(__il, std::forward<_Args>(__args)...), _M_has_value(false)
+ { }
+
+ constexpr ~expected() = default;
+
+ constexpr ~expected()
+ requires (!is_trivially_destructible_v<_Tp>)
+ || (!is_trivially_destructible_v<_Er>)
+ {
+ if (_M_has_value)
+ std::destroy_at(__builtin_addressof(_M_val));
+ else
+ std::destroy_at(__builtin_addressof(_M_unex));
+ }
+
+ // assignment
+
+ expected& operator=(const expected&) = delete;
+
+ constexpr expected&
+ operator=(const expected& __x)
+ noexcept(__and_v<is_nothrow_copy_constructible<_Tp>,
+ is_nothrow_copy_constructible<_Er>,
+ is_nothrow_copy_assignable<_Tp>,
+ is_nothrow_copy_assignable<_Er>>)
+ requires is_copy_assignable_v<_Tp> && is_copy_constructible_v<_Tp>
+ && is_copy_assignable_v<_Er> && is_copy_constructible_v<_Er>
+ && (is_nothrow_move_constructible_v<_Tp>
+ || is_nothrow_move_constructible_v<_Er>)
+ {
+ if (__x._M_has_value)
+ this->_M_assign_val(__x._M_val);
+ else
+ this->_M_assign_unex(__x._M_unex);
+ return *this;
+ }
+
+ constexpr expected&
+ operator=(expected&& __x)
+ noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+ is_nothrow_move_constructible<_Er>,
+ is_nothrow_move_assignable<_Tp>,
+ is_nothrow_move_assignable<_Er>>)
+ requires is_move_assignable_v<_Tp> && is_move_constructible_v<_Tp>
+ && is_move_assignable_v<_Er> && is_move_constructible_v<_Er>
+ && (is_nothrow_move_constructible_v<_Tp>
+ || is_nothrow_move_constructible_v<_Er>)
+ {
+ if (__x._M_has_value)
+ _M_assign_val(std::move(__x._M_val));
+ else
+ _M_assign_unex(std::move(__x._M_unex));
+ return *this;
+ }
+
+ template<typename _Up = _Tp>
+ requires (!is_same_v<expected, remove_cvref_t<_Up>>)
+ && (!__expected::__is_unexpected<remove_cvref_t<_Up>>)
+ && is_constructible_v<_Tp, _Up> && is_assignable_v<_Tp&, _Up>
+ && (is_nothrow_constructible_v<_Tp, _Up>
+ || is_nothrow_move_constructible_v<_Tp>
+ || is_nothrow_move_constructible_v<_Er>)
+ constexpr expected&
+ operator=(_Up&& __v)
+ {
+ _M_assign_val(std::forward<_Up>(__v));
+ return *this;
+ }
+
+ template<typename _Gr>
+ requires is_constructible_v<_Er, const _Gr&>
+ && is_assignable_v<_Er&, const _Gr&>
+ && (is_nothrow_constructible_v<_Er, const _Gr&>
+ || is_nothrow_move_constructible_v<_Tp>
+ || is_nothrow_move_constructible_v<_Er>)
+ constexpr expected&
+ operator=(const unexpected<_Gr>& __e)
+ {
+ _M_assign_unex(__e.error());
+ return *this;
+ }
+
+ template<typename _Gr>
+ requires is_constructible_v<_Er, _Gr>
+ && is_assignable_v<_Er&, _Gr>
+ && (is_nothrow_constructible_v<_Er, _Gr>
+ || is_nothrow_move_constructible_v<_Tp>
+ || is_nothrow_move_constructible_v<_Er>)
+ constexpr expected&
+ operator=(unexpected<_Gr>&& __e)
+ {
+ _M_assign_unex(std::move(__e).error());
+ return *this;
+ }
+
+ // modifiers
+
+ template<typename... _Args>
+ requires is_nothrow_constructible_v<_Tp, _Args...>
+ constexpr _Tp&
+ emplace(_Args&&... __args) noexcept
+ {
+ if (_M_has_value)
+ std::destroy_at(__builtin_addressof(_M_val));
+ else
+ {
+ std::destroy_at(__builtin_addressof(_M_unex));
+ _M_has_value = true;
+ }
+ std::construct_at(__builtin_addressof(_M_val),
+ std::forward<_Args>(__args)...);
+ return _M_val;
+ }
+
+ template<typename _Up, typename... _Args>
+ requires is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
+ _Args...>
+ constexpr _Tp&
+ emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept
+ {
+ if (_M_has_value)
+ std::destroy_at(__builtin_addressof(_M_val));
+ else
+ {
+ std::destroy_at(__builtin_addressof(_M_unex));
+ _M_has_value = true;
+ }
+ std::construct_at(__builtin_addressof(_M_val),
+ __il, std::forward<_Args>(__args)...);
+ return _M_val;
+ }
+
+ // swap
+ constexpr void
+ swap(expected& __x)
+ noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+ is_nothrow_move_constructible<_Er>,
+ is_nothrow_swappable<_Tp&>,
+ is_nothrow_swappable<_Er&>>)
+ requires is_swappable_v<_Tp> && is_swappable_v<_Er>
+ && is_move_constructible_v<_Tp>
+ && is_move_constructible_v<_Er>
+ && (is_nothrow_move_constructible_v<_Tp>
+ || is_nothrow_move_constructible_v<_Er>)
+ {
+ if (_M_has_value)
+ {
+ if (__x._M_has_value)
+ {
+ using std::swap;
+ swap(_M_val, __x._M_val);
+ }
+ else
+ this->_M_swap_val_unex(__x);
+ }
+ else
+ {
+ if (__x._M_has_value)
+ __x._M_swap_val_unex(*this);
+ else
+ {
+ using std::swap;
+ swap(_M_unex, __x._M_unex);
+ }
+ }
+ }
+
+ // observers
+
+ [[nodiscard]]
+ constexpr const _Tp*
+ operator->() const noexcept
+ {
+ __glibcxx_assert(_M_has_value);
+ return __builtin_addressof(_M_val);
+ }
+
+ [[nodiscard]]
+ constexpr _Tp*
+ operator->() noexcept
+ {
+ __glibcxx_assert(_M_has_value);
+ return __builtin_addressof(_M_val);
+ }
+
+ [[nodiscard]]
+ constexpr const _Tp&
+ operator*() const & noexcept
+ {
+ __glibcxx_assert(_M_has_value);
+ return _M_val;
+ }
+
+ [[nodiscard]]
+ constexpr _Tp&
+ operator*() & noexcept
+ {
+ __glibcxx_assert(_M_has_value);
+ return _M_val;
+ }
+
+ [[nodiscard]]
+ constexpr const _Tp&&
+ operator*() const && noexcept
+ {
+ __glibcxx_assert(_M_has_value);
+ return std::move(_M_val);
+ }
+
+ [[nodiscard]]
+ constexpr _Tp&&
+ operator*() && noexcept
+ {
+ __glibcxx_assert(_M_has_value);
+ return std::move(_M_val);
+ }
+
+ [[nodiscard]]
+ constexpr explicit
+ operator bool() const noexcept { return _M_has_value; }
+
+ [[nodiscard]]
+ constexpr bool has_value() const noexcept { return _M_has_value; }
+
+ constexpr const _Tp&
+ value() const &
+ {
+ if (_M_has_value) [[likely]]
+ return _M_val;
+ _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(_M_unex));
+ }
+
+ constexpr _Tp&
+ value() &
+ {
+ if (_M_has_value) [[likely]]
+ return _M_val;
+ _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(_M_unex));
+ }
+
+ constexpr const _Tp&&
+ value() const &&
+ {
+ if (_M_has_value) [[likely]]
+ return std::move(_M_val);
+ _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(
+ std::move(_M_unex)));
+ }
+
+ constexpr _Tp&&
+ value() &&
+ {
+ if (_M_has_value) [[likely]]
+ return std::move(_M_val);
+ _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(
+ std::move(_M_unex)));
+ }
+
+ constexpr const _Er&
+ error() const & noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return _M_unex;
+ }
+
+ constexpr _Er&
+ error() & noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return _M_unex;
+ }
+
+ constexpr const _Er&&
+ error() const && noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return std::move(_M_unex);
+ }
+
+ constexpr _Er&&
+ error() && noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return std::move(_M_unex);
+ }
+
+ template<typename _Up>
+ constexpr _Tp
+ value_or(_Up&& __v) const &
+ noexcept(__and_v<is_nothrow_copy_constructible<_Tp>,
+ is_nothrow_convertible<_Up, _Tp>>)
+ {
+ static_assert( is_copy_constructible_v<_Tp> );
+ static_assert( is_convertible_v<_Up, _Tp> );
+
+ if (_M_has_value)
+ return _M_val;
+ return static_cast<_Tp>(std::forward<_Up>(__v));
+ }
+
+ template<typename _Up>
+ constexpr _Tp
+ value_or(_Up&& __v) &&
+ noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+ is_nothrow_convertible<_Up, _Tp>>)
+ {
+ static_assert( is_move_constructible_v<_Tp> );
+ static_assert( is_convertible_v<_Up, _Tp> );
+
+ if (_M_has_value)
+ return std::move(_M_val);
+ return static_cast<_Tp>(std::forward<_Up>(__v));
+ }
+
+ // equality operators
+
+ template<typename _Up, typename _Er2>
+ requires (!is_void_v<_Up>)
+ friend constexpr bool
+ operator==(const expected& __x, const expected<_Up, _Er2>& __y)
+ noexcept(noexcept(bool(*__x == *__y))
+ && noexcept(bool(__x.error() == __y.error())))
+ {
+ if (__x.has_value())
+ return __y.has_value() && bool(*__x == *__y);
+ else
+ return !__y.has_value() && bool(__x.error() == __y.error());
+ }
+
+ template<typename _Up>
+ friend constexpr bool
+ operator==(const expected& __x, const _Up& __v)
+ noexcept(noexcept(bool(*__x == __v)))
+ { return __x.has_value() && bool(*__x == __v); }
+
+ template<typename _Er2>
+ friend constexpr bool
+ operator==(const expected& __x, const unexpected<_Er2>& __e)
+ noexcept(noexcept(bool(__x.error() == __e.error())))
+ { return !__x.has_value() && bool(__x.error() == __e.error()); }
+
+ friend constexpr void
+ swap(expected& __x, expected& __y)
+ noexcept(noexcept(__x.swap(__y)))
+ requires requires {__x.swap(__y);}
+ { __x.swap(__y); }
+
+ private:
+ template<typename, typename> friend class expected;
+
+ template<typename _Vp>
+ constexpr void
+ _M_assign_val(_Vp&& __v)
+ {
+ if (_M_has_value)
+ _M_val = std::forward<_Vp>(__v);
+ else
+ {
+ __expected::__reinit(__builtin_addressof(_M_val),
+ __builtin_addressof(_M_unex),
+ std::forward<_Vp>(__v));
+ _M_has_value = true;
+ }
+ }
+
+ template<typename _Vp>
+ constexpr void
+ _M_assign_unex(_Vp&& __v)
+ {
+ if (_M_has_value)
+ {
+ __expected::__reinit(__builtin_addressof(_M_unex),
+ __builtin_addressof(_M_val),
+ std::forward<_Vp>(__v));
+ _M_has_value = false;
+ }
+ else
+ _M_unex = std::forward<_Vp>(__v);
+ }
+
+ // Swap two expected objects when only one has a value.
+ // Precondition: this->_M_has_value && !__rhs._M_has_value
+ constexpr void
+ _M_swap_val_unex(expected& __rhs)
+ noexcept(__and_v<is_nothrow_move_constructible<_Er>,
+ is_nothrow_move_constructible<_Tp>>)
+ {
+ if constexpr (is_nothrow_move_constructible_v<_Er>)
+ {
+ __expected::_Guard<_Er> __guard(__rhs._M_unex);
+ std::construct_at(__builtin_addressof(__rhs._M_val),
+ std::move(_M_val)); // might throw
+ __rhs._M_has_value = true;
+ std::destroy_at(__builtin_addressof(_M_val));
+ std::construct_at(__builtin_addressof(_M_unex),
+ __guard.release());
+ _M_has_value = false;
+ }
+ else
+ {
+ __expected::_Guard<_Tp> __guard(__rhs._M_val);
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::move(__rhs._M_unex)); // might throw
+ _M_has_value = false;
+ std::destroy_at(__builtin_addressof(__rhs._M_unex));
+ std::construct_at(__builtin_addressof(__rhs._M_val),
+ __guard.release());
+ __rhs._M_has_value = true;
+ }
+ }
+
+ union {
+ struct { } _M_invalid;
+ _Tp _M_val;
+ _Er _M_unex;
+ };
+
+ bool _M_has_value;
+ };
+
+ // Partial specialization for std::expected<cv void, E>
+ template<typename _Tp, typename _Er> requires is_void_v<_Tp>
+ class expected<_Tp, _Er>
+ {
+ static_assert( __expected::__can_be_unexpected<_Er> );
+
+ template<typename _Up, typename _Err, typename _Unex = unexpected<_Er>>
+ static constexpr bool __cons_from_expected
+ = __or_v<is_constructible<_Unex, expected<_Up, _Err>&>,
+ is_constructible<_Unex, expected<_Up, _Err>>,
+ is_constructible<_Unex, const expected<_Up, _Err>&>,
+ is_constructible<_Unex, const expected<_Up, _Err>>
+ >;
+
+ public:
+ using value_type = _Tp;
+ using error_type = _Er;
+ using unexpected_type = unexpected<_Er>;
+
+ template<typename _Up>
+ using rebind = expected<_Up, error_type>;
+
+ constexpr
+ expected() noexcept
+ : _M_void(), _M_has_value(true)
+ { }
+
+ expected(const expected&) = default;
+
+ constexpr
+ expected(const expected& __x)
+ noexcept(is_nothrow_copy_constructible_v<_Er>)
+ requires is_copy_constructible_v<_Er>
+ && (!is_trivially_copy_constructible_v<_Er>)
+ : _M_void(), _M_has_value(__x._M_has_value)
+ {
+ if (!_M_has_value)
+ std::construct_at(__builtin_addressof(_M_unex), __x._M_unex);
+ }
+
+ expected(expected&&) = default;
+
+ constexpr
+ expected(expected&& __x)
+ noexcept(is_nothrow_move_constructible_v<_Er>)
+ requires is_move_constructible_v<_Er>
+ && (!is_trivially_move_constructible_v<_Er>)
+ : _M_void(), _M_has_value(__x._M_has_value)
+ {
+ if (!_M_has_value)
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::move(__x)._M_unex);
+ }
+
+ template<typename _Up, typename _Gr>
+ requires is_void_v<_Up>
+ && is_constructible_v<_Er, const _Gr&>
+ && (!__cons_from_expected<_Up, _Gr>)
+ constexpr explicit(!is_convertible_v<const _Gr&, _Er>)
+ expected(const expected<_Up, _Gr>& __x)
+ noexcept(is_nothrow_constructible_v<_Er, const _Gr&>)
+ : _M_void(), _M_has_value(__x._M_has_value)
+ {
+ if (!_M_has_value)
+ std::construct_at(__builtin_addressof(_M_unex), __x._M_unex);
+ }
+
+ template<typename _Up, typename _Gr>
+ requires is_void_v<_Tp>
+ && is_constructible_v<_Er, const _Gr&>
+ && (!__cons_from_expected<_Up, _Gr>)
+ constexpr explicit(!is_convertible_v<_Gr, _Er>)
+ expected(expected<_Up, _Gr>&& __x)
+ noexcept(is_nothrow_constructible_v<_Er, _Gr>)
+ : _M_void(), _M_has_value(__x._M_has_value)
+ {
+ if (!_M_has_value)
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::move(__x)._M_unex);
+ }
+
+ template<typename _Gr = _Er>
+ requires is_constructible_v<_Er, const _Gr&>
+ constexpr explicit(!is_convertible_v<const _Gr&, _Er>)
+ expected(const unexpected<_Gr>& __u)
+ noexcept(is_nothrow_constructible_v<_Er, const _Gr&>)
+ : _M_unex(__u.error()), _M_has_value(false)
+ { }
+
+ template<typename _Gr = _Er>
+ requires is_constructible_v<_Er, _Gr>
+ constexpr explicit(!is_convertible_v<_Gr, _Er>)
+ expected(unexpected<_Gr>&& __u)
+ noexcept(is_nothrow_constructible_v<_Er, _Gr>)
+ : _M_unex(std::move(__u).error()), _M_has_value(false)
+ { }
+
+ template<typename... _Args>
+ constexpr explicit
+ expected(in_place_t) noexcept
+ : expected()
+ { }
+
+ template<typename... _Args>
+ requires is_constructible_v<_Er, _Args...>
+ constexpr explicit
+ expected(unexpect_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Er, _Args...>)
+ : _M_unex(std::forward<_Args>(__args)...), _M_has_value(false)
+ { }
+
+ template<typename _Up, typename... _Args>
+ requires is_constructible_v<_Er, initializer_list<_Up>&, _Args...>
+ constexpr explicit
+ expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Er, initializer_list<_Up>&,
+ _Args...>)
+ : _M_unex(__il, std::forward<_Args>(__args)...), _M_has_value(false)
+ { }
+
+ constexpr ~expected() = default;
+
+ constexpr ~expected() requires (!is_trivially_destructible_v<_Er>)
+ {
+ if (!_M_has_value)
+ std::destroy_at(__builtin_addressof(_M_unex));
+ }
+
+ // assignment
+
+ expected& operator=(const expected&) = delete;
+
+ constexpr expected&
+ operator=(const expected& __x)
+ noexcept(__and_v<is_nothrow_copy_constructible<_Er>,
+ is_nothrow_copy_assignable<_Er>>)
+ requires is_copy_constructible_v<_Er>
+ && is_copy_assignable_v<_Er>
+ {
+ if (__x._M_has_value)
+ emplace();
+ else
+ _M_assign_unex(__x._M_unex);
+ return *this;
+ }
+
+ constexpr expected&
+ operator=(expected&& __x)
+ noexcept(__and_v<is_nothrow_move_constructible<_Er>,
+ is_nothrow_move_assignable<_Er>>)
+ requires is_move_constructible_v<_Er>
+ && is_move_assignable_v<_Er>
+ {
+ if (__x._M_has_value)
+ emplace();
+ else
+ _M_assign_unex(std::move(__x._M_unex));
+ return *this;
+ }
+
+ template<typename _Gr>
+ requires is_constructible_v<_Er, const _Gr&>
+ && is_assignable_v<_Er&, const _Gr&>
+ constexpr expected&
+ operator=(const unexpected<_Gr>& __e)
+ {
+ _M_assign_unex(__e.error());
+ return *this;
+ }
+
+ template<typename _Gr>
+ requires is_constructible_v<_Er, _Gr>
+ && is_assignable_v<_Er&, _Gr>
+ constexpr expected&
+ operator=(unexpected<_Gr>&& __e)
+ {
+ _M_assign_unex(std::move(__e.error()));
+ return *this;
+ }
+
+ // modifiers
+
+ constexpr void
+ emplace() noexcept
+ {
+ if (!_M_has_value)
+ {
+ std::destroy_at(__builtin_addressof(_M_unex));
+ _M_has_value = true;
+ }
+ }
+
+ // swap
+ constexpr void
+ swap(expected& __x)
+ noexcept(__and_v<is_nothrow_swappable<_Er&>,
+ is_nothrow_move_constructible<_Er>>)
+ requires is_swappable_v<_Er> && is_move_constructible_v<_Er>
+ {
+ if (_M_has_value)
+ {
+ if (!__x._M_has_value)
+ {
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::move(__x._M_unex)); // might throw
+ std::destroy_at(__builtin_addressof(__x._M_unex));
+ __x._M_has_value = true;
+ }
+ }
+ else
+ {
+ if (__x._M_has_value)
+ {
+ std::construct_at(__builtin_addressof(__x._M_unex),
+ std::move(_M_unex)); // might throw
+ std::destroy_at(__builtin_addressof(_M_unex));
+ _M_has_value = true;
+ }
+ else
+ {
+ using std::swap;
+ swap(_M_unex, __x._M_unex);
+ }
+ }
+ }
+
+ // observers
+
+ [[nodiscard]]
+ constexpr explicit
+ operator bool() const noexcept { return _M_has_value; }
+
+ [[nodiscard]]
+ constexpr bool has_value() const noexcept { return _M_has_value; }
+
+ constexpr void
+ operator*() const noexcept { __glibcxx_assert(_M_has_value); }
+
+ constexpr void
+ value() const&
+ {
+ if (_M_has_value) [[likely]]
+ return;
+ _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(_M_unex));
+ }
+
+ constexpr void
+ value() &&
+ {
+ if (_M_has_value) [[likely]]
+ return;
+ _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(std::move(_M_unex)));
+ }
+
+ constexpr const _Er&
+ error() const & noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return _M_unex;
+ }
+
+ constexpr _Er&
+ error() & noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return _M_unex;
+ }
+
+ constexpr const _Er&&
+ error() const && noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return std::move(_M_unex);
+ }
+
+ constexpr _Er&&
+ error() && noexcept
+ {
+ __glibcxx_assert(!_M_has_value);
+ return std::move(_M_unex);
+ }
+
+ // equality operators
+
+ template<typename _Up, typename _Er2>
+ requires is_void_v<_Up>
+ friend constexpr bool
+ operator==(const expected& __x, const expected<_Up, _Er2>& __y)
+ noexcept(noexcept(bool(__x.error() == __y.error())))
+ {
+ if (__x.has_value())
+ return __y.has_value();
+ else
+ return !__y.has_value() && bool(__x.error() == __y.error());
+ }
+
+ template<typename _Er2>
+ friend constexpr bool
+ operator==(const expected& __x, const unexpected<_Er2>& __e)
+ noexcept(noexcept(bool(__x.error() == __e.error())))
+ { return !__x.has_value() && bool(__x.error() == __e.error()); }
+
+ friend constexpr void
+ swap(expected& __x, expected& __y)
+ noexcept(noexcept(__x.swap(__y)))
+ requires requires { __x.swap(__y); }
+ { __x.swap(__y); }
+
+ private:
+ template<typename, typename> friend class expected;
+
+ template<typename _Vp>
+ constexpr void
+ _M_assign_unex(_Vp&& __v)
+ {
+ if (_M_has_value)
+ {
+ std::construct_at(__builtin_addressof(_M_unex),
+ std::forward<_Vp>(__v));
+ _M_has_value = false;
+ }
+ else
+ _M_unex = std::forward<_Vp>(__v);
+ }
+
+
+ union {
+ struct { } _M_void;
+ _Er _M_unex;
+ };
+
+ bool _M_has_value;
+ };
+ /// @}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++23
+#endif // _GLIBCXX_EXPECTED
@@ -306,6 +306,7 @@
#if _GLIBCXX_HOSTED
#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
+#define __cpp_lib_expected 202202L
#define __cpp_lib_invoke_r 202106L
#define __cpp_lib_ios_noreplace 202200L
#if __cpp_lib_concepts
@@ -79,7 +79,7 @@ namespace std
* abandoned for any reason. It can also be called by the user. */
void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__));
-#if __cplusplus < 201703L || _GLIBCXX_USE_DEPRECATED
+#if __cplusplus < 201703L || (__cplusplus <= 202002L && _GLIBCXX_USE_DEPRECATED)
/// If you write a replacement %unexpected handler, it must be of this type.
typedef void (*_GLIBCXX11_DEPRECATED unexpected_handler) ();
new file mode 100644
@@ -0,0 +1,321 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <expected>
+#include <type_traits>
+#include <testsuite_hooks.h>
+
+int dtor_count;
+constexpr void reset_dtor_count()
+{
+ if (!std::is_constant_evaluated())
+ dtor_count = 0;
+}
+constexpr void inc_dtor_count()
+{
+ if (!std::is_constant_evaluated())
+ ++dtor_count;
+}
+constexpr bool check_dtor_count(int c)
+{
+ if (std::is_constant_evaluated())
+ return true;
+ return dtor_count == c;
+}
+
+struct X
+{
+ constexpr X(int i, int j = 0) noexcept : n(i+j) { }
+ constexpr X(std::initializer_list<int> l, void*) noexcept : n(l.size()) { }
+
+ constexpr X(const X&) = default;
+ constexpr X(X&& x) noexcept : n(x.n) { x.n = -1; }
+
+ constexpr X& operator=(const X&) = default;
+ constexpr X& operator=(X&& x) noexcept { n = x.n; x.n = -1; return *this; }
+
+ constexpr ~X()
+ {
+ inc_dtor_count();
+ }
+
+ constexpr bool operator==(const X&) const = default;
+ constexpr bool operator==(int i) const { return n == i; }
+
+ int n;
+};
+
+constexpr bool
+test_copy(bool = true)
+{
+ reset_dtor_count();
+
+ std::expected<int, int> e1(1), e2(2), e3(std::unexpect, 3);
+
+ e1 = e1;
+ e1 = e2; // T = T
+ VERIFY( e1.value() == e2.value() );
+ e1 = e3; // T = E
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == e3.error() );
+ e1 = e3; // E = E
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == e3.error() );
+ e1 = e2; // E = T
+ VERIFY( e1.value() == e2.value() );
+
+ e1 = std::move(e1);
+ e1 = std::move(e2); // T = T
+ VERIFY( e1.value() == e2.value() );
+ e1 = std::move(e3); // T = E
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == e3.error() );
+ e1 = std::move(e3); // E = E
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == e3.error() );
+ e1 = std::move(e2); // E = T
+ VERIFY( e1.value() == e2.value() );
+
+ std::expected<X, X> x1(1), x2(2), x3(std::unexpect, 3);
+
+ x1 = x1;
+
+ x1 = x2; // T = T
+ VERIFY( check_dtor_count(0) );
+ VERIFY( x1.value() == x2.value() );
+ x1 = x3; // T = E
+ VERIFY( check_dtor_count(1) );
+ VERIFY( ! x1.has_value() );
+ x1 = x3; // E = E
+ VERIFY( check_dtor_count(1) );
+ VERIFY( ! x1.has_value() );
+ x1 = x2; // E = T
+ VERIFY( check_dtor_count(2) );
+ VERIFY( x1.value() == x2.value() );
+
+ reset_dtor_count();
+
+ x1 = std::move(x1);
+ VERIFY( x1.value() == -1 );
+
+ x1 = std::move(x2); // T = T
+ VERIFY( check_dtor_count(0) );
+ VERIFY( x1.value() == 2 );
+ VERIFY( x2.value() == -1 );
+ x1 = std::move(x3); // T = E
+ VERIFY( check_dtor_count(1) );
+ VERIFY( ! x1.has_value() );
+ VERIFY( x1.error() == 3 );
+ VERIFY( x3.error() == -1 );
+ x3.error().n = 33;
+ x1 = std::move(x3); // E = E
+ VERIFY( check_dtor_count(1) );
+ VERIFY( ! x1.has_value() );
+ VERIFY( x1.error() == 33 );
+ VERIFY( x3.error() == -1 );
+ x2.value().n = 22;
+ x1 = std::move(x2); // E = T
+ VERIFY( check_dtor_count(2) );
+ VERIFY( x1.value() == 22 );
+ VERIFY( x2.value() == -1 );
+
+ std::expected<void, int> ev1, ev2, ev3(std::unexpect, 3);
+
+ ev1 = ev2; // T = T
+ VERIFY( ev1.has_value() );
+ ev1 = ev3; // T = E
+ VERIFY( ! ev1.has_value() );
+ VERIFY( ev1.error() == ev3.error() );
+ ev1 = ev3; // E = E
+ VERIFY( ! ev1.has_value() );
+ VERIFY( ev1.error() == ev3.error() );
+ ev1 = ev2; // E = T
+ VERIFY( ev1.has_value() );
+
+ reset_dtor_count();
+ std::expected<void, X> xv1, xv2, xv3(std::unexpect, 3);
+
+ xv1 = std::move(xv2); // T = T
+ VERIFY( check_dtor_count(0) );
+ VERIFY( xv1.has_value() );
+ xv1 = std::move(xv3); // T = E
+ VERIFY( check_dtor_count(0) );
+ VERIFY( ! xv1.has_value() );
+ VERIFY( xv1.error() == 3 );
+ VERIFY( xv3.error() == -1 );
+ xv3.error().n = 33;
+ xv1 = std::move(xv3); // E = E
+ VERIFY( check_dtor_count(0) );
+ VERIFY( xv1.error() == 33 );
+ VERIFY( xv3.error() == -1 );
+ xv1 = std::move(xv2); // E = T
+ VERIFY( check_dtor_count(1) );
+ VERIFY( xv1.has_value() );
+
+ return true;
+}
+
+constexpr bool
+test_converting(bool = true)
+{
+ std::expected<int, int> e1(1);
+ std::expected<unsigned, long> e2(2U), e3(std::unexpect, 3L);
+ e1 = e2;
+ VERIFY( e1.value() == e2.value() );
+ e1 = e3;
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == e3.error() );
+ e1 = e2;
+ VERIFY( e1.value() == e2.value() );
+
+ e1 = std::move(e3);
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == e3.error() );
+ e1 = std::move(e2);
+ VERIFY( e1.value() == e2.value() );
+
+ std::expected<void, int> ev4;
+ std::expected<const void, long> ev5(std::unexpect, 5);
+ ev4 = ev5;
+ VERIFY( ! ev4.has_value() );
+ VERIFY( ev4.error() == 5 );
+ ev4 = std::expected<volatile void, unsigned>();
+ VERIFY( ev4.has_value() );
+ ev4 = std::move(ev5);
+ VERIFY( ! ev4.has_value() );
+ VERIFY( ev4.error() == 5 );
+
+ return true;
+}
+
+constexpr bool
+test_unexpected(bool = true)
+{
+ reset_dtor_count();
+
+ std::expected<X, int> e1(0);
+
+ e1 = std::unexpected<int>(5);
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == 5 );
+ VERIFY( check_dtor_count(1) );
+
+ e1 = std::unexpected<int>(6);
+ VERIFY( check_dtor_count(1) );
+
+ std::expected<int, X> e2;
+
+ std::unexpected<X> x(std::in_place, 1, 2);
+ e2 = x;
+ VERIFY( check_dtor_count(1) );
+
+ e2 = 1;
+ VERIFY( e2.value() == 1 );
+ VERIFY( check_dtor_count(2) );
+
+ return true;
+}
+
+constexpr bool
+test_emplace(bool = true)
+{
+ reset_dtor_count();
+
+ std::expected<int, int> e1(1);
+ e1.emplace(2);
+ VERIFY( e1.value() == 2 );
+
+ std::expected<void, int> ev2;
+ ev2.emplace();
+ VERIFY( ev2.has_value() );
+
+ std::expected<X, int> e3(std::in_place, 0, 0);
+
+ e3.emplace({1,2,3}, nullptr);
+ VERIFY( e3.value() == 3 );
+ VERIFY( check_dtor_count(1) );
+
+ e3.emplace(2, 2);
+ VERIFY( e3.value() == 4 );
+ VERIFY( check_dtor_count(2) );
+
+ std::expected<int, X> ev4(std::unexpect, 4);
+
+ ev4.emplace(5);
+ VERIFY( ev4.value() == 5 );
+ VERIFY( check_dtor_count(3) );
+
+ ev4.emplace(6);
+ VERIFY( ev4.value() == 6 );
+ VERIFY( check_dtor_count(3) );
+
+ return true;
+}
+
+void
+test_exception_safety()
+{
+ struct CopyThrows
+ {
+ CopyThrows(int i) noexcept : x(i) { }
+ CopyThrows(const CopyThrows&) { throw 1; }
+ CopyThrows(CopyThrows&&) = default;
+ CopyThrows& operator=(const CopyThrows&) = default;
+ CopyThrows& operator=(CopyThrows&&) = default;
+ int x;
+
+ bool operator==(int i) const { return x == i; }
+ };
+
+ struct MoveThrows
+ {
+ MoveThrows(int i) noexcept : x(i) { }
+ MoveThrows(const MoveThrows&) = default;
+ MoveThrows(MoveThrows&&) { throw 1L; }
+ MoveThrows& operator=(const MoveThrows&) = default;
+ MoveThrows& operator=(MoveThrows&&) = default;
+ int x;
+
+ bool operator==(int i) const { return x == i; }
+ };
+
+ std::expected<CopyThrows, MoveThrows> c(std::unexpect, 1);
+
+ // operator=(U&&)
+ try {
+ CopyThrows x(2);
+ c = x;
+ VERIFY( false );
+ } catch (int) {
+ VERIFY( ! c.has_value() );
+ VERIFY( c.error() == 1 );
+ }
+
+ c = CopyThrows(2);
+
+ try {
+ c = std::unexpected<MoveThrows>(3);
+ VERIFY( false );
+ } catch (long) {
+ VERIFY( c.value() == 2 );
+ }
+}
+
+int main(int argc, char**)
+{
+ bool non_constant = argc == 1; // force non-constant evaluation
+
+ static_assert( test_copy() );
+ test_copy(non_constant);
+ static_assert( test_converting() );
+ test_converting(non_constant);
+ static_assert( test_unexpected() );
+ test_unexpected(non_constant);
+ static_assert( test_emplace() );
+ test_emplace(non_constant);
+
+ test_exception_safety();
+
+ // Ensure the non-constexpr tests actually ran:
+ VERIFY( dtor_count != 0 );
+}
new file mode 100644
@@ -0,0 +1,175 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <expected>
+#include <testsuite_hooks.h>
+
+constexpr bool
+test_default()
+{
+ std::expected<int, int> e;
+ VERIFY( e.has_value() );
+ VERIFY( *e == 0 );
+
+ std::expected<void, int> ev;
+ VERIFY( ev.has_value() );
+ VERIFY( (ev.value(), true) );
+
+ return true;
+}
+
+constexpr bool
+test_val()
+{
+ std::expected<int, int> e1(1);
+ VERIFY( e1.has_value() );
+ VERIFY( *e1 == 1 );
+
+ std::expected<int, int> e2(std::in_place, 2);
+ VERIFY( e2.has_value() );
+ VERIFY( *e2 == 2 );
+
+ struct X
+ {
+ constexpr X(std::initializer_list<int> l, void*) : n(l.size()) { }
+ int n;
+ };
+
+ std::expected<X, int> e3(X{{1, 2, 3}, nullptr});
+ VERIFY( e3.has_value() );
+ VERIFY( e3->n == 3 );
+
+ std::expected<X, int> e4(std::in_place, {1, 2, 3, 4}, nullptr);
+ VERIFY( e4.has_value() );
+ VERIFY( e4->n == 4 );
+
+ std::expected<void, int> ev(std::in_place);
+ VERIFY( ev.has_value() );
+ VERIFY( (ev.value(), true) );
+
+ return true;
+}
+
+constexpr bool
+test_err()
+{
+ std::expected<int, int> e1(std::unexpected<int>(1));
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == 1 );
+
+ const std::unexpected<int> u2(2);
+ std::expected<int, int> e2(u2);
+ VERIFY( ! e2.has_value() );
+ VERIFY( e2.error() == 2 );
+
+ std::expected<int, int> e3(std::unexpect, 3);
+ VERIFY( ! e3.has_value() );
+ VERIFY( e3.error() == 3 );
+
+ struct X
+ {
+ constexpr X(int i, int j) : n(i+j) { }
+ constexpr X(std::initializer_list<int> l, void*) : n(l.size()) { }
+ int n;
+ };
+
+ std::expected<int, X> e4(std::unexpect, 1, 3);
+ VERIFY( ! e4.has_value() );
+ VERIFY( e4.error().n == 4 );
+
+ std::expected<int, X> e5(std::unexpect, {1, 2, 3, 4, 5}, nullptr);
+ VERIFY( ! e5.has_value() );
+ VERIFY( e5.error().n == 5 );
+
+ std::expected<const void, int> ev1(std::unexpected<int>(1));
+ VERIFY( ! ev1.has_value() );
+ VERIFY( ev1.error() == 1 );
+
+ std::expected<volatile void, int> ev2(u2);
+ VERIFY( ! ev2.has_value() );
+ VERIFY( ev2.error() == 2 );
+
+ std::expected<const volatile void, int> ev3(std::unexpect, 3);
+ VERIFY( ! ev3.has_value() );
+ VERIFY( ev3.error() == 3 );
+
+ std::expected<void, X> ev4(std::unexpect, 1, 3);
+ VERIFY( ! ev4.has_value() );
+ VERIFY( ev4.error().n == 4 );
+
+ std::expected<void, X> ev5(std::unexpect, {1, 2, 3, 4, 5}, nullptr);
+ VERIFY( ! ev5.has_value() );
+ VERIFY( ev5.error().n == 5 );
+
+ return true;
+}
+
+constexpr bool
+test_copy()
+{
+ std::expected<int, int> e1(1);
+ std::expected<int, int> e2(e1);
+ VERIFY( e2.value() == 1 );
+ std::expected<int, int> e3(std::move(e2));
+ VERIFY( e2.value() == 1 );
+ VERIFY( e3.value() == 1 );
+ std::expected<short, short> e4(e1);
+ VERIFY( e4.value() == 1 );
+ std::expected<short, short> e5(std::move(e4));
+ VERIFY( e4.value() == 1 );
+ VERIFY( e5.value() == 1 );
+
+ std::expected<int, int> u1(std::unexpect, 2);
+ std::expected<int, int> u2(u1);
+ VERIFY( ! u2.has_value() );
+ VERIFY( u2.error() == 2 );
+ std::expected<int, int> u3(std::move(u2));
+ VERIFY( ! u3.has_value() );
+ VERIFY( u3.error() == 2 );
+ std::expected<short, short> u4(u1);
+ VERIFY( ! u4.has_value() );
+ VERIFY( u4.error() == 2 );
+ std::expected<short, short> u5(std::move(u4));
+ VERIFY( ! u5.has_value() );
+ VERIFY( u5.error() == 2 );
+
+ std::expected<void, int> ev1;
+ std::expected<void, int> ev2(ev1);
+ VERIFY( ev2.has_value() );
+ std::expected<void, int> ev3(std::move(ev2));
+ VERIFY( ev2.has_value() );
+ VERIFY( ev3.has_value() );
+ std::expected<volatile void, short> ev4(ev1);
+ VERIFY( ev4.has_value() );
+ std::expected<const void, short> ev5(std::move(ev4));
+ VERIFY( ev4.has_value() );
+ VERIFY( ev5.has_value() );
+
+ std::expected<void, int> uv1(std::unexpect, 2);
+ std::expected<void, int> uv2(uv1);
+ VERIFY( ! uv2.has_value() );
+ VERIFY( uv2.error() == 2 );
+ std::expected<void, int> uv3(std::move(uv2));
+ VERIFY( ! uv3.has_value() );
+ VERIFY( uv3.error() == 2 );
+ std::expected<const void, short> uv4(uv1);
+ VERIFY( ! uv4.has_value() );
+ VERIFY( uv4.error() == 2 );
+ std::expected<volatile void, short> uv5(std::move(uv4));
+ VERIFY( ! uv5.has_value() );
+ VERIFY( uv5.error() == 2 );
+
+ return true;
+}
+
+int main()
+{
+ test_default();
+ static_assert( test_default() );
+ test_val();
+ static_assert( test_val() );
+ test_err();
+ static_assert( test_err() );
+ test_copy();
+ static_assert( test_copy() );
+}
new file mode 100644
@@ -0,0 +1,67 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <expected>
+
+void
+test_unexpected()
+{
+ int i[2]{};
+
+ // std::unexpected<E> is ill-formed if E is a non-object type,
+
+ std::unexpected<int&> ref(i[0]); // { dg-error "here" }
+ std::unexpected<void()> func(test_unexpected); // { dg-error "here" }
+ // { dg-error "no matching function for call to" "" { target *-*-* } 0 }
+ // { dg-error "invalidly declared function type" "" { target *-*-* } 0 }
+
+ // an array type,
+ std::unexpected<int[2]> array(i); // { dg-error "here" }
+
+ // a specialization of std::unexpected,
+ std::unexpected<int> u(1);
+ std::unexpected<std::unexpected<int>> nested(u); // { dg-error "here" }
+ //
+ // or a cv-qualified type.
+ std::unexpected<const int> c_int(1); // { dg-error "here" }
+ std::unexpected<volatile int> v_int(1); // { dg-error "here" }
+}
+
+void
+test_expected_value()
+{
+ // std::expected<T, E> is ill-formed if T is a reference type,
+ std::expected<int&, int> ref(std::unexpect); // { dg-error "here" }
+ // { dg-error "reference type" "" { target *-*-* } 0 }
+
+ // a function type,
+ std::expected<void(), int> func(std::unexpect); // { dg-error "here" }
+ // { dg-error "returning a function" "" { target *-*-* } 0 }
+ //
+ // possibly cv-qualified types in_place_t,
+ std::expected<std::in_place_t, int> tag(std::unexpect); // { dg-error "here" }
+ std::expected<const std::in_place_t, int> ctag(std::unexpect); // { dg-error "here" }
+ // unexpect_t,
+ std::expected<std::unexpect_t, int> utag(std::unexpect); // { dg-error "here" }
+ std::expected<const std::unexpect_t, int> cutag(std::unexpect); // { dg-error "here" }
+ // or a specialization of unexpected.
+ std::expected<std::unexpected<int>, int> unex(std::in_place, 1); // { dg-error "here" }
+ std::expected<const std::unexpected<int>, int> cunex(std::in_place, 1); // { dg-error "here" }
+}
+
+void
+test_expected_error()
+{
+
+ // std::expected<T, E> is ill-formed if std::unexpected<E> would be
+ // ill-formed. Test the same types as in test_unexpected().
+
+ std::expected<int, int&> ref; // { dg-error "here" }
+ std::expected<int, void()> func; // { dg-error "here" }
+ std::expected<int, int[2]> array; // { dg-error "here" }
+ std::expected<int, std::unexpected<int>> nested; // { dg-error "here" }
+ std::expected<int, const int> c_int; // { dg-error "here" }
+ std::expected<int, volatile int> v_int; // { dg-error "here" }
+}
+
+// { dg-prune-output "static assertion failed" }
new file mode 100644
@@ -0,0 +1,209 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <expected>
+#include <expected>
+#include <testsuite_hooks.h>
+
+struct X
+{
+ constexpr int f() & { return 1; }
+ constexpr int f() const & { return 2; }
+ constexpr int f() && { return 3; }
+ constexpr int f() const && { return 4; }
+};
+
+constexpr bool
+test_arrow()
+{
+ std::expected<X, int> e1;
+ VERIFY( e1->f() == 1 );
+ const auto& e2 = e1;
+ VERIFY( e2->f() == 2 );
+
+ return true;
+}
+
+constexpr bool
+test_star()
+{
+ std::expected<X, int> e1;
+ VERIFY( (*e1).f() == 1 );
+ VERIFY( std::move(*e1).f() == 3 );
+ const auto& e2 = e1;
+ VERIFY( (*e2).f() == 2 );
+ VERIFY( std::move(*e2).f() == 4 );
+
+ std::expected<void, int> v;
+ *v;
+
+ return true;
+}
+
+constexpr bool
+test_has_value()
+{
+ std::expected<int, int> e;
+ VERIFY( e.has_value() );
+ VERIFY( e );
+ e = std::unexpected(1);
+ VERIFY( ! e.has_value() );
+ VERIFY( ! e );
+
+ std::expected<void, int> v;
+ VERIFY( v.has_value() );
+ VERIFY( v );
+ v = std::unexpected(1);
+ VERIFY( ! v.has_value() );
+ VERIFY( ! v );
+
+ return true;
+}
+
+constexpr bool
+test_value()
+{
+ std::expected<X, int> e1;
+
+ VERIFY( e1.value().f() == 1 );
+ VERIFY( std::move(e1).value().f() == 3 );
+ const auto& e2 = e1;
+ VERIFY( e2.value().f() == 2 );
+ VERIFY( std::move(e2).value().f() == 4 );
+
+ std::expected<void, int> v1;
+ v1.value();
+ std::move(v1).value();
+
+ return true;
+}
+
+void
+test_value_throw()
+{
+ std::expected<int, int> e1 = std::unexpected(9);
+
+ try {
+ e1.value();
+ VERIFY( false );
+ } catch (const std::bad_expected_access<int>& e) {
+ VERIFY( e.error() == 9 );
+ }
+ try {
+ std::move(e1).value();
+ VERIFY( false );
+ } catch (const std::bad_expected_access<int>& e) {
+ VERIFY( e.error() == 9 );
+ }
+
+ const auto& e2 = e1;
+ try {
+ e2.value();
+ VERIFY( false );
+ } catch (const std::bad_expected_access<int>& e) {
+ VERIFY( e.error() == 9 );
+ }
+ try {
+ std::move(e2).value();
+ VERIFY( false );
+ } catch (const std::bad_expected_access<int>& e) {
+ VERIFY( e.error() == 9 );
+ }
+
+ std::expected<void, int> v1 = std::unexpected(8);
+ try {
+ v1.value();
+ VERIFY( false );
+ } catch (const std::bad_expected_access<int>& e) {
+ VERIFY( e.error() == 8 );
+ }
+ try {
+ std::move(v1).value();
+ VERIFY( false );
+ } catch (const std::bad_expected_access<int>& e) {
+ VERIFY( e.error() == 8 );
+ }
+}
+
+constexpr bool
+test_error()
+{
+ std::expected<int, X> e1(std::unexpect);
+
+ VERIFY( e1.error().f() == 1 );
+ VERIFY( std::move(e1).error().f() == 3 );
+ const auto& e2 = e1;
+ VERIFY( e2.error().f() == 2 );
+ VERIFY( std::move(e2).error().f() == 4 );
+
+ std::expected<void, X> v1(std::unexpect);
+
+ VERIFY( v1.error().f() == 1 );
+ VERIFY( std::move(v1).error().f() == 3 );
+ const auto& v2 = v1;
+ VERIFY( v2.error().f() == 2 );
+ VERIFY( std::move(v2).error().f() == 4 );
+
+ return true;
+}
+
+constexpr bool
+test_value_or()
+{
+ struct Movable
+ {
+ constexpr Movable(int i) : x(i) { }
+ constexpr Movable(const Movable&) = default;
+ constexpr Movable(Movable&& m) : x(m.x) { m.x = -1; }
+ int x;
+
+ constexpr bool operator==(int i) const { return x == i; }
+ };
+
+ std::expected<Movable, int> e1(1);
+
+ Movable m2(2);
+ VERIFY( e1.value_or(2) == 1 );
+ VERIFY( e1.value_or(m2) == 1 );
+ VERIFY( e1.value_or(std::move(m2)) == 1 );
+ VERIFY( m2 == 2 );
+
+ VERIFY( std::move(e1).value_or(m2) == 1 );
+ VERIFY( *e1 == -1 ); // moved
+ VERIFY( m2 == 2 );
+
+ e1 = std::unexpected(3);
+ VERIFY( e1.value_or(m2) == 2 );
+ VERIFY( m2 == 2 );
+ VERIFY( std::move(e1).value_or(m2) == 2 );
+ VERIFY( m2 == 2 );
+
+ VERIFY( e1.value_or(std::move(m2)) == 2 );
+ VERIFY( m2 == -1 );
+
+ m2.x = 4;
+ VERIFY( std::move(e1).value_or(std::move(m2)) == 4 );
+ VERIFY( m2 == -1 );
+
+ VERIFY( e1.value_or(5) == 5 );
+ VERIFY( std::move(e1).value_or(6) == 6 );
+
+ return true;
+}
+
+int main()
+{
+ static_assert( test_arrow() );
+ test_arrow();
+ static_assert( test_star() );
+ test_star();
+ static_assert( test_has_value() );
+ test_has_value();
+ static_assert( test_value() );
+ test_value();
+ test_value_throw();
+ static_assert( test_error() );
+ test_error();
+ static_assert( test_value_or() );
+ test_value_or();
+}
new file mode 100644
@@ -0,0 +1,129 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <expected>
+#include <type_traits>
+
+// Default construction
+
+template<typename T, typename E>
+ constexpr bool default_constructible
+ = std::is_default_constructible_v<std::expected<T, E>>;
+
+struct A { A(int); };
+
+static_assert( default_constructible< int, int > );
+static_assert( default_constructible< A, int > == false );
+static_assert( default_constructible< int, A > );
+static_assert( default_constructible< A, A > == false );
+static_assert( default_constructible< int, A > );
+static_assert( default_constructible< void, int > );
+
+// Destruction
+
+template<typename T, typename E>
+ constexpr bool trivially_destructible
+ = std::is_trivially_destructible_v<std::expected<T, E>>;
+
+struct B { ~B(); };
+
+static_assert( trivially_destructible< int, int > );
+static_assert( trivially_destructible< B, int > == false );
+static_assert( trivially_destructible< int, B > == false );
+static_assert( trivially_destructible< B, B > == false );
+static_assert( trivially_destructible< void, int > );
+static_assert( trivially_destructible< void, B > == false );
+
+enum Result { No, Yes, NoThrow, Trivial };
+
+// Copy construction
+
+template<typename T, typename E>
+ constexpr Result copy_constructible
+ = std::is_trivially_copy_constructible_v<std::expected<T, E>> ? Trivial
+ : std::is_copy_constructible_v<std::expected<T, E>> ? Yes
+ : No;
+
+struct C { C(const C&); };
+struct D { D(D&&); };
+
+static_assert( copy_constructible< int, int > == Trivial );
+static_assert( copy_constructible< C, C > == Yes );
+static_assert( copy_constructible< C, int > == Yes );
+static_assert( copy_constructible< int, C > == Yes );
+static_assert( copy_constructible< int, D > == No );
+static_assert( copy_constructible< D, int > == No );
+static_assert( copy_constructible< D, D > == No );
+static_assert( copy_constructible< void, int > == Trivial );
+static_assert( copy_constructible< void, C > == Yes );
+static_assert( copy_constructible< void, D > == No );
+
+// Move construction
+
+template<typename T, typename E>
+ constexpr Result move_constructible
+ = std::is_trivially_move_constructible_v<std::expected<T, E>> ? Trivial
+ : std::is_nothrow_move_constructible_v<std::expected<T, E>> ? NoThrow
+ : std::is_move_constructible_v<std::expected<T, E>> ? Yes
+ : No;
+
+struct E { E(E&&) noexcept; };
+
+static_assert( move_constructible< int, int > == Trivial );
+static_assert( move_constructible< C, C > == Yes );
+static_assert( move_constructible< C, int > == Yes );
+static_assert( move_constructible< int, C > == Yes );
+static_assert( move_constructible< D, D > == Yes );
+static_assert( move_constructible< D, int > == Yes );
+static_assert( move_constructible< int, D > == Yes );
+static_assert( move_constructible< E, E > == NoThrow );
+static_assert( move_constructible< E, int > == NoThrow );
+static_assert( move_constructible< int, E > == NoThrow );
+static_assert( move_constructible< void, int > == Trivial );
+static_assert( move_constructible< void, C > == Yes );
+static_assert( move_constructible< void, D > == Yes );
+static_assert( move_constructible< void, E > == NoThrow );
+
+// Copy assignment
+
+template<typename T, typename E>
+ constexpr bool copy_assignable
+ = std::is_copy_assignable_v<std::expected<T, E>>;
+
+struct F { F(F&&); F& operator=(const F&); }; // not copy-constructible
+struct G { G(const G&); G(G&&); G& operator=(const G&); }; // throwing move
+
+static_assert( copy_assignable< int, int > );
+static_assert( copy_assignable< F, int > == false );
+static_assert( copy_assignable< int, F > == false );
+static_assert( copy_assignable< F, F > == false );
+static_assert( copy_assignable< G, int > );
+static_assert( copy_assignable< int, G > );
+static_assert( copy_assignable< G, G > == false );
+static_assert( copy_assignable< void, int > );
+static_assert( copy_assignable< void, F > == false );
+static_assert( copy_assignable< void, G > );
+
+// Move assignment
+
+template<typename T, typename E>
+ constexpr bool move_assignable
+ = std::is_move_assignable_v<std::expected<T, E>>;
+
+static_assert( move_assignable< int, int > );
+static_assert( move_assignable< F, int > );
+static_assert( move_assignable< int, F > );
+static_assert( move_assignable< F, F > == false );
+static_assert( move_assignable< G, int > );
+static_assert( move_assignable< int, G > );
+static_assert( move_assignable< G, G > == false );
+static_assert( move_assignable< void, int > );
+static_assert( move_assignable< void, F > );
+static_assert( move_assignable< void, G > );
+
+// QoI properties
+static_assert( sizeof(std::expected<char, unsigned char>) == 2 );
+static_assert( sizeof(std::expected<void, char>) == 2 );
+static_assert( sizeof(std::expected<void*, char>) == 2 * __alignof(void*) );
+static_assert( alignof(std::expected<void, char>) == 1 );
+static_assert( alignof(std::expected<void*, char>) == alignof(void*) );
new file mode 100644
@@ -0,0 +1,57 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <expected>
+#include <testsuite_hooks.h>
+
+constexpr bool
+test_swap()
+{
+ std::expected<int, int> e1(1), e2(2);
+ std::expected<int, int> e3(std::unexpect, 3), e4(std::unexpect, 4);
+
+ swap(e1, e2);
+ VERIFY( e1.value() == 2 );
+ VERIFY( e2.value() == 1 );
+ swap(e1, e3);
+ VERIFY( ! e1.has_value() );
+ VERIFY( e1.error() == 3 );
+ VERIFY( e3.value() == 2 );
+ swap(e1, e3);
+ VERIFY( ! e3.has_value() );
+ VERIFY( e1.value() == 2 );
+ VERIFY( e3.error() == 3 );
+ swap(e3, e4);
+ VERIFY( ! e3.has_value() );
+ VERIFY( ! e4.has_value() );
+ VERIFY( e3.error() == 4 );
+ VERIFY( e4.error() == 3 );
+
+ std::expected<int, int> v1(1), v2(2);
+ std::expected<int, int> v3(std::unexpect, 3), v4(std::unexpect, 4);
+
+ swap(v1, v2);
+ VERIFY( v1.value() == 2 );
+ VERIFY( v2.value() == 1 );
+ swap(v1, v3);
+ VERIFY( ! v1.has_value() );
+ VERIFY( v1.error() == 3 );
+ VERIFY( v3.value() == 2 );
+ swap(v1, v3);
+ VERIFY( ! v3.has_value() );
+ VERIFY( v1.value() == 2 );
+ VERIFY( v3.error() == 3 );
+ swap(v3, v4);
+ VERIFY( ! v3.has_value() );
+ VERIFY( ! v4.has_value() );
+ VERIFY( v3.error() == 4 );
+ VERIFY( v4.error() == 3 );
+
+ return true;
+}
+
+int main()
+{
+ static_assert( test_swap() );
+ test_swap();
+}
new file mode 100644
@@ -0,0 +1,21 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do compile { target c++23 } }
+
+#include <expected>
+
+#ifndef __cpp_lib_expected
+# error "Feature-test macro for expected missing in <expected>"
+#elif __cpp_lib_expected != 202202L
+# error "Feature-test macro for expected has wrong value in <expected>"
+#endif
+
+namespace std
+{
+ template<class E> class unexpected;
+ template<class E> class bad_expected_access;
+ template<> class bad_expected_access<void>;
+ struct unexpect_t;
+ extern inline const unexpect_t unexpect;
+ template<class T, class E> class expected;
+ template<class T, class E> requires is_void_v<T> class expected<T, E>;
+}
new file mode 100644
@@ -0,0 +1,80 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <expected>
+#include <testsuite_hooks.h>
+
+static_assert( sizeof(std::unexpected<char>) == 1 );
+
+constexpr bool
+test()
+{
+ std::unexpected<int> u1(1);
+ VERIFY( u1.error() == 1 );
+
+ std::unexpected<int> u2(std::in_place, 2);
+ VERIFY( u2.error() == 2 );
+
+ struct X
+ {
+ constexpr X(int i, int j) : n(i+j) { }
+ constexpr X(std::initializer_list<int> l, void*) : n(l.size()) { }
+
+ constexpr X(const X&) = default;
+ constexpr X(X&& x) :n(x.n) { x.n = -1; }
+
+ constexpr X& operator=(const X&) = default;
+ constexpr X& operator=(X&& x) { n = x.n; x.n = -1; return *this; }
+
+ constexpr bool operator==(const X&) const = default;
+ constexpr bool operator==(int i) const { return n == i; }
+
+ int n;
+ };
+
+ std::unexpected<X> u3(std::in_place, 2, 1);
+ VERIFY( u3.error() == 3 );
+
+ std::unexpected<X> u4(std::in_place, {1,2,3,4}, nullptr);
+ VERIFY( u4.error() == 4 );
+
+ std::unexpected<X> u5(u4);
+ VERIFY( u5.error() == 4 );
+ VERIFY( u4.error() == 4 );
+
+ std::unexpected<X> u6(std::move(u4));
+ VERIFY( u6.error() == 4 );
+ VERIFY( u4.error() == -1 );
+
+ u6 = u3;
+ VERIFY( u6.error() == 3 );
+ VERIFY( u3.error() == 3 );
+
+ u5 = std::move(u3);
+ VERIFY( u5.error() == 3 );
+ VERIFY( u3.error() == -1 );
+
+ u5.swap(u3);
+ VERIFY( u3.error() == 3 );
+ VERIFY( u5.error() == -1 );
+
+ swap(u5, u3);
+ VERIFY( u5.error() == 3 );
+ VERIFY( u3.error() == -1 );
+
+ VERIFY( u1 == u1 );
+ VERIFY( u1 != u2 );
+ VERIFY( u3 == u4 );
+
+ // CTAD
+ std::unexpected u7(1L);
+ static_assert( std::is_same_v<decltype(u7), std::unexpected<long>> );
+
+ return true;
+}
+
+int main()
+{
+ static_assert( test() );
+ test();
+}
new file mode 100644
@@ -0,0 +1,10 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do preprocess { target c++23 } }
+
+#include <version>
+
+#ifndef __cpp_lib_expected
+# error "Feature-test macro for expected missing in <version>"
+#elif __cpp_lib_expected != 202202L
+# error "Feature-test macro for expected has wrong value in <version>"
+#endif