libstdc++: Implement formatters for queue, priority_queue and stack [PR109162]

This patch implements formatter specializations for standard container adaptors
(queue, priority_queue and stack) from P2286R8.

To be able to access the protected `c` member, the adaptors befriend
corresponding formatter specializations. Note that such specialization
may be disable if the container is formattable, in such case
specializations are unharmful.

As in the case of previous commits, the signatures of the user-facing parse
and format methods of the provided formatters deviate from the standard by
constraining types of parameters:
 * _CharT is constrained __formatter::__char
 * basic_format_parse_context<_CharT> for parse argument
 * basic_format_context<_Out, _CharT> for format second argument
The standard specifies all above as unconstrained types. In particular
_CharT constrain, allow us to befriend all allowed specializations.

Furthermore the standard specifies these formatters as delegating to
formatter<ranges::ref_view<const? _Container>, charT>, which in turn
delegates to range_formatter. This patch avoids one level of indirection,
and dependency of ranges::ref_view.  This is technically observable if
user specializes formatter<std::ref_view<PD>> where PD is program defined
container, but I do not think this is the case worth extra indirection.

This patch also moves the formattable and it's dependencies to the formatfwd.h,
so it can be used in adapters formatters, without including format header.
The definition of _Iter_for is changed from alias to denoting
back_insert_iterator<basic_string<_CharT>>, to struct with type nested typedef
that points to same type, that is forward declared.

	PR libstdc++/109162

libstdc++-v3/ChangeLog:

	* include/bits/formatfwd.h (__format::__parsable_with)
	(__format::__formattable_with, __format::__formattable_impl)
	(__format::__has_debug_format, __format::__const_formattable_range)
	(__format::__maybe_const_range, __format::__maybe_const)
	(std::formattable): Moved from std/format.
	(__format::Iter_for, std::range_formatter): Forward declare.
	* include/bits/stl_queue.h (std::formatter): Forward declare.
	(std::queue, std::priority_queue): Befriend formatter specializations.
	* include/bits/stl_stack.h (std::formatter): Forward declare.
	(std::stack): Befriend formatter specializations.
	* include/std/format (__format::_Iter_for): Define as struct with
	(__format::__parsable_with, __format::__formattable_with)
	(__format::__formattable_impl, __format::__has_debug_format)
	(_format::__const_formattable_range, __format::__maybe_const_range)
	(__format::__maybe_const, std::formattable): Moved to bits/formatfwd.h.
	(std::range_formatter): Remove default argument specified in declaration
	in bits/formatfwd.h.
	* include/std/queue: Include bits/version.h before bits/stl_queue.h.
	(formatter<queue<_Tp, _Container, _Compare>, _CharT>)
	(formatter<priority_queue<_Tp, _Container, _Compare>, _CharT>): Define.
	* include/std/stack: Include bits/version.h before bits/stl_stack.h
	(formatter<stack<_Tp, _Container, _Compare>, _CharT>): Define.
	* testsuite/std/format/ranges/adaptors.cc: New test.

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

1 files changed, 156 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc b/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc
new file mode 100644
index 0000000..854c7ee
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc
@@ -0,0 +1,156 @@
+// { dg-do run { target c++23 } }
+// { dg-timeout-factor 2 }
+
+#include <format>
+#include <queue>
+#include <stack>
+#include <testsuite_hooks.h>
+
+template<typename... Args>
+bool
+is_format_string_for(const char* str, Args&&... args)
+{
+  try {
+    (void) std::vformat(str, std::make_format_args(args...));
+    return true;
+  } catch (const std::format_error&) {
+    return false;
+  }
+}
+
+#define WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
+#define WIDEN(S) WIDEN_(_CharT, S)
+
+template<template<typename Tp> class Adaptor>
+void
+test_format_string()
+{
+  Adaptor<int> q;
+  VERIFY( !is_format_string_for("{:?}", q) );
+  VERIFY( !is_format_string_for("{:P}", q) );
+
+  // width needs to be integer type
+  VERIFY( !is_format_string_for("{:{}}", q, 1.0f) );
+}
+
+struct NoFormat
+{
+  friend auto operator<=>(NoFormat, NoFormat) = default;
+};
+
+struct MutFormat
+{
+  MutFormat() = default;
+  MutFormat(int p) : x(p) {}
+
+  int x;
+  friend auto operator<=>(MutFormat, MutFormat) = default;
+};
+
+template<typename CharT>
+struct std::formatter<MutFormat, CharT>
+  : std::formatter<int, CharT>
+{
+   template<typename Out>
+   Out format(MutFormat& mf, basic_format_context<Out, CharT>& ctx) const
+   { return std::formatter<int, CharT>::format(mf.x, ctx); }
+};
+
+template<typename T>
+struct NotFormattableCont : std::vector<T>
+{
+  using std::vector<T>::vector;
+};
+
+template<typename T>
+constexpr auto std::format_kind<NotFormattableCont<T>>
+  = std::range_format::disabled;
+
+template<typename _CharT,
+	 template<typename Tp, typename Cont = std::vector<Tp>> class Adaptor>
+void
+test_output()
+{
+  const std::vector<int> v{3, 2, 1};
+  std::basic_string<_CharT> res;
+  Adaptor<int, std::vector<int>> q(std::from_range, v);
+
+  res = std::format(WIDEN("{}"), q);
+  VERIFY( res == WIDEN("[3, 2, 1]") );
+
+  res = std::format(WIDEN("{}"), std::as_const(q));
+  VERIFY( res == WIDEN("[3, 2, 1]") );
+
+  res = std::format(WIDEN("{:n:#x}"), q);
+  VERIFY( res == WIDEN("0x3, 0x2, 0x1") );
+
+  res = std::format(WIDEN("{:=^23:#04x}"), q);
+  VERIFY( res == WIDEN("==[0x03, 0x02, 0x01]===") );
+
+  // Sequence output is always used
+  std::queue<_CharT, std::basic_string<_CharT>> qs(
+    std::from_range,
+    std::basic_string_view<_CharT>(WIDEN("321")));
+
+  res = std::format(WIDEN("{}"), qs);
+  VERIFY( res == WIDEN("['3', '2', '1']") );
+
+  res = std::format(WIDEN("{::}"), std::as_const(qs));
+  VERIFY( res == WIDEN("[3, 2, 1]") );
+
+  res = std::format(WIDEN("{:?s}"), qs);
+  VERIFY( res == WIDEN(R"("321")") );
+
+  Adaptor<int, std::deque<int>> qd(std::from_range, v);
+
+  res = std::format(WIDEN("{}"), qd);
+  VERIFY( res == WIDEN("[3, 2, 1]") );
+
+  res = std::format(WIDEN("{}"), std::as_const(qd));
+  VERIFY( res == WIDEN("[3, 2, 1]") );
+
+  Adaptor<MutFormat> mq(std::from_range, v);
+
+  res = std::format(WIDEN("{}"), mq);
+  VERIFY( res == WIDEN("[3, 2, 1]") );
+
+  static_assert(!std::formattable<const Adaptor<MutFormat>, _CharT>);
+
+  static_assert(!std::formattable<Adaptor<NoFormat>, _CharT>);
+  static_assert(!std::formattable<const Adaptor<NoFormat>, _CharT>);
+
+  // Formatter check if container is formattable, not container elements.
+  static_assert(!std::formattable<Adaptor<int, NotFormattableCont<int>>, _CharT>);
+}
+
+template<template<typename Tp, typename Cont = std::vector<Tp>> class Adaptor>
+void
+test_adaptor()
+{
+  test_format_string<Adaptor>();
+  test_output<char, Adaptor>();
+  test_output<wchar_t, Adaptor>();
+
+  static_assert(!std::formattable<Adaptor<int>, int>);
+  static_assert(!std::formattable<Adaptor<int>, char32_t>);
+}
+
+template<typename _CharT>
+void
+test_compare()
+{
+  const std::vector<int> v{3, 2, 1};
+  std::basic_string<_CharT> res;
+  std::priority_queue<int, std::vector<int>, std::greater<>> q(
+     std::from_range, v);
+
+  res = std::format(WIDEN("{}"), q);
+  VERIFY( res == WIDEN("[1, 2, 3]") );
+}
+
+int main()
+{
+  test_adaptor<std::queue>();
+  test_adaptor<std::priority_queue>();
+  test_compare<char>();
+}