[libc++][format] Add __format_arg_store.

[Mordante]

Summary

This implements the struct __format_arg_store and its dependencies:

• the class basic_format_arg,
• the class basic_format_args,
• the class basic_format_context,
• the function make_format_args,
• the function make_format_args,
• the function visit_format_arg,
• several Standard required typedefs.

The following parts will be implemented in a later patch:

• the child class basic_format_arg::handle,
• the function basic_format_arg::basic_format_arg(const T* p).

The following extension has been implemented:

• the class basic_format_arg supports __[u]int128_t when there's libc++ support for 128 bit integrals.

Implements parts of:

• P0645 Text Formatting

Completes:

• LWG3371 visit_format_arg and make_format_args are not hidden friends

Note it's possible to make the code more efficient, but for now the focus
is to get a Standard conforming implementation. Improving the QoI will be
done later.

[Mordante]

It seems the CI build fails since it can't process the dependencies properly. I'll rebase and trigger an CI build once the dependencies have landed.

[curdeius]

libcxx/include/format

290

Typo: implemented.

292

We should make sure not to define __cpp_lib_concepts before having these concepts implemented then (or better, have all concepts implemented).
Personally, I'd rather just use below defined concepts and get rid of this ifdef.

[Mordante]

Thanks for the review.

libcxx/include/format

290

Thanks will fix.

292

We should make sure not to define __cpp_lib_concepts before having these concepts implemented then (or better, have all concepts implemented).

Agreed.

Personally, I'd rather just use below defined concepts and get rid of this ifdef.

I've no objection. That also makes it possible to switch to specific concepts once they've landed. The (un)signed_integral is already in review.

[Mordante]

• Fixed spelling errors
• Only depend on our own concepts and no longer use #ifdef for not yet implement ed concepts.
• Use MKSTR instead of make_string
• Added synopsis
• Targeted release paper for libc++ 13 instead of 12.
• Ran clang-format (fixes formatting of if constexpr)
• Rebased and use __throw_format_error instead of __format::__throw_error

[Mordante]

There seem to be build issues, so will investigate them.

[Mordante]

• Fixes documentation formatting error.
• Use a layer of indirection to avoid inconsistent default arguments, probably fixes GCC's build failure.
• Don't use temporary strings in std::make_format_args, probably fixes the sanitizer build issues.
• The filesystem issue will be solved in a different way.

[Mordante]

More changes will be needed.

[Mordante]

• Fixes the sanitizer issues, this probably fixes the GCC issue.
• It seems AppleClang 12 doesn't support concepts, first test whether disabling them works.

[Mordante]

Wanted to have a CI run to test some fixes, more work still needs to be done.

libcxx/include/format

286

@ldionne If you agree with this approach I'll move it to D93166, which then should fix the issues @mehdi_amini has using clang 8.

libcxx/test/std/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp

52

MKSTR -> MAKE_STRING and all other occurrences.

[Mordante]

Rebased to trigger CI.

[Mordante]

Switch to MAKE_STRING instead of MKSTR, this should fix the filesystem build.

[Mordante]

Need to solve the the CI merge issue first.

[ldionne]

libcxx/include/format

286

Ok, but please add a fat TODO here.

It's now my #1 priority to bump the compiler requirements for building libc++. It just doesn't make sense to try to build a C++20 library with a compiler that doesn't support C++20. The resulting library will be broken. Plus we've been accumulating serious debt lately due to this outdated policy.

For now make sure it works with Clang 8, but I'll kick this off on llvm-dev and the other lists.

@mehdi_amini You should move to building libc++ with the runtimes build (i.e. building libc++ with the Clang you just bootstrapped) to avoid issues like this in the future. Building libc++ with Clangs that old is only supported on paper, but I would never do that. I'll work on making the policy meet reality.

[Mordante]

libcxx/include/format

286

Ok, but please add a fat TODO here.

Will do

It's now my #1 priority to bump the compiler requirements for building libc++. It just doesn't make sense to try to build a C++20 library with a compiler that doesn't support C++20. The resulting library will be broken. Plus we've been accumulating serious debt lately due to this outdated policy.

It would indeed be great if we can change this policy. Thanks for working on it.

[Mordante]

Rebased to trigger CI.

[Mordante]

Removed so obsolete comment.
Use the arithmetic concepts directly since they've landed in main.

[Mordante]

Make _LIBCPP_HAS_NO_CONCEPTS not GCC specific. (The lack of indention made it hard to detect it was a GCC specific section.)

[Mordante]

Let all unit test require concepts. Test whether that fixes the Apple build issues.

[Mordante]

The concept fix for Apple seems to be working, but needs to be enabled for some existing tests.

[Mordante]

Rebased on main to merge the already committed part.
@ldionne can you have a look at this patch it should be ready.

[miscco]

Thanks for working on this. It is a considerable library

I am really concerned about doing a "quick" implementation and then being locked in due to ABI issues.

I believe we should spend the time up front to get a clean efficient implementation

libcxx/include/format

481–491

I think we whould really constraint this on template<integral _Tp> and handle all integral types here. Having them as multiple separat functions has significant maintainance overhead. Same for <template<floating_point _Tp>

I think they are in flight by @cjdb so maybe wait a bit to get this in.

(FYI this i how it I dit it for MSVC STL https://github.com/microsoft/STL/blob/99e8a2d7f2a083a6f768cff35a5e1792feb625a6/stl/inc/format#L933-L962 )

576–579

I *think* we should be able to default this as it is C++20

[cjdb]

libcxx/include/format

481–491

same_as, integral, and floating_point are all merged :-)

[tschuett]

You could put a comment at the top of the format header:
This library is still in development and there are no stability guarantees.

Or if you dare:

#warning the format library is still in development

[Mordante]

In D93593#2577296, @miscco wrote:

Thanks for working on this. It is a considerable library

I am really concerned about doing a "quick" implementation and then being locked in due to ABI issues.

I believe we should spend the time up front to get a clean efficient implementation

In general I agree. However the ABI will most likely be broken. Victor contacted me and http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2216r2.html will most likely be accepted for C++23 and retroactively be part of C++20. I'll will discuss this on Slack in the near future.

I also like to have some of the basics in so I can add benchmarks to see whether optimizations have a positive effect.

I already added a warning in the release document that the ABI isn't stable yet. Until it is I don't want to set __cpp_lib_format.

What do you think @ldionne?

In D93593#2577315, @tschuett wrote:

You could put a comment at the top of the format header:
This library is still in development and there are no stability guarantees.

That sounds like a good idea.

Or if you dare:

#warning the format library is still in development

I'm quite sure that will fail in our lit tests ;-)

libcxx/include/format

481–491

I think we whould really constraint this on template<integral _Tp> and handle all integral types here. Having them as multiple separat functions has significant maintainance overhead. Same for <template<floating_point _Tp>

I'll have a look at we can combine. But I think here we need some separate functions.

I think they are in flight by @cjdb so maybe wait a bit to get this in.

Yes I've already used some of the newer concepts recently added. But it seems I've missed same_as.

(FYI this i how it I dit it for MSVC STL https://github.com/microsoft/STL/blob/99e8a2d7f2a083a6f768cff35a5e1792feb625a6/stl/inc/format#L933-L962 )

Thanks for the link. It seems MSVC has more overloads for this part https://github.com/microsoft/STL/blob/99e8a2d7f2a083a6f768cff35a5e1792feb625a6/stl/inc/format#L195
(Obviously it's required there since Microsoft doesn't use a variant.)

576–579

I think that should be possible in theory. However I'm not sure how well compiler support for this feature is. Clang hasn't implemented all related papers yet. Since it's trivial to write the function manually I've done so. I'm not sure whether the performance of the variant is good enough. If not I need to change it to something else.

[Mordante]

• Added a warning as proposed by @tschuett
• Use more concepts as suggested by @miscco
• Rebased on main

[Mordante]

Friendly ping @ldionne.

[Mordante]

Rebased and adjusted due to D100736 [libc++] s/_LIBCPP_NO_HAS_CHAR8_T/_LIBCPP_HAS_NO_CHAR8_T/g

[Mordante]

Due to https://wg21.link/P2216 some functions need to be disabled on Apple.

[• Quuxplusone]

Very small comments, leading presumably to a lot of changes in the next revision. I didn't review closely or anything.

libcxx/include/format

428–433

Nit throughout: _VSTD::forward (and all other functions of >=1 argument) because ADL.
But you don't need (and therefore shouldn't put) _VSTD:: on concepts, classes, or variables; i.e. you should write monostate not _VSTD::monostate, and same_as not _VSTD::same_as, and so on.
Essentially, just as you should think of explicit as meaning "Here comes a constructor!", you should think of _VSTD:: in the libc++ codebase as meaning "Here comes a function call!"

Hopefully this fixes line 442's )&&sizeof(_Tp) misformatting, as well.

548–549

This being a "Precondition", I think it'd be better to use _LIBCPP_ASSERT here. Users of libc++ shouldn't be taught to rely on this exception happening, because it'll probably stop happening as soon (heh) as Contracts lands.

[Mordante]

Adresses review comments:

• Improves usage of _VSTD
• Use a _LIBCPP_ASSERT to validate a precondition instead of an exception

[Mordante]

Rebase to trigger CI. Just to make sure the build error isn't related to other recent build errors.

[Mordante]

Use _VSTD::locale to fix GCC errors.

[Mordante]

Fixes an ambiguity in the template overload resolution when char is unsigned.
This probably fixes the AArch64 and Arm build failures.

[tschuett]

Funny enough there is [[deprecated("message")]], but there is no [[unstable("message")]].

[Mordante]

In D93593#2714591, @tschuett wrote:

Funny enough there is [[deprecated("message")]], but there is no [[unstable("message")]].

:-)

For the CI passes. Still need to look at the attributes. I'll also look at polishing the code a bit further.

libcxx/include/format

428–433

Good point. I addressed these issues.
The formatting is still not great. Guess we need to wait for clang-format to properly implement concepts formatting.

[Mordante]

Major patch rework

• Separated in multiple headers
• Removed the variant
• Several minor improvements

Note the patch isn't ready for review yet, but getting close.

[Mordante]

Rebase to trigger CI.

[Mordante]

This patch has been abandoned in favour of D103357. Some of the prerequisites have landed which causes the CI to have merge issues.

libcxx/docs/Cxx2aStatusIssuesStatus.csv

 "`3358 <https://wg21.link/LWG3358>`__","|sect|\ [span.cons] is mistaken that ``to_address``\  can throw","Prague","",""
 "`3359 <https://wg21.link/LWG3359>`__","``<chrono>``\  leap second support should allow for negative leap seconds","Prague","",""
 "`3360 <https://wg21.link/LWG3360>`__","``three_way_comparable_with``\  is inconsistent with similar concepts","Prague","",""
 "`3362 <https://wg21.link/LWG3362>`__","Strike ``stop_source``\ 's ``operator!=``\ ","Prague","",""
 "`3363 <https://wg21.link/LWG3363>`__","``drop_while_view``\  should opt-out of ``sized_range``\ ","Prague","",""
 "`3364 <https://wg21.link/LWG3364>`__","Initialize data members of ranges and their iterators","Prague","",""
 "`3367 <https://wg21.link/LWG3367>`__","Integer-class conversions should not throw","Prague","",""
 "`3369 <https://wg21.link/LWG3369>`__","``span``\ 's deduction-guide for built-in arrays doesn't work","Prague","",""
-"`3371 <https://wg21.link/LWG3371>`__","``visit_format_arg``\  and ``make_format_args``\  are not hidden friends","Prague","",""
+"`3371 <https://wg21.link/LWG3371>`__","``visit_format_arg``\  and ``make_format_args``\  are not hidden friends","Prague","|Complete|,"12.0"
 "`3372 <https://wg21.link/LWG3372>`__","``vformat_to``\  should not try to deduce ``Out``\  twice","Prague","",""
 "`3373 <https://wg21.link/LWG3373>`__","``{to,from}_chars_result``\  and ``format_to_n_result``\  need the  ""we really mean what we say"" wording","Prague","",""
 "`3374 <https://wg21.link/LWG3374>`__","P0653 + P1006 should have made the other ``std::to_address``\  overload ``constexpr``\ ","Prague","|Complete|","12.0"
 "`3375 <https://wg21.link/LWG3375>`__","``decay``\  in ``viewable_range``\  should be ``remove_cvref``\ ","Prague","",""
 "`3377 <https://wg21.link/LWG3377>`__","``elements_view::iterator``\  befriends a specialization of itself","Prague","",""
 "`3379 <https://wg21.link/LWG3379>`__","""``safe``\ "" in several library names is misleading","Prague","",""
 "`3380 <https://wg21.link/LWG3380>`__","``common_type``\  and comparison categories","Prague","",""
 "`3381 <https://wg21.link/LWG3381>`__","``begin``\  and ``data``\  must agree for ``contiguous_range``\ ","Prague","",""

libcxx/include/format

public:
     explicit format_error(const string& what_arg);
     explicit format_error(const char* what_arg);
   };
 }
 
 */
 
 #include <__config>
+#include <array>
+#include <concepts>
+#include <iterator>
 #include <stdexcept>
+#include <string>
 #include <string_view>
+#include <type_traits>
 #include <version>
+#include <variant>
 
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif
 
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#include <locale>
+#include <optional>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
+// TODO FMT Evaluate which templates should be external templates. This
+// improves the efficency 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.
+
+// libc++ has a concepts header, but currently only a small subset of the
+// concepts is implemented. To ease the transition to using the not yet
+// implemetned concepts some helper concepts are added.
+// TODO FMT Switch to the real concepts when they are available.
+#if defined(__cpp_lib_concepts) && __cpp_lib_concepts >= 201806
+template <class _Tp>
+concept __signed_integral = _VSTD::signed_integral<_Tp>;
+template <class _Tp>
+concept __unsigned_integral = _VSTD::unsigned_integral<_Tp>;
+template <class _Tp>
+concept __output_iterator = _VSTD::output_iterator<_Tp>;
+#else
+template <class _Tp>
+concept __signed_integral = _VSTD::is_integral_v<_Tp>&& _VSTD::is_signed_v<_Tp>;
+template <class _Tp>
+concept __unsigned_integral =
+    _VSTD::is_integral_v<_Tp>&& _VSTD::is_unsigned_v<_Tp>;
+template <class _Tp>
+concept
+    __output_iterator = _VSTD::__has_iterator_category_convertible_to<
+                            _Tp, _VSTD::output_iterator_tag>::value ||
+                        // std::string::iterator needs additional tests.
+                        // This sounds buggy, however since the code should use
+                        // the concept don't fix it.
+                        (_VSTD::__has_iterator_category_convertible_to<
+                             _Tp, _VSTD::forward_iterator_tag>::value &&
+                         !_VSTD::__is_exactly_cpp17_input_iterator<_Tp>::value);
+#endif
+
+// Forward declarations.
+
+template <class _Context>
+class _LIBCPP_TEMPLATE_VIS basic_format_arg;
+
+template <class _Context, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS __format_arg_store {
+  _VSTD::array<basic_format_arg<_Context>, sizeof...(_Args)> __args;
+};
+
+template <class _Ctx, class... _Args>
+_LIBCPP_INLINE_VISIBILITY __format_arg_store<_Ctx, _Args...>
+make_format_args(const _Args&...);
+
+template <class _Tp, class _CharT = char>
+struct _LIBCPP_TEMPLATE_VIS formatter;
+
 class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
 public:
   _LIBCPP_INLINE_VISIBILITY explicit format_error(const string& __s)
       : runtime_error(__s) {}
   _LIBCPP_INLINE_VISIBILITY explicit format_error(const char* __s)
       : runtime_error(__s) {}
   virtual ~format_error() noexcept;
 };
private:
   _Indexing __indexing_;
   size_t __next_arg_id_;
   size_t __num_args_;
 };
 
 using format_parse_context = basic_format_parse_context<char>;
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
+// TODO FMT Add unit test for testing the return value of visit.
+template <class _Visitor, class _Context>
+_LIBCPP_INLINE_VISIBILITY auto
+visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
+    -> decltype(_VSTD::visit(forward<_Visitor>(__vis), __arg.__value_)) {
+  return _VSTD::visit(forward<_Visitor>(__vis), __arg.__value_);
+}
+
+template <class _Context>
+class _LIBCPP_TEMPLATE_VIS basic_format_arg {
+public:
+  // TODO FMT Define the handle class.
+  class handle;
+
+  _LIBCPP_INLINE_VISIBILITY basic_format_arg() noexcept = default;
+
+  _LIBCPP_INLINE_VISIBILITY explicit operator bool() const noexcept {
+    return !holds_alternative<_VSTD::monostate>(__value_);
+  }
+
+private:
+  using char_type = typename _Context::char_type;
+
+  // TODO FMT Implement constrain [format.arg]/4
+  // Constraints: The template specialization
+  //   typename Context::template formatter_type<T>
+  // meets the Formatter requirements ([formatter.requirements]).  The extent
+  // to which an implementation determines that the specialization meets the
+  // Formatter requirements is unspecified, except that as a minimum the
+  // expression
+  //   typename Context::template formatter_type<T>()
+  //    .format(declval<const T&>(), declval<Context&>())
+  // shall be well-formed when treated as an unevaluated operand.
+
+  template <class _Ctx, class... _Args>
+  _LIBCPP_INLINE_VISIBILITY friend __format_arg_store<_Ctx, _Args...>
+  _VSTD::make_format_args(const _Args&...);
+
+  template <class _Visitor, class _Ctx>
+  _LIBCPP_INLINE_VISIBILITY friend auto
+  _VSTD::visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx> __arg)
+      -> decltype(_VSTD::visit(forward<_Visitor>(__vis), __arg.__value_));
+
+  _VSTD::variant<_VSTD::monostate, bool, char_type, int, unsigned, long long,
+                 unsigned long long,
+#ifndef _LIBCPP_HAS_NO_INT128
+                 __int128_t, __uint128_t,
+#endif
+                 float, double, long double, const char_type*,
+                 _VSTD::basic_string_view<char_type>, const void*
+                 // TODO FMT Enable the handle.
+                 /*, handle*/>
+      __value_{_VSTD::monostate{}};
+
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(
+      const _Tp& __value) noexcept
+      requires(_VSTD::is_same_v<_Tp, bool> || _VSTD::is_same_v<_Tp, char_type>
+#ifndef _LIBCPP_HAS_NO_INT128
+               || _VSTD::is_same_v<_Tp, __int128_t> ||
+               _VSTD::is_same_v<_Tp, __uint128_t>
+#endif
+      ) {
+    __value_ = __value;
+  }
+
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(const _Tp& __value)
+      noexcept requires(
+          _VSTD::is_same_v<_Tp, char>&& _VSTD::is_same_v<char_type, wchar_t>) {
+    __value_ = static_cast<char_type>(__value);
+  }
+
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(
+      const _Tp& __value) noexcept
+      requires(__signed_integral<_Tp> && !_VSTD::is_same_v<_Tp, char_type> &&
+               !(_VSTD::is_same_v<_Tp, char> &&
+                 _VSTD::is_same_v<char_type, wchar_t>)&&sizeof(_Tp) <=
+                   sizeof(int)) {
+    __value_ = static_cast<int>(__value);
+  }
+
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(
+      const _Tp& __value) noexcept
+      // Don't depend on the signedness of the char_type.
+      requires(__unsigned_integral<_Tp> && !_VSTD::is_same_v<_Tp, bool> &&
+               !_VSTD::is_same_v<_Tp, char_type> &&
+               sizeof(_Tp) <= sizeof(unsigned)) {
+    __value_ = static_cast<unsigned>(__value);
+  }
+
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(
+      const _Tp& __value) noexcept
+      // Avoid ambiguous lookups with types where sizeof(_Tp)  <= sizeof(int)
+      // Since sizeof(char_type) is not larger than sizeof(int) don't test them.
+      requires(__signed_integral<_Tp> && sizeof(_Tp) > sizeof(int) &&
+               sizeof(_Tp) <= sizeof(long long)) {
+    __value_ = static_cast<long long>(__value);
+  }
+
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(const _Tp& __value)
+      noexcept requires(
+          // Avoid ambiguous lookups with types where
+          // sizeof(_Tp) <= sizeof(unsigned). Since sizeof(bool) and
+          // sizeof(char) are not larger than sizeof(unsigned) don't test them.
+          __unsigned_integral<_Tp> && sizeof(_Tp) > sizeof(unsigned) &&
+          sizeof(_Tp) <= sizeof(unsigned long long)) {
+    __value_ = static_cast<unsigned long long>(__value);
+  }
+
+  // TODO FMT Implement the handle overload.
+
+  _LIBCPP_INLINE_VISIBILITY
+  explicit basic_format_arg(float __n) noexcept { __value_ = __n; }
+  _LIBCPP_INLINE_VISIBILITY
+  explicit basic_format_arg(double __n) noexcept { __value_ = __n; }
+  _LIBCPP_INLINE_VISIBILITY
+  explicit basic_format_arg(long double __n) noexcept { __value_ = __n; }
+  _LIBCPP_INLINE_VISIBILITY
+  explicit basic_format_arg(const char_type* __s) {
+    if (!__s)
+      __format::__throw_error(
+          "Used a nullptr argument to initialize a C-string.");
+    __value_ = __s;
+  }
+
+  template <class _Traits>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(
+      _VSTD::basic_string_view<char_type, _Traits> __s) noexcept {
+    __value_ = __s;
+  }
+
+  template <class _Traits, class _Allocator>
+  _LIBCPP_INLINE_VISIBILITY explicit basic_format_arg(
+      const _VSTD::basic_string<char_type, _Traits, _Allocator>& __s) noexcept {
+    __value_ = _VSTD::basic_string_view<char_type>(__s.data(), __s.size());
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  explicit basic_format_arg(nullptr_t) noexcept {
+    __value_ = static_cast<const void*>(nullptr);
+  }
+
+  // TODO FMT Implement the const _Tp constructor.
+
+  // The operator isn't specified in the Standard but is useful in unit tests.
+  friend bool operator==(const basic_format_arg& __lhs,
+                         const basic_format_arg& __rhs) {
+    return __lhs.__value_ == __rhs.__value_;
+  }
+};
+
+template <class _Context>
+class _LIBCPP_TEMPLATE_VIS basic_format_args {
+public:
+  // TODO FMT Implement [format.args]/5
+  // [Note 1: Implementations are encouraged to optimize the representation of
+  // basic_format_args for small number of formatting arguments by storing
+  // indices of type alternatives separately from values and packing the
+  // former. — end note]
+  _LIBCPP_INLINE_VISIBILITY basic_format_args() noexcept = default;
+
+  template <class... _Args>
+  _LIBCPP_INLINE_VISIBILITY basic_format_args(
+      const __format_arg_store<_Context, _Args...>& __store) noexcept {
+    __size_ = sizeof...(_Args);
+    __data_ = __store.__args.data();
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  basic_format_arg<_Context> get(size_t __id) const noexcept {
+    return __id < __size_ ? __data_[__id] : basic_format_arg<_Context>();
+  }
+
+  // Returns: The number of formatting arguments.
+  size_t __size() const noexcept { return __size_; }
+
+private:
+  size_t __size_{0};
+  const basic_format_arg<_Context>* __data_;
+};
+
+template <class _OutIt, class _CharT>
+requires __output_iterator<const _OutIt> class _LIBCPP_TEMPLATE_VIS
+    basic_format_context {
+public:
+  using iterator = _OutIt;
+  using char_type = _CharT;
+  template <class _Tp>
+  using formatter_type = formatter<_Tp, _CharT>;
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  // Note: the Standard doesn't specify the required constructors.
+  _LIBCPP_INLINE_VISIBILITY
+  basic_format_context(_OutIt __out_it,
+                       basic_format_args<basic_format_context> __args,
+                       _VSTD::optional<_VSTD::locale>&& __loc = _VSTD::nullopt)
+      : __out_it_(__out_it), __args_(__args), __loc_(_VSTD::move(__loc)) {}
+#else
+  _LIBCPP_INLINE_VISIBILITY
+  basic_format_context(_OutIt __out_it,
+                       basic_format_args<basic_format_context> __args)
+      : __out_it_(__out_it), __args_(__args) {}
+#endif
+
+  basic_format_context(const basic_format_context&) = delete;
+  basic_format_context& operator=(const basic_format_context&) = delete;
+
+  _LIBCPP_INLINE_VISIBILITY basic_format_arg<basic_format_context>
+  arg(size_t __id) const {
+    return __args_.get(__id);
+  }
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  _LIBCPP_INLINE_VISIBILITY _VSTD::locale locale() {
+    if (!__loc_)
+      __loc_ = _VSTD::locale();
+    return *__loc_;
+  }
+#endif
+  _LIBCPP_INLINE_VISIBILITY iterator out() { return __out_it_; }
+  _LIBCPP_INLINE_VISIBILITY void advance_to(iterator __it) { __out_it_ = __it; }
+
+private:
+  iterator __out_it_;
+  basic_format_args<basic_format_context> __args_;
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  // The Standard doesn't specify how the locale is stored.
+  // [format.context]/6
+  // std::locale locale();
+  //   Returns: The locale passed to the formatting function if the latter
+  //   takes one, and std::locale() otherwise.
+  // This is done by storing the locale of the constructor in this optional. If
+  // locale() is called and the optional has no value the value will be create.
+  // This allow the implementation to lazily create the locale.
+  // TODO FMT Validate whether lazy creation is the best solution.
+  _VSTD::optional<_VSTD::locale> __loc_;
+#endif
+};
+
+// TODO FMT Implement [format.context]/4
+// [Note 1: For a given type charT, implementations are encouraged to provide a
+// single instantiation of basic_format_context for appending to
+// basic_string<charT>, vector<charT>, or any other container with contiguous
+// storage by wrapping those in temporary objects with a uniform interface
+// (such as a span<charT>) and polymorphic reallocation.  — end note]
+
+using format_context =
+    basic_format_context<_VSTD::back_insert_iterator<_VSTD::string>, char>;
+using wformat_context =
+    basic_format_context<_VSTD::back_insert_iterator<_VSTD::wstring>, wchar_t>;
+
+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 = format_context, class... _Args>
+_LIBCPP_INLINE_VISIBILITY __format_arg_store<_Context, _Args...>
+make_format_args(const _Args&... __args) {
+  return {basic_format_arg<_Context>(__args)...};
+}
+template <class... _Args>
+_LIBCPP_INLINE_VISIBILITY __format_arg_store<wformat_context, _Args...>
+make_wformat_args(const _Args&... __args) {
+  return make_format_args<wformat_context>(__args...);
+}
+
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_FORMAT

libcxx/test/std/utilities/format/format.arguments/format.arg.store/class.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
+
+// <format>
+
+// template<class Context, class... Args>
+// struct format-arg-store {      // exposition only
+//   array<basic_format_arg<Context>, sizeof...(Args)> args;
+// };
+//
+// Note more testing is done in the unit test for:
+// template<class Visitor, class Context>
+//   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class Context>
+void test() {
+  {
+    auto store = std::make_format_args<Context>();
+    static_assert(
+        std::is_same_v<decltype(store), std::__format_arg_store<Context> >);
+    static_assert(
+        std::is_same_v<decltype(store.__args),
+                       std::array<std::basic_format_arg<Context>, 0> >);
+    assert(store.__args.size() == 0);
+  }
+  {
+    auto store = std::make_format_args<Context>(1);
+    static_assert(std::is_same_v<decltype(store),
+                                 std::__format_arg_store<Context, int> >);
+    static_assert(
+        std::is_same_v<decltype(store.__args),
+                       std::array<std::basic_format_arg<Context>, 1> >);
+    assert(store.__args.size() == 1);
+  }
+  {
+    auto store = std::make_format_args<Context>(1, 'c');
+    static_assert(std::is_same_v<decltype(store),
+                                 std::__format_arg_store<Context, int, char> >);
+    static_assert(
+        std::is_same_v<decltype(store.__args),
+                       std::array<std::basic_format_arg<Context>, 2> >);
+    assert(store.__args.size() == 2);
+  }
+  {
+    auto store = std::make_format_args<Context>(1, 'c', nullptr);
+    static_assert(std::is_same_v<
+                  decltype(store),
+                  std::__format_arg_store<Context, int, char, nullptr_t> >);
+    static_assert(
+        std::is_same_v<decltype(store.__args),
+                       std::array<std::basic_format_arg<Context>, 3> >);
+    assert(store.__args.size() == 3);
+  }
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.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
+
+// <format>
+
+// template<class Context = format_context, class... Args>
+// format-arg-store<Context, Args...> make_format_args(const Args&... args);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  using Context = std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char>;
+
+  auto value = std::make_format_args(42, nullptr, false, 1.0);
+  auto expected =
+      std::make_format_args<Context, int, std::nullptr_t, bool, double>(
+          42, nullptr, false, 1.0);
+
+  assert(value.__args.size() == 4);
+  assert(expected.__args.size() == value.__args.size());
+
+  for (size_t i = 0, e = value.__args.size(); i != e; ++i)
+    assert(value.__args[i] == expected.__args[i]);
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_wformat_args.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
+
+// <format>
+
+// template<class... Args>
+//   format-arg-store<wformat_context, Args...>
+//   make_wformat_args(const Args&... args);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  using Context = std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t>;
+
+  auto value = std::make_wformat_args(42, nullptr, false, 1.0);
+  auto expected =
+      std::make_format_args<Context, int, std::nullptr_t, bool, double>(
+          42, nullptr, false, 1.0);
+
+  assert(value.__args.size() == 4);
+  assert(expected.__args.size() == value.__args.size());
+
+  for (size_t i = 0, e = value.__args.size(); i != e; ++i)
+    assert(value.__args[i] == expected.__args[i]);
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.arg/ctor.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
+
+// <format>
+
+// basic_format_arg() noexcept;
+//
+// The unit test for:
+// template<class Visitor, class Context>
+//   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+// tests the private constructors:
+// template<class T> explicit basic_format_arg(const T& v) noexcept;
+// explicit basic_format_arg(float n) noexcept;
+// explicit basic_format_arg(double n) noexcept;
+// explicit basic_format_arg(long double n) noexcept;
+// explicit basic_format_arg(const char_type* s);
+// template<class traits>
+//   explicit basic_format_arg(
+//     basic_string_view<char_type, traits> s) noexcept;
+// template<class traits, class Allocator>
+//   explicit basic_format_arg(
+//     const basic_string<char_type, traits, Allocator>& s) noexcept;
+// explicit basic_format_arg(nullptr_t) noexcept;
+// template<class T>
+//   explicit basic_format_arg(const T* p) noexcept;
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class Context>
+void test() {
+  ASSERT_NOEXCEPT(std::basic_format_arg<Context>{});
+
+  std::basic_format_arg<Context> format_arg{};
+  assert(!format_arg);
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.arg/operator_bool.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
+
+// <format>
+
+// explicit operator bool() const noexcept
+//
+// Note more testing is done in the unit test for:
+// template<class Visitor, class Context>
+//   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+void test(const auto& store) {
+  for (const auto& arg : store.__args) {
+    assert(arg);
+    assert(static_cast<bool>(arg));
+  }
+}
+
+template <class Context>
+void test() {
+  {
+    std::basic_format_arg<Context> format_arg{};
+    ASSERT_NOEXCEPT(!format_arg);
+    assert(!format_arg);
+    ASSERT_NOEXCEPT(static_cast<bool>(format_arg));
+    assert(!static_cast<bool>(format_arg));
+  }
+  test(std::make_format_args<Context>());
+  test(std::make_format_args<Context>(1));
+  test(std::make_format_args<Context>(1, 'c'));
+  test(std::make_format_args<Context>(1, 'c', nullptr));
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.arg/visit_format_arg.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
+
+// Due to make_string.
+// UNSUPPORTED: libcpp-has-no-localization
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: with_system_cxx_lib=macosx10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
+// <format>
+
+// template<class Visitor, class Context>
+//   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+template <class Context, class To, class From>
+void test(From value) {
+  auto format_args = std::make_format_args<Context>(value);
+  assert(format_args.__args.size() == 1);
+  assert(format_args.__args[0]);
+  std::visit_format_arg(
+      [v = To(value)](auto&& a) {
+        if
+          constexpr(std::is_same_v<To, std::decay_t<decltype(a)> >)
+              assert(v == a);
+        else
+          assert(false);
+      },
+      format_args.__args[0]);
+}
+
+template <class Context>
+void test() {
+  using char_type = typename Context::char_type;
+  std::basic_string<char_type> empty;
+  std::basic_string<char_type> str = make_string<char_type>("abc");
+
+  // Test boolean types.
+
+  test<Context, bool>(true);
+  test<Context, bool>(false);
+
+  // Test char_type types.
+
+  test<Context, char_type, char_type>('a');
+  test<Context, char_type, char_type>('z');
+  test<Context, char_type, char_type>('0');
+  test<Context, char_type, char_type>('9');
+
+  // Test char types.
+
+  if (std::is_same_v<char_type, char>) {
+    // char to char -> char
+    test<Context, char_type, char>('a');
+    test<Context, char_type, char>('z');
+    test<Context, char_type, char>('0');
+    test<Context, char_type, char>('9');
+  } else {
+    if (std::is_same_v<char_type, wchar_t>) {
+      // char to wchar_t -> wchar_t
+      test<Context, wchar_t, char>('a');
+      test<Context, wchar_t, char>('z');
+      test<Context, wchar_t, char>('0');
+      test<Context, wchar_t, char>('9');
+    } else if (std::is_signed_v<char>) {
+      // char to char_type -> int
+      // This happens when Context::char_type is a char8_t, char16_t, or
+      // char32_t and char is a signed type.
+      // Note if sizeof(char_type) > sizeof(int) this test fails. If there are
+      // platforms where that occurs extra tests need to be added for char32_t
+      // testing it against a long long.
+      test<Context, int, char>('a');
+      test<Context, int, char>('z');
+      test<Context, int, char>('0');
+      test<Context, int, char>('9');
+    } else {
+      // char to char_type -> unsigned
+      // This happens when Context::char_type is a char8_t, char16_t, or
+      // char32_t and char is an unsigned type.
+      // Note if sizeof(char_type) > sizeof(unsigned) this test fails. If there
+      // are platforms where that occurs extra tests need to be added for
+      // char32_t testing it against an unsigned long long.
+      test<Context, unsigned, char>('a');
+      test<Context, unsigned, char>('z');
+      test<Context, unsigned, char>('0');
+      test<Context, unsigned, char>('9');
+    }
+  }
+
+  // Test signed integer types.
+
+  test<Context, int, signed char>(std::numeric_limits<signed char>::min());
+  test<Context, int, signed char>(0);
+  test<Context, int, signed char>(std::numeric_limits<signed char>::max());
+
+  test<Context, int, short>(std::numeric_limits<short>::min());
+  test<Context, int, short>(std::numeric_limits<signed char>::min());
+  test<Context, int, short>(0);
+  test<Context, int, short>(std::numeric_limits<signed char>::max());
+  test<Context, int, short>(std::numeric_limits<short>::max());
+
+  test<Context, int, int>(std::numeric_limits<int>::min());
+  test<Context, int, int>(std::numeric_limits<short>::min());
+  test<Context, int, int>(std::numeric_limits<signed char>::min());
+  test<Context, int, int>(0);
+  test<Context, int, int>(std::numeric_limits<signed char>::max());
+  test<Context, int, int>(std::numeric_limits<short>::max());
+  test<Context, int, int>(std::numeric_limits<int>::max());
+
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<long>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<int>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<short>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<signed char>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(0);
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<signed char>::max());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<short>::max());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<int>::max());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<long>::max());
+
+  test<Context, long long, long long>(std::numeric_limits<long long>::min());
+  test<Context, long long, long long>(std::numeric_limits<long>::min());
+  test<Context, long long, long long>(std::numeric_limits<int>::min());
+  test<Context, long long, long long>(std::numeric_limits<short>::min());
+  test<Context, long long, long long>(std::numeric_limits<signed char>::min());
+  test<Context, long long, long long>(0);
+  test<Context, long long, long long>(std::numeric_limits<signed char>::max());
+  test<Context, long long, long long>(std::numeric_limits<short>::max());
+  test<Context, long long, long long>(std::numeric_limits<int>::max());
+  test<Context, long long, long long>(std::numeric_limits<long>::max());
+  test<Context, long long, long long>(std::numeric_limits<long long>::max());
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::min());
+  test<Context, __int128_t, __int128_t>(
+      std::numeric_limits<signed char>::min());
+  test<Context, __int128_t, __int128_t>(0);
+  test<Context, __int128_t, __int128_t>(
+      std::numeric_limits<signed char>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::max());
+#endif
+
+  // Test unsigned integer types.
+
+  test<Context, unsigned, unsigned char>(0);
+  test<Context, unsigned, unsigned char>(
+      std::numeric_limits<unsigned char>::max());
+
+  test<Context, unsigned, unsigned short>(0);
+  test<Context, unsigned, unsigned short>(
+      std::numeric_limits<unsigned char>::max());
+  test<Context, unsigned, unsigned short>(
+      std::numeric_limits<unsigned short>::max());
+
+  test<Context, unsigned, unsigned>(0);
+  test<Context, unsigned, unsigned>(std::numeric_limits<unsigned char>::max());
+  test<Context, unsigned, unsigned>(std::numeric_limits<unsigned short>::max());
+  test<Context, unsigned, unsigned>(std::numeric_limits<unsigned>::max());
+
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(0);
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned char>::max());
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned short>::max());
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned>::max());
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned long>::max());
+
+  test<Context, unsigned long long, unsigned long long>(0);
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned char>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned short>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned long>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned long long>::max());
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  test<Context, __uint128_t, __uint128_t>(0);
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned char>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned short>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned int>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned long>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned long long>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<__uint128_t>::max());
+#endif
+
+  // Test floating point types.
+
+  test<Context, float, float>(-std::numeric_limits<float>::max());
+  test<Context, float, float>(-std::numeric_limits<float>::min());
+  test<Context, float, float>(-0.0);
+  test<Context, float, float>(0.0);
+  test<Context, float, float>(std::numeric_limits<float>::min());
+  test<Context, float, float>(std::numeric_limits<float>::max());
+
+  test<Context, double, double>(-std::numeric_limits<double>::max());
+  test<Context, double, double>(-std::numeric_limits<double>::min());
+  test<Context, double, double>(-0.0);
+  test<Context, double, double>(0.0);
+  test<Context, double, double>(std::numeric_limits<double>::min());
+  test<Context, double, double>(std::numeric_limits<double>::max());
+
+  test<Context, long double, long double>(
+      -std::numeric_limits<long double>::max());
+  test<Context, long double, long double>(
+      -std::numeric_limits<long double>::min());
+  test<Context, long double, long double>(-0.0);
+  test<Context, long double, long double>(0.0);
+  test<Context, long double, long double>(
+      std::numeric_limits<long double>::min());
+  test<Context, long double, long double>(
+      std::numeric_limits<long double>::max());
+
+  // Test const char_type pointer types.
+
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  [] {
+    try {
+      test<Context, const char_type*, const char_type*>(nullptr);
+      assert(false);
+    } catch (const std::format_error& e) {
+      assert(strcmp(e.what(),
+                    "Used a nullptr argument to initialize a C-string.") == 0);
+      return;
+    }
+    assert(false);
+  }();
+#endif
+  test<Context, const char_type*, const char_type*>(empty.c_str());
+  test<Context, const char_type*, const char_type*>(str.c_str());
+
+  // Test string_view types.
+
+  test<Context, std::basic_string_view<char_type> >(
+      std::basic_string_view<char_type>());
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string_view<char_type> >(empty);
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string_view<char_type> >(str);
+
+  // Test string types.
+
+  test<Context, std::basic_string_view<char_type> >(
+      std::basic_string<char_type>());
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string<char_type> >(empty);
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string<char_type> >(str);
+
+  // Test pointer types.
+
+  test<Context, const void*>(nullptr);
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.args/__size.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
+
+// <format>
+
+// size_t __size() const noexcept;
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class Context>
+void test() {
+  {
+    const std::basic_format_args<Context> format_args{};
+    ASSERT_NOEXCEPT(format_args.__size());
+    assert(format_args.__size() == 0);
+  }
+  {
+    const std::basic_format_args<Context> format_args{
+        std::make_format_args<Context>(42)};
+    assert(format_args.__size() == 1);
+  }
+  {
+    const std::basic_format_args<Context> format_args{
+        std::make_format_args<Context>(42, nullptr)};
+    assert(format_args.__size() == 2);
+  }
+  {
+    const std::basic_format_args<Context> format_args{
+        std::make_format_args<Context>(42, nullptr, true)};
+    assert(format_args.__size() == 3);
+  }
+  {
+    const std::basic_format_args<Context> format_args{
+        std::make_format_args<Context>(42, nullptr, true, 1U)};
+    assert(format_args.__size() == 4);
+  }
+  {
+    const std::basic_format_args<Context> format_args{
+        std::make_format_args<Context>(42, nullptr, true, 1U, 1.0f)};
+    assert(format_args.__size() == 5);
+  }
+  {
+    const std::basic_format_args<Context> format_args{
+        std::make_format_args<Context>(42, nullptr, true, 1U, 1.0f, 1.0)};
+    assert(format_args.__size() == 6);
+  }
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.args/ctor.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
+
+// <format>
+
+// basic_format_args() noexcept;
+// template<class... Args>
+//   basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class Context>
+void test() {
+  {
+    ASSERT_NOEXCEPT(std::basic_format_args<Context>{});
+
+    std::basic_format_args<Context> format_args{};
+    assert(!format_args.get(0));
+  }
+  {
+    auto store = std::make_format_args<Context>(1);
+    ASSERT_NOEXCEPT(std::basic_format_args<Context>{store});
+    std::basic_format_args<Context> format_args{store};
+    assert(format_args.get(0));
+    assert(!format_args.get(1));
+  }
+  {
+    auto store = std::make_format_args<Context>(1, 'c');
+    ASSERT_NOEXCEPT(std::basic_format_args<Context>{store});
+    std::basic_format_args<Context> format_args{store};
+    assert(format_args.get(0));
+    assert(format_args.get(1));
+    assert(!format_args.get(2));
+  }
+  {
+    auto store = std::make_format_args<Context>(1, 'c', nullptr);
+    ASSERT_NOEXCEPT(std::basic_format_args<Context>{store});
+    std::basic_format_args<Context> format_args{store};
+    assert(format_args.get(0));
+    assert(format_args.get(1));
+    assert(format_args.get(2));
+    assert(!format_args.get(3));
+  }
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.arguments/format.args/get.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
+
+// Due to make_string.
+// UNSUPPORTED: libcpp-has-no-localization
+
+// This test requires the dylib support introduced in D92214.
+// XFAIL: with_system_cxx_lib=macosx10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
+// <format>
+
+// basic_format_arg<Context> get(size_t i) const noexcept;
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+template <class Context, class To, class From>
+void test(From value) {
+  const std::basic_format_args<Context> format_args{
+      std::make_format_args<Context>(value)};
+
+  std::visit_format_arg(
+      [v = To(value)](auto&& a) {
+        if
+          constexpr(std::is_same_v<To, std::decay_t<decltype(a)> >)
+              assert(v == a);
+        else
+          assert(false);
+      },
+      format_args.get(0));
+}
+
+template <class Context>
+void test() {
+  {
+    const std::basic_format_args<Context> format_args{};
+    ASSERT_NOEXCEPT(format_args.get(0));
+    assert(!format_args.get(0));
+  }
+
+  using char_type = typename Context::char_type;
+  std::basic_string<char_type> empty;
+  std::basic_string<char_type> str = make_string<char_type>("abc");
+
+  // Test boolean types.
+
+  test<Context, bool>(true);
+  test<Context, bool>(false);
+
+  // Test char_type types.
+
+  test<Context, char_type, char_type>('a');
+  test<Context, char_type, char_type>('z');
+  test<Context, char_type, char_type>('0');
+  test<Context, char_type, char_type>('9');
+
+  // Test char types.
+
+  if (std::is_same_v<char_type, char>) {
+    // char to char -> char
+    test<Context, char_type, char>('a');
+    test<Context, char_type, char>('z');
+    test<Context, char_type, char>('0');
+    test<Context, char_type, char>('9');
+  } else {
+    if (std::is_same_v<char_type, wchar_t>) {
+      // char to wchar_t -> wchar_t
+      test<Context, wchar_t, char>('a');
+      test<Context, wchar_t, char>('z');
+      test<Context, wchar_t, char>('0');
+      test<Context, wchar_t, char>('9');
+    } else if (std::is_signed_v<char>) {
+      // char to char_type -> int
+      // This happens when Context::char_type is a char8_t, char16_t, or
+      // char32_t and char is a signed type.
+      // Note if sizeof(char_type) > sizeof(int) this test fails. If there are
+      // platforms where that occurs extra tests need to be added for char32_t
+      // testing it against a long long.
+      test<Context, int, char>('a');
+      test<Context, int, char>('z');
+      test<Context, int, char>('0');
+      test<Context, int, char>('9');
+    } else {
+      // char to char_type -> unsigned
+      // This happens when Context::char_type is a char8_t, char16_t, or
+      // char32_t and char is an unsigned type.
+      // Note if sizeof(char_type) > sizeof(unsigned) this test fails. If there
+      // are platforms where that occurs extra tests need to be added for
+      // char32_t testing it against an unsigned long long.
+      test<Context, unsigned, char>('a');
+      test<Context, unsigned, char>('z');
+      test<Context, unsigned, char>('0');
+      test<Context, unsigned, char>('9');
+    }
+  }
+
+  // Test signed integer types.
+
+  test<Context, int, signed char>(std::numeric_limits<signed char>::min());
+  test<Context, int, signed char>(0);
+  test<Context, int, signed char>(std::numeric_limits<signed char>::max());
+
+  test<Context, int, short>(std::numeric_limits<short>::min());
+  test<Context, int, short>(std::numeric_limits<signed char>::min());
+  test<Context, int, short>(0);
+  test<Context, int, short>(std::numeric_limits<signed char>::max());
+  test<Context, int, short>(std::numeric_limits<short>::max());
+
+  test<Context, int, int>(std::numeric_limits<int>::min());
+  test<Context, int, int>(std::numeric_limits<short>::min());
+  test<Context, int, int>(std::numeric_limits<signed char>::min());
+  test<Context, int, int>(0);
+  test<Context, int, int>(std::numeric_limits<signed char>::max());
+  test<Context, int, int>(std::numeric_limits<short>::max());
+  test<Context, int, int>(std::numeric_limits<int>::max());
+
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<long>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<int>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<short>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<signed char>::min());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(0);
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<signed char>::max());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<short>::max());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<int>::max());
+  test<Context, std::conditional_t<sizeof(long) == sizeof(int), int, long long>,
+       long>(std::numeric_limits<long>::max());
+
+  test<Context, long long, long long>(std::numeric_limits<long long>::min());
+  test<Context, long long, long long>(std::numeric_limits<long>::min());
+  test<Context, long long, long long>(std::numeric_limits<int>::min());
+  test<Context, long long, long long>(std::numeric_limits<short>::min());
+  test<Context, long long, long long>(std::numeric_limits<signed char>::min());
+  test<Context, long long, long long>(0);
+  test<Context, long long, long long>(std::numeric_limits<signed char>::max());
+  test<Context, long long, long long>(std::numeric_limits<short>::max());
+  test<Context, long long, long long>(std::numeric_limits<int>::max());
+  test<Context, long long, long long>(std::numeric_limits<long>::max());
+  test<Context, long long, long long>(std::numeric_limits<long long>::max());
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::min());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::min());
+  test<Context, __int128_t, __int128_t>(
+      std::numeric_limits<signed char>::min());
+  test<Context, __int128_t, __int128_t>(0);
+  test<Context, __int128_t, __int128_t>(
+      std::numeric_limits<signed char>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::max());
+  test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::max());
+#endif
+
+  // Test unsigned integer types.
+
+  test<Context, unsigned, unsigned char>(0);
+  test<Context, unsigned, unsigned char>(
+      std::numeric_limits<unsigned char>::max());
+
+  test<Context, unsigned, unsigned short>(0);
+  test<Context, unsigned, unsigned short>(
+      std::numeric_limits<unsigned char>::max());
+  test<Context, unsigned, unsigned short>(
+      std::numeric_limits<unsigned short>::max());
+
+  test<Context, unsigned, unsigned>(0);
+  test<Context, unsigned, unsigned>(std::numeric_limits<unsigned char>::max());
+  test<Context, unsigned, unsigned>(std::numeric_limits<unsigned short>::max());
+  test<Context, unsigned, unsigned>(std::numeric_limits<unsigned>::max());
+
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(0);
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned char>::max());
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned short>::max());
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned>::max());
+  test<Context,
+       std::conditional_t<sizeof(unsigned long) == sizeof(unsigned), unsigned,
+                          unsigned long long>,
+       unsigned long>(std::numeric_limits<unsigned long>::max());
+
+  test<Context, unsigned long long, unsigned long long>(0);
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned char>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned short>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned long>::max());
+  test<Context, unsigned long long, unsigned long long>(
+      std::numeric_limits<unsigned long long>::max());
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  test<Context, __uint128_t, __uint128_t>(0);
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned char>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned short>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned int>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned long>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<unsigned long long>::max());
+  test<Context, __uint128_t, __uint128_t>(
+      std::numeric_limits<__uint128_t>::max());
+#endif
+
+  // Test floating point types.
+
+  test<Context, float, float>(-std::numeric_limits<float>::max());
+  test<Context, float, float>(-std::numeric_limits<float>::min());
+  test<Context, float, float>(-0.0);
+  test<Context, float, float>(0.0);
+  test<Context, float, float>(std::numeric_limits<float>::min());
+  test<Context, float, float>(std::numeric_limits<float>::max());
+
+  test<Context, double, double>(-std::numeric_limits<double>::max());
+  test<Context, double, double>(-std::numeric_limits<double>::min());
+  test<Context, double, double>(-0.0);
+  test<Context, double, double>(0.0);
+  test<Context, double, double>(std::numeric_limits<double>::min());
+  test<Context, double, double>(std::numeric_limits<double>::max());
+
+  test<Context, long double, long double>(
+      -std::numeric_limits<long double>::max());
+  test<Context, long double, long double>(
+      -std::numeric_limits<long double>::min());
+  test<Context, long double, long double>(-0.0);
+  test<Context, long double, long double>(0.0);
+  test<Context, long double, long double>(
+      std::numeric_limits<long double>::min());
+  test<Context, long double, long double>(
+      std::numeric_limits<long double>::max());
+
+  // Test const char_type pointer types.
+
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  [] {
+    try {
+      test<Context, const char_type*, const char_type*>(nullptr);
+      assert(false);
+    } catch (const std::format_error& e) {
+      assert(strcmp(e.what(),
+                    "Used a nullptr argument to initialize a C-string.") == 0);
+      return;
+    }
+    assert(false);
+  }();
+#endif
+  test<Context, const char_type*, const char_type*>(empty.c_str());
+  test<Context, const char_type*, const char_type*>(str.c_str());
+
+  // Test string_view types.
+
+  test<Context, std::basic_string_view<char_type> >(
+      std::basic_string_view<char_type>());
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string_view<char_type> >(empty);
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string_view<char_type> >(str);
+
+  // Test string types.
+
+  test<Context, std::basic_string_view<char_type> >(
+      std::basic_string<char_type>());
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string<char_type> >(empty);
+  test<Context, std::basic_string_view<char_type>,
+       std::basic_string<char_type> >(str);
+
+  // Test pointer types.
+
+  test<Context, const void*>(nullptr);
+}
+
+void test() {
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char> >, char> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char8_t> >, char8_t> >();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char16_t> >, char16_t> >();
+  test<std::basic_format_context<
+      std::back_insert_iterator<std::basic_string<char32_t> >, char32_t> >();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

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
+
+// <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.formatter/format.context/advance_to.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
+
+// <format>
+
+// void advance_to(iterator it);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class OutIt, class CharT>
+void test(
+    std::basic_format_args<std::basic_format_context<OutIt, CharT> > args) {
+  {
+    std::basic_string<CharT> str[3];
+    std::basic_format_context context{OutIt{str[0]}, args};
+    context.out() = CharT('a');
+    context.advance_to(OutIt{str[1]});
+    context.out() = CharT('b');
+    context.advance_to(OutIt{str[2]});
+    context.out() = CharT('c');
+
+    assert(str[0].size() == 1);
+    assert(str[0].front() == CharT('a'));
+    assert(str[1].size() == 1);
+    assert(str[1].front() == CharT('b'));
+    assert(str[2].size() == 1);
+    assert(str[2].front() == CharT('c'));
+  }
+}
+
+void test() {
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char> >, char> >()));
+
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<wchar_t> >,
+          wchar_t> >()));
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char8_t> >,
+          char8_t> >()));
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char16_t> >,
+          char16_t> >()));
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char32_t> >,
+          char32_t> >()));
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.context/arg.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
+
+// Due to make_string.
+// UNSUPPORTED: libcpp-has-no-localization
+
+// <format>
+
+// basic_format_arg<basic_format_context> arg(size_t id) const;
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+template <class OutIt, class CharT>
+void test() {
+  std::basic_format_args args =
+      std::make_format_args<std::basic_format_context<OutIt, CharT>, CharT>(
+          true, CharT('a'), 42, make_string<CharT>("string"));
+
+  std::basic_string<CharT> str;
+  {
+    const std::basic_format_context context{OutIt{str}, args};
+    assert(args.__size() == 4);
+    for (size_t i = 0, e = args.__size(); i != e; ++i) {
+      assert(context.arg(i));
+      assert(context.arg(i) == args.get(i));
+    }
+    assert(!context.arg(args.__size()));
+  }
+}
+
+int main(int, char**) {
+  test<std::back_insert_iterator<std::basic_string<char> >, char>();
+  test<std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t>();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::back_insert_iterator<std::basic_string<char8_t> >, char8_t>();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::back_insert_iterator<std::basic_string<char16_t> >, char16_t>();
+  test<std::back_insert_iterator<std::basic_string<char32_t> >, char32_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.context/ctor.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-localization
+
+// REQUIRES: locale.en_US.UTF-8
+// REQUIRES: locale.fr_FR.UTF-8
+
+// <format>
+
+// The Standard does not specifiy a constructor
+// basic_format_context(Out out,
+//                      basic_format_args<basic_format_context> args,
+//                      std::optional<std::::locale>&& loc = std::nullopt);
+// If compliled with -D_LIBCPP_HAS_NO_LOCALIZATION
+// basic_format_context(Out out,
+//                      basic_format_args<basic_format_context> args);
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "platform_support.h" // locale name macros
+#include "make_string.h"
+
+template <class OutIt, class CharT>
+void test() {
+  static_assert(
+      !std::is_copy_constructible_v<std::basic_format_context<OutIt, CharT> >);
+  static_assert(
+      !std::is_copy_assignable_v<std::basic_format_context<OutIt, CharT> >);
+  // The move operations are implicitly deleted due to the
+  // deleted copy operations.
+  static_assert(
+      !std::is_move_constructible_v<std::basic_format_context<OutIt, CharT> >);
+  static_assert(
+      !std::is_move_assignable_v<std::basic_format_context<OutIt, CharT> >);
+
+  std::basic_format_args args =
+      std::make_format_args<std::basic_format_context<OutIt, CharT>, CharT>(
+          true, CharT('a'), 42, make_string<CharT>("string"));
+
+  {
+    std::basic_string<CharT> str;
+    OutIt out_it{str};
+    std::basic_format_context context{out_it, args};
+    assert(args.__size() == 4);
+    for (size_t i = 0, e = args.__size(); i != e; ++i)
+      assert(context.arg(i) == args.get(i));
+
+    context.out() = CharT('a');
+    assert(str.size() == 1);
+    assert(str.front() == CharT('a'));
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+    assert(context.locale() == std::locale());
+#endif
+  }
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  std::locale en_US{LOCALE_en_US_UTF_8};
+  std::locale fr_FR{LOCALE_fr_FR_UTF_8};
+  {
+    std::basic_string<CharT> str;
+    OutIt out_it{str};
+    std::basic_format_context context{out_it, args, en_US};
+    assert(args.__size() == 4);
+    for (size_t i = 0, e = args.__size(); i != e; ++i)
+      assert(context.arg(i) == args.get(i));
+
+    context.out() = CharT('a');
+    assert(str.size() == 1);
+    assert(str.front() == CharT('a'));
+
+    assert(context.locale() != fr_FR);
+    assert(context.locale() == en_US);
+  }
+
+  {
+    std::basic_string<CharT> str;
+    OutIt out_it{str};
+    std::basic_format_context context{out_it, args, fr_FR};
+    assert(args.__size() == 4);
+    for (size_t i = 0, e = args.__size(); i != e; ++i)
+      assert(context.arg(i) == args.get(i));
+
+    context.out() = CharT('a');
+    assert(str.size() == 1);
+    assert(str.front() == CharT('a'));
+
+    assert(context.locale() == fr_FR);
+    assert(context.locale() != en_US);
+  }
+#endif
+}
+
+void test() {
+  test<std::back_insert_iterator<std::basic_string<char> >, char>();
+  test<std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t>();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::back_insert_iterator<std::basic_string<char8_t> >, char8_t>();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::back_insert_iterator<std::basic_string<char16_t> >, char16_t>();
+  test<std::back_insert_iterator<std::basic_string<char32_t> >, char32_t>();
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.context/locale.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-localization
+
+// REQUIRES: locale.en_US.UTF-8
+// REQUIRES: locale.fr_FR.UTF-8
+
+// <format>
+
+// std::locale locale();
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+#include "platform_support.h" // locale name macros
+#include "make_string.h"
+
+template <class OutIt, class CharT>
+void test() {
+  std::locale en_US{LOCALE_en_US_UTF_8};
+  std::locale fr_FR{LOCALE_fr_FR_UTF_8};
+  std::basic_format_args args =
+      std::make_format_args<std::basic_format_context<OutIt, CharT>, CharT>(
+          true, CharT('a'), 42, make_string<CharT>("string"));
+
+  {
+    std::basic_string<CharT> str;
+    OutIt out_it{str};
+    std::basic_format_context context{out_it, args, en_US};
+    assert(args.__size() == 4);
+    for (size_t i = 0, e = args.__size(); i != e; ++i)
+      assert(context.arg(i) == args.get(i));
+
+    context.out() = CharT('a');
+    assert(str.size() == 1);
+    assert(str.front() == CharT('a'));
+
+    assert(context.locale() != fr_FR);
+    assert(context.locale() == en_US);
+  }
+
+  {
+    std::basic_string<CharT> str;
+    OutIt out_it{str};
+    std::basic_format_context context{out_it, args, fr_FR};
+    assert(args.__size() == 4);
+    for (size_t i = 0, e = args.__size(); i != e; ++i)
+      assert(context.arg(i) == args.get(i));
+
+    context.out() = CharT('a');
+    assert(str.size() == 1);
+    assert(str.front() == CharT('a'));
+
+    assert(context.locale() == fr_FR);
+    assert(context.locale() != en_US);
+  }
+}
+
+void test() {
+  test<std::back_insert_iterator<std::basic_string<char> >, char>();
+  test<std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t>();
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test<std::back_insert_iterator<std::basic_string<char8_t> >, char8_t>();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<std::back_insert_iterator<std::basic_string<char16_t> >, char16_t>();
+  test<std::back_insert_iterator<std::basic_string<char32_t> >, char32_t>();
+#endif
+}
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.context/out.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
+
+// <format>
+
+// iterator out();
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class OutIt, class CharT>
+void test(
+    std::basic_format_args<std::basic_format_context<OutIt, CharT> > args) {
+  {
+    std::basic_string<CharT> str;
+    OutIt out_it{str};
+    std::basic_format_context context{out_it, args};
+    context.out() = CharT('a');
+    context.out() = CharT('b');
+    context.out() = CharT('c');
+
+    assert(str.size() == 3);
+    assert(str[0] == CharT('a'));
+    assert(str[1] == CharT('b'));
+    assert(str[2] == CharT('c'));
+  }
+}
+
+void test() {
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char> >, char> >()));
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<wchar_t> >,
+          wchar_t> >()));
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char8_t> >,
+          char8_t> >()));
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char16_t> >,
+          char16_t> >()));
+  test(std::basic_format_args(
+      std::make_format_args<std::basic_format_context<
+          std::back_insert_iterator<std::basic_string<char32_t> >,
+          char32_t> >()));
+#endif
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.context/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
+
+// <format>
+
+// Class typedefs:
+// template<class Out, class charT>
+// class basic_format_context {
+// public:
+//   using iterator = Out
+//   using char_type = charT;
+//   template<class T> using formatter_type = formatter<T, charT>;
+// }
+//
+// Namespace std typedefs:
+// using format_context = basic_format_context<unspecified, char>;
+// using wformat_context = basic_format_context<unspecified, wchar_t>;
+
+#include <format>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class OutIt, class CharT>
+constexpr void test() {
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<OutIt, CharT>::iterator,
+                     OutIt>);
+  static_assert(
+      std::is_same_v<
+          typename std::basic_format_context<OutIt, CharT>::char_type, CharT>);
+  static_assert(std::is_same_v<typename std::basic_format_context<
+                                   OutIt, CharT>::template formatter_type<bool>,
+                               std::formatter<bool, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<CharT>,
+                     std::formatter<CharT, CharT> >);
+  static_assert(std::is_same_v<typename std::basic_format_context<
+                                   OutIt, CharT>::template formatter_type<int>,
+                               std::formatter<int, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<unsigned>,
+                     std::formatter<unsigned, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<long long>,
+                     std::formatter<long long, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<OutIt, CharT>::
+                         template formatter_type<unsigned long long>,
+                     std::formatter<unsigned long long, CharT> >);
+#ifndef _LIBCPP_HAS_NO_INT128
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<__int128_t>,
+                     std::formatter<__int128_t, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<__uint128_t>,
+                     std::formatter<__uint128_t, CharT> >);
+#endif
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<float>,
+                     std::formatter<float, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<double>,
+                     std::formatter<double, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<long double>,
+                     std::formatter<long double, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<const CharT*>,
+                     std::formatter<const CharT*, CharT> >);
+  static_assert(std::is_same_v<
+                typename std::basic_format_context<OutIt, CharT>::
+                    template formatter_type<std::basic_string_view<CharT> >,
+                std::formatter<std::basic_string_view<CharT>, CharT> >);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<const void*>,
+                     std::formatter<const void*, CharT> >);
+}
+
+constexpr void test() {
+  test<std::back_insert_iterator<std::basic_string<char> >, char>();
+  test<std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t>();
+  test<std::back_insert_iterator<std::basic_string<char8_t> >, char8_t>();
+  test<std::back_insert_iterator<std::basic_string<char16_t> >, char16_t>();
+  test<std::back_insert_iterator<std::basic_string<char32_t> >, char32_t>();
+}
+
+static_assert(std::is_same_v<
+              std::format_context,
+              std::basic_format_context<
+                  std::back_insert_iterator<std::basic_string<char> >, char> >);
+static_assert(
+    std::is_same_v<
+        std::wformat_context,
+        std::basic_format_context<
+            std::back_insert_iterator<std::basic_string<wchar_t> >, wchar_t> >);
+
+// Required for MSVC internal test runner compatibility.
+int main(int, char**) { return 0; }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.verify.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr void check_arg_id(size_t id);
+
+#include <format>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  // [format.parse.ctx]/11
+  // Remarks: Call expressions where id >= num_args_ are not
+  // core constant expressions ([expr.const]).
+  std::format_parse_context context("", 0);
+  context.check_arg_id(1);
+
+  return true;
+}
+
+int main(int, char**) {
+  // expected-error@+1 {{static_assert expression is not an integral constant expression}}
+  static_assert(test());
+
+  return 0;
+}