[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

329

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

64

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".

73–75

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

78

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.

85

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

92

This function looks unnecessary, I suggest merging into format.

120

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

136

Why do you need to specify alignment here?

139

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

111–118

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

117

Maybe __allow_colon_in_fill_ would be more descriptive?

390

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 ↗

(On Diff #471734)

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

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

58 ↗

(On Diff #471734)

Add a test case with a multibyte fill?

157 ↗

(On Diff #471734)

Add a test case with invalid UTF-8?

302–303 ↗

(On Diff #471734)

We should fix this.

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

34 ↗

(On Diff #471734)

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

73–75

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.

78

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

85

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

120

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

136

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

139

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

111–118

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

117

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

390

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 ↗

(On Diff #471734)

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 ↗

(On Diff #471734)

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 ↗

(On Diff #471734)

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 ↗

(On Diff #471734)

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 ↗

(On Diff #471734)

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

28

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

120

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

120

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

105

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

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_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,Mark de Wever,,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::local_info``",A ``<chrono>`` implementation,Mark de Wever,,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::zoned_time<Duration, TimeZonePtr>``",A ``<chrono>`` implementation,Mark de Wever,,
 `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/range_default_formatter.h
   __format/unicode.h
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind.h
   __functional/bind_back.h
   __functional/bind_front.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
+#  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
+#endif   //_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;
 };
 
-#endif //_LIBCPP_STD_VER > 17
+#  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/integer_sequence.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);
+
+    // [format.tuple]/7
+    //   ... For each element e in underlying_, if e.set_debug_format()
+    //   is a valid expression, calls e.set_debug_format().
+    // TODO FMT this can be removed when P2733 is accepted.
+    std::__for_each_index_sequence(make_index_sequence<sizeof...(_Args)>(), [&]<size_t _Index> {
+      std::__set_debug_format(std::get<_Index>(__underlying_));
+    });
+
+    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 format specifier m requires a pair or a two-element tuple");
+    } else if (*__begin == _CharT('n')) {
+      set_brackets({}, {});
+      ++__begin;
+    }
+
+    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 {
+    __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
+
+    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);
+
+    std::__for_each_index_sequence(make_index_sequence<sizeof...(_Args)>(), [&]<size_t _Index> {
+      if constexpr (_Index)
+        __ctx.advance_to(std::ranges::copy(__separator_, __ctx.out()).out);
+
+        // During review Victor suggested to make the exposition only
+        // __underlying_ member a local variable. Currently the Standard
+        // requires nested debug-enabled formatter specializations not to
+        // output escaped output. P2733 fixes that bug, once accepted the
+        // code below can be used.
+        // (Note when a paper allows parsing a tuple-underlying-spec the
+        // exposition only member needs to be a class member. Earlier
+        // revisions of P2286 proposed that, but this was not pursued,
+        // due to time constrains and complexity of the matter.)
+        // TODO FMT This can be updated after P2733 is accepted.
+#  if 0
+      // P2286 uses an exposition only member in the formatter
+      //   tuple<formatter<remove_cvref_t<_Args>, _CharT>...> __underlying_;
+      // This was used in earlier versions of the paper since
+      // __underlying_.parse(...) was called. This is no longer the case
+      // so we can reduce the scope of the formatter.
+      //
+      // It does require the underlying's parse effect to be moved here too.
+      using _Arg = tuple_element<_Index, decltype(__tuple)>;
+      formatter<remove_cvref_t<_Args>, _CharT> __underlying;
+
+      // [format.tuple]/7
+      //   ... For each element e in underlying_, if e.set_debug_format()
+      //   is a valid expression, calls e.set_debug_format().
+      std::__set_debug_format(__underlying);
+#  else
+      __ctx.advance_to(std::get<_Index>(__underlying_).format(std::get<_Index>(__tuple), __ctx));
+#  endif
+    });
+
+    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 _VSTD::__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.
+// TODO FMT Use an ABI tag for this struct.
 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};
+  // Determines the valid values for fill.
+  //
+  // Originally the fill could be any character except { and }. Range-based
+  // formatters use the colon to mark the beginning of the
+  // underlying-format-spec. To avoid parsing ambiguities these formatter
+  // specializations prohibit the use of the colon as a fill character.
+  uint8_t __allow_colon_in_fill_ : 1 {false};
 };
 
 // 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, .__allow_colon_in_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.__allow_colon_in_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('}'))
+        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))
       return false;

libcxx/include/__utility/integer_sequence.h

template<class _Tp, _Tp _Np>
     using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
 
 template<size_t _Np>
     using make_index_sequence = make_integer_sequence<size_t, _Np>;
 
 template<class... _Tp>
     using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
 
+#  if _LIBCPP_STD_VER > 17
+// Executes __func for every element in an index_sequence.
+template <size_t... _Index, class _Function>
+_LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) {
+    (__func.template operator()<_Index>(), ...);
+}
+#  endif // _LIBCPP_STD_VER > 17
+
 #endif // _LIBCPP_STD_VER > 11
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H

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/range_default_formatter.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 {
         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"
         export algorithm.__algorithm.in_out_result
       }
       module ranges_copy_backward {
         private header "__algorithm/ranges_copy_backward.h"
         export algorithm.__algorithm.in_out_result
       }
       module ranges_copy_if {
         private header "__algorithm/ranges_copy_if.h"
         export algorithm.__algorithm.in_out_result
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 range_default_formatter         { private header "__format/range_default_formatter.h" }
       module unicode                         { private header "__format/unicode.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list

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/range_default_formatter.h> // expected-error@*:* {{use of private header from outside its module: '__format/range_default_formatter.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'}}

libcxx/test/libcxx/utilities/intseq/for_each_index_sequence.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
+
+// <utility>
+
+// inline constexpr auto __for_each_index_sequence = []<size_t... _Index>(index_sequence<_Index...>, auto __func)
+
+#include <utility>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  int count = 0;
+  std::__for_each_index_sequence(std::make_index_sequence<8>(), [&]<size_t _Index> { count += _Index; });
+  assert(count == 28);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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 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);
 
-  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.functions.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
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// template<class charT, formattable<charT>... Ts>
+//   struct formatter<pair-or-tuple<Ts...>, charT>
+//
+// tested in the format functions
+//
+// template<class... Args>
+//   string format(format-string<Args...> fmt, const Args&... args);
+// template<class... Args>
+//   wstring format(wformat-string<Args...> fmt, const Args&... args);
+
+#include <format>
+#include <cassert>
+
+#include "format.functions.tests.h"
+#include "test_format_string.h"
+#include "test_macros.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.functions.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.functions.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 format specifier m requires a pair or a two-element tuple", 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 format specifier m requires a pair or a two-element tuple", 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. The paper
+  //   P2733 Fix handling of empty specifiers in std::format
+  // addressed this.
+
+  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("")));
+
+  // Test cvref-qualified types.
+  // clang-format off
+  check(SV("(42)"), SV("{}"), std::tuple<               int  >{42});
+  check(SV("(42)"), SV("{}"), std::tuple<const          int  >{42});
+  check(SV("(42)"), SV("{}"), std::tuple<      volatile int  >{42});
+  check(SV("(42)"), SV("{}"), std::tuple<const volatile int  >{42});
+
+  int answer = 42;
+  check(SV("(42)"), SV("{}"), std::tuple<               int& >{answer});
+  check(SV("(42)"), SV("{}"), std::tuple<const          int& >{answer});
+  check(SV("(42)"), SV("{}"), std::tuple<      volatile int& >{answer});
+  check(SV("(42)"), SV("{}"), std::tuple<const volatile int& >{answer});
+
+  check(SV("(42)"), SV("{}"), std::tuple<               int&&>{42});
+  check(SV("(42)"), SV("{}"), std::tuple<const          int&&>{42});
+  check(SV("(42)"), SV("{}"), std::tuple<      volatile int&&>{42});
+  check(SV("(42)"), SV("{}"), std::tuple<const volatile int&&>{42});
+  // clang-format on
+}
+
+#endif // TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H

libcxx/test/std/utilities/format/format.tuple/format.functions.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
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// template<class charT, formattable<charT>... Ts>
+//   struct formatter<pair-or-tuple<Ts...>, charT>
+//
+// tested in the format functions
+//
+// string vformat(string_view fmt, format_args args);
+// wstring vformat(wstring_view fmt, wformat_args args);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "format.functions.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;
+}

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
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// template<class charT, formattable<charT>... Ts>
+//   struct formatter<pair-or-tuple<Ts...>, charT>
+
+// template<class FormatContext>
+//   typename FormatContext::iterator
+//     format(see below& elems, FormatContext& ctx) const;
+
+// Note this tests the basics of this function. It's tested in more detail in
+// the format functions tests.
+
+#include <cassert>
+#include <concepts>
+#include <format>
+#include <tuple>
+#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 StringViewT, class Arg>
+void test(StringViewT expected, Arg arg) {
+  using CharT      = typename StringViewT::value_type;
+  using String     = std::basic_string<CharT>;
+  using OutIt      = std::back_insert_iterator<String>;
+  using FormatCtxT = std::basic_format_context<OutIt, CharT>;
+
+  const std::formatter<Arg, CharT> formatter;
+
+  String result;
+  OutIt out             = std::back_inserter(result);
+  FormatCtxT format_ctx = test_format_context_create<OutIt, CharT>(out, std::make_format_args<FormatCtxT>(arg));
+  formatter.format(arg, format_ctx);
+  assert(result == expected);
+}
+
+template <class CharT>
+void test() {
+  test(SV("(1)"), std::tuple<int>{1});
+  test(SV("(1, 1)"), std::tuple<int, CharT>{1, CharT('1')});
+  test(SV("(1, 1)"), std::pair<int, CharT>{1, CharT('1')});
+  test(SV("(1, 1, 1)"), std::tuple<int, CharT, double>{1, CharT('1'), 1.0});
+}
+
+void test() {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.tuple/parse.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
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// template<class charT, formattable<charT>... Ts>
+//   struct formatter<pair-or-tuple<Ts...>, charT>
+
+// template<class ParseContext>
+//   constexpr typename ParseContext::iterator
+//     parse(ParseContext& ctx);
+
+// Note this tests the basics of this function. It's tested in more detail in
+// the format functions tests.
+
+#include <cassert>
+#include <concepts>
+#include <format>
+#include <tuple>
+#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 Arg, class StringViewT>
+constexpr void test(StringViewT fmt) {
+  using CharT    = typename StringViewT::value_type;
+  auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+  std::formatter<Arg, CharT> formatter;
+  static_assert(std::semiregular<decltype(formatter)>);
+
+  std::same_as<typename StringViewT::iterator> auto it = formatter.parse(parse_ctx);
+  assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+}
+
+template <class CharT, class Arg>
+constexpr void test() {
+  test<Arg>(SV(""));
+  test<Arg>(SV("42"));
+
+  test<Arg>(SV("}"));
+  test<Arg>(SV("42}"));
+}
+
+template <class CharT>
+constexpr void test() {
+  test<CharT, std::tuple<int>>();
+  test<CharT, std::tuple<int, CharT>>();
+  test<CharT, std::pair<int, CharT>>();
+  test<CharT, std::tuple<int, CharT, double>>();
+}
+
+constexpr bool test() {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.tuple/set_brackets.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
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// template<class charT, formattable<charT>... Ts>
+//   struct formatter<pair-or-tuple<Ts...>, charT>
+
+// constexpr void constexpr void set_brackets(basic_string_view<charT> opening,
+//                                            basic_string_view<charT> closing);
+
+// Note this tests the basics of this function. It's tested in more detail in
+// the format functions tests.
+
+#include <format>
+#include <tuple>
+#include <utility>
+
+#include "make_string.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT, class Arg>
+constexpr void test() {
+  std::formatter<Arg, CharT> formatter;
+  formatter.set_brackets(SV("open"), SV("close"));
+
+  // Note there is no direct way to validate this function modified the object.
+}
+
+template <class CharT>
+constexpr void test() {
+  test<CharT, std::tuple<int>>();
+  test<CharT, std::tuple<int, CharT>>();
+  test<CharT, std::pair<int, CharT>>();
+  test<CharT, std::tuple<int, CharT, double>>();
+}
+
+constexpr bool test() {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.tuple/set_separator.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
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx11.{{.+}}
+
+// <format>
+
+// class range_formatter
+// template<class charT, formattable<charT>... Ts>
+//   struct formatter<pair-or-tuple<Ts...>, charT>
+
+// constexpr void set_separator(basic_string_view<charT> sep);
+
+// Note this tests the basics of this function. It's tested in more detail in
+// the format functions tests.
+
+#include <format>
+#include <tuple>
+#include <utility>
+
+#include "make_string.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT, class Arg>
+constexpr void test() {
+  std::formatter<Arg, CharT> formatter;
+  formatter.set_separator(SV("sep"));
+
+  // Note there is no direct way to validate this function modified the object.
+}
+
+template <class CharT>
+constexpr void test() {
+  test<CharT, std::tuple<int>>();
+  test<CharT, std::tuple<int, CharT>>();
+  test<CharT, std::pair<int, CharT>>();
+  test<CharT, std::tuple<int, CharT, double>>();
+}
+
+constexpr bool test() {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/utils/ci/run-buildbot

check-generated-output)
     fi
 
     # Reject patches that introduce non-ASCII characters or hard tabs.
     # Depends on LC_COLLATE set at the top of this script.
     ! grep -rn '[^ -~]' libcxx/include libcxx/src libcxx/test libcxx/benchmarks \
            --exclude '*.dat' \
            --exclude 'escaped_output.*.pass.cpp' \
            --exclude 'format_tests.h' \
+           --exclude 'format.functions.tests.h' \
            --exclude 'formatter.*.pass.cpp' \
            --exclude 'grep.pass.cpp' \
            --exclude 'locale-specific_form.pass.cpp' \
            --exclude 'ostream.pass.cpp' \
            --exclude 'std_format_spec_string_unicode.bench.cpp' \
            --exclude 'underflow.pass.cpp' \
            || false