[libc++][format][1/6] Reduce binary size.

[Mordante]

Summary

This removes the format_args_t from <format> and adjusts the type of
the format_args for the vformat_to overloads.

The format_context uses a back_insert_iterator<string> therefore the
new output_iterator function uses a string as its temporary storage
buffer. This isn't ideal. The next patches in this series will improve
this. These improvements make it easy to also improve format_to_n and
formatted_size.

This addresses P2216 6. Binary size.
P2216 5. Compile-time checks are not part of this change.

Implements parts of:

• P2216 std::format improvements

Depends on D103670

[Mordante]

The patches below this one had errors with Buildkite applying patches.
Rebase since all dependencies have landed.

[Mordante]

Rebased to test with wchar_t changes.

[vitaut]

Now that the format context is almost always format_context, it might be worth adding [[clang::preferred_name(format_context)]] to the basic_format_context template.

[vitaut]

libcxx/include/format

494–499

Is there a good reason to introduce this function as opposed to having this logic directly in __vformat_to?

[Mordante]

In D110494#3068986, @vitaut wrote:

Now that the format context is almost always format_context, it might be worth adding [[clang::preferred_name(format_context)]] to the basic_format_context template.

Yes we can also add both format_context and wformat_context, this seems the way we do it for string_view.

libcxx/include/format

494–499

It was easier for testing, but it seems during cleaning up the patch I never moved it back. Will do so.

[Mordante]

Rebased against main.
Addresses review comments.

[vitaut]

libcxx/include/format

520

Maybe force inline format_to* / vformat_to* to make debug codegen less horrible (https://godbolt.org/z/Kah4sqY5z) and since they are just trivial wrappers around __vformat_to*?

[vitaut]

LGTM provided that the extra copy and buffering is eliminated in the follow-up diffs. Not directly related to this diff but I recommend doing something about the default codegen (see the inline comment).

[vitaut]

libcxx/include/format

520

Note that without this code bloat prevention isn't working even with -O2 right now which is quite worrying: https://godbolt.org/z/1dn836jzG.

[Mordante]

Address review comments.

[Mordante]

In D110494#3145162, @vitaut wrote:

LGTM provided that the extra copy and buffering is eliminated in the follow-up diffs.

Thanks for the review.
The followup patches in this branch should indeed eliminated the extra copying and buffering.

libcxx/include/format

520

I've added force inlines. I still want to look at the size of the generated code at a later point in time. I think it makes more sense to look at after the all papers and LWG issues have been implemented.

[ldionne]

This LGTM but I am a bit concerned by the use of _LIBCPP_ALWAYS_INLINE. Normally, I would expect the compiler to do the right thing.

This seems reasonable to me since we are applying it systematically on functions that are thin wrappers around __vformat_to, which contains the real meat of the implementation and is not marked as _LIBCPP_ALWAYS_INLINE.

libcxx/docs/Status/Cxx20Papers.csv

 "`P2091 <https://wg21.link/P2091>`__","LWG","Issues with range access CPOs","Prague","* *",""
 "`P2101 <https://wg21.link/P2101>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
 "`P2102 <https://wg21.link/P2102>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
 "`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
 "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
 "`P2231 <https://wg21.link/P2231>`__","LWG","Missing constexpr in std::optional and std::variant","February 2021","|In progress|","13.0"
 "`P2325 <https://wg21.link/P2325>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|",""
 "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""
-"`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","",""
+"`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","|Partial|",""
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","",""
 "`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","",""
 "`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""

libcxx/include/format

template<class... Args>
       basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
 
     basic_format_arg<Context> get(size_t i) const noexcept;
   };
   using format_args = basic_format_args<format_context>;
   using wformat_args = basic_format_args<wformat_context>;
 
 
-  template<class Out, class charT>
-    using format_args_t = basic_format_args<basic_format_context<Out, charT>>;
-
   // [format.functions], formatting functions
   template<class... Args>
     string format(string_view fmt, const Args&... args);
   template<class... Args>
     wstring format(wstring_view fmt, const Args&... args);
   template<class... Args>
     string format(const locale& loc, string_view fmt, const Args&... args);
   template<class... Args>
namespace std {
   template<class Out, class... Args>
     Out format_to(Out out, wstring_view fmt, const Args&... args);
   template<class Out, class... Args>
     Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args);
   template<class Out, class... Args>
     Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args);
 
   template<class Out>
-    Out vformat_to(Out out, string_view fmt,
-                   format_args_t<type_identity_t<Out>, char> args);
+    Out vformat_to(Out out, string_view fmt, format_args args);
   template<class Out>
-    Out vformat_to(Out out, wstring_view fmt,
-                   format_args_t<type_identity_t<Out>, wchar_t> args);
+    Out vformat_to(Out out, wstring_view fmt, wformat_args args);
   template<class Out>
     Out vformat_to(Out out, const locale& loc, string_view fmt,
-                   format_args_t<type_identity_t<Out>, char> args);
+                   format_args char> args);
   template<class Out>
     Out vformat_to(Out out, const locale& loc, wstring_view fmt,
-                   format_args_t<type_identity_t<Out>, wchar_t> args);
+                   wformat_args args);
 
   template<class Out> struct format_to_n_result {
     Out out;
     iter_difference_t<Out> size;
   };
 
  template<class Out, class... Args>
     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,

 // TODO FMT Evaluate which templates should be external templates. This
 // improves the efficiency of the header. However since the header is still
 // under heavy development and not all classes are stable it makes no sense
 // to do this optimization now.
 
 using format_args = basic_format_args<format_context>;
 using wformat_args = basic_format_args<wformat_context>;
 
-template <class _OutIt, class _CharT>
-using format_args_t = basic_format_args<basic_format_context<_OutIt, _CharT>>;
-
 template <class _Context, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS __format_arg_store {
   // TODO FMT Use a built-in array.
   array<basic_format_arg<_Context>, sizeof...(_Args)> __args;
 };
 
 template <class _Context = format_context, class... _Args>
 _LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...>
private:
   template <class _Uv>
   _LIBCPP_HIDDEN static wstring
   __convert(_Uv __value) requires(same_as<_CharT, wchar_t>) {
     return _VSTD::to_wstring(__value);
   }
 
   template <class _Uv>
   _LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx)
-      -> decltype(__ctx.out())
-  {
+      -> decltype(__ctx.out()) {
     // TODO FMT Implement using formatting arguments
     // TODO FMT Improve PoC since using std::to_string is inefficient.
     // Note the code doesn't use std::string::iterator since the unit tests
     // test with debug iterators and they fail with strings created from
     // std::to_string.
     auto __str = __convert(__value);
     auto __out_it = __ctx.out();
     for (size_t __i = 0, __e = __str.size(); __i != __e; ++__i)
while (__begin != __end) {
     // Copy the character to the output verbatim.
     *__out_it++ = *__begin++;
   }
   return __out_it;
 }
 
 } // namespace __format
 
-template <class _OutIt, class _CharT>
+template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
-    __vformat_to(_OutIt __out_it, basic_string_view<_CharT> __fmt,
-                 format_args_t<type_identity_t<_OutIt>, _CharT> __args) {
-  return __format::__vformat_to(
+    __vformat_to_wrapped(
+        _OutIt __out_it, basic_string_view<_CharT> __fmt,
+        basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
+
+  basic_string<_CharT> __str;
+  _VSTD::__format::__vformat_to(
+      basic_format_parse_context{__fmt, __args.__size()},
+      _VSTD::__format_context_create(_VSTD::back_inserter(__str), __args));
+  return _VSTD::copy_n(__str.begin(), __str.size(), _VSTD::move(__out_it));
+}
+
+template <class _OutIt, class _CharT, class _FormatOutIt>
+requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
+    __vformat_to(
+        _OutIt __out_it, basic_string_view<_CharT> __fmt,
+        basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
+  if constexpr (same_as<_OutIt, _FormatOutIt>)
+    return _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
+  else
+    return _VSTD::__vformat_to_wrapped(_VSTD::move(__out_it), __fmt, __args);
 }
 
 template <output_iterator<const char&> _OutIt>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-vformat_to(_OutIt __out_it, string_view __fmt,
-           format_args_t<type_identity_t<_OutIt>, char> __args) {
+vformat_to(_OutIt __out_it, string_view __fmt, format_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
 }
 
 template <output_iterator<const wchar_t&> _OutIt>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-vformat_to(_OutIt __out_it, wstring_view __fmt,
-           format_args_t<type_identity_t<_OutIt>, wchar_t> __args) {
+vformat_to(_OutIt __out_it, wstring_view __fmt, wformat_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
 format_to(_OutIt __out_it, string_view __fmt, const _Args&... __args) {
-  return _VSTD::vformat_to(
-      _VSTD::move(__out_it), __fmt,
-      _VSTD::make_format_args<basic_format_context<_OutIt, char>>(__args...));
+  return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt,
+                           _VSTD::make_format_args(__args...));
 }
 
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
 format_to(_OutIt __out_it, wstring_view __fmt, const _Args&... __args) {
-  return _VSTD::vformat_to(
-      _VSTD::move(__out_it), __fmt,
-      _VSTD::make_format_args<basic_format_context<_OutIt, wchar_t>>(
-          __args...));
+  return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt,
+                           _VSTD::make_wformat_args(__args...));
 }
 
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
 vformat(string_view __fmt, format_args __args) {
   string __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
   return __res;
 }

 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
 formatted_size(wstring_view __fmt, const _Args&... __args) {
   // TODO FMT Improve PoC: using std::string is inefficient.
   return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)).size();
 }
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 
-template <class _OutIt, class _CharT>
+template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
-    __vformat_to(_OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
-                 format_args_t<type_identity_t<_OutIt>, _CharT> __args) {
-  return __format::__vformat_to(
+    __vformat_to_wrapped(
+        _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
+        basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
+
+  basic_string<_CharT> __str;
+  _VSTD::__format::__vformat_to(
+      basic_format_parse_context{__fmt, __args.__size()},
+      _VSTD::__format_context_create(_VSTD::back_inserter(__str), __args,
+                                     _VSTD::move(__loc)));
+  return _VSTD::copy_n(__str.begin(), __str.size(), _VSTD::move(__out_it));
+}
+
+template <class _OutIt, class _CharT, class _FormatOutIt>
+requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
+    __vformat_to(
+        _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
+        basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
+
+  if constexpr (same_as<_OutIt, _FormatOutIt>)
+    return _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args,
                                        _VSTD::move(__loc)));
+  else
+    return _VSTD::__vformat_to_wrapped(_VSTD::move(__out_it),
+                                       _VSTD::move(__loc), __fmt, __args);
 }
 
 template <output_iterator<const char&> _OutIt>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-vformat_to(_OutIt __out_it, locale __loc, string_view __fmt,
-           format_args_t<type_identity_t<_OutIt>, char> __args) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(
+    _OutIt __out_it, locale __loc, string_view __fmt, format_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
                              __args);
 }
 
 template <output_iterator<const wchar_t&> _OutIt>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-vformat_to(_OutIt __out_it, locale __loc, wstring_view __fmt,
-           format_args_t<type_identity_t<_OutIt>, wchar_t> __args) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(
+    _OutIt __out_it, locale __loc, wstring_view __fmt, wformat_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
                              __args);
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to(
     _OutIt __out_it, locale __loc, string_view __fmt, const _Args&... __args) {
-  return _VSTD::vformat_to(
-      _VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
-      _VSTD::make_format_args<basic_format_context<_OutIt, char>>(__args...));
+  return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
+                           _VSTD::make_format_args(__args...));
 }
 
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to(
     _OutIt __out_it, locale __loc, wstring_view __fmt, const _Args&... __args) {
-  return _VSTD::vformat_to(
-      _VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
-      _VSTD::make_format_args<basic_format_context<_OutIt, wchar_t>>(
-          __args...));
+  return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
+                           _VSTD::make_wformat_args(__args...));
 }
 
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string
 vformat(locale __loc, string_view __fmt, format_args __args) {
   string __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
                     __args);
   return __res;

libcxx/include/version

 __cpp_lib_endian                                        201907L <bit>
 __cpp_lib_erase_if                                      202002L <deque> <forward_list> <list>
                                                                 <map> <set> <string>
                                                                 <unordered_map> <unordered_set> <vector>
 __cpp_lib_exchange_function                             201304L <utility>
 __cpp_lib_execution                                     201902L <execution>
                                                         201603L // C++17
 __cpp_lib_filesystem                                    201703L <filesystem>
-__cpp_lib_format                                        201907L <format>
+__cpp_lib_format                                        202106L <format>
 __cpp_lib_gcd_lcm                                       201606L <numeric>
 __cpp_lib_generic_associative_lookup                    201304L <map> <set>
 __cpp_lib_generic_unordered_lookup                      201811L <unordered_map> <unordered_set>
 __cpp_lib_hardware_interference_size                    201703L <new>
 __cpp_lib_has_unique_object_representations             201606L <type_traits>
 __cpp_lib_hypot                                         201603L <cmath>
 __cpp_lib_incomplete_container_elements                 201505L <forward_list> <list> <vector>
 __cpp_lib_int_pow2                                      202002L <bit>

 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L
 # undef  __cpp_lib_execution
 // # define __cpp_lib_execution                            201902L
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format)
-// #   define __cpp_lib_format                             201907L
+// #   define __cpp_lib_format                             202106L
 # endif
 # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_int_pow2                             202002L
 # if !defined(_LIBCPP_HAS_NO_CONCEPTS)
 #   define __cpp_lib_integer_comparison_functions       202002L
 # endif
 # define __cpp_lib_interpolate                          201902L
 # define __cpp_lib_is_constant_evaluated                201811L

libcxx/test/std/language.support/support.limits/support.limits.general/format.version.pass.cpp

 
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // <format>
 
 // Test the feature test macros defined by <format>
 
 /*  Constant            Value
-    __cpp_lib_format    201907L [C++20]
+    __cpp_lib_format    202106L [C++20]
 */
 
 #include <format>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_format

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_format
 #     error "__cpp_lib_format should be defined in c++20"
 #   endif
-#   if __cpp_lib_format != 201907L
-#     error "__cpp_lib_format should have the value 201907L in c++20"
+#   if __cpp_lib_format != 202106L
+#     error "__cpp_lib_format should have the value 202106L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_format
 #     error "__cpp_lib_format should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_format
 #     error "__cpp_lib_format should be defined in c++2b"
 #   endif
-#   if __cpp_lib_format != 201907L
-#     error "__cpp_lib_format should have the value 201907L in c++2b"
+#   if __cpp_lib_format != 202106L
+#     error "__cpp_lib_format should have the value 202106L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_format
 #     error "__cpp_lib_format should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_destroying_delete                    201806L [C++20]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++20]
     __cpp_lib_erase_if                             202002L [C++20]
     __cpp_lib_exchange_function                    201304L [C++14]
     __cpp_lib_execution                            201603L [C++17]
                                                    201902L [C++20]
     __cpp_lib_filesystem                           201703L [C++17]
-    __cpp_lib_format                               201907L [C++20]
+    __cpp_lib_format                               202106L [C++20]
     __cpp_lib_gcd_lcm                              201606L [C++17]
     __cpp_lib_generic_associative_lookup           201304L [C++14]
     __cpp_lib_generic_unordered_lookup             201811L [C++20]
     __cpp_lib_hardware_interference_size           201703L [C++17]
     __cpp_lib_has_unique_object_representations    201606L [C++17]
     __cpp_lib_hypot                                201603L [C++17]
     __cpp_lib_incomplete_container_elements        201505L [C++17]
     __cpp_lib_int_pow2                             202002L [C++20]

 #     error "__cpp_lib_filesystem should not be defined when !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_format
 #     error "__cpp_lib_format should be defined in c++20"
 #   endif
-#   if __cpp_lib_format != 201907L
-#     error "__cpp_lib_format should have the value 201907L in c++20"
+#   if __cpp_lib_format != 202106L
+#     error "__cpp_lib_format should have the value 202106L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_format
 #     error "__cpp_lib_format should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_gcd_lcm

 #     error "__cpp_lib_filesystem should not be defined when !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_format
 #     error "__cpp_lib_format should be defined in c++2b"
 #   endif
-#   if __cpp_lib_format != 201907L
-#     error "__cpp_lib_format should have the value 201907L in c++2b"
+#   if __cpp_lib_format != 202106L
+#     error "__cpp_lib_format should have the value 202106L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_format
 #     error "__cpp_lib_format should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_gcd_lcm

libcxx/test/std/utilities/format/format.arguments/format.args/types.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // <format>
 
 // Namespace std typedefs:
 // using format_args = basic_format_args<format_context>;
 // using wformat_args = basic_format_args<wformat_context>;
-// template<class Out, class charT>
-//   using format_args_t = basic_format_args<basic_format_context<Out, charT>>;
 
 #include <format>
 #include <vector>
 #include <type_traits>
 
 #include "test_macros.h"
 
 static_assert(std::is_same_v<std::format_args,
                              std::basic_format_args<std::format_context>>);
 static_assert(std::is_same_v<std::wformat_args,
                              std::basic_format_args<std::wformat_context>>);
 
-static_assert(std::is_same_v<
-              std::format_args_t<std::back_insert_iterator<std::string>, char>,
-              std::basic_format_args<std::basic_format_context<
-                  std::back_insert_iterator<std::string>, char>>>);
-
-static_assert(
-    std::is_same_v<
-        std::format_args_t<std::back_insert_iterator<std::wstring>, wchar_t>,
-        std::basic_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::wstring>, wchar_t>>>);
-
-static_assert(
-    std::is_same_v<
-        std::format_args_t<std::back_insert_iterator<std::vector<char>>, char>,
-        std::basic_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::vector<char>>, char>>>);
-
 // Required for MSVC internal test runner compatibility.
 int main(int, char**) { return 0; }

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 <format>
+
 #include "make_string.h"
 
 // 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)
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
+template <class T>
+struct context {};
+
+template <>
+struct context<char> {
+  using type = std::format_context;
+};
+
+template <>
+struct context<wchar_t> {
+  using type = std::wformat_context;
+};
+
+template <class T>
+using context_t = typename context<T>::type;
+
 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;

libcxx/test/std/utilities/format/format.functions/locale-specific_form.pass.cpp

 //  template<class Out, class... Args>
 //    Out format_to(Out out, wstring_view fmt, const Args&... args);
 //  template<class Out, class... Args>
 //    Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args);
 //  template<class Out, class... Args>
 //    Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args);
 //
 //  template<class Out>
-//    Out vformat_to(Out out, string_view fmt,
-//                   format_args_t<type_identity_t<Out>, char> args);
+//    Out vformat_to(Out out, string_view fmt, format_args args);
 //  template<class Out>
-//    Out vformat_to(Out out, wstring_view fmt,
-//                   format_args_t<type_identity_t<Out>, wchar_t> args);
+//    Out vformat_to(Out out, wstring_view fmt, wformat_args args);
 //  template<class Out>
 //    Out vformat_to(Out out, const locale& loc, string_view fmt,
-//                   format_args_t<type_identity_t<Out>, char> args);
+//                   format_args args);
 //  template<class Out>
 //    Out vformat_to(Out out, const locale& loc, wstring_view fmt,
-//                   format_args_t<type_identity_t<Out>, wchar_t> args);
+//                   wformat_arg args);
 //
 //  template<class Out> struct format_to_n_result {
 //    Out out;
 //    iter_difference_t<Out> size;
 //  };
 //
 // template<class Out, class... Args>
 //    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,

 #include <format>
 #include <cassert>
 #include <iostream>
 #include <vector>
 
 #include "test_macros.h"
 #include "make_string.h"
 #include "platform_support.h" // locale name macros
+#include "format_tests.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 
 template <class CharT>
 struct numpunct;
 
 template <>
 struct numpunct<char> : std::numpunct<char> {
// *** format ***
     if constexpr (std::same_as<CharT, char>)
       if (out != expected)
         std::cerr << "\nFormat string   " << fmt << "\nExpected output "
                   << expected << "\nActual output   " << out << '\n';
     assert(out == expected);
   }
   // *** vformat ***
   {
-    std::basic_string<CharT> out = std::vformat(
-        fmt, std::make_format_args<std::basic_format_context<
-                 std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-                 args...));
+    std::basic_string<CharT> out =
+        std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(out == expected);
   }
   // *** format_to ***
   {
     std::basic_string<CharT> out(expected.size(), CharT(' '));
     auto it = std::format_to(out.begin(), fmt, args...);
     assert(it == out.end());
     assert(out == expected);
   }
   // *** vformat_to ***
   {
     std::basic_string<CharT> out(expected.size(), CharT(' '));
-    auto it = std::vformat_to(
-        out.begin(), fmt,
-        std::make_format_args<std::basic_format_context<
-            typename std::basic_string<CharT>::iterator, CharT>>(args...));
+    auto it = std::vformat_to(out.begin(), fmt,
+                              std::make_format_args<context_t<CharT>>(args...));
     assert(it == out.end());
     assert(out == expected);
   }
   // *** format_to_n ***
   {
     std::basic_string<CharT> out;
     std::format_to_n_result result =
         std::format_to_n(std::back_inserter(out), 1000, fmt, args...);
if constexpr (std::same_as<CharT, char>)
       if (out != expected)
         std::cerr << "\nFormat string   " << fmt << "\nExpected output "
                   << expected << "\nActual output   " << out << '\n';
     assert(out == expected);
   }
   // *** vformat ***
   {
     std::basic_string<CharT> out = std::vformat(
-        loc, fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-            args...));
+        loc, fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(out == expected);
   }
   // *** format_to ***
   {
     std::basic_string<CharT> out(expected.size(), CharT(' '));
     auto it = std::format_to(out.begin(), loc, fmt, args...);
     assert(it == out.end());
     assert(out == expected);
   }
   // *** vformat_to ***
   {
     std::basic_string<CharT> out(expected.size(), CharT(' '));
-    auto it = std::vformat_to(
-        out.begin(), loc, fmt,
-        std::make_format_args<std::basic_format_context<
-            typename std::basic_string<CharT>::iterator, CharT>>(args...));
+    auto it = std::vformat_to(out.begin(), loc, fmt,
+                              std::make_format_args<context_t<CharT>>(args...));
     assert(it == out.end());
     assert(out == expected);
   }
   // *** format_to_n ***
   {
     std::basic_string<CharT> out;
     std::format_to_n_result result =
         std::format_to_n(std::back_inserter(out), 1000, loc, fmt, args...);

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

 
 #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(
-      std::locale(), fmt,
-      std::make_format_args<std::basic_format_context<
-          std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-          args...));
+      std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
   assert(out == expected);
 };
 
 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
-    std::vformat(
-        std::locale(), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-            args...));
+    std::vformat(std::locale(), fmt,
+                 std::make_format_args<context_t<CharT>>(args...));
     assert(false);
   } catch (std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
 #else
   (void)what;

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

 #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(
-      fmt, std::make_format_args<std::basic_format_context<
-               std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-               args...));
+  std::basic_string<CharT> out =
+      std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
   assert(out == expected);
 };
 
 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
-    std::vformat(
-        fmt, std::make_format_args<std::basic_format_context<
-                 std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-                 args...));
+    std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(false);
   } catch (std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
 #else
   (void)what;

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

 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-11 status
 // UNSUPPORTED: gcc-11
 
 // <format>
 
 // template<class Out>
 //   Out vformat_to(Out out, const locale& loc, string_view fmt,
-//                  format_args_t<type_identity_t<Out>, char> args);
+//                  format_args args);
 // template<class Out>
 //    Out vformat_to(Out out, const locale& loc, wstring_view fmt,
-//                   format_args_t<type_identity_t<Out>, wchar_t> args);
+//                   wformat_args args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #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(expected.size(), CharT(' '));
-    auto it = std::vformat_to(
-        out.begin(), std::locale(), fmt,
-        std::make_format_args<std::basic_format_context<
-            typename std::basic_string<CharT>::iterator, CharT>>(args...));
+    auto it = std::vformat_to(out.begin(), std::locale(), fmt,
+                              std::make_format_args<context_t<CharT>>(args...));
     assert(it == out.end());
     assert(out == expected);
   }
   {
     std::list<CharT> out;
-    std::vformat_to(
-        std::back_inserter(out), std::locale(), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::list<CharT>>, CharT>>(args...));
+    std::vformat_to(std::back_inserter(out), std::locale(), fmt,
+                    std::make_format_args<context_t<CharT>>(args...));
     assert(
         std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
   }
   {
     std::vector<CharT> out;
-    std::vformat_to(
-        std::back_inserter(out), std::locale(), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::vector<CharT>>, CharT>>(args...));
+    std::vformat_to(std::back_inserter(out), std::locale(), fmt,
+                    std::make_format_args<context_t<CharT>>(args...));
     assert(
         std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
   }
   {
     assert(expected.size() < 4096 && "Update the size of the buffer.");
     CharT out[4096];
-    CharT* it = std::vformat_to(
-        out, std::locale(), fmt,
-        std::make_format_args<std::basic_format_context<CharT*, CharT>>(
-            args...));
+    CharT* it =
+        std::vformat_to(out, std::locale(), fmt,
+                        std::make_format_args<context_t<CharT>>(args...));
     assert(std::distance(out, it) == int(expected.size()));
     // Convert to std::string since output contains '\0' for boolean tests.
     assert(std::basic_string<CharT>(out, it) == expected);
   }
 };
 
 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
     std::basic_string<CharT> out;
-    std::vformat_to(
-        std::back_inserter(out), std::locale(), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-            args...));
+    std::vformat_to(std::back_inserter(out), std::locale(), fmt,
+                    std::make_format_args<context_t<CharT>>(args...));
     assert(false);
   } catch (std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
 #else
   (void)what;

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

 
 // The tests write fixed size buffer, make sure it remains in bounds.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // <format>
 
 // template<class Out>
-//   Out vformat_to(Out out, string_view fmt,
-//                  format_args_t<type_identity_t<Out>, char> args);
+//   Out vformat_to(Out out, string_view fmt, format_args args);
 // template<class Out>
-//    Out vformat_to(Out out, wstring_view fmt,
-//                   format_args_t<type_identity_t<Out>, wchar_t> args);
+//    Out vformat_to(Out out, wstring_view fmt, wformat_args_t args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
 #include <list>
 #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(expected.size(), CharT(' '));
-    auto it = std::vformat_to(
-        out.begin(), fmt,
-        std::make_format_args<std::basic_format_context<
-            typename std::basic_string<CharT>::iterator, CharT>>(args...));
+    auto it = std::vformat_to(out.begin(), fmt,
+                              std::make_format_args<context_t<CharT>>(args...));
     assert(it == out.end());
     assert(out == expected);
   }
   {
     std::list<CharT> out;
-    std::vformat_to(
-        std::back_inserter(out), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::list<CharT>>, CharT>>(args...));
+    std::vformat_to(std::back_inserter(out), fmt,
+                    std::make_format_args<context_t<CharT>>(args...));
     assert(
         std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
   }
   {
     std::vector<CharT> out;
-    std::vformat_to(
-        std::back_inserter(out), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::vector<CharT>>, CharT>>(args...));
+    std::vformat_to(std::back_inserter(out), fmt,
+                    std::make_format_args<context_t<CharT>>(args...));
     assert(
         std::equal(out.begin(), out.end(), expected.begin(), expected.end()));
   }
   {
     assert(expected.size() < 4096 && "Update the size of the buffer.");
     CharT out[4096];
     CharT* it = std::vformat_to(
-        out, fmt,
-        std::make_format_args<std::basic_format_context<CharT*, CharT>>(
-            args...));
+        out, fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(std::distance(out, it) == int(expected.size()));
     // Convert to std::string since output contains '\0' for boolean tests.
     assert(std::basic_string<CharT>(out, it) == expected);
   }
 };
 
 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
     std::basic_string<CharT> out;
-    std::vformat_to(
-        std::back_inserter(out), fmt,
-        std::make_format_args<std::basic_format_context<
-            std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
-            args...));
+    std::vformat_to(std::back_inserter(out), fmt,
+                    std::make_format_args<context_t<CharT>>(args...));
     assert(false);
   } catch (std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
 #else
   (void)what;

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_filesystem",
     "values": { "c++17": 201703 },
     "headers": ["filesystem"],
     "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)",
     "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)"
   }, {
     "name": "__cpp_lib_format",
-    "values": { "c++20": 201907 },
+    "values": { "c++20": 202106 },
     "headers": ["format"],
     "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format)",
     "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_gcd_lcm",
     "values": { "c++17": 201606 },
     "headers": ["numeric"],