[libc++][format] Adds formatter for tuple and pair

[Mordante]

Summary

Implements parts of

• P2286R8 Formatting Ranges

[Mordante]

Fix CI.

[Mordante]

Fixes.

[Mordante]

Fixes and polishing.

[Mordante]

Cleanups and fixes.

[Mordante]

libcxx/include/module.modulemap.in

330

Note this is part of D136711.

[vitaut]

Overall looks good but we need to fix escaping in the standard and the implementation before this ships. Also a bunch of minor(ish) comments inline.

libcxx/include/__format/formatter.h

45–46

Note that there is a paper in flight to change set_debug_format API. Do you see any problems with applying the change if the current diff lands?

libcxx/include/__format/formatter_tuple.h

63

nit: tuple-format-spec sounds too standardese and it's not super clear what elements the error refers to, I would suggest something along the lines of "The format specifier m requires a two-element tuple".

72–74

This won't be called in case of an early return above.

77

Similarly, I suggest making this error message a bit more user-friendly e.g. "Unknown format specifier for tuple". Right now it is a bit too standardese (format-spec) and describing the implementation rather than the observable problem.

84

Do you know why we do this conditional_t dance? For tuples with move-only elements?

91

This function looks unnecessary, I suggest merging into format.

119

Maybe store the output iterator in a local variable and only call advance_to when you need to pass the context externally?

135

Why do you need to specify alignment here?

138

I don't think you need this because the formatter is only used in the format function and can be constructed there. This will be more efficient and simpler.

libcxx/include/__format/parser_std_format_spec.h

105

Not related to this diff but __type_ should probably be renamed to something more descriptive.

111

Maybe __allow_colon_in_fill_ would be more descriptive?

382

Again, I would recommend avoiding standardese terms. Maybe something like "The fill format specifier contains an invalid character"?

libcxx/test/std/utilities/format/format.tuple/format.verify.cpp

22

Out of curiosity, what does @*:* syntax mean here?

libcxx/test/std/utilities/format/format.tuple/format_tests.h

58

Add a test case with a multibyte fill?

157

Add a test case with invalid UTF-8?

302–303

We should fix this.

libcxx/test/std/utilities/format/format.tuple/pair.pass.cpp

34

nit: {} is redundant

[Mordante]

Thanks for the review!

In D136775#3968626, @vitaut wrote:

Overall looks good but we need to fix escaping in the standard and the implementation before this ships. Also a bunch of minor(ish) comments inline.

I too think we should fix escaping. I also think we should fix the nesting of formatters.
Normally we only implement papers after they have been voted in. That is a bit problematic since the next LLVM version will
branch a few weeks before the Issaquah meeting. I would like to see how the papers are received in LEWG, when positive I'll discuss with @ldionne which direction we want to take. (@ldionne I've seen the papers for both issues and I expect they will be in the next WG21 mailing.)

libcxx/include/__format/formatter.h

45–46

That won't be an issue. I've implemented your paper P2733R0 locally, on top of a work-in-progress range-formatting branch.

libcxx/include/__format/formatter_tuple.h

72–74

Nice catch. I didn't notice since that doesn't happen in practice since that only happens when the format string has no terminal '}'. So this version passes all tests.

I have moved it to be Standard conforming.

77

I use this message at other places too. Improving all error messages is still on my todo list.

84

I haven't checked, why. But I too assume it's for move-only elements.

119

While iterating over the underlying formatters we call advance every iteration. So I don't feel using a local variable helps a lot.

135

This is the default in the paper, therefore I set it explicitly.

138

I followed your suggestion, but unfortunately __underlying_ is used in parse. It could be solved by calling set_debug_format in format. However that gives a change of behaviour; nested formatters will enable debug formatting. I've added a comment instead. This suggestion can be applied when implementing P2733R0.

(I prefer to keep the underlying_ in the Standard since that makes it easier when we enable parsing for the underlying formatters.)

libcxx/include/__format/parser_std_format_spec.h

105

The names here match the names of the fields in the Standard. In that context I feel the name __type_ is descriptive.

111

I like that suggestion! I've updated the comments too.

382

I will do that in a follow-up. Then I use the same message for both the "normal" and the "range" fill character.

libcxx/test/std/utilities/format/format.tuple/format.verify.cpp

22

This is a way to say "I don't care where the diagnostic is generated". This error checking is heavily used in Clang and LLVM where the message usually generated on the next line in the test. This error is generated in one of the format headers, using the exact location is a maintenance burden. Adding or removing a line it the header or refactoring headers will break this test. So in libc++ we use this style to reduce the maintenance in libc++. (We still run into test failures when the compiler changes its diagnostic, but that doesn't happen often.)

libcxx/test/std/utilities/format/format.tuple/format_tests.h

58

libc++ doesn't support multibyte fill for char.

I haven't implemented, not yet voted in paper, P2572 std::format() fill character allowances yet.

157

I left thous out on purpose. Invalid Unicode sequences depend: on the type char/wchar_t, for wchar_t its size, and whether users have selected a library without Unicode support. These are tested in other places. Here I just test the basics of the escaping.

302–303

Agreed, I've added a comment regarding P2733.

[Mordante]

Addresses review comments.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

libcxx/test/std/utilities/format/format.tuple/pair.pass.cpp

34

I removed it, but it turns out not to be redundant. When omitted GCC will issue a diagnostic. I then recalled that was why I added it before, so added a comment.

[ldionne]

Mostly LGTM but I would like to see again for for_each.

libcxx/docs/Status/FormatPaper.csv

26–27

I too think we should fix escaping. I also think we should fix the nesting of formatters.
Normally we only implement papers after they have been voted in. That is a bit problematic since the next LLVM version
will branch a few weeks before the Issaquah meeting. I would like to see how the papers are received in LEWG, when
positive I'll discuss with @ldionne which direction we want to take.

If these issues were already in the pipeline and we knew pretty much which way things were going to go, I would say "sure, let's implement the expected issue resolution right away". However, it seems that we're a bit earlier than this here. I would recommend implementing whatever the standard says right now and have another patch ready to apply the expected issue resolution once it is discussed and we know which way we'll go.

We can also raise the unfortunate timing of the committee meeting and the LLVM release with the release manager -- perhaps it would be better for everyone to push back the LLVM branch point by 2 weeks or so.

libcxx/include/__chrono/statically_widen.h

36

Stray whitespace?

libcxx/include/__format/formatter_tuple.h

58–59

Let's use __for_each here too.

119

Here I would really suggest doing this to simplify things a bit:

auto __for_each = []<size_t ..._Index>(index_sequence<_Index...>, auto __func) {
  (__func.operator()<_Index>(), ...);
};

__for_each(make_index_sequence<sizeof...(_Args)>(), [&]<size_t _Index>() {
  // current code
});

This gets rid of one level of nesting. Also this __for_each function here should be extracted into a more general utility, since this has nothing specific to format.

Also it's unusual to use double-underscore with capital letter, so I'd stick to something more representative like _Index. And once you factor out __for_each, you don't need to number your indices anymore.

125–133

Can you add a TODO(format) here and also above where we currently set the debug format? IIUC the above one needs to be removed when we use this #if 0 branch.

libcxx/include/__format/parser_std_format_spec.h

114

TODO FMT We're now at 7 fields, should we increase the size for ABI reasons?

I think instead we should find a way to make sure that this type doesn't need to be kept ABI-stable. I think we can probably achieve this by using an ABI tag on it, since this is never stored in a struct.

libcxx/test/std/utilities/format/format.tuple/format.pass.cpp

8

Here and elsewhere, can you please add a synopsis of what you're testing?

[Mordante]

Thanks for the review!

libcxx/include/__chrono/statically_widen.h

36

No clang-format.

libcxx/include/__format/formatter_tuple.h

119

Looking at the code afterwards this is indeed an improvement, also the one above without the fold expression looks better.
Thanks for the suggestion.

libcxx/include/__format/parser_std_format_spec.h

114

I've given it some more thought and I indeed think this is ABI save since it's only used for function arguments and these all use an ABI tag.

libcxx/test/std/utilities/format/format.tuple/format.pass.cpp

8

Based on our discussion regarding D139561 I did a bit of renaming of these tests to make sure it's clear this tests the format function std::format and not the formatter's member function format.

[Mordante]

Rebased, address review comments, and improve tests.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[ldionne]

libcxx/include/__chrono/statically_widen.h

48

libcxx/include/__format/formatter.h

49–50

libcxx/include/__format/formatter_tuple.h

60

std::? Just for consistency.

libcxx/include/__format/parser_std_format_spec.h

99

So then here we would also need to ABI-tag this. What we want is like _LIBCPP_HIDE_FROM_ABI but for types. I think it would do:

// like _LIBCPP_HIDE_FROM_ABI but without the __exclude_from_explicit_instantiation__
#define _LIBCPP_HIDE_TYPE_FROM_ABI _LIBCPP_HIDDEN __attribute__((__abi_tag__(_LIBCPP_TOSTRING(_LIBCPP_VERSIONED_IDENTIFIER))))

Can you add a TODO instead?

libcxx/include/__utility/integer_sequence.h

141–144 ↗

(On Diff #482927)

I would avoid using an inline variable here. They have the unfortunate side effect of creating a weak def for the variable itself, which is not really useful here. Instead, I would just use a normal function template. It'll also be more consistent.

[Mordante]

Rebased and addresses review comments. Give a spin before landing.

[Mordante]

Thanks for the reviews!

[Mordante]

CI fixes.

libcxx/docs/Status/FormatPaper.csv

 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::month_day_last``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::month_weekday``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::month_weekday_last``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_day``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_day_last``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_weekday``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_weekday_last``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::hh_mm_ss<duration<Rep, Period>>``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::sys_info``",A ``<chrono>`` implementation,Not assigned,,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::local_info``",A ``<chrono>`` implementation,Not assigned,,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::zoned_time<Duration, TimeZonePtr>``",A ``<chrono>`` implementation,Not assigned,,
 `P2286R8 <https://wg21.link/P2286R8>`__,"Formatting ranges"
 `[format.syn] <https://wg21.link/format.syn>`_,"Concept ``formattable``",,Mark de Wever,|Complete|, Clang 16
 `[format.string.std] <https://wg21.link/format.string.std>`_,"std-format-spec ``type`` debug",,Mark de Wever,|Complete|,Clang 16
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: sequences",,Mark de Wever,|In Progress|,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: associative",,Mark de Wever,,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: container adaptors",,Mark de Wever,,
-`[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: ``pair`` and ``tuple``",,Mark de Wever,|In Progress|,
+`[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: ``pair`` and ``tuple``",,Mark de Wever,|Complete|,Clang 16
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: ``vector<bool>``",,Mark de Wever,,

libcxx/include/CMakeLists.txt

set(files
   __format/formatter_bool.h
   __format/formatter_char.h
   __format/formatter_floating_point.h
   __format/formatter_integer.h
   __format/formatter_integral.h
   __format/formatter_output.h
   __format/formatter_pointer.h
   __format/formatter_string.h
+  __format/formatter_tuple.h
   __format/parser_std_format_spec.h
   __format/unicode.h
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind.h
   __functional/bind_back.h
   __functional/bind_front.h
   __functional/binder1st.h

libcxx/include/__chrono/statically_widen.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <__fmt_char_type _CharT>
-consteval const _CharT* __statically_widen(const char* __str, const wchar_t* __wstr) {
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __statically_widen(const char* __str, const wchar_t* __wstr) {
   if constexpr (same_as<_CharT, char>)
     return __str;
   else
     return __wstr;
 }
 #    define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str, L##__str)
 #  else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 // Without this indirection the unit test test/libcxx/modules_include.sh.cpp
 // fails for the CI build "No wide characters". This seems like a bug.
 // TODO FMT investigate why this is needed.
 template <__fmt_char_type _CharT>
-consteval const _CharT* __statically_widen(const char* __str) {
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __statically_widen(const char* __str) {
   return __str;
 }
 #    define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str)
 #  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 #endif //if _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHRONO_STATICALLY_WIDEN_H

libcxx/include/__format/formatter.h

 /// - is_move_assignable<F>.
 template <class _Tp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
   formatter() = delete;
   formatter(const formatter&) = delete;
   formatter& operator=(const formatter&) = delete;
 };
 
+#  if _LIBCPP_STD_VER > 20
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr void __set_debug_format(_Tp& __formatter) {
+  if constexpr (requires { __formatter.set_debug_format(); })
+    __formatter.set_debug_format();
+}
+
+#  endif //_LIBCPP_STD_VER > 20
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_H

libcxx/include/__format/formatter_tuple.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FORMAT_FORMATTER_TUPLE_H
+#define _LIBCPP___FORMAT_FORMATTER_TUPLE_H
+
+#include <__algorithm/ranges_copy.h>
+#include <__availability>
+#include <__chrono/statically_widen.h>
+#include <__config>
+#include <__format/concepts.h>
+#include <__format/format_args.h>
+#include <__format/format_context.h>
+#include <__format/format_error.h>
+#include <__format/format_parse_context.h>
+#include <__format/formatter.h>
+#include <__format/formatter_output.h>
+#include <__format/parser_std_format_spec.h>
+#include <__iterator/back_insert_iterator.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/pair.h>
+#include <string_view>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 20
+
+template <__fmt_char_type _CharT, class _Tuple, formattable<_CharT>... _Args>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_tuple {
+  _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) {
+    __separator_ = __separator;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
+    __opening_bracket_ = __opening_bracket;
+    __closing_bracket_ = __closing_bracket;
+  }
+
+  template <class _ParseContext>
+  _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __parse_ctx) {
+    const _CharT* __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_tuple);
+    const _CharT* __end   = __parse_ctx.end();
+    if (__begin == __end)
+      return __begin;
+
+    if (*__begin == _CharT('m')) {
+      if constexpr (sizeof...(_Args) == 2) {
+        set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ": "));
+        set_brackets({}, {});
+        ++__begin;
+      } else
+        std::__throw_format_error("The tuple-format-spec type m requires two elements");
+    } else if (*__begin == _CharT('n')) {
+      set_brackets({}, {});
+      ++__begin;
+    }
+
+    // [format.tuple]/7
+    //   ... For each element e in underlying_, if e.set_debug_format()
+    //   is a valid expression, calls e.set_debug_format().
+    [&]<size_t... __I>(index_sequence<__I...>) {
+      (std::__set_debug_format(std::get<__I>(__underlying_)), ...);
+    }(std::make_index_sequence<sizeof...(_Args)>());
+
+    if (__begin != __end && *__begin != _CharT('}'))
+      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+
+    return __begin;
+  }
+
+  template <class _FormatContext>
+  typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI
+  format(conditional_t<(formattable<const _Args, _CharT> && ...), const _Tuple&, _Tuple&> __tuple,
+         _FormatContext& __ctx) const {
+    return __format(__tuple, __ctx, __parser_.__get_parsed_std_specifications(__ctx));
+  }
+
+  template <class _FormatContext>
+  typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI
+  __format(auto&& __tuple, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) const {
+    if (!__specs.__has_width())
+      return __format_tuple(__tuple, __ctx);
+
+    basic_string<_CharT> __str;
+
+    // Since the output is written to a different iterator a new context is
+    // created. Since the underlying formatter uses the default formatting it
+    // doesn't need a locale or the formatting arguments. So creating a new
+    // context works.
+    //
+    // This solution works for this formatter, but it will not work for the
+    // range_formatter. In that patch a generic solution is work in progress.
+    // Once that is finished it can be used here. (The range_formatter will use
+    // these features so it's easier to add it there and then port it.)
+    //
+    // TODO FMT Use formatting wrapping used in the range_formatter.
+    basic_format_context __c = std::__format_context_create(
+        back_insert_iterator{__str},
+        basic_format_args<basic_format_context<back_insert_iterator<basic_string<_CharT>>, _CharT>>{});
+
+    __format_tuple(__tuple, __c);
+
+    return __formatter::__write_string_no_precision(basic_string_view{__str}, __ctx.out(), __specs);
+  }
+
+  template <class _FormatContext>
+  _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator __format_tuple(auto&& __tuple, _FormatContext& __ctx) const {
+    __ctx.advance_to(std::ranges::copy(__opening_bracket_, __ctx.out()).out);
+
+    [&]<size_t... __I>(index_sequence<__I...>) {
+      (
+          [&]<size_t __II>() {
+            if constexpr (__II)
+              __ctx.advance_to(std::ranges::copy(__separator_, __ctx.out()).out);
+
+            __ctx.advance_to(std::get<__II>(__underlying_).format(std::get<__II>(__tuple), __ctx));
+          }.template operator()<__I>(),
+          ...);
+    }(std::make_index_sequence< sizeof...(_Args)>());
+
+    return std::ranges::copy(__closing_bracket_, __ctx.out()).out;
+  }
+
+  __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__left};
+
+private:
+  tuple<formatter<remove_cvref_t<_Args>, _CharT>...> __underlying_;
+  basic_string_view<_CharT> __separator_       = _LIBCPP_STATICALLY_WIDEN(_CharT, ", ");
+  basic_string_view<_CharT> __opening_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "(");
+  basic_string_view<_CharT> __closing_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ")");
+};
+
+template <__fmt_char_type _CharT, formattable<_CharT>... _Args>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<pair<_Args...>, _CharT>
+    : public __formatter_tuple<_CharT, pair<_Args...>, _Args...> {};
+
+template <__fmt_char_type _CharT, formattable<_CharT>... _Args>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<tuple<_Args...>, _CharT>
+    : public __formatter_tuple<_CharT, tuple<_Args...>, _Args...> {};
+
+#endif //_LIBCPP_STD_VER > 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_FORMATTER_TUPLE_H

libcxx/include/__format/parser_std_format_spec.h

return visit_format_arg(
       },
       __format_arg);
 }
 
 /// These fields are a filter for which elements to parse.
 ///
 /// They default to false so when a new field is added it needs to be opted in
 /// explicitly.
 struct __fields {
   uint8_t __sign_ : 1 {false};
   uint8_t __alternate_form_ : 1 {false};
   uint8_t __zero_padding_ : 1 {false};
   uint8_t __precision_ : 1 {false};
   uint8_t __locale_specific_form_ : 1 {false};
   uint8_t __type_ : 1 {false};
+  // Is the fill a range-fill?
+  //
+  // When not set it is a normal fill. The difference is whether or not ':' is
+  // a valid fill character.
+  // Note tuple-fill is the same as range-fill and has no separate type.
+  uint8_t __use_range_fill_ : 1 {false};
+
+  // TODO FMT We're now at 7 fields, should we increase the size for ABI reasons?
 };
 
 // By not placing this constant in the formatter class it's not duplicated for
 // char and wchar_t.
 inline constexpr __fields __fields_integral{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__locale_specific_form_ = true,
     .__type_                 = true};
 inline constexpr __fields __fields_floating_point{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__precision_            = true,
     .__locale_specific_form_ = true,
     .__type_                 = true};
 inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true};
 inline constexpr __fields __fields_pointer{.__type_ = true};
 
+#  if _LIBCPP_STD_VER > 20
+inline constexpr __fields __fields_tuple{.__type_ = false, .__use_range_fill_ = true};
+#  endif
+
 enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
   /// No alignment is set in the format string.
   __default,
   __left,
   __center,
   __right,
   __zero_padding
 };
public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields)
       -> decltype(__parse_ctx.begin()) {
 
     const _CharT* __begin = __parse_ctx.begin();
     const _CharT* __end = __parse_ctx.end();
     if (__begin == __end)
       return __begin;
 
-    if (__parse_fill_align(__begin, __end) && __begin == __end)
+    if (__parse_fill_align(__begin, __end, __fields.__use_range_fill_) && __begin == __end)
       return __begin;
 
     if (__fields.__sign_ && __parse_sign(__begin) && __begin == __end)
       return __begin;
 
     if (__fields.__alternate_form_ && __parse_alternate_form(__begin) && __begin == __end)
       return __begin;
 
_LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alignment(_CharT __c) {
 
     case _CharT('>'):
       __alignment_ = __alignment::__right;
       return true;
     }
     return false;
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(const _CharT*& __begin, const _CharT* __end) {
+  // range-fill and tuple-fill are identical
+  _LIBCPP_HIDE_FROM_ABI constexpr bool
+  __parse_fill_align(const _CharT*& __begin, const _CharT* __end, bool __use_range_fill) {
     _LIBCPP_ASSERT(__begin != __end, "when called with an empty input the function will cause "
                                      "undefined behavior by evaluating data not in the input");
     if (__begin + 1 != __end) {
       if (__parse_alignment(*(__begin + 1))) {
-        if (*__begin == _CharT('{') || *__begin == _CharT('}'))
-          __throw_format_error("The format-spec fill field contains an invalid character");
+        if (__use_range_fill && (*__begin == _CharT('{') || *__begin == _CharT('}') || *__begin == _CharT(':')))
+          std::__throw_format_error("The format-spec range-fill field contains an invalid character");
+        else if (*__begin == _CharT('{') || *__begin == _CharT('}'))
+          std::__throw_format_error("The format-spec fill field contains an invalid character");
 
         __fill_ = *__begin;
         __begin += 2;
         return true;
       }
     }
 
     if (!__parse_alignment(*__begin))

libcxx/include/format

 #include <__format/format_to_n_result.h>
 #include <__format/formatter.h>
 #include <__format/formatter_bool.h>
 #include <__format/formatter_char.h>
 #include <__format/formatter_floating_point.h>
 #include <__format/formatter_integer.h>
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
+#include <__format/formatter_tuple.h>
 #include <__format/parser_std_format_spec.h>
 #include <__format/unicode.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 
 #endif // _LIBCPP_FORMAT

libcxx/include/module.modulemap.in

module __algorithm {
       module ranges_binary_search {
         private header "__algorithm/ranges_binary_search.h"
         export functional.__functional.ranges_operations
       }
       module ranges_clamp {
         private header "__algorithm/ranges_clamp.h"
         export functional.__functional.ranges_operations
       }
-      module ranges_copy                     { private header "__algorithm/ranges_copy.h" }
+      module ranges_copy {
+        private header "__algorithm/ranges_copy.h"
+        export std.algorithm.__algorithm.in_out_result
+      }
       module ranges_copy_backward            { private header "__algorithm/ranges_copy_backward.h" }
       module ranges_copy_if                  { private header "__algorithm/ranges_copy_if.h" }
-      module ranges_copy_n                   { private header "__algorithm/ranges_copy_n.h" }
+      module ranges_copy_n {
+        private header "__algorithm/ranges_copy_n.h"
+        export std.algorithm.__algorithm.in_out_result
+      }
       module ranges_count                    { private header "__algorithm/ranges_count.h" }
       module ranges_count_if                 { private header "__algorithm/ranges_count_if.h" }
       module ranges_equal                    { private header "__algorithm/ranges_equal.h" }
       module ranges_equal_range {
         private header "__algorithm/ranges_equal_range.h"
         export functional.__functional.ranges_operations
       }
       module ranges_fill                     { private header "__algorithm/ranges_fill.h" }
module __format {
       module formatter_bool                  { private header "__format/formatter_bool.h" }
       module formatter_char                  { private header "__format/formatter_char.h" }
       module formatter_floating_point        { private header "__format/formatter_floating_point.h" }
       module formatter_integer               { private header "__format/formatter_integer.h" }
       module formatter_integral              { private header "__format/formatter_integral.h" }
       module formatter_output                { private header "__format/formatter_output.h" }
       module formatter_pointer               { private header "__format/formatter_pointer.h" }
       module formatter_string                { private header "__format/formatter_string.h" }
+      module formatter_tuple                 { private header "__format/formatter_tuple.h" }
       module parser_std_format_spec          { private header "__format/parser_std_format_spec.h" }
       module unicode                         { private header "__format/unicode.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__format/formatter_bool.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_bool.h'}}
 #include <__format/formatter_char.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_char.h'}}
 #include <__format/formatter_floating_point.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_floating_point.h'}}
 #include <__format/formatter_integer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integer.h'}}
 #include <__format/formatter_integral.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integral.h'}}
 #include <__format/formatter_output.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_output.h'}}
 #include <__format/formatter_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_pointer.h'}}
 #include <__format/formatter_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_string.h'}}
+#include <__format/formatter_tuple.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_tuple.h'}}
 #include <__format/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__format/parser_std_format_spec.h'}}
 #include <__format/unicode.h> // expected-error@*:* {{use of private header from outside its module: '__format/unicode.h'}}
 #include <__functional/binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_function.h'}}
 #include <__functional/binary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_negate.h'}}
 #include <__functional/bind.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind.h'}}
 #include <__functional/bind_back.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_back.h'}}
 #include <__functional/bind_front.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_front.h'}}
 #include <__functional/binder1st.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binder1st.h'}}

libcxx/test/std/utilities/format/format.formattable/concept.formattable.compile.pass.cpp

void test_P2286() {
   assert_is_not_formattable<std::stack<int>, CharT>();
   assert_is_not_formattable<std::queue<int>, CharT>();
   assert_is_not_formattable<std::priority_queue<int>, CharT>();
 
   assert_is_not_formattable<std::span<int>, CharT>();
 
   assert_is_not_formattable<std::valarray<int>, CharT>();
 
-  assert_is_not_formattable<std::pair<int, int>, CharT>();
-  assert_is_not_formattable<std::tuple<int>, CharT>();
+  assert_is_formattable<std::pair<int, int>, CharT>();
+  assert_is_formattable<std::tuple<int>, CharT>();
 }
 
 class c {
   void f();
   void fc() const;
   static void sf();
 };
 enum e { a };

libcxx/test/std/utilities/format/format.functions/format_tests.h

void format_test_string(const W& world, const U& universe, TestFunction check, ExceptionTest check_exception) {
   check(SV("hello universe and world"), SV("hello {1} and {0}"), world, universe);
 
   check(SV("hello world"), SV("hello {:_>}"), world);
   check(SV("hello    world"), SV("hello {:>8}"), world);
   check(SV("hello ___world"), SV("hello {:_>8}"), world);
   check(SV("hello _world__"), SV("hello {:_^8}"), world);
   check(SV("hello world___"), SV("hello {:_<8}"), world);
 
-  check(SV("hello >>>world"), SV("hello {:>>8}"), world);
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("hello :::world"), SV("hello {::>8}"), world);
   check(SV("hello <<<world"), SV("hello {:<>8}"), world);
   check(SV("hello ^^^world"), SV("hello {:^>8}"), world);
 
   check(SV("hello $world"), SV("hello {:$>{}}"), world, 6);
   check(SV("hello $world"), SV("hello {0:$>{1}}"), world, 6);
   check(SV("hello $world"), SV("hello {1:$>{0}}"), 6, world);
 
   check(SV("hello world"), SV("hello {:.5}"), world);
void format_test_bool(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is 'true   '"), SV("answer is '{:<7}'"), true);
   check(SV("answer is ' true  '"), SV("answer is '{:^7}'"), true);
 
   check(SV("answer is 'false   '"), SV("answer is '{:8s}'"), false);
   check(SV("answer is '   false'"), SV("answer is '{:>8s}'"), false);
   check(SV("answer is 'false   '"), SV("answer is '{:<8s}'"), false);
   check(SV("answer is ' false  '"), SV("answer is '{:^8s}'"), false);
 
-  check(SV("answer is '---true'"), SV("answer is '{:->7}'"), true);
-  check(SV("answer is 'true---'"), SV("answer is '{:-<7}'"), true);
-  check(SV("answer is '-true--'"), SV("answer is '{:-^7}'"), true);
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::true'"), SV("answer is '{::>7}'"), true);
+  check(SV("answer is 'true:::'"), SV("answer is '{::<7}'"), true);
+  check(SV("answer is ':true::'"), SV("answer is '{::^7}'"), true);
 
   check(SV("answer is '---false'"), SV("answer is '{:->8s}'"), false);
   check(SV("answer is 'false---'"), SV("answer is '{:-<8s}'"), false);
   check(SV("answer is '-false--'"), SV("answer is '{:-^8s}'"), false);
 
   // *** Sign ***
   check_exception("A sign field isn't allowed in this format-spec", SV("{:-}"), true);
   check_exception("A sign field isn't allowed in this format-spec", SV("{:+}"), true);
void format_test_bool_as_integer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is '1 '"), SV("answer is '{:<2d}'"), true);
   check(SV("answer is '0 '"), SV("answer is '{:<2d}'"), false);
 
   check(SV("answer is '     1'"), SV("answer is '{:6d}'"), true);
   check(SV("answer is '     1'"), SV("answer is '{:>6d}'"), true);
   check(SV("answer is '1     '"), SV("answer is '{:<6d}'"), true);
   check(SV("answer is '  1   '"), SV("answer is '{:^6d}'"), true);
 
-  check(SV("answer is '*****0'"), SV("answer is '{:*>6d}'"), false);
-  check(SV("answer is '0*****'"), SV("answer is '{:*<6d}'"), false);
-  check(SV("answer is '**0***'"), SV("answer is '{:*^6d}'"), false);
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::::0'"), SV("answer is '{::>6d}'"), false);
+  check(SV("answer is '0:::::'"), SV("answer is '{::<6d}'"), false);
+  check(SV("answer is '::0:::'"), SV("answer is '{::^6d}'"), false);
 
   // Test whether zero padding is ignored
   check(SV("answer is '     1'"), SV("answer is '{:>06d}'"), true);
   check(SV("answer is '1     '"), SV("answer is '{:<06d}'"), true);
   check(SV("answer is '  1   '"), SV("answer is '{:^06d}'"), true);
 
   // *** Sign ***
   check(SV("answer is 1"), SV("answer is {:d}"), true);
void format_test_integer_as_integer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is '42'"), SV("answer is '{:<2}'"), I(42));
   check(SV("answer is '42 '"), SV("answer is '{:<3}'"), I(42));
 
   check(SV("answer is '     42'"), SV("answer is '{:7}'"), I(42));
   check(SV("answer is '     42'"), SV("answer is '{:>7}'"), I(42));
   check(SV("answer is '42     '"), SV("answer is '{:<7}'"), I(42));
   check(SV("answer is '  42   '"), SV("answer is '{:^7}'"), I(42));
 
-  check(SV("answer is '*****42'"), SV("answer is '{:*>7}'"), I(42));
-  check(SV("answer is '42*****'"), SV("answer is '{:*<7}'"), I(42));
-  check(SV("answer is '**42***'"), SV("answer is '{:*^7}'"), I(42));
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::::42'"), SV("answer is '{::>7}'"), I(42));
+  check(SV("answer is '42:::::'"), SV("answer is '{::<7}'"), I(42));
+  check(SV("answer is '::42:::'"), SV("answer is '{::^7}'"), I(42));
 
   // Test whether zero padding is ignored
   check(SV("answer is '     42'"), SV("answer is '{:>07}'"), I(42));
   check(SV("answer is '42     '"), SV("answer is '{:<07}'"), I(42));
   check(SV("answer is '  42   '"), SV("answer is '{:^07}'"), I(42));
 
   // *** Sign ***
   if constexpr (std::signed_integral<I>)

 template <class I, class CharT, class TestFunction, class ExceptionTest>
 void format_test_integer_as_char(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '*     '"), SV("answer is '{:6c}'"), I(42));
   check(SV("answer is '     *'"), SV("answer is '{:>6c}'"), I(42));
   check(SV("answer is '*     '"), SV("answer is '{:<6c}'"), I(42));
   check(SV("answer is '  *   '"), SV("answer is '{:^6c}'"), I(42));
 
-  check(SV("answer is '-----*'"), SV("answer is '{:->6c}'"), I(42));
-  check(SV("answer is '*-----'"), SV("answer is '{:-<6c}'"), I(42));
-  check(SV("answer is '--*---'"), SV("answer is '{:-^6c}'"), I(42));
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::::*'"), SV("answer is '{::>6c}'"), I(42));
+  check(SV("answer is '*:::::'"), SV("answer is '{::<6c}'"), I(42));
+  check(SV("answer is '::*:::'"), SV("answer is '{::^6c}'"), I(42));
 
   // *** Sign ***
   check(SV("answer is *"), SV("answer is {:c}"), I(42));
   check_exception("A sign field isn't allowed in this format-spec", SV("answer is {:-c}"), I(42));
   check_exception("A sign field isn't allowed in this format-spec", SV("answer is {:+c}"), I(42));
   check_exception("A sign field isn't allowed in this format-spec", SV("answer is {: c}"), I(42));
 
   // *** alternate form ***
void format_test_char(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is '*     '"), SV("answer is '{:<6}'"), CharT('*'));
   check(SV("answer is '  *   '"), SV("answer is '{:^6}'"), CharT('*'));
 
   check(SV("answer is '*     '"), SV("answer is '{:6c}'"), CharT('*'));
   check(SV("answer is '     *'"), SV("answer is '{:>6c}'"), CharT('*'));
   check(SV("answer is '*     '"), SV("answer is '{:<6c}'"), CharT('*'));
   check(SV("answer is '  *   '"), SV("answer is '{:^6c}'"), CharT('*'));
 
-  check(SV("answer is '-----*'"), SV("answer is '{:->6}'"), CharT('*'));
-  check(SV("answer is '*-----'"), SV("answer is '{:-<6}'"), CharT('*'));
-  check(SV("answer is '--*---'"), SV("answer is '{:-^6}'"), CharT('*'));
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::::*'"), SV("answer is '{::>6}'"), CharT('*'));
+  check(SV("answer is '*:::::'"), SV("answer is '{::<6}'"), CharT('*'));
+  check(SV("answer is '::*:::'"), SV("answer is '{::^6}'"), CharT('*'));
 
   check(SV("answer is '-----*'"), SV("answer is '{:->6c}'"), CharT('*'));
   check(SV("answer is '*-----'"), SV("answer is '{:-<6c}'"), CharT('*'));
   check(SV("answer is '--*---'"), SV("answer is '{:-^6c}'"), CharT('*'));
 
   // *** Sign ***
   check_exception("A sign field isn't allowed in this format-spec", SV("{:-}"), CharT('*'));
   check_exception("A sign field isn't allowed in this format-spec", SV("{:+}"), CharT('*'));
void format_test_char_as_integer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is '42'"), SV("answer is '{:<2d}'"), CharT('*'));
   check(SV("answer is '42 '"), SV("answer is '{:<3d}'"), CharT('*'));
 
   check(SV("answer is '     42'"), SV("answer is '{:7d}'"), CharT('*'));
   check(SV("answer is '     42'"), SV("answer is '{:>7d}'"), CharT('*'));
   check(SV("answer is '42     '"), SV("answer is '{:<7d}'"), CharT('*'));
   check(SV("answer is '  42   '"), SV("answer is '{:^7d}'"), CharT('*'));
 
-  check(SV("answer is '*****42'"), SV("answer is '{:*>7d}'"), CharT('*'));
-  check(SV("answer is '42*****'"), SV("answer is '{:*<7d}'"), CharT('*'));
-  check(SV("answer is '**42***'"), SV("answer is '{:*^7d}'"), CharT('*'));
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::::42'"), SV("answer is '{::>7d}'"), CharT('*'));
+  check(SV("answer is '42:::::'"), SV("answer is '{::<7d}'"), CharT('*'));
+  check(SV("answer is '::42:::'"), SV("answer is '{::^7d}'"), CharT('*'));
 
   // Test whether zero padding is ignored
   check(SV("answer is '     42'"), SV("answer is '{:>07d}'"), CharT('*'));
   check(SV("answer is '42     '"), SV("answer is '{:<07d}'"), CharT('*'));
   check(SV("answer is '  42   '"), SV("answer is '{:^07d}'"), CharT('*'));
 
   // *** Sign ***
   check(SV("answer is 42"), SV("answer is {:d}"), CharT('*'));
void format_test_floating_point_hex_lower_case(TestFunction check) {
   check(SV("answer is '1.defp+0'"), SV("answer is '{:a}'"), F(0x1.defp+0));
 
   // *** align-fill & width ***
   check(SV("answer is '   1p-2'"), SV("answer is '{:7a}'"), F(0.25));
   check(SV("answer is '   1p-2'"), SV("answer is '{:>7a}'"), F(0.25));
   check(SV("answer is '1p-2   '"), SV("answer is '{:<7a}'"), F(0.25));
   check(SV("answer is ' 1p-2  '"), SV("answer is '{:^7a}'"), F(0.25));
 
-  check(SV("answer is '---1p-3'"), SV("answer is '{:->7a}'"), F(125e-3));
-  check(SV("answer is '1p-3---'"), SV("answer is '{:-<7a}'"), F(125e-3));
-  check(SV("answer is '-1p-3--'"), SV("answer is '{:-^7a}'"), F(125e-3));
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::1p-3'"), SV("answer is '{::>7a}'"), F(125e-3));
+  check(SV("answer is '1p-3:::'"), SV("answer is '{::<7a}'"), F(125e-3));
+  check(SV("answer is ':1p-3::'"), SV("answer is '{::^7a}'"), F(125e-3));
 
   check(SV("answer is '***inf'"), SV("answer is '{:*>6a}'"), std::numeric_limits<F>::infinity());
   check(SV("answer is 'inf***'"), SV("answer is '{:*<6a}'"), std::numeric_limits<F>::infinity());
   check(SV("answer is '*inf**'"), SV("answer is '{:*^6a}'"), std::numeric_limits<F>::infinity());
 
   check(SV("answer is '###-inf'"), SV("answer is '{:#>7a}'"), -std::numeric_limits<F>::infinity());
   check(SV("answer is '-inf###'"), SV("answer is '{:#<7a}'"), -std::numeric_limits<F>::infinity());
   check(SV("answer is '#-inf##'"), SV("answer is '{:#^7a}'"), -std::numeric_limits<F>::infinity());

 template <class P, class CharT, class TestFunction, class ExceptionTest>
 void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   // *** align-fill & width ***
   check(SV("answer is '   0x0'"), SV("answer is '{:6}'"), P(nullptr));
   check(SV("answer is '   0x0'"), SV("answer is '{:>6}'"), P(nullptr));
   check(SV("answer is '0x0   '"), SV("answer is '{:<6}'"), P(nullptr));
   check(SV("answer is ' 0x0  '"), SV("answer is '{:^6}'"), P(nullptr));
 
-  check(SV("answer is '---0x0'"), SV("answer is '{:->6}'"), P(nullptr));
-  check(SV("answer is '0x0---'"), SV("answer is '{:-<6}'"), P(nullptr));
-  check(SV("answer is '-0x0--'"), SV("answer is '{:-^6}'"), P(nullptr));
+  // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
+  check(SV("answer is ':::0x0'"), SV("answer is '{::>6}'"), P(nullptr));
+  check(SV("answer is '0x0:::'"), SV("answer is '{::<6}'"), P(nullptr));
+  check(SV("answer is ':0x0::'"), SV("answer is '{::^6}'"), P(nullptr));
 
   // *** Sign ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), P(nullptr));
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), P(nullptr));
   check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), P(nullptr));
 
   // *** alternate form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), P(nullptr));

libcxx/test/std/utilities/format/format.tuple/format.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "format_tests.h"
+#include "test_format_string.h"
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <iostream>
+#  include <concepts>
+#endif
+
+auto test = []<class CharT, class... Args>(
+                std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) {
+  std::basic_string<CharT> out = std::format(fmt, std::forward<Args>(args)...);
+#ifndef TEST_HAS_NO_LOCALIZATION
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt.get() << "\nExpected output " << expected << "\nActual output   " << out
+                << '\n';
+#endif // TEST_HAS_NO_LOCALIZATION
+  assert(out == expected);
+};
+
+auto test_exception = []<class CharT, class... Args>(std::string_view, std::basic_string_view<CharT>, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+
+int main(int, char**) {
+  run_tests<char>(test, test_exception);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  run_tests<wchar_t>(test, test_exception);
+#endif
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.tuple/format.verify.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+#include <format>
+
+#include <utility>
+#include <tuple>
+
+#include "test_macros.h"
+
+// clang-format off
+
+void f() {
+  std::format("{::}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format("{::^}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format("{:+}", std::make_pair(0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format("{:m}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format("{:m}", std::make_tuple(0, 0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  std::format(L"{::}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format(L"{::^}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format(L"{:+}", std::make_pair(0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format(L"{:m}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+
+  std::format(L"{:m}", std::make_tuple(0, 0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
+#endif
+}

libcxx/test/std/utilities/format/format.tuple/format_tests.h

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H
+#define TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H
+
+#include <concepts>
+#include <format>
+
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class T>
+struct context {};
+
+template <>
+struct context<char> {
+  using type = std::format_context;
+};
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+template <>
+struct context<wchar_t> {
+  using type = std::wformat_context;
+};
+#endif
+
+template <class T>
+using context_t = typename context<T>::type;
+
+enum class color { black, red, gold };
+
+template <class CharT>
+struct std::formatter<color, CharT> : std::formatter<basic_string_view<CharT>, CharT> {
+  static constexpr basic_string_view<CharT> color_names[] = {SV("black"), SV("red"), SV("gold")};
+  auto format(color c, auto& ctx) const {
+    return formatter<basic_string_view<CharT>, CharT>::format(color_names[static_cast<int>(c)], ctx);
+  }
+};
+
+//
+// Generic tests for a tuple and pair with two elements.
+//
+template <class CharT, class TestFunction, class ExceptionTest, class TupleOrPair>
+void test_tuple_or_pair_int_int(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
+  check(SV("(42, 99)"), SV("{}"), input);
+
+  // *** align-fill & width ***
+  check(SV("(42, 99)     "), SV("{:13}"), input);
+  check(SV("(42, 99)*****"), SV("{:*<13}"), input);
+  check(SV("__(42, 99)___"), SV("{:_^13}"), input);
+  check(SV("#####(42, 99)"), SV("{:#>13}"), input);
+
+  check(SV("(42, 99)     "), SV("{:{}}"), input, 13);
+  check(SV("(42, 99)*****"), SV("{:*<{}}"), input, 13);
+  check(SV("__(42, 99)___"), SV("{:_^{}}"), input, 13);
+  check(SV("#####(42, 99)"), SV("{:#>{}}"), input, 13);
+
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+
+  // *** sign ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+
+  // *** alternate form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+
+  // *** zero-padding ***
+  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+
+  // *** precision ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+
+  // *** locale-specific form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+
+  // *** type ***
+  check(SV("__42: 99___"), SV("{:_^11m}"), input);
+  check(SV("__42, 99___"), SV("{:_^11n}"), input);
+
+  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+    check_exception("The format-spec should consume the input or end with a '}'",
+                    std::basic_string_view{STR("{:") + c + STR("}")},
+                    input);
+  }
+}
+
+template <class CharT, class TestFunction, class ExceptionTest, class TupleOrPair>
+void test_tuple_or_pair_int_string(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
+  check(SV("(42, \"hello\")"), SV("{}"), input);
+
+  // *** align-fill & width ***
+  check(SV("(42, \"hello\")     "), SV("{:18}"), input);
+  check(SV("(42, \"hello\")*****"), SV("{:*<18}"), input);
+  check(SV("__(42, \"hello\")___"), SV("{:_^18}"), input);
+  check(SV("#####(42, \"hello\")"), SV("{:#>18}"), input);
+
+  check(SV("(42, \"hello\")     "), SV("{:{}}"), input, 18);
+  check(SV("(42, \"hello\")*****"), SV("{:*<{}}"), input, 18);
+  check(SV("__(42, \"hello\")___"), SV("{:_^{}}"), input, 18);
+  check(SV("#####(42, \"hello\")"), SV("{:#>{}}"), input, 18);
+
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+
+  // *** sign ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+
+  // *** alternate form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+
+  // *** zero-padding ***
+  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+
+  // *** precision ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+
+  // *** locale-specific form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+
+  // *** type ***
+  check(SV("__42: \"hello\"___"), SV("{:_^16m}"), input);
+  check(SV("__42, \"hello\"___"), SV("{:_^16n}"), input);
+
+  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+    check_exception("The format-spec should consume the input or end with a '}'",
+                    std::basic_string_view{STR("{:") + c + STR("}")},
+                    input);
+  }
+}
+
+template <class CharT, class TestFunction, class TupleOrPair>
+void test_escaping(TestFunction check, TupleOrPair&& input) {
+  static_assert(std::same_as<std::remove_cvref_t<decltype(std::get<0>(input))>, CharT>);
+  static_assert(std::same_as<std::remove_cvref_t<decltype(std::get<1>(input))>, std::basic_string<CharT>>);
+
+  check(SV(R"(('*', ""))"), SV("{}"), input);
+
+  // Char
+  std::get<0>(input) = CharT('\t');
+  check(SV(R"(('\t', ""))"), SV("{}"), input);
+  std::get<0>(input) = CharT('\n');
+  check(SV(R"(('\n', ""))"), SV("{}"), input);
+  std::get<0>(input) = CharT('\0');
+  check(SV(R"(('\u{0}', ""))"), SV("{}"), input);
+
+  // String
+  std::get<0>(input) = CharT('*');
+  std::get<1>(input) = SV("hellö");
+  check(SV("('*', \"hellö\")"), SV("{}"), input);
+}
+
+//
+// pair tests
+//
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void test_pair_int_int(TestFunction check, ExceptionTest check_exception) {
+  test_tuple_or_pair_int_int<CharT>(check, check_exception, std::make_pair(42, 99));
+}
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void test_pair_int_string(TestFunction check, ExceptionTest check_exception) {
+  test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_pair(42, SV("hello")));
+}
+
+//
+// tuple tests
+//
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
+  auto input = std::make_tuple(42);
+
+  check(SV("(42)"), SV("{}"), input);
+
+  // *** align-fill & width ***
+  check(SV("(42)     "), SV("{:9}"), input);
+  check(SV("(42)*****"), SV("{:*<9}"), input);
+  check(SV("__(42)___"), SV("{:_^9}"), input);
+  check(SV("#####(42)"), SV("{:#>9}"), input);
+
+  check(SV("(42)     "), SV("{:{}}"), input, 9);
+  check(SV("(42)*****"), SV("{:*<{}}"), input, 9);
+  check(SV("__(42)___"), SV("{:_^{}}"), input, 9);
+  check(SV("#####(42)"), SV("{:#>{}}"), input, 9);
+
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+
+  // *** sign ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+
+  // *** alternate form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+
+  // *** zero-padding ***
+  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+
+  // *** precision ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+
+  // *** locale-specific form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+
+  // *** type ***
+  check_exception("The tuple-format-spec type m requires two elements", SV("{:m}"), input);
+  check(SV("__42___"), SV("{:_^7n}"), input);
+
+  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+    check_exception("The format-spec should consume the input or end with a '}'",
+                    std::basic_string_view{STR("{:") + c + STR("}")},
+                    input);
+  }
+}
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void test_tuple_int_string_color(TestFunction check, ExceptionTest check_exception) {
+  const auto input = std::make_tuple(42, SV("hello"), color::red);
+
+  check(SV("(42, \"hello\", \"red\")"), SV("{}"), input);
+
+  // *** align-fill & width ***
+  check(SV("(42, \"hello\", \"red\")     "), SV("{:25}"), input);
+  check(SV("(42, \"hello\", \"red\")*****"), SV("{:*<25}"), input);
+  check(SV("__(42, \"hello\", \"red\")___"), SV("{:_^25}"), input);
+  check(SV("#####(42, \"hello\", \"red\")"), SV("{:#>25}"), input);
+
+  check(SV("(42, \"hello\", \"red\")     "), SV("{:{}}"), input, 25);
+  check(SV("(42, \"hello\", \"red\")*****"), SV("{:*<{}}"), input, 25);
+  check(SV("__(42, \"hello\", \"red\")___"), SV("{:_^{}}"), input, 25);
+  check(SV("#####(42, \"hello\", \"red\")"), SV("{:#>{}}"), input, 25);
+
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+
+  // *** sign ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+
+  // *** alternate form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+
+  // *** zero-padding ***
+  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+
+  // *** precision ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+
+  // *** locale-specific form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+
+  // *** type ***
+  check_exception("The tuple-format-spec type m requires two elements", SV("{:m}"), input);
+  check(SV("__42, \"hello\", \"red\"___"), SV("{:_^23n}"), input);
+
+  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+    check_exception("The format-spec should consume the input or end with a '}'",
+                    std::basic_string_view{STR("{:") + c + STR("}")},
+                    input);
+  }
+}
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void test_tuple_int_int(TestFunction check, ExceptionTest check_exception) {
+  test_tuple_or_pair_int_int<CharT>(check, check_exception, std::make_tuple(42, 99));
+}
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void test_tuple_int_string(TestFunction check, ExceptionTest check_exception) {
+  test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_tuple(42, SV("hello")));
+}
+
+//
+// nested tests
+//
+
+template <class CharT, class TestFunction, class ExceptionTest, class Nested>
+void test_nested(TestFunction check, ExceptionTest check_exception, Nested&& input) {
+  // [format.formatter.spec]/2
+  //   A debug-enabled specialization of formatter additionally provides a
+  //   public, constexpr, non-static member function set_­debug_­format()
+  //   which modifies the state of the formatter to be as if the type of the
+  //   std-format-spec parsed by the last call to parse were ?.
+  // pair and tuple are not debug-enabled specializations to the
+  // set_debug_format is not propagated.
+
+  check(SV("(42, (hello, red))"), SV("{}"), input);
+
+  // *** align-fill & width ***
+  check(SV("(42, (hello, red))     "), SV("{:23}"), input);
+  check(SV("(42, (hello, red))*****"), SV("{:*<23}"), input);
+  check(SV("__(42, (hello, red))___"), SV("{:_^23}"), input);
+  check(SV("#####(42, (hello, red))"), SV("{:#>23}"), input);
+
+  check(SV("(42, (hello, red))     "), SV("{:{}}"), input, 23);
+  check(SV("(42, (hello, red))*****"), SV("{:*<{}}"), input, 23);
+  check(SV("__(42, (hello, red))___"), SV("{:_^{}}"), input, 23);
+  check(SV("#####(42, (hello, red))"), SV("{:#>{}}"), input, 23);
+
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:}<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{:{<}"), input);
+  check_exception("The format-spec range-fill field contains an invalid character", SV("{::<}"), input);
+
+  // *** sign ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), input);
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), input);
+
+  // *** alternate form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), input);
+
+  // *** zero-padding ***
+  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), input);
+
+  // *** precision ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), input);
+
+  // *** locale-specific form ***
+  check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
+
+  // *** type ***
+  check(SV("__42: (hello, red)___"), SV("{:_^21m}"), input);
+  check(SV("__42, (hello, red)___"), SV("{:_^21n}"), input);
+
+  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+    check_exception("The format-spec should consume the input or end with a '}'",
+                    std::basic_string_view{STR("{:") + c + STR("}")},
+                    input);
+  }
+}
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void run_tests(TestFunction check, ExceptionTest check_exception) {
+  test_pair_int_int<CharT>(check, check_exception);
+  test_pair_int_string<CharT>(check, check_exception);
+
+  test_tuple_int<CharT>(check, check_exception);
+  test_tuple_int_int<CharT>(check, check_exception);
+  test_tuple_int_string<CharT>(check, check_exception);
+  test_tuple_int_string_color<CharT>(check, check_exception);
+
+  test_nested<CharT>(check, check_exception, std::make_pair(42, std::make_pair(SV("hello"), color::red)));
+  test_nested<CharT>(check, check_exception, std::make_pair(42, std::make_tuple(SV("hello"), color::red)));
+  test_nested<CharT>(check, check_exception, std::make_tuple(42, std::make_pair(SV("hello"), color::red)));
+  test_nested<CharT>(check, check_exception, std::make_tuple(42, std::make_tuple(SV("hello"), color::red)));
+
+  test_escaping<CharT>(check, std::make_pair(CharT('*'), STR("")));
+  test_escaping<CharT>(check, std::make_tuple(CharT('*'), STR("")));
+}
+
+#endif // TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H

libcxx/test/std/utilities/format/format.tuple/pair.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// formatter specialization for pair
+// tests the format member function without parsing
+//
+// These two functions are never tested directly in the format functions:
+// - constexpr void set_separator(basic_string_view<charT> sep);
+// - constexpr void set_brackets(basic_string_view<charT> opening, basic_string_view<charT> closing);
+
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <optional>
+#include <string_view>
+#include <utility>
+
+#include "test_format_context.h"
+#include "test_macros.h"
+#include "make_string.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+struct settings {
+  std::optional<std::basic_string_view<CharT>> separator{};
+  std::optional<std::pair<std::basic_string_view<CharT>, std::basic_string_view<CharT>>> brackets{};
+};
+
+template <class CharT>
+static void format(std::basic_string_view<CharT> expected, settings<CharT> s, auto arg) {
+  using T = std::remove_cvref_t<decltype(arg)>;
+  std::formatter<T, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+  if (s.separator)
+    formatter.set_separator(*s.separator);
+  if (s.brackets)
+    formatter.set_brackets(s.brackets->first, s.brackets->second);
+
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    std::basic_string<CharT> result;
+    auto out         = std::back_inserter(result);
+    using OutT       = decltype(out);
+    using FormatCtxT = std::basic_format_context<OutT, CharT>;
+
+    FormatCtxT format_ctx = test_format_context_create<OutT, CharT>(out, std::make_format_args<FormatCtxT>(arg));
+    formatter.format(arg, format_ctx);
+    assert(result == expected);
+  }
+}
+
+template <class CharT>
+static void test() {
+  // Note the debug format is set by parse, which is not called.
+  // Hence the output is not escaped
+  format(SV("(*, hello)"), settings<CharT>{}, std::make_pair(CharT('*'), SV("hello")));
+  format(SV("(* - hello)"), settings<CharT>{.separator = SV(" - ")}, std::make_pair(CharT('*'), SV("hello")));
+  format(SV("[--*, hello--]"),
+         settings<CharT>{.brackets = std::make_pair(SV("[--"), SV("--]"))},
+         std::make_pair(CharT('*'), SV("hello")));
+  format(SV("[--* # hello--]"),
+         settings<CharT>{.separator = SV(" # "), .brackets = std::make_pair(SV("[--"), SV("--]"))},
+         std::make_pair(CharT('*'), SV("hello")));
+}
+
+// This only verifies the members can be called in constexpr context. There is
+// no way to directly test the values set.
+constexpr bool test_constexpr() {
+  {
+    std::formatter<std::pair<int, int>, char> formatter;
+    formatter.set_separator(": ");
+    formatter.set_brackets("[", "]");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::formatter<std::pair<int, int>, wchar_t> formatter;
+    formatter.set_separator(L": ");
+    formatter.set_brackets(L"[", L"]");
+  }
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
+
+  return true;
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  static_assert(test_constexpr());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.tuple/tuple.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// formatter specialization for tuple
+// tests the format member function without parsing
+//
+// These two functions are never tested directly in the format functions:
+// - constexpr void set_separator(basic_string_view<charT> sep);
+// - constexpr void set_brackets(basic_string_view<charT> opening, basic_string_view<charT> closing);
+
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <optional>
+#include <string_view>
+#include <tuple>
+
+#include "test_format_context.h"
+#include "test_macros.h"
+#include "make_string.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+struct settings {
+  std::optional<std::basic_string_view<CharT>> separator{};
+  std::optional<std::pair<std::basic_string_view<CharT>, std::basic_string_view<CharT>>> brackets{};
+};
+
+template <class CharT>
+static void format(std::basic_string_view<CharT> expected, settings<CharT> s, auto arg) {
+  using T = std::remove_cvref_t<decltype(arg)>;
+  std::formatter<T, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+  if (s.separator)
+    formatter.set_separator(*s.separator);
+  if (s.brackets)
+    formatter.set_brackets(s.brackets->first, s.brackets->second);
+
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    std::basic_string<CharT> result;
+    auto out         = std::back_inserter(result);
+    using OutT       = decltype(out);
+    using FormatCtxT = std::basic_format_context<OutT, CharT>;
+
+    FormatCtxT format_ctx = test_format_context_create<OutT, CharT>(out, std::make_format_args<FormatCtxT>(arg));
+    formatter.format(arg, format_ctx);
+    assert(result == expected);
+  }
+}
+
+template <class CharT>
+static void test() {
+  // Note the debug format is set by parse, which is not called.
+  // Hence the output is not escaped
+  format(SV("(*, hello)"), settings<CharT>{}, std::make_tuple(CharT('*'), SV("hello")));
+  format(SV("(* - hello)"), settings<CharT>{.separator = SV(" - ")}, std::make_tuple(CharT('*'), SV("hello")));
+  format(SV("[--*, hello--]"),
+         settings<CharT>{.brackets = std::make_pair(SV("[--"), SV("--]"))},
+         std::make_tuple(CharT('*'), SV("hello")));
+  format(SV("[--* # hello--]"),
+         settings<CharT>{.separator = SV(" # "), .brackets = std::make_pair(SV("[--"), SV("--]"))},
+         std::make_tuple(CharT('*'), SV("hello")));
+}
+
+// This only verifies the members can be called in constexpr context. There is
+// no way to directly test the values set.
+constexpr bool test_constexpr() {
+  {
+    std::formatter<std::tuple<int, int>, char> formatter;
+    formatter.set_separator(": ");
+    formatter.set_brackets("[", "]");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::formatter<std::tuple<int, int>, wchar_t> formatter;
+    formatter.set_separator(L": ");
+    formatter.set_brackets(L"[", L"]");
+  }
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
+
+  return true;
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+  static_assert(test_constexpr());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.tuple/vformat.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "format_tests.h"
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <iostream>
+#  include <concepts>
+#endif
+
+auto test = []<class CharT, class... Args>(
+                std::basic_string_view<CharT> expected, std::basic_string_view<CharT> fmt, Args&&... args) {
+  std::basic_string<CharT> out = std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
+#ifndef TEST_HAS_NO_LOCALIZATION
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt << "\nExpected output " << expected << "\nActual output   " << out
+                << '\n';
+#endif // TEST_HAS_NO_LOCALIZATION
+  assert(out == expected);
+};
+
+auto test_exception =
+    []<class CharT, class... Args>(
+        [[maybe_unused]] std::string_view what,
+        [[maybe_unused]] std::basic_string_view<CharT> fmt,
+        [[maybe_unused]] Args&&... args) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+      try {
+        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
+#  if !defined(TEST_HAS_NO_LOCALIZATION)
+        if constexpr (std::same_as<CharT, char>)
+          std::cerr << "\nFormat string   " << fmt << "\nDidn't throw an exception.\n";
+#  endif //  !defined(TEST_HAS_NO_LOCALIZATION
+        assert(false);
+      } catch ([[maybe_unused]] const std::format_error& e) {
+#  if defined(_LIBCPP_VERSION)
+#    if !defined(TEST_HAS_NO_LOCALIZATION)
+        if constexpr (std::same_as<CharT, char>) {
+          if (e.what() != what)
+            std::cerr << "\nFormat string   " << fmt << "\nExpected exception " << what << "\nActual exception   "
+                      << e.what() << '\n';
+        }
+#    endif // !defined(TEST_HAS_NO_LOCALIZATION
+        assert(e.what() == what);
+#  endif // defined(_LIBCPP_VERSION)
+        return;
+      }
+      assert(false);
+#endif
+    };
+
+int main(int, char**) {
+  run_tests<char>(test, test_exception);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  run_tests<wchar_t>(test, test_exception);
+#endif
+
+  return 0;
+}