[libc++][format] Adds string formatter.

[Mordante]

Summary

Implements the formatter for all string types.
[format.formatter.spec]/2.2
For each charT, the string type specializations

template<> struct formatter<charT*, charT>;
template<> struct formatter<const charT*, charT>;
template<size_t N> struct formatter<const charT[N], charT>;
template<class traits, class Allocator>
  struct formatter<basic_string<charT, traits, Allocator>, charT>;
template<class traits>
  struct formatter<basic_string_view<charT, traits>, charT>;

This removes the stub implemented in D96664.

Implements parts of:

• P0645 Text Formatting
• P1868 width: clarifying units of width and precision in std::format

[Mordante]

• Rebase
• Rename __pre and __post since they are reserved on Windows. D103541 will add these names to the nasty macros
• Remove a dupliated hunk. The hunk was moved to its own function to used for Boolean formatting, but the original remained instead of calling the new function.

[Mordante]

Disable the failing part of a test on Windows.

[vitaut]

libcxx/include/CMakeLists.txt

144

Not sure if it's worth having such a fine-grained header split for built-in formatters considering that all of them are pretty small and end up being included in <format>.

libcxx/include/__format/formatter.h

65

As in earlier diffs I suggest using a struct instead of pair.

Also inline seems redundant.

103

Is the space between < and = intentional?

111

Something is missing after "For Unicode this".

117–118

This function returns an iterator, not a char type.

130

Fill can consist of multiple code units.

143

As commented elsewhere __number_max as currently defined is a valid precision and shouldn't be used for "no limit".

libcxx/include/__format/formatter_string.h

40

This class looks unnecessary, why not fold it into __formatter_string?

88–89

Width being greater than precision is perfectly valid and useful. It shouldn't result in an error.

[Mordante]

libcxx/include/CMakeLists.txt

144

Recently libc++ started to move towards using tiny headers. This started with the people working on ranges and I like that direction. So that's why I made these small headers. (This also makes it a lot easier to maintain larger patch series.)

libcxx/include/__format/formatter.h

117–118

This returns refers the the to_char function, which should have been std::to_chars. I added a @returns and improved this @note to avoid confusion.
This integer part isn't added yet, but is part of D103433.

130

For now libc++ uses one character as mentioned in D103368. I've added a comment as reminder that this needs to be adjusted in the future.

143

The new invalid value is -1.

libcxx/include/__format/formatter_string.h

40

In my original design it seemed nice, but now it's indeed unnecessary.

88–89

Interesting. I overlooked that in the Standard. I've adjusted to code to support this case and added a test.

[Mordante]

Addresses review comments and other changes:

• remove std::pair
• improve comments
• change the value of no precision -1 instead of __number_max
• merge the class __parser_string with __formatter_string
• allow precision < width as required by the Standard
• update the module map
• integrate changes done before in the patch series

[Mordante]

Rebase to get all changes in and resolve merge conflicts.

[vitaut]

Some nits inline, otherwise LGTM.

libcxx/include/__format/formatter.h

125–127

Did you mean the type of values in [__first, __last) being different from the type of __fill? __first and __last themselves are pointers, not code units.

Also the comment says "This function returns a buffer with @c char elements." while in fact it returns an output iterator.

libcxx/include/__format/formatter_string.h

102

nit: public is redundant here and elsewhere since this is a struct.

[Mordante]

libcxx/include/__format/formatter.h

125–127

I updated the wording.

libcxx/include/__format/formatter_string.h

102

true, I'm just used to writing this explicitly. AFAIK that's also the code convention in libc++. So for now I keep it unless @ldionne objects.

[Mordante]

Rebase
Contrain the formatter to the allowed character types
Remove the monolithic algorithm include
Use private module headers
Guard unit tests for implementation details
Addresses review comments

[Mordante]

Needs updates due to changes in D103368.

[Mordante]

Rebased and adjusted for changes in main
s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/

[Mordante]

Rebased and moved tests from the old .inc to the new .h file.

[Mordante]

Remove the unneeded _LIBCPP_PUSH_MACROS.

[Mordante]

Rebased

[ldionne]

libcxx/include/__format/formatter_string.h

102

I don't think we have a convention for this. No strong opinion.

libcxx/include/CMakeLists.txt

set(files
   __format/format_arg.h
   __format/format_args.h
   __format/format_context.h
   __format/format_error.h
   __format/format_fwd.h
   __format/format_parse_context.h
   __format/format_string.h
   __format/formatter.h
+  __format/formatter_string.h
   __format/parser_std_format_spec.h
   __function_like.h
   __functional_base
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind_back.h
   __functional/bind_front.h
   __functional/bind.h
   __functional/binder1st.h

libcxx/include/__format/format_string.h

 #include <__format/format_error.h>
 #include <cstddef>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // TODO FMT Remove this once we require compilers with proper C++20 support.
 // If the compiler has no concepts support, the format header will be disabled.
 // Without concepts support enable_if needs to be used and that too much effort
 // to support compilers with partial C++20 support.

 } // namespace __format
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
-_LIBCPP_POP_MACROS
-
 #endif // _LIBCPP___FORMAT_FORMAT_STRING_H

libcxx/include/__format/formatter.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_H
 #define _LIBCPP___FORMAT_FORMATTER_H
 
+#include <__algorithm/copy.h>
+#include <__algorithm/fill_n.h>
 #include <__availability>
 #include <__config>
 #include <__format/format_error.h>
+#include <__format/format_fwd.h>
+#include <__format/format_string.h>
 #include <__format/parser_std_format_spec.h>
+#include <concepts>
+#include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
   }
 
 private:
   _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw() {
     __throw_format_error("Argument type not implemented yet");
   }
 };
 
+namespace __formatter {
+
+/** The character types that formatters are specialized for. */
+template <class _CharT>
+concept __char_type = same_as<_CharT, char> || same_as<_CharT, wchar_t>;
+
+struct _LIBCPP_TEMPLATE_VIS __padding_size_result {
+  size_t __before;
+  size_t __after;
+};
+
+_LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result
+__padding_size(size_t __size, size_t __width,
+               __format_spec::_Flags::_Alignment __align) {
+  _LIBCPP_ASSERT(__width > __size,
+                 "Don't call this function when no padding is required");
+  _LIBCPP_ASSERT(
+      __align != __format_spec::_Flags::_Alignment::__default,
+      "Caller should adjust the default to the value required by the type");
+
+  size_t __fill = __width - __size;
+  switch (__align) {
+  case __format_spec::_Flags::_Alignment::__default:
+    _LIBCPP_UNREACHABLE();
+
+  case __format_spec::_Flags::_Alignment::__left:
+    return {0, __fill};
+
+  case __format_spec::_Flags::_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::_Flags::_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 input.
+ *
+ * @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 __out_it    The output iterator to write to.
+ * @param __first     Pointer to the first element to write.
+ * @param __last      Pointer beyond the last element to write.
+ * @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.
+ * @param __width     The number of output columns to write.
+ * @param __fill      The character used for the alignment of the output.
+ *                    TODO FMT Will probably change to support Unicode grapheme
+ *                    cluster.
+ * @param __alignment The requested alignment.
+ *
+ * @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 __fill. 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 _Fill>
+_LIBCPP_HIDE_FROM_ABI auto
+__write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
+        const _CharT* __last, size_t __size, size_t __width, _Fill __fill,
+        __format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {
+
+  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
+  _LIBCPP_ASSERT(__size < __width, "Precondition failure");
+
+  __padding_size_result __padding =
+      __padding_size(__size, __width, __alignment);
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
+  __out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
+  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
+}
+
+/**
+ * Writes Unicode input to the output with the required padding.
+ *
+ * This function does almost the same as the @ref __write function, but handles
+ * the width estimation of the Unicode input.
+ *
+ * @param __str       The range [@a __first, @a __last).
+ * @param __precision The width to truncate the input string to, use @c -1 for
+ *                     no limit.
+ */
+template <class _CharT, class _Fill>
+_LIBCPP_HIDE_FROM_ABI auto
+__write_unicode(output_iterator<const _CharT&> auto __out_it,
+                basic_string_view<_CharT> __str, ptrdiff_t __width,
+                ptrdiff_t __precision, _Fill __fill,
+                __format_spec::_Flags::_Alignment __alignment)
+    -> decltype(__out_it) {
+
+  // This value changes when there Unicode column width limits the output
+  // size.
+  auto __last = __str.end();
+  if (__width != 0 || __precision != -1) {
+    __format_spec::__string_alignment<_CharT> __format_traits =
+        __format_spec::__get_string_alignment(__str.begin(), __str.end(),
+                                              __width, __precision);
+
+    if (__format_traits.__align)
+      return __write(_VSTD::move(__out_it), __str.begin(),
+                     __format_traits.__last, __format_traits.__size, __width,
+                     __fill, __alignment);
+
+    // No alignment required update the output based on the precision.
+    // This might be the same as __str.end().
+    __last = __format_traits.__last;
+  }
+
+  // Copy the input to the output. The output size might be limited by the
+  // precision.
+  return _VSTD::copy(__str.begin(), __last, _VSTD::move(__out_it));
+}
+
+} // namespace __formatter
+
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_FORMATTER_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 <__config>
+#include <__format/format_error.h>
+#include <__format/format_fwd.h>
+#include <__format/format_string.h>
+#include <__format/formatter.h>
+#include <__format/parser_std_format_spec.h>
+#include <algorithm>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// TODO FMT Remove this once we require compilers with proper C++20 support.
+// If the compiler has no concepts support, the format header will be disabled.
+// Without concepts support enable_if needs to be used and that too much effort
+// to support compilers with partial C++20 support.
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+namespace __format_spec {
+
+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));
+
+    if (this->__precision_needs_substitution())
+      this->__substitute_precision_arg_id(__ctx.arg(this->__precision));
+
+    return __formatter::__write_unicode(
+        __ctx.out(), __str, this->__width,
+        this->__has_precision_field() ? this->__precision : -1, this->__fill,
+        this->__alignment);
+  }
+};
+
+} //namespace __format_spec
+
+// [format.formatter.spec]/2.2 For each charT, the string type specializations
+
+// Formatter const char*.
+template <class _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>;
+
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx)
+      -> 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);
+
+    // 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 <class _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()) {
+    return _Base::format(__str, __ctx);
+  }
+};
+
+// Formatter const char[].
+template <class _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>;
+
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx)
+      -> decltype(__ctx.out()) {
+    return _Base::format(_VSTD::basic_string_view<_CharT>(__str, _Size), __ctx);
+  }
+};
+
+// Formatter std::string.
+template <class _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>;
+
+  _LIBCPP_HIDE_FROM_ABI auto
+  format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx)
+      -> decltype(__ctx.out()) {
+    return _Base::format(_VSTD::basic_string_view<_CharT>(__str), __ctx);
+  }
+};
+
+// Formatter std::string_view.
+template <class _CharT, class _Traits>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
+    formatter<basic_string_view<_CharT, _Traits>, _CharT>
+    : public __format_spec::__formatter_string<_CharT> {};
+
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FORMAT_FORMATTER_STRING_H

libcxx/include/__format/parser_std_format_spec.h

return visit_format_arg(
                                    "have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
           if (static_cast<_CT>(__arg) >
               static_cast<_CT>(__format::__number_max))
             __throw_format_error("A format-spec arg-id replacement exceeds "
                                  "the maximum supported value");
+
           return __arg;
         } else if constexpr (same_as<_Type, monostate>)
           __throw_format_error("Argument index out of bounds");
         else
           __throw_format_error("A format-spec arg-id replacement argument "
                                "isn't an integral type");
       },
       __arg);

libcxx/include/format

 #include <__config>
 #include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
-#include <__format/parser_std_format_spec.h>
 #include <__format/formatter.h>
+#include <__format/formatter_string.h>
+#include <__format/parser_std_format_spec.h>
 #include <__variant/monostate.h>
 #include <array>
 #include <concepts>
 #include <string>
 #include <string_view>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
struct _LIBCPP_TEMPLATE_VIS __formatter_char {
   auto format(_Tp __c, auto& __ctx) -> decltype(__ctx.out()) {
     // TODO FMT Implement the parsed formatting arguments.
     auto __out_it = __ctx.out();
     *__out_it++ = _CharT(__c);
     return __out_it;
   }
 };
 
-template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS __formatter_c_string {
-  _LIBCPP_HIDE_FROM_ABI
-  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
-    // TODO FMT Implement this function.
-    return __parse_ctx.begin();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI
-  auto format(const _CharT* __str, auto& __ctx) -> decltype(__ctx.out()) {
-    // TODO FMT Implement the parsed formatting arguments.
-    auto __out_it = __ctx.out();
-    while (*__str)
-      *__out_it++ = *__str++;
-    return __out_it;
-  }
-};
-
-template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS __formatter_string {
-  _LIBCPP_HIDE_FROM_ABI
-  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
-    // TODO FMT Implement this function.
-    return __parse_ctx.begin();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI
-  auto format(basic_string_view<_CharT> __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
-    // TODO FMT Implement the parsed formatting arguments.
-    auto __out_it = __ctx.out();
-    for (const auto __c : __str)
-      *__out_it++ = __c;
-    return __out_it;
-  }
-};
-
 template <class _Tp, class _CharT>
 requires(is_arithmetic_v<_Tp> &&
          !same_as<_Tp, bool>) struct _LIBCPP_HIDE_FROM_ABI
     __formatter_arithmetic {
   _LIBCPP_HIDE_FROM_ABI
   auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
     // TODO FMT Implement
     return __parse_ctx.begin();

 template <>
 struct _LIBCPP_TEMPLATE_VIS formatter<char, wchar_t>
     : public __format::__formatter_char<char, wchar_t> {};
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t>
     : public __format::__formatter_char<wchar_t, wchar_t> {};
 
-// [format.formatter.spec]/2.2 For each charT, the string type specializations
-
-template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT>
-    : public __format::__formatter_c_string<_CharT> {
-  using _Base = __format::__formatter_c_string<_CharT>;
-
-  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
-    _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
-                          "prevented an invalid pointer");
-    return _Base::format(__str, __ctx);
-  }
-};
-
-template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT>
-    : public __format::__formatter_c_string<_CharT> {};
-
-template <class _CharT, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT[_Size], _CharT>
-    : public __format::__formatter_string<_CharT> {
-  using _Base = __format::__formatter_string<_CharT>;
-
-  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx)
-      -> decltype(__ctx.out()) {
-    return _Base::format(_VSTD::basic_string_view<_CharT>(__str, _Size), __ctx);
-  }
-};
-
-template <class _CharT, class _Traits, class _Allocator>
-struct _LIBCPP_TEMPLATE_VIS
-    formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
-    : public __format::__formatter_string<_CharT> {
-  using _Base = __format::__formatter_string<_CharT>;
-
-  _LIBCPP_HIDE_FROM_ABI auto
-  format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
-    return _Base::format(_VSTD::basic_string_view<_CharT>(__str), __ctx);
-  }
-};
-
-template <class _CharT, class _Traits>
-struct _LIBCPP_TEMPLATE_VIS
-    formatter<basic_string_view<_CharT, _Traits>, _CharT>
-    : public __format::__formatter_string<_CharT> {};
-
 // [format.formatter.spec]/2.3
 // For each charT, for each cv-unqualified arithmetic type ArithmeticT other
 // than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
 
 // Boolean.
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {
   _LIBCPP_HIDE_FROM_ABI

libcxx/include/module.modulemap

module __format {
         export optional
         export locale
       }
       module format_error           { private header "__format/format_error.h"           }
       module format_fwd             { private header "__format/format_fwd.h"             }
       module format_parse_context   { private header "__format/format_parse_context.h"   }
       module format_string          { private header "__format/format_string.h"          }
       module formatter              { private header "__format/formatter.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
     export *
   }

libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_string.module.verify.cpp

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__format/formatter_string.h'}}
+#include <__format/formatter_string.h>

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.c_string.pass.cpp

 void test_char_pointer() {
   using CharT = std::remove_cv_t<std::remove_pointer_t<ArgumentT>>;
 
   test_termination_condition<ArgumentT>(STR(" azAZ09,./<>?"), STR("}"),
                                         CSTR(" azAZ09,./<>?"));
 
   std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
   test_termination_condition<ArgumentT>(STR("abc"), STR("}"), s.c_str());
+
+  test_termination_condition<ArgumentT>(STR("world"), STR("}"), CSTR("world"));
+  test_termination_condition<ArgumentT>(STR("world"), STR("_>}"),
+                                        CSTR("world"));
+
+  test_termination_condition<ArgumentT>(STR("   world"), STR(">8}"),
+                                        CSTR("world"));
+  test_termination_condition<ArgumentT>(STR("___world"), STR("_>8}"),
+                                        CSTR("world"));
+  test_termination_condition<ArgumentT>(STR("_world__"), STR("_^8}"),
+                                        CSTR("world"));
+  test_termination_condition<ArgumentT>(STR("world___"), STR("_<8}"),
+                                        CSTR("world"));
+
+  test_termination_condition<ArgumentT>(STR("world"), STR(".5}"),
+                                        CSTR("world"));
+  test_termination_condition<ArgumentT>(STR("unive"), STR(".5}"),
+                                        CSTR("universe"));
+
+  test_termination_condition<ArgumentT>(STR("%world%"), STR("%^7.7}"),
+                                        CSTR("world"));
+  test_termination_condition<ArgumentT>(STR("univers"), STR("%^7.7}"),
+                                        CSTR("universe"));
 }
 
 int main(int, char**) {
   test_char_pointer<char*>();
   test_char_pointer<const char*>();
   test_char_pointer<wchar_t*>();
   test_char_pointer<const wchar_t*>();
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.const_char_array.pass.cpp

 }
 
 template <class CharT>
 void test_array() {
   test_helper_wrapper<" azAZ09,./<>?">(STR(" azAZ09,./<>?"), STR("}"));
 
   std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
   test_helper_wrapper<"abc\0abc">(s, STR("}"));
+
+  test_helper_wrapper<"world">(STR("world"), STR("}"));
+  test_helper_wrapper<"world">(STR("world"), STR("_>}"));
+
+  test_helper_wrapper<"world">(STR("   world"), STR(">8}"));
+  test_helper_wrapper<"world">(STR("___world"), STR("_>8}"));
+  test_helper_wrapper<"world">(STR("_world__"), STR("_^8}"));
+  test_helper_wrapper<"world">(STR("world___"), STR("_<8}"));
+
+  test_helper_wrapper<"world">(STR("world"), STR(".5}"));
+  test_helper_wrapper<"universe">(STR("unive"), STR(".5}"));
+
+  test_helper_wrapper<"world">(STR("%world%"), STR("%^7.7}"));
+  test_helper_wrapper<"universe">(STR("univers"), STR("%^7.7}"));
 }
 
 int main(int, char**) {
   test_array<char>();
   test_array<wchar_t>();
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.string.pass.cpp

static_assert(std::same_as<typename T::value_type,
                              typename std::decay_t<ArgumentT>::value_type>);
   using CharT = typename T::value_type;
 
   test_termination_condition<T, ArgumentT>(STR(" azAZ09,./<>?"), STR("}"),
                                            STR(" azAZ09,./<>?"));
 
   std::basic_string<CharT> s(CSTR("abc\0abc"), 7);
   test_termination_condition<T, ArgumentT>(s, STR("}"), s);
+
+  test_termination_condition<T, ArgumentT>(STR("world"), STR("}"),
+                                           STR("world"));
+  test_termination_condition<T, ArgumentT>(STR("world"), STR("_>}"),
+                                           STR("world"));
+
+  test_termination_condition<T, ArgumentT>(STR("   world"), STR(">8}"),
+                                           STR("world"));
+  test_termination_condition<T, ArgumentT>(STR("___world"), STR("_>8}"),
+                                           STR("world"));
+  test_termination_condition<T, ArgumentT>(STR("_world__"), STR("_^8}"),
+                                           STR("world"));
+  test_termination_condition<T, ArgumentT>(STR("world___"), STR("_<8}"),
+                                           STR("world"));
+
+  test_termination_condition<T, ArgumentT>(STR("world"), STR(".5}"),
+                                           STR("world"));
+  test_termination_condition<T, ArgumentT>(STR("unive"), STR(".5}"),
+                                           STR("universe"));
+
+  test_termination_condition<T, ArgumentT>(STR("%world%"), STR("%^7.7}"),
+                                           STR("world"));
+  test_termination_condition<T, ArgumentT>(STR("univers"), STR("%^7.7}"),
+                                           STR("universe"));
 }
 
 template <class CharT>
 void test_all_string_types() {
   test_string_type<std::basic_string<CharT>, const std::basic_string<CharT>&>();
   test_string_type<std::basic_string_view<CharT>,
                    std::basic_string_view<CharT>>();
 }
 
 int main(int, char**) {
   test_all_string_types<char>();
   test_all_string_types<wchar_t>();
 
   return 0;
 }

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

 // template<class... Args>
 //   wstring format(wstring_view fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #include <iostream>
 #endif
+#include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 
 auto test = []<class CharT, class... Args>(std::basic_string<CharT> expected,
                                            std::basic_string<CharT> fmt,
                                            const Args&... args) {
   std::basic_string<CharT> out = std::format(fmt, args...);

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

 //===----------------------------------------------------------------------===//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
 #define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
 
 #include "make_string.h"
 
-#define STR(S) MAKE_STRING(CharT, S)
-
+// In this file the following template types are used:
 // TestFunction must be callable as check(expected-result, string-to-format, args-to-format...)
 // ExceptionTest must be callable as check_exception(expected-exception, string-to-format, args-to-format...)
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class CharT>
+std::vector<std::basic_string<CharT>> invalid_types(std::string valid) {
+  std::vector<std::basic_string<CharT>> result;
+
+#define CASE(T)                                                                \
+  case #T[0]:                                                                  \
+    result.push_back(STR("Invalid formatter type {:" #T "}"));                 \
+    break;
+
+  for (auto type : "aAbBcdeEfFgGopsxX") {
+    if (valid.find(type) != std::string::npos)
+      continue;
+
+    switch (type) {
+      CASE(a)
+      CASE(A)
+      CASE(b)
+      CASE(B)
+      CASE(c)
+      CASE(d)
+      CASE(e)
+      CASE(E)
+      CASE(f)
+      CASE(F)
+      CASE(g)
+      CASE(G)
+      CASE(o)
+      CASE(p)
+      CASE(s)
+      CASE(x)
+      CASE(X)
+    case 0:
+      break;
+    default:
+      assert(false && "Add the type to the list of cases.");
+    }
+  }
+#undef CASE
+
+  return result;
+}
+
+template <class CharT, class T, class TestFunction, class ExceptionTest>
+void format_test_string(T world, T universe, TestFunction check,
+                        ExceptionTest check_exception) {
+
+  // *** Valid input tests ***
+  // Unsed argument is ignored. TODO FMT what does the Standard mandate?
+  check(STR("hello world"), STR("hello {}"), world, universe);
+  check(STR("hello world and universe"), STR("hello {} and {}"), world,
+        universe);
+  check(STR("hello world"), STR("hello {0}"), world, universe);
+  check(STR("hello universe"), STR("hello {1}"), world, universe);
+  check(STR("hello universe and world"), STR("hello {1} and {0}"), world,
+        universe);
+
+  check(STR("hello world"), STR("hello {:_>}"), world);
+  check(STR("hello    world"), STR("hello {:>8}"), world);
+  check(STR("hello ___world"), STR("hello {:_>8}"), world);
+  check(STR("hello _world__"), STR("hello {:_^8}"), world);
+  check(STR("hello world___"), STR("hello {:_<8}"), world);
+
+  check(STR("hello >>>world"), STR("hello {:>>8}"), world);
+  check(STR("hello <<<world"), STR("hello {:<>8}"), world);
+  check(STR("hello ^^^world"), STR("hello {:^>8}"), world);
+
+  check(STR("hello $world"), STR("hello {:$>{}}"), world, 6);
+  check(STR("hello $world"), STR("hello {0:$>{1}}"), world, 6);
+  check(STR("hello $world"), STR("hello {1:$>{0}}"), 6, world);
+
+  check(STR("hello world"), STR("hello {:.5}"), world);
+  check(STR("hello unive"), STR("hello {:.5}"), universe);
+
+  check(STR("hello univer"), STR("hello {:.{}}"), universe, 6);
+  check(STR("hello univer"), STR("hello {0:.{1}}"), universe, 6);
+  check(STR("hello univer"), STR("hello {1:.{0}}"), 6, universe);
+
+  check(STR("hello %world%"), STR("hello {:%^7.7}"), world);
+  check(STR("hello univers"), STR("hello {:%^7.7}"), universe);
+  check(STR("hello %world%"), STR("hello {:%^{}.{}}"), world, 7, 7);
+  check(STR("hello %world%"), STR("hello {0:%^{1}.{2}}"), world, 7, 7);
+  check(STR("hello %world%"), STR("hello {0:%^{2}.{1}}"), world, 7, 7);
+  check(STR("hello %world%"), STR("hello {1:%^{0}.{2}}"), 7, world, 7);
+
+  check(STR("hello world"), STR("hello {:_>s}"), world);
+  check(STR("hello $world"), STR("hello {:$>{}s}"), world, 6);
+  check(STR("hello world"), STR("hello {:.5s}"), world);
+  check(STR("hello univer"), STR("hello {:.{}s}"), universe, 6);
+  check(STR("hello %world%"), STR("hello {:%^7.7s}"), world);
+
+  check(STR("hello #####uni"), STR("hello {:#>8.3s}"), universe);
+  check(STR("hello ##uni###"), STR("hello {:#^8.3s}"), universe);
+  check(STR("hello uni#####"), STR("hello {:#<8.3s}"), universe);
+
+  // *** sign ***
+  check_exception("The format-spec should consume the input or end with a '}'",
+                  STR("hello {:-}"), world);
+
+  // *** alternate form ***
+  check_exception("The format-spec should consume the input or end with a '}'",
+                  STR("hello {:#}"), world);
+
+  // *** zero-padding ***
+  check_exception("A format-spec width field shouldn't have a leading zero",
+                  STR("hello {:0}"), world);
+
+  // *** width ***
+#if _LIBCPP_VERSION
+  // This limit isn't specified in the Standard.
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  check_exception("The numeric value of the format-spec is too large",
+                  STR("{:2147483648}"), world);
+  check_exception("The numeric value of the format-spec is too large",
+                  STR("{:5000000000}"), world);
+  check_exception("The numeric value of the format-spec is too large",
+                  STR("{:10000000000}"), world);
+#endif
+
+  check_exception(
+      "A format-spec width field replacement should have a positive value",
+      STR("hello {:{}}"), world, 0);
+  check_exception(
+      "A format-spec arg-id replacement shouldn't have a negative value",
+      STR("hello {:{}}"), world, -1);
+  check_exception(
+      "A format-spec arg-id replacement exceeds the maximum supported value",
+      STR("hello {:{}}"), world, -1u);
+  check_exception("Argument index out of bounds", STR("hello {:{}}"), world);
+  check_exception(
+      "A format-spec arg-id replacement argument isn't an integral type",
+      STR("hello {:{}}"), world, universe);
+  check_exception(
+      "Using manual argument numbering in automatic argument numbering mode",
+      STR("hello {:{0}}"), world, 1);
+  check_exception(
+      "Using automatic argument numbering in manual argument numbering mode",
+      STR("hello {0:{}}"), world, 1);
+
+  // *** precision ***
+  check_exception("A format-spec precision field shouldn't have a leading zero",
+                  STR("hello {:.01}"), world);
+
+#if _LIBCPP_VERSION
+  // This limit isn't specified in the Standard.
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  check_exception("The numeric value of the format-spec is too large",
+                  STR("{:.2147483648}"), world);
+  check_exception("The numeric value of the format-spec is too large",
+                  STR("{:.5000000000}"), world);
+  check_exception("The numeric value of the format-spec is too large",
+                  STR("{:.10000000000}"), world);
+#endif
+
+  // Precision 0 allowed, but not useful for string arguments.
+  check(STR("hello "), STR("hello {:.{}}"), world, 0);
+  check_exception(
+      "A format-spec arg-id replacement shouldn't have a negative value",
+      STR("hello {:.{}}"), world, -1);
+  check_exception(
+      "A format-spec arg-id replacement exceeds the maximum supported value",
+      STR("hello {:.{}}"), world, -1u);
+  check_exception("Argument index out of bounds", STR("hello {:.{}}"), world);
+  check_exception(
+      "A format-spec arg-id replacement argument isn't an integral type",
+      STR("hello {:.{}}"), world, universe);
+  check_exception(
+      "Using manual argument numbering in automatic argument numbering mode",
+      STR("hello {:.{0}}"), world, 1);
+  check_exception(
+      "Using automatic argument numbering in manual argument numbering mode",
+      STR("hello {0:.{}}"), world, 1);
+
+  // *** locale-specific form ***
+  check_exception("The format-spec should consume the input or end with a '}'",
+                  STR("hello {:L}"), world);
+
+  // *** type ***
+  for (const auto& fmt : invalid_types<CharT>("s"))
+    check_exception(
+        "The format-spec type has a type not supported for a string argument",
+        fmt, world);
+}
+
+template <class CharT, class TestFunction>
+void format_test_string_unicode(TestFunction check) {
+#ifndef _LIBCPP_HAS_NO_UNICODE
+  // ß requires one column
+  check(STR("aßc"), STR("{}"), STR("aßc"));
+
+  check(STR("aßc"), STR("{:.3}"), STR("aßc"));
+  check(STR("aß"), STR("{:.2}"), STR("aßc"));
+  check(STR("a"), STR("{:.1}"), STR("aßc"));
+
+  check(STR("aßc"), STR("{:3.3}"), STR("aßc"));
+  check(STR("aß"), STR("{:2.2}"), STR("aßc"));
+  check(STR("a"), STR("{:1.1}"), STR("aßc"));
+
+  check(STR("aßc---"), STR("{:-<6}"), STR("aßc"));
+  check(STR("-aßc--"), STR("{:-^6}"), STR("aßc"));
+  check(STR("---aßc"), STR("{:->6}"), STR("aßc"));
+
+  // \u1000 requires two columns
+  check(STR("a\u1110c"), STR("{}"), STR("a\u1110c"));
+
+  check(STR("a\u1100c"), STR("{:.4}"), STR("a\u1100c"));
+  check(STR("a\u1100"), STR("{:.3}"), STR("a\u1100c"));
+  check(STR("a"), STR("{:.2}"), STR("a\u1100c"));
+  check(STR("a"), STR("{:.1}"), STR("a\u1100c"));
+
+  check(STR("a\u1100c"), STR("{:-<4.4}"), STR("a\u1100c"));
+  check(STR("a\u1100"), STR("{:-<3.3}"), STR("a\u1100c"));
+  check(STR("a-"), STR("{:-<2.2}"), STR("a\u1100c"));
+  check(STR("a"), STR("{:-<1.1}"), STR("a\u1100c"));
+
+  check(STR("a\u1110c---"), STR("{:-<7}"), STR("a\u1110c"));
+  check(STR("-a\u1110c--"), STR("{:-^7}"), STR("a\u1110c"));
+  check(STR("---a\u1110c"), STR("{:->7}"), STR("a\u1110c"));
+#else
+  (void)check;
+#endif
+}
+
+template <class CharT, class TestFunction, class ExceptionTest>
+void format_string_tests(TestFunction check, ExceptionTest check_exception) {
+  std::basic_string<CharT> world = STR("world");
+  std::basic_string<CharT> universe = STR("universe");
+
+  // Testing the char const[] is a bit tricky due to array to pointer decay.
+  // Since there are separate tests in format.formatter.spec the array is not
+  // tested here.
+  format_test_string<CharT>(world.c_str(), universe.c_str(), check,
+                            check_exception);
+  format_test_string<CharT>(const_cast<CharT*>(world.c_str()),
+                            const_cast<CharT*>(universe.c_str()), check,
+                            check_exception);
+  format_test_string<CharT>(std::basic_string_view<CharT>(world),
+                            std::basic_string_view<CharT>(universe), check,
+                            check_exception);
+  format_test_string<CharT>(world, universe, check, check_exception);
+  format_test_string_unicode<CharT>(check);
+}
+
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_tests(TestFunction check, ExceptionTest check_exception) {
   // *** Test escaping  ***
   check(STR("{"), STR("{{"));
   check(STR("}"), STR("}}"));
 
   // *** Test argument ID ***
   check(STR("hello 01"), STR("hello {0:}{1:}"), false, true);
// *** Test string format argument ***
     std::basic_string<CharT> data = STR("world");
     check(STR("hello world"), STR("hello {}"), data);
   }
   {
     std::basic_string<CharT> buffer = STR("world");
     std::basic_string_view<CharT> data = buffer;
     check(STR("hello world"), STR("hello {}"), data);
   }
+  format_string_tests<CharT>(check, check_exception);
 
   // *** Test Boolean format argument ***
   check(STR("hello 01"), STR("hello {}{}"), false, true);
 
   // *** Test signed integral format argument ***
   check(STR("hello 42"), STR("hello {}"), static_cast<signed char>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<short>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<int>(42));

libcxx/test/std/utilities/format/format.functions/formatted_size.pass.cpp

 
 // template<class... Args>
 //   size_t formatted_size(string_view fmt, const Args&... args);
 // template<class... Args>
 //   size_t formatted_size(wstring_view fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 
 auto test = []<class CharT, class... Args>(std::basic_string<CharT> expected,
                                            std::basic_string<CharT> fmt,
                                            const Args&... args) {
   size_t size = std::formatted_size(fmt, args...);

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

 
 // <format>
 
 // string vformat(string_view fmt, format_args args);
 // wstring vformat(wstring_view fmt, wformat_args args);
 
 #include <format>
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 
 auto test = []<class CharT, class... Args>(std::basic_string<CharT> expected,
                                            std::basic_string<CharT> fmt,
                                            const Args&... args) {
   std::basic_string<CharT> out = std::vformat(