[libc++][format] Use forwarding references.

[Mordante]

Summary

This implements a not accepted LWG issue. Not doing so would require
integral types to use the handle class instead of being directly stored
in the basic_format_arg.

The previous code used std::forward in places where it wasn't required
by the Standard. These are now removed.

Implements:

• P2418R2 Add support for std::generator-like types to std::format
• LWG 3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout

[Mordante]

Add a separate test for move only types.

[Mordante]

Fixes CI and minor cleanups.

[ldionne]

LGTM with a question.

libcxx/include/__format/format_arg.h

260

IIUC this means that we can't construct a handle from a temporary anymore, however I don't think I saw any tests that needed to change in reaction to that -- is that expected?

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.pass.cpp

27–31

You could also use LIBCPP_STATIC_ASSERT if you prefer.

[Mordante]

libcxx/include/__format/format_arg.h

260

We can still construct a handle using a temporary, there are test for that. However the temporary is "stored" in __basic_format_arg_value<_Context>::__handle and not in this object.

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.pass.cpp

27–31

Good one! I forgot about that macro.

[Mordante]

Rebased and addresses review comments.

[vitaut]

libcxx/include/__format/format_arg.h

213–215

Why pass __handle by rvalue or call forward here? Note that handle is just a pair of pointers so it probably makes more sense to pass it by value as before.

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

32

format should be const.

[Mordante]

Thanks for the review!

libcxx/include/__format/format_arg.h

213–215

There's something odd, I can remove the references. But when I remove the std::forward it breaks. I will investigate this at a later time.

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

32

Good catch! Unfortunately std::formatter<int, CharT>::format isn't const qualified yet. That's WIP and will be fixed soon. Instead I'll add a TODO.

[Mordante]

Rebased
Addresses review comments
Updates the release notes to the latest style

[h-vetinari]

This PR didn't update the format status page. Is the warning from C++20 status still current?

P0645: The paper is implemented but still marked as an incomplete feature (the feature-test macro is not set and the libary is only available when built with LIBCXX_ENABLE_INCOMPLETE_FEATURES). Not yet implemented LWG-issues will cause API and ABI breakage.

I would have though that the chrono-integration is orthogonal to the ABI issues.

[Mordante]

In D127570#3647884, @h-vetinari wrote:

This PR didn't update the format status page. Is the warning from C++20 status still current?

P0645: The paper is implemented but still marked as an incomplete feature (the feature-test macro is not set and the libary is only available when built with LIBCXX_ENABLE_INCOMPLETE_FEATURES). Not yet implemented LWG-issues will cause API and ABI breakage.

I would have though that the chrono-integration is orthogonal to the ABI issues.

I'm quite sure I indeed can do chono without an ABI break. But https://wg21.link/p2572r0 will be ABI breaking for at least char. If I really wanted, I probably can work around it. But since the paper hasn't been seen by LEWG I don't know how it will be received there. I also intend to look at some other improvements, this will be a lot easier when we're not ABI frozen.

However when we have -fexperimental-library I can set the feature-test macro to the value for P2418. That's already on my todo list. Having it in experimental will make it a lot easier to use format, so I'm quite happy about that.

libcxx/docs/ReleaseNotes.rst

 
 - Implemented P2216R3 (std::format improvements). The format functions
   (``std::format``, ``std::format_to``, ``std::format_to_n``, and
   ``std::formatted_size``) now validate the format string at compile time.
   When the format string is invalid this will make the code ill-formed instead
   of throwing an exception at run-time.  (This does not affect the ``v``
   functions.)
 
+- Implemented P2418R2 (Add support for ``std::generator``-like types to
+  ``std::format``). This allows the usage of non-copyable types as argument for
+  the formatting functions. The change means that bit fields can no longer be
+  used as argument for the formatting functions.
 
 API Changes
 -----------
 
 - The ``_LIBCPP_ABI_UNSTABLE`` macro has been removed in favour of setting
   ``_LIBCPP_ABI_VERSION=2``. This should not have any impact on users because
   they were not supposed to set ``_LIBCPP_ABI_UNSTABLE`` manually, however we
   still feel that it is worth mentioning in the release notes in case some users

libcxx/docs/Status/Cxx20Papers.csv

 "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""
 "`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","|Complete|","15.0"
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","|Complete|","14.0"
 "`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","",""
 "","","","","",""
 "`P2372R3 <https://wg21.link/P2372R3>`__","LWG","Fixing locale handling in chrono formatters","October 2021","",""
 "`P2415R2 <https://wg21.link/P2415R2>`__","LWG","What is a ``view``","October 2021","|Complete|","14.0"
-"`P2418R2 <https://wg21.link/P2418R2>`__","LWG","Add support for ``std::generator``-like types to ``std::format``","October 2021","|Partial|",""
+"`P2418R2 <https://wg21.link/P2418R2>`__","LWG","Add support for ``std::generator``-like types to ``std::format``","October 2021","|Complete|","15.0"
 "`P2432R1 <https://wg21.link/P2432R1>`__","LWG","Fix ``istream_view``","October 2021","",""

libcxx/docs/Status/Cxx2bIssues.csv

 "`3650 <https://wg21.link/LWG3650>`__","Are ``std::basic_string`` 's ``iterator`` and ``const_iterator`` constexpr iterators?","February 2022","|Nothing to do|",""
 "`3654 <https://wg21.link/LWG3654>`__","``basic_format_context::arg(size_t)`` should be ``noexcept`` ","February 2022","|Complete|","15.0","|format|"
 "`3657 <https://wg21.link/LWG3657>`__","``std::hash<std::filesystem::path>`` is not enabled","February 2022","",""
 "`3660 <https://wg21.link/LWG3660>`__","``iterator_traits<common_iterator>::pointer`` should conform to §[iterator.traits]","February 2022","|Complete|","14.0"
 "`3661 <https://wg21.link/LWG3661>`__","``constinit atomic<shared_ptr<T>> a(nullptr);`` should work","February 2022","",""
 "","","","",""
 "`3645 <https://wg21.link/LWG3645>`__","``resize_and_overwrite`` is overspecified to call its callback with lvalues","Not voted in","|Complete|","14.0",""
 "`3656 <https://wg21.link/LWG3656>`__","Inconsistent bit operations returning a count","Not voted in","|Complete|","15.0",""
+"`3631 <https://wg21.link/LWG3631>`__","``basic_format_arg(T&&)`` should use ``remove_cvref_t<T>`` throughout","Not voted in","|Complete|","15.0",""
 "","","","",""

libcxx/include/__format/format_arg.h

 template <class _Context>
 class __basic_format_arg_value {
   using _CharT = typename _Context::char_type;
 
 public:
   /// Contains the implementation for basic_format_arg::handle.
   struct __handle {
     template <class _Tp>
-    _LIBCPP_HIDE_FROM_ABI explicit __handle(const _Tp& __v) noexcept
+    _LIBCPP_HIDE_FROM_ABI explicit __handle(_Tp&& __v) noexcept
         : __ptr_(_VSTD::addressof(__v)),
           __format_([](basic_format_parse_context<_CharT>& __parse_ctx, _Context& __ctx, const void* __ptr) {
-            using _Formatter = typename _Context::template formatter_type<_Tp>;
-            using _Qp = conditional_t<requires { _Formatter().format(declval<const _Tp&>(), declval<_Context&>()); },
-                                      const _Tp, _Tp>;
+            using _Dp = remove_cvref_t<_Tp>;
+            using _Formatter = typename _Context::template formatter_type<_Dp>;
+            constexpr bool __const_formattable =
+                requires { _Formatter().format(declval<const _Dp&>(), declval<_Context&>()); };
+            using _Qp = conditional_t<__const_formattable, const _Dp, _Dp>;
+
+            static_assert(__const_formattable || !is_const_v<remove_reference_t<_Tp>>, "Mandated by [format.arg]/18");
+
             _Formatter __f;
             __parse_ctx.advance_to(__f.parse(__parse_ctx));
-            __ctx.advance_to(__f.format(*const_cast<_Qp*>(static_cast<const _Tp*>(__ptr)), __ctx));
+            __ctx.advance_to(__f.format(*const_cast<_Qp*>(static_cast<const _Dp*>(__ptr)), __ctx));
           }) {}
 
     const void* __ptr_;
     void (*__format_)(basic_format_parse_context<_CharT>&, _Context&, const void*);
   };
 
   union {
     monostate __monostate_;

 #  endif
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(float __value) noexcept : __float_(__value) {}
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(double __value) noexcept : __double_(__value) {}
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(long double __value) noexcept : __long_double_(__value) {}
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const _CharT* __value) noexcept : __const_char_type_ptr_(__value) {}
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(basic_string_view<_CharT> __value) noexcept
       : __string_view_(__value) {}
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const void* __value) noexcept : __ptr_(__value) {}
-  _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle __value) noexcept : __handle_(__value) {}
+  _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle&& __value) noexcept
+      : __handle_(std::forward<__handle>(__value)) {}
 };
 
 template <class _Context>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg {
 public:
   class _LIBCPP_TEMPLATE_VIS handle;
 
   _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept
       : __type_{__format::__arg_t::__none} {}

 template <class _Context>
 class _LIBCPP_TEMPLATE_VIS basic_format_arg<_Context>::handle {
 public:
   _LIBCPP_HIDE_FROM_ABI
   void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
     __handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle __handle) noexcept
+  _LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle& __handle) noexcept
       : __handle_(__handle) {}
 
 private:
-  typename __basic_format_arg_value<_Context>::__handle __handle_;
+  typename __basic_format_arg_value<_Context>::__handle& __handle_;
 };
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_ARG_H

libcxx/include/__format/format_arg_store.h

 }
 
 template <class _Context, class... _Args>
 _LIBCPP_HIDE_FROM_ABI void __create_packed_storage(uint64_t& __types, __basic_format_arg_value<_Context>* __values,
                                                    _Args&&... __args) noexcept {
   int __shift = 0;
   (
       [&] {
-        basic_format_arg<_Context> __arg = __create_format_arg<_Context>(_VSTD::forward<_Args>(__args));
+        basic_format_arg<_Context> __arg = __create_format_arg<_Context>(__args);
         if (__shift != 0)
           __types |= static_cast<uint64_t>(__arg.__type_) << __shift;
         else
           // Assigns the initial value.
           __types = static_cast<uint64_t>(__arg.__type_);
         __shift += __packed_arg_t_bits;
         *__values++ = __arg.__value_;
       }(),
       ...);
 }
 
 template <class _Context, class... _Args>
 _LIBCPP_HIDE_FROM_ABI void __store_basic_format_arg(basic_format_arg<_Context>* __data, _Args&&... __args) noexcept {
-  ([&] { *__data++ = __create_format_arg<_Context>(_VSTD::forward<_Args>(__args)); }(), ...);
+  ([&] { *__data++ = __create_format_arg<_Context>(__args); }(), ...);
 }
 
 template <class _Context, size_t N>
 struct __packed_format_arg_store {
   __basic_format_arg_value<_Context> __values_[N];
   uint64_t __types_;
 };
 
 template <class _Context, size_t N>
 struct __unpacked_format_arg_store {
   basic_format_arg<_Context> __args_[N];
 };
 
 } // namespace __format
 
 template <class _Context, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS __format_arg_store {
   _LIBCPP_HIDE_FROM_ABI
-  __format_arg_store(_Args&&... __args) noexcept {
+  __format_arg_store(_Args&... __args) noexcept {
     if constexpr (sizeof...(_Args) != 0) {
       if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args)))
-        __format::__create_packed_storage(__storage.__types_, __storage.__values_, _VSTD::forward<_Args>(__args)...);
+        __format::__create_packed_storage(__storage.__types_, __storage.__values_, __args...);
       else
-        __format::__store_basic_format_arg<_Context>(__storage.__args_, _VSTD::forward<_Args>(__args)...);
+        __format::__store_basic_format_arg<_Context>(__storage.__args_, __args...);
     }
   }
 
   using _Storage = conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)),
                                  __format::__packed_format_arg_store<_Context, sizeof...(_Args)>,
                                  __format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>;
 
   _Storage __storage;
 };
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_ARG_STORE_H

libcxx/include/format

template<class... Args>
     using format-string =                             // exposition only
       basic-format-string<char, type_identity_t<Args>...>;
   template<class... Args>
     using wformat-string =                            // exposition only
       basic-format-string<wchar_t, type_identity_t<Args>...>;
 
   // [format.functions], formatting functions
   template<class... Args>
-    string format(format-string<Args...> fmt, const Args&... args);
+    string format(format-string<Args...> fmt, Args&&... args);
   template<class... Args>
-    wstring format(wformat-string<Args...> fmt, const Args&... args);
+    wstring format(wformat-string<Args...> fmt, Args&&... args);
   template<class... Args>
-    string format(const locale& loc, format-string<Args...> fmt, const Args&... args);
+    string format(const locale& loc, format-string<Args...> fmt, Args&&... args);
   template<class... Args>
-    wstring format(const locale& loc, wformat-string<Args...> fmt, const Args&... args);
+    wstring format(const locale& loc, wformat-string<Args...> fmt, Args&&... args);
 
   string vformat(string_view fmt, format_args args);
   wstring vformat(wstring_view fmt, wformat_args args);
   string vformat(const locale& loc, string_view fmt, format_args args);
   wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
 
   template<class Out, class... Args>
-    Out format_to(Out out, format-string<Args...> fmt, const Args&... args);
+    Out format_to(Out out, format-string<Args...> fmt, Args&&... args);
   template<class Out, class... Args>
-    Out format_to(Out out, wformat-string<Args...> fmt, const Args&... args);
+    Out format_to(Out out, wformat-string<Args...> fmt, Args&&... args);
   template<class Out, class... Args>
-    Out format_to(Out out, const locale& loc, format-string<Args...> fmt, const Args&... args);
+    Out format_to(Out out, const locale& loc, format-string<Args...> fmt, Args&&... args);
   template<class Out, class... Args>
-    Out format_to(Out out, const locale& loc, wformat-string<Args...> fmt, const Args&... args);
+    Out format_to(Out out, const locale& loc, wformat-string<Args...> fmt, Args&&... args);
 
   template<class Out>
     Out vformat_to(Out out, string_view fmt, format_args args);
   template<class Out>
     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 char> args);
   template<class Out>
     Out vformat_to(Out out, const locale& loc, wstring_view fmt,
                    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,
-                                        format-string<Args...> fmt, const Args&... args);
+                                        format-string<Args...> fmt, Args&&... args);
   template<class Out, class... Args>
     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                        wformat-string<Args...> fmt, const Args&... args);
+                                        wformat-string<Args...> fmt, Args&&... args);
   template<class Out, class... Args>
     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                         const locale& loc, format-string<Args...> fmt,
-                                        const Args&... args);
+                                        Args&&... args);
   template<class Out, class... Args>
     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                         const locale& loc, wformat-string<Args...> fmt,
-                                        const Args&... args);
+                                        Args&&... args);
 
   template<class... Args>
-    size_t formatted_size(format-string<Args...> fmt, const Args&... args);
+    size_t formatted_size(format-string<Args...> fmt, Args&&... args);
   template<class... Args>
-    size_t formatted_size(wformat-string<Args...> fmt, const Args&... args);
+    size_t formatted_size(wformat-string<Args...> fmt, Args&&... args);
   template<class... Args>
-    size_t formatted_size(const locale& loc, format-string<Args...> fmt, const Args&... args);
+    size_t formatted_size(const locale& loc, format-string<Args...> fmt, Args&&... args);
   template<class... Args>
-    size_t formatted_size(const locale& loc, wformat-string<Args...> fmt, const Args&... args);
+    size_t formatted_size(const locale& loc, wformat-string<Args...> fmt, Args&&... args);
 
   // [format.formatter], formatter
   template<class T, class charT = char> struct formatter;
 
   // [format.parse.ctx], class template basic_format_parse_context
   template<class charT> class basic_format_parse_context;
   using format_parse_context = basic_format_parse_context<char>;
   using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
   // [format.arguments], arguments
   // [format.arg], class template basic_format_arg
   template<class Context> class basic_format_arg;
 
   template<class Visitor, class Context>
     see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
 
   // [format.arg.store], class template format-arg-store
   template<class Context, class... Args> struct format-arg-store;      // exposition only
 
   template<class Context = format_context, class... Args>
     format-arg-store<Context, Args...>
-      make_format_args(const Args&... args);
+      make_format_args(Args&&... args);
   template<class... Args>
     format-arg-store<wformat_context, Args...>
-      make_wformat_args(const Args&... args);
+      make_wformat_args(Args&&... args);
 
   // [format.error], class format_error
   class format_error;
 }
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler

 // 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>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_args = basic_format_args<wformat_context>;
 #endif
 
-// TODO FMT This helper wrapper can probably be removed after P2418 has been
-// implemented.
-template <class _Context, class... _Args>
-_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...>
-__make_format_args(_Args&&... __args) {
-  return _VSTD::__format_arg_store<_Context, _Args...>(
-      _VSTD::forward<_Args>(__args)...);
-}
-
-// TODO FMT After P2418 specify the return type instead of using auto.
 template <class _Context = format_context, class... _Args>
-_LIBCPP_HIDE_FROM_ABI auto make_format_args(const _Args&... __args) {
-  return _VSTD::__make_format_args<_Context>(__args...);
+_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> make_format_args(_Args&&... __args) {
+  return _VSTD::__format_arg_store<_Context, _Args...>(__args...);
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-// TODO FMT After P2418 specify the return type instead of using auto.
 template <class... _Args>
-_LIBCPP_HIDE_FROM_ABI auto make_wformat_args(const _Args&... __args) {
-  return _VSTD::make_format_args<wformat_context>(__args...);
+_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> make_wformat_args(_Args&&... __args) {
+  return _VSTD::__format_arg_store<wformat_context, _Args...>(__args...);
 }
 #endif
 
 namespace __format {
 
 /// Helper class parse and handle argument.
 ///
 /// When parsing a handle which is not enabled the code is ill-formed.

 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
 vformat_to(_OutIt __out_it, wstring_view __fmt, wformat_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
 }
 #endif
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-format_to(_OutIt __out_it, __format_string_t<_Args...> __fmt, const _Args&... __args) {
+format_to(_OutIt __out_it, __format_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.__str_,
                            _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-format_to(_OutIt __out_it, __wformat_string_t<_Args...> __fmt, const _Args&... __args) {
+format_to(_OutIt __out_it, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.__str_,
                            _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 _LIBCPP_ALWAYS_INLINE 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;
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
 vformat(wstring_view __fmt, wformat_args __args) {
   wstring __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
   return __res;
 }
 #endif
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string format(__format_string_t<_Args...> __fmt,
-                                                                                      const _Args&... __args) {
+                                                                                      _Args&&... __args) {
   return _VSTD::vformat(__fmt.__str_, _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
-format(__wformat_string_t<_Args...> __fmt, const _Args&... __args) {
+format(__wformat_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat(__fmt.__str_, _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.make_output_iterator(), __args));
   return _VSTD::move(__buffer).result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
-format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, __format_string_t<_Args...> __fmt, const _Args&... __args) {
+format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, __format_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, __fmt.__str_, _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, __wformat_string_t<_Args...> __fmt,
-            const _Args&... __args) {
+            _Args&&... __args) {
   return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, __fmt.__str_, _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.make_output_iterator(), __args));
   return _VSTD::move(__buffer).result();
 }
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
-formatted_size(__format_string_t<_Args...> __fmt, const _Args&... __args) {
+formatted_size(__format_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(__fmt.__str_, basic_format_args{_VSTD::make_format_args(__args...)});
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
-formatted_size(__wformat_string_t<_Args...> __fmt, const _Args&... __args) {
+formatted_size(__wformat_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(__fmt.__str_, basic_format_args{_VSTD::make_wformat_args(__args...)});
 }
 #endif
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 
 template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
_LIBCPP_ALWAYS_INLINE _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);
 }
 #endif
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-format_to(_OutIt __out_it, locale __loc, __format_string_t<_Args...> __fmt, const _Args&... __args) {
+format_to(_OutIt __out_it, locale __loc, __format_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.__str_,
                            _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
-format_to(_OutIt __out_it, locale __loc, __wformat_string_t<_Args...> __fmt, const _Args&... __args) {
+format_to(_OutIt __out_it, locale __loc, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.__str_,
                            _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 _LIBCPP_ALWAYS_INLINE 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;
 }
 #endif
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string format(locale __loc,
                                                                                       __format_string_t<_Args...> __fmt,
-                                                                                      const _Args&... __args) {
+                                                                                      _Args&&... __args) {
   return _VSTD::vformat(_VSTD::move(__loc), __fmt.__str_,
                         _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring
-format(locale __loc, __wformat_string_t<_Args...> __fmt, const _Args&... __args) {
+format(locale __loc, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat(_VSTD::move(__loc), __fmt.__str_,
                         _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 locale __loc, basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, __format_string_t<_Args...> __fmt,
-            const _Args&... __args) {
+            _Args&&... __args) {
   return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.__str_,
                                                _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, __wformat_string_t<_Args...> __fmt,
-            const _Args&... __args) {
+            _Args&&... __args) {
   return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.__str_,
                                                 _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).result();
 }
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
-formatted_size(locale __loc, __format_string_t<_Args...> __fmt, const _Args&... __args) {
+formatted_size(locale __loc, __format_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.__str_, basic_format_args{_VSTD::make_format_args(__args...)});
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
-formatted_size(locale __loc, __wformat_string_t<_Args...> __fmt, const _Args&... __args) {
+formatted_size(locale __loc, __wformat_string_t<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.__str_, basic_format_args{_VSTD::make_wformat_args(__args...)});
 }
 #endif
 
 #endif // _LIBCPP_HAS_NO_LOCALIZATION
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 
 #endif // _LIBCPP_FORMAT

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.pass.cpp

 #include <format>
 #include <iterator>
 #include <string>
 
 #include "test_basic_format_arg.h"
 #include "test_macros.h"
 
 int main(int, char**) {
-  using Context [[maybe_unused]] = std::basic_format_context< std::back_insert_iterator<std::basic_string<char>>, char>;
+  [[maybe_unused]] auto store = std::make_format_args(42, nullptr, false, 1.0);
 
-  std::make_format_args(42, nullptr, false, 1.0);
+#ifdef _LIBCPP_VERSION
+  static_assert(
+      std::same_as<decltype(store), std::__format_arg_store<std::format_context, int, nullptr_t, bool, double>>);
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_wformat_args.pass.cpp

 
 #include <cassert>
 #include <format>
 
 #include "test_basic_format_arg.h"
 #include "test_macros.h"
 
 int main(int, char**) {
-  using Context [[maybe_unused]] =
-      std::basic_format_context<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>;
+  [[maybe_unused]] auto store = std::make_wformat_args(42, nullptr, false, 1.0);
 
-  std::make_wformat_args(42, nullptr, false, 1.0);
+#ifdef _LIBCPP_VERSION
+  static_assert(
+      std::same_as<decltype(store), std::__format_arg_store<std::wformat_context, int, nullptr_t, bool, double>>);
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/P2418.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-has-no-incomplete-format
+
+// Tests whether a move only type can be formatted. This is required by
+// P2418R2 "Add support for std::generator-like types to std::format"
+
+// <format>
+
+#include <format>
+#include <cassert>
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <locale>
+#endif
+
+#include "MoveOnly.h"
+#include "make_string.h"
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+struct std::formatter<MoveOnly, CharT> : std::formatter<int, CharT> {
+  auto format(const MoveOnly& m, auto& ctx) -> decltype(ctx.out()) {
+    return std::formatter<int, CharT>::format(m.get(), ctx);
+  }
+};
+
+template <class CharT>
+static void test() {
+  MoveOnly m{10};
+  CharT buffer[10];
+#ifndef TEST_HAS_NO_LOCALIZATION
+  std::locale loc;
+#endif
+
+  assert(std::format(SV("{}"), MoveOnly{}) == SV("1"));
+
+  assert(std::format(SV("{}"), m) == SV("10"));
+  assert(m.get() == 10);
+
+  assert(std::format(SV("{}"), std::move(m)) == SV("10"));
+  assert(m.get() == 10);
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+  assert(std::format(loc, SV("{}"), MoveOnly{}) == SV("1"));
+
+  assert(std::format(loc, SV("{}"), m) == SV("10"));
+  assert(m.get() == 10);
+
+  assert(std::format(loc, SV("{}"), std::move(m)) == SV("10"));
+  assert(m.get() == 10);
+#endif
+
+  assert(std::format_to(buffer, SV("{}"), MoveOnly{}) == &buffer[1]);
+
+  assert(std::format_to(buffer, SV("{}"), m) == &buffer[2]);
+  assert(m.get() == 10);
+
+  assert(std::format_to(buffer, SV("{}"), std::move(m)) == &buffer[2]);
+  assert(m.get() == 10);
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+  assert(std::format_to(buffer, loc, SV("{}"), MoveOnly{}) == &buffer[1]);
+
+  assert(std::format_to(buffer, loc, SV("{}"), m) == &buffer[2]);
+  assert(m.get() == 10);
+
+  assert(std::format_to(buffer, loc, SV("{}"), std::move(m)) == &buffer[2]);
+  assert(m.get() == 10);
+#endif
+
+  assert(std::format_to_n(buffer, 5, SV("{}"), MoveOnly{}).out == &buffer[1]);
+
+  assert(std::format_to_n(buffer, 5, SV("{}"), m).out == &buffer[2]);
+  assert(m.get() == 10);
+
+  assert(std::format_to_n(buffer, 5, SV("{}"), std::move(m)).out == &buffer[2]);
+  assert(m.get() == 10);
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+  assert(std::format_to_n(buffer, 5, loc, SV("{}"), MoveOnly{}).out == &buffer[1]);
+
+  assert(std::format_to_n(buffer, 5, loc, SV("{}"), m).out == &buffer[2]);
+  assert(m.get() == 10);
+
+  assert(std::format_to_n(buffer, 5, loc, SV("{}"), std::move(m)).out == &buffer[2]);
+  assert(m.get() == 10);
+#endif
+
+  assert(std::formatted_size(SV("{}"), MoveOnly{}) == 1);
+
+  assert(std::formatted_size(SV("{}"), m) == 2);
+  assert(m.get() == 10);
+
+  assert(std::formatted_size(SV("{}"), std::move(m)) == 2);
+  assert(m.get() == 10);
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+  assert(std::formatted_size(loc, SV("{}"), MoveOnly{}) == 1);
+
+  assert(std::formatted_size(loc, SV("{}"), m) == 2);
+  assert(m.get() == 10);
+
+  assert(std::formatted_size(loc, SV("{}"), std::move(m)) == 2);
+  assert(m.get() == 10);
+#endif
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

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

 //   string format(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
 #include <vector>
 
-#include "test_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
+#include "test_macros.h"
 
 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <iostream>
 #  include <type_traits>
 #endif
 
 auto test = []<string_literal fmt, class CharT, class... Args>(std::basic_string_view<CharT> expected,
                                                                const Args&... args) constexpr {
   std::basic_string<CharT> out = std::format(fmt.template sv<CharT>(), args...);
 #ifndef TEST_HAS_NO_LOCALIZATION
   if constexpr (std::same_as<CharT, char>)
     if (out != expected)
       std::cerr << "\nFormat string   " << fmt.template sv<char>() << "\nExpected output " << expected
                 << "\nActual output   " << out << '\n';
 #endif
   assert(out == expected);
 };
 
-auto test_exception = []<class CharT, class... Args>(std::string_view, std::basic_string_view<CharT>, const Args&...) {
+auto test_exception = []<class CharT, class... Args>(std::string_view, std::basic_string_view<CharT>, Args&&...) {
   // After P2216 most exceptions thrown by std::format become ill-formed.
   // Therefore this tests does nothing.
   // A basic ill-formed test is done in format.verify.cpp
   // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
 };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

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

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
 
   std::format(L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
   std::format(L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #endif
 }
+
+struct tiny {
+  int bit : 1;
+};
+
+void P2418()
+{
+  auto t = tiny{};
+  std::format("{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  std::format(L"{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
+#endif
+}

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

void format_test_handle(TestFunction check, ExceptionTest check_exception) {
   check.template operator()<"answer is '{:X}'">(SV("answer is '0X5555'"), status::bar);
   check.template operator()<"answer is '{:s}'">(SV("answer is 'bar'"), status::bar);
 
   check.template operator()<"answer is '{}'">(SV("answer is '0xaa55'"), status::foobar);
   check.template operator()<"answer is '{:x}'">(SV("answer is '0xaa55'"), status::foobar);
   check.template operator()<"answer is '{:X}'">(SV("answer is '0XAA55'"), status::foobar);
   check.template operator()<"answer is '{:s}'">(SV("answer is 'foobar'"), status::foobar);
 
+  // P2418 Changed the argument from a const reference to a forwarding reference.
+  // This mainly affects handle classes, however since we use an abstraction
+  // layer here it's "tricky" to verify whether this test would do the "right"
+  // thing. So these tests are done separately.
+
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("xXs"))
     check_exception("The format-spec type has a type not supported for a status argument", fmt, status::foo);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   format_test_pointer<std::nullptr_t, CharT>(check, check_exception);