[libc++][format] Improve string formatters

[Mordante]

Summary

This changes the implementation of the formatter. Instead of inheriting
from a specialized parser all formatters will use the same generic
parser. This reduces the binary size.

The new parser contains some additional fields only used in the chrono
formatting. Since this doesn't change the size of the parser the fields
are in the generic parser. The parser is designed to fit in 128-bit,
making it cheap to pass by value.

The new format function is a const member function. This isn't required
by the Standard yet, but it will be after LWG-3636 is accepted.
Additionally P2286 adds a formattable concept which requires the member
function to be const qualified in C++23. This paper is likely to be
accepted in the 2022 July plenary.

Depends on D121530

NOTE parts of the code now contains duplicates for the current and new parser.
The intention is to remove the duplication in followup patches. A general
overview of the final code is available in D124620. That review however lacks a
bit of polish.

Most of the new code is based on the same algorithms used in the current code.

The final version of this code reduces the binary size by 17 KB for this example
code

int main() {
  {
    std::string_view sv{"hello world"};
    std::format("{}{}|{}{}{}{}{}{}|{}{}{}{}{}{}|{}{}{}|{}{}|{}", true, '*',
                (signed char)(42), (short)(42), (int)(42), (long)(42), (long long)(42), (__int128_t)(42),
                (unsigned char)(42), (unsigned short)(42), (unsigned int)(42), (unsigned long)(42),
                (unsigned long long)(42), (__uint128_t)(42),
                (float)(42), (double)(42), (long double)(42),
                "hello world", sv,
                nullptr);
  }
  {
    std::wstring_view sv{L"hello world"};
    std::format(L"{}{}|{}{}{}{}{}{}|{}{}{}{}{}{}|{}{}{}|{}{}|{}", true, L'*',
                (signed char)(42), (short)(42), (int)(42), (long)(42), (long long)(42), (__int128_t)(42),
                (unsigned char)(42), (unsigned short)(42), (unsigned int)(42), (unsigned long)(42),
                (unsigned long long)(42), (__uint128_t)(42),
                (float)(42), (double)(42), (long double)(42),
                L"hello world", sv,
                nullptr);
  }
}

[philnik]

libcxx/include/__format/parser_std_format_spec.h

1538

Why not use bool?

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

1538

That will most likely change the size of the object on Windows. (Note that the underlying type of the enum classes is an uint8_t too.) I can test this after the Windows build is green.

[Mordante]

Attempt to fix the CI.

[Mordante]

Attempt to fix Windows build.

[Mordante]

Another attempt to fix the Windows build.

[Mordante]

Test whether bools work on all supported platforms as @philnik suggested.

[Mordante]

Minor polishing.

[Mordante]

libcxx/include/__format/formatter_output.h

32

This will be done after all formatters are converted to this style.

libcxx/include/__format/parser_std_format_spec.h

1538

I tested in Godbolt and it seems bool works. Maybe because it has the same size and alignment as the uint8_t. Since the CI is also happy I'll keep the bools.

[Mordante]

Rebased

[Mordante]

Rebased to fix CI.

[Mordante]

Rebased on main.

[vitaut]

Looks great! My main suggestion is to rename __parser into something more appropriate (see an inline comment) and possibly separate the actual parsing logic from the parser output.

libcxx/include/__format/formatter_output.h

80

Normally parser is something that does parsing. "The parsed formatting output settings" sounds more like format specs so I'd suggest renaming accordingly and making parser return these specs.

119–132

Not specific to this diff but I think it would be cleaner to fold Unicode/non-Unicode handling into __estimate_column_width and have a single check and copy here.

libcxx/include/__format/formatter_string.h

35

What is this function for? Why not use __write_unicode directly?

81–83

Premature optimization: you could use negative values to indicate "no width/precision" and avoid extra checks here.

libcxx/include/__format/parser_std_format_spec.h

1528

Another option is to fold this into fill/alignment (this would require an additional alignment enumerator making it larger). Not suggesting to change, just something to consider.

1689

nit: maybe replace float_hexadecimal with hexfloat for consistency with the naming in the standard (e.g. https://en.cppreference.com/w/cpp/io/manip/fixed)? The other names seem to be already consistent.

1750–1751

This is a weird check. I think we should open an LWG issue to allow zero dynamic width and remove this unnecessary check.

1757

nit: why assign false here but 0 to __width_as_arg_ in __substitute_width_arg_id above? Make this consistent?

[Mordante]

Thanks for the review!

In D125606#3559009, @vitaut wrote:

Looks great! My main suggestion is to rename __parser into something more appropriate (see an inline comment) and possibly separate the actual parsing logic from the parser output.

I'll investigate that direction.

libcxx/include/__format/formatter_output.h

80

Interesting observation. I give this some thought.

119–132

I like this suggestion, but I leave it as is in this patch.
I noticed this code doesn't do grapheme clustering at all.
I've been working on that in D126971. So it makes more sense it implement those changes in that patch.

libcxx/include/__format/formatter_string.h

35

I did that to be consistent with the other new formatters. But this one indeed can be removed.

81–83

That won't work. Here I need to check for both the value set or an argument used. Here I haven't resolved the formatting arguments.

However when a formatting argument used for the width can contain the value 0 it would be easier to resolve this width before validating its value.

libcxx/include/__format/parser_std_format_spec.h

1528

I had considered that in the original parser, but it didn't work out in that design. But I don't see why it can't work in this design. I like the idea since it makes the code of setting the zero-padding alignment cleaner. During the parsing I can test whether another alignment is set, instead of having "uglier" post processing code.

Indeed the number of bits required to store the data remains the same.

Thanks for the suggestion!

1689

Good point.

1750–1751

Currently width is specified as

width:
    positive-integer
    { arg-idopt }

do you want to change that also to nonnegative-integer? When not it's the question what the width of 0 should do.
Note that __format_spec::__substitute_arg_id(__arg); already throws on negative values.

Another option would be to give the minimum as an argument to __substitute_arg_id so there it can validate the proper boundary.

1757

I originally used 0 and 1 but switched to false and true later. It seems I missed one place.

[Mordante]

Addresses review comments.

[vitaut]

libcxx/include/__format/parser_std_format_spec.h

1750–1751

The grammar was done that way to avoid confusion between zero width and zero flag. I am not suggesting to change the grammar, just remove the runtime check for zero dynamic width since it's mostly harmless and only adds overhead.

[ldionne]

I really like the new approach, especially since it cuts down on code size. I don't have any strong reservations about this patch, the only thing I'd really like is to investigate what the patch would look like if we did not jam the chrono and non-chrono formatter specs into the same structs. Other than that, I'm generally really happy with this -- thanks for making these improvements!

libcxx/include/__format/parser_std_format_spec.h

1390–1391

I am not sure I understand this comment.

1403–1407

It seems to me like it might be cleaner to define it inside formatter_string.h (closer to its point of use), but this is just a suggestion, if you've been through these changes and feel like this is the right way to group things, go with it.

1459–1463

I think it's nice that this is really tailor-made to fit into as little space as possible, however I do have a concern that it might not be robust against future changes. For example, this code would break if we added a (admittedly large) number of elements to the __type enumeration. I'm not sure what would make me feel more easy about this -- perhaps simply adding some sort of static_assert to make sure the code stays in sync would be enough?

1465–1466

I find it a bit confusing that we're jamming these chrono specific fields here. I think we should either have a separate __chrono_parsed_specifications with just the fields it needs, or make this some sort of union { <things-needed-by-std-format-spec>; <things-needed-by-chrono-format-spec> }.

1468

Do you think that makes sense? Otherwise, perhaps a comment is enough. Basically, it would be nice not to leave a raw hard-coded number unexplained, for newbies like me :-)

1553–1556

Perhaps we could centralize this 4 value with this comment, and then reuse it here and above where I left a similar review comment?

[Mordante]

@ldionne I've the suggested changes, but before putting it up for review again I want to see whether these changes impact other work-in-progress code. (Not merge conflicts, but incompatibilities.)

libcxx/include/__format/parser_std_format_spec.h

1390–1391

As discussed, this is a left-over of an experiment. Removed the unneeded part.

1403–1407

I prefer to keep it here. That way it's easy to see which options are used for a formatter. The other formatters will also get their specific flags here. I expect to look more often at the flags when working on the format specs then when working on the formatters.

1459–1463

We currently have 18 members in the enum. I'm only aware of two papers intending to add a field

• http://wg21.link/P2510 "Formatting pointers" adds an upper case for pointer
• http://wg21.link/P2286 "Formatting Ranges" adds a debug output for chars and strings

This would leave use with 12 unused values. I can add one bit, which would give us 44 values to use.

I've added a static_assert for the entire struct.

1465–1466

I added a union. These two unions share __alignment __alignment_ : 3; since that field is shared between the two formatters. This means we can access a member of a not active member. However this is valid per http://eel.is/c++draft/class.union#def:active,union_member

In a union, a non-static data member is active if its name refers to an object
whose lifetime has begun and has not ended ([basic.life]).  At most one of the
non-static data members of an object of union type can be active at any time,
that is, the value of at most one of the non-static data members can be stored
in a union at any time.

[Note 1: One special guarantee is made in order to simplify the use of unions:
If a standard-layout union contains several standard-layout structs that share
a common initial sequence ([class.mem]), and if a non-static data member of an
object of this standard-layout union type is active and is one of the
standard-layout structs, it is permitted to inspect the common initial sequence
of any of the standard-layout struct members; see [class.mem].  — end note]

Clearly this is intended to put the tag of a tagged union at the start, but we can use that for our purposes.

1468

I moved this field after the precision_. The next field width_ is an int32_t and has the wanted alignment and avoids using magic values.

1553–1556

I moved this field after the __precision_. The next field __width_ is an int32_t and has the wanted alignment and avoids using magic values.

[ldionne]

libcxx/include/__format/parser_std_format_spec.h

1459–1463

Do you know how other implementations handle this problem? What about @vitaut 's fmt library?

I'm sure there will be more stuff added to <format> in the future, but I have no idea of how much stuff is going to be added. Is it possible that we'll ever run into this limitation? I don't know. However, the situation I'd like to avoid is one where WG21 wants to move forward with a paper, but libc++ has to say "we won't be able to implement it due to ABI", while other implementations are able to implement it <for some reason>. If all other implementations make a tradeoff similar to this, I think it's fine.

Basically, I'd just like to make sure we're not painting our implementation into a corner.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

1459–1463

fmt uses a struct with bitfields. It stores the type as an enum class with unsigned char as underlying value. This type isn't a bitfield.

MSVC STL uses a struct without bitfields and stores the type as the char used in the format string.

So if we want to avoid to be ever in a corner this field should not be a bit field. I feel it's a bit overkill, but it's not like the available space is tight, so I'll make this field 8 bits.

[Mordante]

Address review comments.

[ldionne]

libcxx/include/__format/parser_std_format_spec.h

1468

1470

We don't need visibility(default). First of all, it doesn't change anything because all the member functions are marked with HIDE_FROM_ABI (which gives them visibility(hidden)) and there's no vtable to give visibility to, and secondly it's kind of confusing to use a visibility annotation other than _LIBCPP_HIDDEN on a struct that we call out as being not part of the ABI.

1477

1502

Can you add a comment explaining *why* you perform those tests (something like // make sure it fits in a register and it's trivially copyable for performance)? Otherwise, it looks as-if you are trying to enforce some ABI stability, which would be counter to the comment above (and your actual intent IIUC).

1515

[Mordante]

Thanks for the reviews!

libcxx/include/__format/parser_std_format_spec.h

1515

Fair point. Looking at the amount of papers aiming to use format I still guess it's a matter of when ;-)

1750–1751

I've filed an LWG-issue Sunday, based on previous experience it will be processed next weekend.
(I don't feel the need to add the issue in the comments of the code.)

[Mordante]

Addresses all review comments and rebased.
Make sure the CI passes since during the last iteration the CI was down.

libcxx/include/CMakeLists.txt

set(files
   __format/format_string.h
   __format/format_to_n_result.h
   __format/formatter.h
   __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/parser_std_format_spec.h
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind.h
   __functional/bind_back.h
   __functional/bind_front.h

libcxx/include/__format/formatter_output.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_OUTPUT_H
+#define _LIBCPP___FORMAT_FORMATTER_OUTPUT_H
+
+#include <__algorithm/copy.h>
+#include <__algorithm/fill_n.h>
+#include <__config>
+#include <__format/parser_std_format_spec.h>
+#include <__utility/move.h>
+#include <__utility/unreachable.h>
+#include <cstddef>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+namespace __formatter {
+
+// TODO FMT remove _v2 suffix.
+struct _LIBCPP_TYPE_VIS __padding_size_result_v2 {
+  size_t __before_;
+  size_t __after_;
+};
+
+// TODO FMT remove _v2 suffix.
+_LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result_v2 __padding_size_v2(size_t __size, size_t __width,
+                                                                           __format_spec::__alignment __align) {
+  _LIBCPP_ASSERT(__width > __size, "Don't call this function when no padding is required");
+  _LIBCPP_ASSERT(__align != __format_spec::__alignment::__default,
+                 "Caller should adjust the default to the value required by the type");
+
+  size_t __fill = __width - __size;
+  switch (__align) {
+  case __format_spec::__alignment::__default:
+    __libcpp_unreachable();
+
+  case __format_spec::__alignment::__left:
+    return {0, __fill};
+
+  case __format_spec::__alignment::__center: {
+    // The extra padding is divided per [format.string.std]/3
+    // __before = floor(__fill, 2);
+    // __after = ceil(__fill, 2);
+    size_t __before = __fill / 2;
+    size_t __after = __fill - __before;
+    return {__before, __after};
+  }
+  case __format_spec::__alignment::__right:
+    return {__fill, 0};
+  }
+  __libcpp_unreachable();
+}
+
+/// Writes the input to the output with the required padding.
+///
+/// Since the output column width is specified the function can be used for
+/// ASCII and Unicode output.
+///
+/// \pre [\a __first, \a __last) is a valid range.
+/// \pre \a __size <= \a __width. Using this function when this pre-condition
+///      doesn't hold incurs an unwanted overhead.
+///
+/// \param __first     Pointer to the first element to write.
+/// \param __last      Pointer beyond the last element to write.
+/// \param __out_it    The output iterator to write to.
+/// \param __parser    The parsed formatting output settings.
+/// \param __size      The (estimated) output column width. When the elements
+///                    to be written are ASCII the following condition holds
+///                    \a __size == \a __last - \a __first.
+///
+/// \returns           An iterator pointing beyond the last element written.
+///
+/// \note The type of the elements in range [\a __first, \a __last) can differ
+/// from the type of \a __parser. Integer output uses \c std::to_chars for its
+/// conversion, which means the [\a __first, \a __last) always contains elements
+/// of the type \c char.
+template <class _CharT, class _ParserCharT>
+_LIBCPP_HIDE_FROM_ABI auto __write(const _CharT* __first, const _CharT* __last,
+                                   output_iterator<const _CharT&> auto __out_it,
+                                   __format_spec::__parser<_ParserCharT> __parser, ptrdiff_t __size)
+    -> decltype(__out_it) {
+  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
+
+  if (__size >= __parser.__width_)
+    return _VSTD::copy(__first, __last, _VSTD::move(__out_it));
+
+  __padding_size_result_v2 __padding = __formatter::__padding_size_v2(__size, __parser.__width_, __parser.__alignment_);
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before_, __parser.__fill_);
+  __out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
+  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after_, __parser.__fill_);
+}
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __write_unicode_no_precision(basic_string_view<_CharT> __str,
+                                                        output_iterator<const _CharT&> auto __out_it,
+                                                        __format_spec::__parser<_CharT> __parser)
+    -> decltype(__out_it) {
+  _LIBCPP_ASSERT(!__parser.__has_precision(), "use __write_unicode");
+  // No padding -> copy the string
+  if (!__parser.__has_width())
+    return _VSTD::copy(__str.begin(), __str.end(), _VSTD::move(__out_it));
+
+  // Non Unicode part larger than width -> copy the string
+  auto __last = __format_spec::__detail::__estimate_column_width_fast(__str.begin(), __str.end());
+  ptrdiff_t __size = __last - __str.begin();
+  if (__size >= __parser.__width_)
+    return _VSTD::copy(__str.begin(), __str.end(), _VSTD::move(__out_it));
+
+  // Is there a non Unicode part?
+  if (__last != __str.end()) {
+    // Non Unicode and Unicode part larger than width -> copy the string
+    __format_spec::__detail::__column_width_result __column_width =
+        __format_spec::__detail::__estimate_column_width(__last, __str.end(), __parser.__width_);
+    __size += __column_width.__width; // Note this new size is used when __size < __parser.__width_
+    if (__size >= __parser.__width_)
+      return _VSTD::copy(__str.begin(), __str.end(), _VSTD::move(__out_it));
+  }
+
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __size);
+}
+#  endif
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __write_unicode(basic_string_view<_CharT> __str,
+                                           output_iterator<const _CharT&> auto __out_it,
+                                           __format_spec::__parser<_CharT> __parser) -> decltype(__out_it) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  if (!__parser.__has_precision())
+    return __formatter::__write_unicode_no_precision(__str, _VSTD::move(__out_it), __parser);
+
+  // Non unicode part larger than precision -> truncate the output and use the normal write operation.
+  auto __last = __format_spec::__detail::__estimate_column_width_fast(__str.begin(), __str.end());
+  ptrdiff_t __size = __last - __str.begin();
+  if (__size >= __parser.__precision_)
+    return __formatter::__write(__str.begin(), __str.begin() + __parser.__precision_, _VSTD::move(__out_it), __parser,
+                                __parser.__precision_);
+
+  // No non Unicode part, implies __size <  __parser.__precision_ -> use normal write operation
+  if (__last == __str.end())
+    return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __str.size());
+
+  __format_spec::__detail::__column_width_result __column_width =
+      __format_spec::__detail::__estimate_column_width(__last, __str.end(), __parser.__precision_ - __size);
+  __size += __column_width.__width;
+  // Truncate the output
+  if (__column_width.__ptr != __str.end())
+    __str.remove_suffix(__str.end() - __column_width.__ptr);
+
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __size);
+
+#  else
+  if (__parser.__has_precision()) {
+    ptrdiff_t __size = __str.size();
+    if (__size > __parser.__precision_)
+      return __formatter::__write(__str.begin(), __str.begin() + __parser.__precision_, _VSTD::move(__out_it), __parser,
+                                  __parser.__precision_);
+  }
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __str.size());
+
+#  endif
+}
+
+} // namespace __formatter
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_FORMATTER_OUTPUT_H

libcxx/include/__format/formatter_string.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_STRING_H
 #define _LIBCPP___FORMAT_FORMATTER_STRING_H
 
-#include <__assert>
+#include <__availability>
 #include <__config>
-#include <__format/format_error.h>
 #include <__format/format_fwd.h>
-#include <__format/format_string.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <__utility/move.h>
+#include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-namespace __format_spec {
+namespace __formatter {
 
-template <__formatter::__char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __formatter_string : public __parser_string<_CharT> {
-public:
-  _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT> __str,
-                                    auto& __ctx) -> decltype(__ctx.out()) {
-
-    _LIBCPP_ASSERT(this->__alignment != _Flags::_Alignment::__default,
-                   "The parser should not use these defaults");
-
-    if (this->__width_needs_substitution())
-      this->__substitute_width_arg_id(__ctx.arg(this->__width));
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_string_view(basic_string_view<_CharT> __str,
+                                                output_iterator<const _CharT&> auto __out_it,
+                                                __format_spec::__parser<_CharT> __parser) -> decltype(__out_it) {
+  return __formatter::__write_unicode(__str, _VSTD::move(__out_it), __parser);
+}
 
-    if (this->__precision_needs_substitution())
-      this->__substitute_precision_arg_id(__ctx.arg(this->__precision));
+} // namespace __formatter
 
-    return __formatter::__write_unicode(
-        __ctx.out(), __str, this->__width,
-        this->__has_precision_field() ? this->__precision : -1, this->__fill,
-        this->__alignment);
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_string {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_string);
+    __format_spec::__process_display_type_string(__parser_.__type_);
+    return __result;
   }
-};
 
-} //namespace __format_spec
+  _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT> __str, auto& __ctx) const -> decltype(__ctx.out()) {
+    return __formatter::__format_string_view(__str, __ctx.out(), __parser_.__resolve_dynamic_sizes(__ctx));
+  }
 
-// [format.formatter.spec]/2.2 For each charT, the string type specializations
+  __format_spec::__parser<_CharT> __parser_;
+};
 
 // Formatter const char*.
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<const _CharT*, _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const _CharT*, _CharT>
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx) const -> decltype(__ctx.out()) {
     _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
                           "prevented an invalid pointer.");
 
     // When using a center or right alignment and the width option the length
     // of __str must be known to add the padding upfront. This case is handled
     // by the base class by converting the argument to a basic_string_view.
     //
     // When using left alignment and the width option the padding is added
     // after outputting __str so the length can be determined while outputting
     // __str. The same holds true for the precision, during outputting __str it
     // can be validated whether the precision threshold has been reached. For
     // now these optimizations aren't implemented. Instead the base class
     // handles these options.
     // TODO FMT Implement these improvements.
-    if (this->__has_width_field() || this->__has_precision_field())
-      return _Base::format(__str, __ctx);
+    if (_Base::__parser_.__width_as_arg_ || _Base::__parser_.__precision_as_arg_ || _Base::__parser_.__has_width() ||
+        _Base::__parser_.__has_precision())
+      return _Base::format(basic_string_view<_CharT>(__str), __ctx);
 
     // No formatting required, copy the string to the output.
     auto __out_it = __ctx.out();
     while (*__str)
       *__out_it++ = *__str++;
     return __out_it;
   }
 };
 
 // Formatter char*.
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<_CharT*, _CharT> : public formatter<const _CharT*, _CharT> {
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_CharT*, _CharT>
+    : public formatter<const _CharT*, _CharT> {
   using _Base = formatter<const _CharT*, _CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx) const -> decltype(__ctx.out()) {
     return _Base::format(__str, __ctx);
   }
 };
 
 // Formatter char[].
 template <__formatter::__char_type _CharT, size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_CharT[_Size], _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  static_assert(!is_const_v<_CharT>);
-  using _Base = __format_spec::__formatter_string<_CharT>;
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(_CharT __str[_Size], auto& __ctx) -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(_CharT __str[_Size], auto& __ctx) const -> decltype(__ctx.out()) {
     return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx);
   }
 };
 
 // Formatter const char[].
 template <__formatter::__char_type _CharT, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<const _CharT[_Size], _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const _CharT[_Size], _CharT>
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx) const -> decltype(__ctx.out()) {
     return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx);
   }
 };
 
 // Formatter std::string.
 template <__formatter::__char_type _CharT, class _Traits, class _Allocator>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto
-  format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx)
+  _LIBCPP_HIDE_FROM_ABI auto format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx) const
       -> decltype(__ctx.out()) {
-    // drop _Traits and _Allocator
+    // Drop _Traits and _Allocator to have one std::basic_string formatter.
     return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
   }
 };
 
 // Formatter std::string_view.
 template <__formatter::__char_type _CharT, class _Traits>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<basic_string_view<_CharT, _Traits>, _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto
-  format(basic_string_view<_CharT, _Traits> __str, auto& __ctx)
+  _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT, _Traits> __str, auto& __ctx) const
       -> decltype(__ctx.out()) {
-    // drop _Traits
+    // Drop _Traits to have one std::basic_string_view formatter.
     return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
   }
 };
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_STRING_H

libcxx/include/__format/parser_std_format_spec.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_PARSER_STD_FORMAT_SPEC_H
 #define _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H
 
+/// \file Contains the std-format-spec parser.
+///
+/// Most of the code can be reused in the chrono-format-spec.
+/// This header has some support for the chrono-format-spec since it doesn't
+/// affect the std-format-spec.
+
 #include <__algorithm/find_if.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
+#include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_error.h>
+#include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__variant/monostate.h>
 #include <bit>
 #include <concepts>
 #include <cstdint>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
__get_string_alignment(const _CharT* __first, const _CharT* __last,
   const _CharT* __limit =
       __first +
       (__precision == -1 ? __length : _VSTD::min(__length, __precision));
   ptrdiff_t __size = __limit - __first;
   return {__limit, __size, __size < __width};
 }
 #endif // _LIBCPP_HAS_NO_UNICODE
 
+/// 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. That way the behaviour of user-defined formatters won't change.
+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};
+  // This field is special it's always true for the std-format-spec.
+  // Since the chrono-format-spec doesn't use this field it can be disabled.
+  uint8_t __type_ : 1 {true};
+};
+
+// By not placing this constant in the formatter class it's not duplicated for
+// char and wchar_t.
+inline constexpr __fields __fields_string{
+    .__precision_ = true,
+};
+
+enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
+  /// No alignment is set in the format string.
+  ///
+  /// Zero-padding is ignored when an alignment is selected.
+  /// The default alignment depends on the selected format-type.
+  __default,
+  __left,
+  __center,
+  __right
+};
+
+enum class _LIBCPP_ENUM_VIS __sign : uint8_t {
+  /// No sign is set in the format string.
+  ///
+  /// The sign isn't allowed for certain format-types. By using this value
+  /// it's possible to detect whether or not the user explicitly set the sign
+  /// flag. For formatting purposes it behaves the same as \ref __minus.
+  __default,
+  __minus,
+  __plus,
+  __space
+};
+
+enum class _LIBCPP_ENUM_VIS __type : uint8_t {
+  __default,
+  __string,
+  __binary_lower_case,
+  __binary_upper_case,
+  __octal,
+  __decimal,
+  __hexadecimal_lower_case,
+  __hexadecimal_upper_case,
+  __pointer,
+  __char,
+  __float_hexadecimal_lower_case,
+  __float_hexadecimal_upper_case,
+  __scientific_lower_case,
+  __scientific_upper_case,
+  __fixed_lower_case,
+  __fixed_upper_case,
+  __general_lower_case,
+  __general_upper_case
+};
+
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser {
+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)
+      return __begin;
+
+    if (__fields.__sign_ && __parse_sign(__begin) && __begin == __end)
+      return __begin;
+
+    if (__fields.__alternate_form_ && __parse_alternate_form(__begin) && __begin == __end)
+      return __begin;
+
+    if (__fields.__zero_padding_ && __parse_zero_padding(__begin) && __begin == __end)
+      return __begin;
+
+    if (__parse_width(__begin, __end, __parse_ctx) && __begin == __end)
+      return __begin;
+
+    if (__fields.__precision_ && __parse_precision(__begin, __end, __parse_ctx) && __begin == __end)
+      return __begin;
+
+    if (__fields.__locale_specific_form_ && __parse_locale_specific_form(__begin) && __begin == __end)
+      return __begin;
+
+    if (__fields.__type_) {
+      __parse_type(__begin);
+
+      // When __type_ is false the calling parser is expected to do additional
+      // parsing. In that case that parser should do the end of format string
+      // validation.
+      if (__begin != __end && *__begin != _CharT('}'))
+        __throw_format_error("The format-spec should consume the input or end with a '}'");
+    }
+
+    return __begin;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_width() const {
+    _LIBCPP_ASSERT(!__width_as_arg_, "the function should only be used to test __width_");
+    return __width_ > 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_precision() const {
+    _LIBCPP_ASSERT(!__precision_as_arg_, "the function should only be used to test __precision_");
+    return __precision_ >= 0;
+  }
+
+  /// \returns a copy of the parser with the resolved dynamic sizes.
+  ///
+  /// Returning a copy makes it possible to create a const qualified format
+  /// member function. The parser is cheap to copy.
+  _LIBCPP_HIDE_FROM_ABI
+  __parser __resolve_dynamic_sizes(auto& __ctx) const {
+    __parser __result{*this};
+
+    if (__result.__width_as_arg_)
+      __result.__substitute_width_arg_id(__ctx.arg(__result.__width_));
+
+    if (__result.__precision_as_arg_)
+      __result.__substitute_precision_arg_id(__ctx.arg(__result.__precision_));
+
+    return __result;
+  }
+
+  __alignment __alignment_ : 2 {__alignment::__default};
+  __sign __sign_ : 2 {__sign::__default};
+  bool __alternate_form_ : 1 {false};
+  bool __zero_padding_ : 1 {false};
+  bool __locale_specific_form_ : 1 {false};
+  __type __type_ : 5 {__type::__default};
+
+  bool __width_as_arg_ : 1 {false};
+  bool __precision_as_arg_ : 1 {false};
+
+  // These two flags are used for formatting chrono. Since the struct has
+  // padding space left it's added to this structure.
+  bool __weekday_name_ : 1 {false};
+  bool __month_name_ : 1 {false};
+  // LWG 3576 will probably change this to always accept a Unicode code point
+  // To avoid changing the size with that change align the field so when it
+  // becomes 32-bit its alignment will remain the same. That also means the
+  // size will remain the same. (D2572 addresses the solution for LWG 3576.)
+  alignas(4) _CharT __fill_{_CharT(' ')};
+  int32_t __width_{0};
+  int32_t __precision_{-1};
+
+private:
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alignment(_CharT __c) {
+    switch (__c) {
+    case _CharT('<'):
+      __alignment_ = __alignment::__left;
+      return true;
+
+    case _CharT('^'):
+      __alignment_ = __alignment::__center;
+      return true;
+
+    case _CharT('>'):
+      __alignment_ = __alignment::__right;
+      return true;
+    }
+    return false;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(const _CharT*& __begin, const _CharT* __end) {
+    _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");
+
+        __fill_ = *__begin;
+        __begin += 2;
+        return true;
+      }
+    }
+
+    if (!__parse_alignment(*__begin))
+      return false;
+
+    ++__begin;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_sign(const _CharT*& __begin) {
+    switch (*__begin) {
+    case _CharT('-'):
+      __sign_ = __sign::__minus;
+      break;
+    case _CharT('+'):
+      __sign_ = __sign::__plus;
+      break;
+    case _CharT(' '):
+      __sign_ = __sign::__space;
+      break;
+    default:
+      return false;
+    }
+    ++__begin;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alternate_form(const _CharT*& __begin) {
+    if (*__begin != _CharT('#'))
+      return false;
+
+    __alternate_form_ = true;
+    ++__begin;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_zero_padding(const _CharT*& __begin) {
+    if (*__begin != _CharT('0'))
+      return false;
+
+    __zero_padding_ = true;
+    ++__begin;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(const _CharT*& __begin, const _CharT* __end, auto& __parse_ctx) {
+    if (*__begin == _CharT('0'))
+      __throw_format_error("A format-spec width field shouldn't have a leading zero");
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __width_as_arg_ = true;
+      __width_ = __r.__value;
+      __begin = __r.__ptr;
+      return true;
+    }
+
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      return false;
+
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __width_ = __r.__value;
+    _LIBCPP_ASSERT(__width_ != 0, "A zero value isn't allowed and should be impossible, "
+                                  "due to validations in this function");
+    __begin = __r.__ptr;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(const _CharT*& __begin, const _CharT* __end,
+                                                         auto& __parse_ctx) {
+    if (*__begin != _CharT('.'))
+      return false;
+
+    ++__begin;
+    if (__begin == __end)
+      __throw_format_error("End of input while parsing format-spec precision");
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __precision_as_arg_ = true;
+      __precision_ = __arg_id.__value;
+      __begin = __arg_id.__ptr;
+      return true;
+    }
+
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      __throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
+
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __precision_ = __r.__value;
+    __precision_as_arg_ = false;
+    __begin = __r.__ptr;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_locale_specific_form(const _CharT*& __begin) {
+    if (*__begin != _CharT('L'))
+      return false;
+
+    __locale_specific_form_ = true;
+    ++__begin;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(const _CharT*& __begin) {
+    // Determines the type. It does not validate whether the selected type is
+    // valid. Most formatters have optional fields that are only allowed for
+    // certain types. These parsers need to do validation after the type has
+    // been parsed. So its easier to implement the validation for all types in
+    // the specific parse function.
+    switch (*__begin) {
+    case 'A':
+      __type_ = __type::__float_hexadecimal_upper_case;
+      break;
+    case 'B':
+      __type_ = __type::__binary_upper_case;
+      break;
+    case 'E':
+      __type_ = __type::__scientific_upper_case;
+      break;
+    case 'F':
+      __type_ = __type::__fixed_upper_case;
+      break;
+    case 'G':
+      __type_ = __type::__general_upper_case;
+      break;
+    case 'X':
+      __type_ = __type::__hexadecimal_upper_case;
+      break;
+    case 'a':
+      __type_ = __type::__float_hexadecimal_lower_case;
+      break;
+    case 'b':
+      __type_ = __type::__binary_lower_case;
+      break;
+    case 'c':
+      __type_ = __type::__char;
+      break;
+    case 'd':
+      __type_ = __type::__decimal;
+      break;
+    case 'e':
+      __type_ = __type::__scientific_lower_case;
+      break;
+    case 'f':
+      __type_ = __type::__fixed_lower_case;
+      break;
+    case 'g':
+      __type_ = __type::__general_lower_case;
+      break;
+    case 'o':
+      __type_ = __type::__octal;
+      break;
+    case 'p':
+      __type_ = __type::__pointer;
+      break;
+    case 's':
+      __type_ = __type::__string;
+      break;
+    case 'x':
+      __type_ = __type::__hexadecimal_lower_case;
+      break;
+    default:
+      return;
+    }
+    ++__begin;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __substitute_width_arg_id(auto __arg) {
+    _LIBCPP_ASSERT(__width_as_arg_ == true, "Substitute width called when no substitution is required");
+
+    __width_as_arg_ = 0;
+    __width_ = __format_spec::__substitute_arg_id(__arg);
+    if (__width_ == 0)
+      __throw_format_error("A format-spec width field replacement should have a positive value");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __substitute_precision_arg_id(auto __arg) {
+    _LIBCPP_ASSERT(__precision_as_arg_ == true, "Substitute width called when no substitution is required");
+
+    __precision_as_arg_ = false;
+    __precision_ = __format_spec::__substitute_arg_id(__arg);
+  }
+};
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_string(__format_spec::__type __type) {
+  switch (__type) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__string:
+    break;
+
+  default:
+    __throw_format_error("The format-spec type has a type not supported for "
+                         "a string argument");
+  }
+}
+
 } // namespace __format_spec
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H

libcxx/include/format

__compile_time_validate_argument(basic_format_parse_context<_CharT>& __parse_ctx,
   formatter<_Tp, _CharT> __formatter;
   __parse_ctx.advance_to(__formatter.parse(__parse_ctx));
   // [format.string.std]/7
   // ... If the corresponding formatting argument is not of integral type, or
   // its value is negative for precision or non-positive for width, an
   // exception of type format_error is thrown.
   //
   // Validate whether the arguments are integrals.
+  if constexpr (requires(formatter<_Tp, _CharT> __f) { __f.__width_needs_substitution(); }) {
+    // TODO FMT Remove this when parser v1 has been phased out.
     if (__formatter.__width_needs_substitution())
       __format::__compile_time_validate_integral(__ctx.arg(__formatter.__width));
 
     if constexpr (_HasPrecision)
       if (__formatter.__precision_needs_substitution())
         __format::__compile_time_validate_integral(__ctx.arg(__formatter.__precision));
+  } else {
+    if (__formatter.__parser_.__width_as_arg_)
+      __format::__compile_time_validate_integral(__ctx.arg(__formatter.__parser_.__width_));
+
+    if constexpr (_HasPrecision)
+      if (__formatter.__parser_.__precision_as_arg_)
+        __format::__compile_time_validate_integral(__ctx.arg(__formatter.__parser_.__precision_));
+  }
 }
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_format_parse_context<_CharT>& __parse_ctx,
                                                                      __compile_time_basic_format_context<_CharT>& __ctx,
                                                                      __arg_t __type) {
   switch (__type) {
   case __arg_t::__none:

libcxx/include/module.modulemap

module __format {
       module format_string            { private header "__format/format_string.h" }
       module format_to_n_result       { private header "__format/format_to_n_result.h" }
       module formatter                { private header "__format/formatter.h" }
       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 parser_std_format_spec   { private header "__format/parser_std_format_spec.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list

libcxx/test/libcxx/private_headers.verify.cpp

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