This adjusts the return statements of optional::value_or and
expected::value_or to not perform explicit conversions, so that the
actual conversion performed matches the requirements expressed in the
Mandates: elements (LWG 4406).

Also adjust the return types to remove cv-qualifiers (LWG 3424).

libstdc++-v3/ChangeLog:

	* include/std/expected (expected::value_or): Use remove_cv_t for
	the return type. Do not use static_cast for return statement.
	Adjust static_assert conditions to match return statements.
	* include/std/optional (optional::value_or): Likewise.
	(optional<T&>::value_or): Likewise.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>

This implements P3913R1: Optimize for std::optional in range adaptors.

Specifically, for an opt of type optional<T> that is a view:
* views::reverse(opt), views::take(opt, n), and views::drop(opt, n) returns
   optional<T>.
* views::as_const(opt), optional<T&> is converted into optional<const T&>.
  optional<T const> is not used in the non-reference case because, such
  type is not move assignable, and thus not a view.

libstdc++-v3/ChangeLog:

	* include/std/optional (__is_optional_ref): Define.
	* include/std/ranges (_Take::operator(), _Drop::operator())
	(_Reverse::operator()):	Handle optional<T> that are view.
	(_AsConst::operator()): Handle optional<T&>.
	* testsuite/20_util/optional/range.cc: New tests.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

	PR libstdc++/122425

libstdc++-v3/ChangeLog:

	* include/std/optional
	(ranges::enable_borrowed_range<optional<_Tp&>>): Define.
	* testsuite/20_util/optional/range.cc: Update tests.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

This implements proposed resolution for LWG4308 [1].

For T denoting either function type or unbounded array, the optional<T&> no
longer exposes iterator, and viable begin/end members. The conditionally
provided iterator type, it is now defined in __optional_ref_base
base class.

Furthermore, range support for optional<T&> is now also guarded by
__cpp_lib_optional_range_support.

[1] https://cplusplus.github.io/LWG/issue4308

	PR libstdc++/122396

libstdc++-v3/ChangeLog:

	* include/std/optional (__optional_ref_base): Define.
	(std::optional<_Tp&>): Inherit from __optional_ref_base<_Tp>.
	(optional<_Tp&>::iterator): Move to base class.
	(optional<_Tp&>::begin, optional<_Tp&>::end): Use deduced return
	type and constrain accordingly.
	* testsuite/20_util/optional/range.cc: Add test for optional<T&>.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

This patch implements optional<T&> based on the P2988R12 paper, incorporating
corrections from LWG4300, LWG4304, and LWG3467. The resolution for LWG4015
is also extended to cover optional<T&>.

We introduce _M_fwd() helper, that is equivalent to operator*(), except that
it does not check non-empty precondition. It is used in to correctly propagate
the value during move construction from optional<T&>. This is necessary because
moving an optional<T&> must not move the contained object, which is the key
distinction between *std::move(opt) and std::move(*opt).

The implementation deviates from the standard by providing a separate std::swap
overload for std::optional<T&>, which simplifies preserving the resolution of
LWG2766.

This introduces a few changes to make_optional behavior (see included test):
* some previously valid uses of make_optional<T>({...}) (where T is not a
  reference type) now become ill-formed (see optional/make_optional_neg.cc).
* make_optional<T&>(t) and make_optional<const T&>(ct), where decltype(t) is T&,
  and decltype(ct) is const T& now produce optional<T&> and optional<const T&>
  respectively, instead of optional<T>.
* a few other uses of make_optional<R> with reference type R are now ill-formed.

	PR libstdc++/121748

libstdc++-v3/ChangeLog:

	* include/bits/version.def: Bump value for optional,
	* include/bits/version.h: Regenerate.
	* include/std/optional (std::__is_valid_contained_type_for_optional):
	Define.
	(std::optional<T>): Use __is_valid_contained_type_for_optional.
	(optional<T>(const optional<_Up>&), optional<T>(optional<_Up>&&))
	(optional<T>::operator=(const optional<_Up>&))
	(optional<T>::operator=(optional<_Up>&&)): Replacex._M_get() with
	x._M_fwd(), and std::move(x._M_get()) with std::move(x)._M_fwd().
	(optional<T>::and_then): Remove uncessary remove_cvref_t.
	(optional<T>::_M_fwd): Define.
	(std::optional<T&>): Define new partial specialization.
	(std::swap(std::optional<T&>, std::optional<T&>)): Define.
	(std::make_optional(_Tp&&)): Add non-type template parameter.
	(std::make_optional): Use parenthesis to constructor optional.
	(std::hash<optional<T>>): Add comment.
	* testsuite/20_util/optional/make_optional-2.cc: Guarded not longer
	working example.
	* testsuite/20_util/optional/relops/constrained.cc: Expand test to
	cover optionals of reference.
	* testsuite/20_util/optional/requirements.cc: Ammend for
	optional<T&>.
	* testsuite/20_util/optional/requirements_neg.cc: Likewise.
	* testsuite/20_util/optional/version.cc: Test new value of
	__cpp_lib_optional.
	* testsuite/20_util/optional/make_optional_neg.cc: New test.
	* testsuite/20_util/optional/monadic/ref_neg.cc: New test.
	* testsuite/20_util/optional/ref/access.cc: New test.
	* testsuite/20_util/optional/ref/assign.cc: New test.
	* testsuite/20_util/optional/ref/cons.cc: New test.
	* testsuite/20_util/optional/ref/internal_traits.cc: New test.
	* testsuite/20_util/optional/ref/make_optional/1.cc: New test.
	* testsuite/20_util/optional/ref/make_optional/from_args_neg.cc:
	New test.
	* testsuite/20_util/optional/ref/make_optional/from_lvalue_neg.cc:
	New test.
	* testsuite/20_util/optional/ref/make_optional/from_rvalue_neg.cc:
	New test.
	* testsuite/20_util/optional/ref/monadic.cc: New test.
	* testsuite/20_util/optional/ref/relops.cc: New test.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Co-authored-by: Tomasz Kamiński <tkaminsk@redhat.com>

We pre-emptively implemented part of LWG 2766, which still hasn't been
approved. Add comments to the deleted swap overloads saying why they're
there, because the standard doesn't require them.

libstdc++-v3/ChangeLog:

	* include/bits/stl_pair.h (swap): Add comment to deleted
	overload.
	* include/bits/unique_ptr.h (swap): Likewise.
	* include/std/array (swap): Likewise.
	* include/std/optional (swap): Likewise.
	* include/std/tuple (swap): Likewise.
	* include/std/variant (swap): Likewise.
	* testsuite/23_containers/array/tuple_interface/get_neg.cc:
	Adjust dg-error line numbers.

The specialization of format_kind for optional is causing a problem when
optional is imported and included. The comments on the PR strongly
suggest that this is a frontend bug; this commit just works around the
issue by specifying the type of format_kind<optional<T>> to be
`range_format`, rather than leaving the compiler deduce it via `auto`.

	PR c++/120644

libstdc++-v3/ChangeLog:

	* include/std/optional (format_kind): Do not use `auto`.

This commit implements P3168 ("Give std::optional Range Support"), added
for C++26. Both begin() and end() are straightforward, implemented using
normal_iterator over a raw pointer.

std::optional is also a view, so specialize enable_view for it.

We also need to disable automatic formatting a std::optional as a range
by specializing format_kind. In order to avoid dragging <format> when
including <optional>, I've isolated format_kind and some supporting code
into <bits/formatfwd.h> so that I can use that (comparatively) lighter
header.

libstdc++-v3/ChangeLog:

	* include/bits/formatfwd.h (format_kind): Move the definition
	(and some supporting code) from <format>.
	* include/std/format (format_kind): Likewise.
	* include/bits/version.def (optional_range_support): Add
	the feature-testing macro.
	* include/bits/version.h: Regenerate.
	* include/std/optional (iterator, const_iterator, begin, end):
	Add range support.
	(enable_view): Specialize for std::optional.
	(format_kind): Specialize for std::optional.
	* testsuite/20_util/optional/range.cc: New test.
	* testsuite/20_util/optional/version.cc: Test the new
	feature-testing macro.

It turns out the reason the behavior of this testcase changed after CWG
2369 is because validity of the substituted return type is now checked
later, after constraints.  So a more reliable workaround for this issue
is to add a constraint to check the validity of the return type earlier,
matching the pre-CWG 2369 semantics.

	PR libstdc++/104606

libstdc++-v3/ChangeLog:

	* include/std/optional (operator<=>): Revert r14-9771 change.
	Add constraint checking the validity of the return type
	compare_three_way_result_t before the three_way_comparable_with
	constraint.

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