[libc++][format] Improves CTAD.

[Mordante]

Summary

This partly reverts D133535 and enables CTAD for more parts in format.

[ldionne]

libcxx/include/__config

1201–1202

1208–1210

In a follow-up patch, I think we could consider also renaming this macro to _LIBCPP_CTAD_INTENDED_TO_WORK? We can bikeshed on that but I think we can find something better than _LIBCPP_CTAD_SUPPORTED_FOR_TYPE.

1208–1211

Can we instead try this?

#define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) \
  template <class ..._Tag> \
  _ClassName(typename _Tag::__allow_ctad...) -> _ClassName<_Tag...>;

Would that allow handling class templates that take any number of arguments?

[Mordante]

Rebased and addresses review comments.

[Mordante]

libcxx/include/__config

1208–1211

I tried this locally and it works, let's see what the CI thinks.

libcxx/include/__config

 // determining the latter depends on internal GNU libc details. If the
 // __cpp_char8_t feature test macro is not defined, then a char8_t typedef
 // will be declared as well.
 #  if defined(_LIBCPP_GLIBC_PREREQ) && defined(__GLIBC_USE)
 #    if _LIBCPP_GLIBC_PREREQ(2, 36) && (defined(__cpp_char8_t) || __GLIBC_USE(ISOC2X))
 #      undef _LIBCPP_HAS_NO_C8RTOMB_MBRTOC8
 #    endif
 #  endif
 
-// There are a handful of standard library types that are intended to support CTAD but don't need any
-// explicit deduction guides to do so. This macro is used to mark them as such, which suppresses the
-// '-Wctad-maybe-unsupported' compiler warning when CTAD is used in user code with these classes.
+// There are a handful of public standard library types that are intended to
+// support CTAD but don't need any explicit deduction guides to do so. This
+// macro is used to mark them as such, which suppresses the
+// '-Wctad-maybe-unsupported' compiler warning when CTAD is used in user code
+// with these classes.
 #if _LIBCPP_STD_VER >= 17
-#  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName)                                                                  \
-    template <class _Tag = void>                                                                                       \
-    _ClassName(typename _Tag::__allow_ctad) -> _ClassName<_Tag>
+#    define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName)                                                                \
+      template <class ..._Tag>                                                                                         \
+      _ClassName(typename _Tag::__allow_ctad...) -> _ClassName<_Tag...>
 #else
 #  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
 #endif
 
 #endif // __cplusplus
 
 #endif // _LIBCPP___CONFIG

libcxx/include/__format/format_context.h

  * This is needed since the constructor is private.
  */
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
 __format_context_create(
     _OutIt __out_it,
     basic_format_args<basic_format_context<_OutIt, _CharT>> __args,
     optional<_VSTD::locale>&& __loc = nullopt) {
-  return _VSTD::basic_format_context<_OutIt, _CharT>(_VSTD::move(__out_it), __args,
-                                                     _VSTD::move(__loc));
+  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args, _VSTD::move(__loc));
 }
 #else
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
 __format_context_create(
     _OutIt __out_it,
     basic_format_args<basic_format_context<_OutIt, _CharT>> __args) {
-  return _VSTD::basic_format_context<_OutIt, _CharT>(_VSTD::move(__out_it), __args);
+  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args);
 }
 #endif
 
 using format_context =
     basic_format_context<back_insert_iterator<__format::__output_buffer<char>>,
                          char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_context = basic_format_context<
friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
       __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>);
 
   _LIBCPP_HIDE_FROM_ABI
   explicit basic_format_context(_OutIt __out_it,
                                 basic_format_args<basic_format_context> __args)
       : __out_it_(_VSTD::move(__out_it)), __args_(__args) {}
 #endif
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_context);
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_CONTEXT_H

libcxx/include/__format/format_functions.h

#      endif
   }
   __throw_format_error("Invalid argument");
 }
 
 template <class _CharT, class _ParseCtx, class _Ctx>
 _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
 __handle_replacement_field(const _CharT* __begin, const _CharT* __end,
                            _ParseCtx& __parse_ctx, _Ctx& __ctx) {
-  __format::__parse_number_result<_CharT> __r =
-      __format::__parse_arg_id(__begin, __end, __parse_ctx);
+  __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   bool __parse = *__r.__ptr == _CharT(':');
   switch (*__r.__ptr) {
   case _CharT(':'):
     // The arg-id has a format-specifier, advance the input to the format-spec.
     __parse_ctx.advance_to(__r.__ptr + 1);
     break;
   case _CharT('}'):

 #endif
 
 template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
     __vformat_to(
         _OutIt __out_it, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
-    return _VSTD::__format::__vformat_to(
-        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
+    return _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                          _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
   else {
     __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
-    _VSTD::__format::__vformat_to(
-        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
-        _VSTD::__format_context_create(__buffer.__make_output_iterator(),
-                                       __args));
+    _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+                                  _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
     return _VSTD::move(__buffer).__out_it();
   }
 }
 
 // The function is _LIBCPP_ALWAYS_INLINE since the compiler is bad at inlining
 // https://reviews.llvm.org/D110499#inline-1180704
 // TODO FMT Evaluate whether we want to file a Clang bug report regarding this.
 template <output_iterator<const char&> _OutIt>

 }
 #endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
-  _VSTD::__format::__vformat_to(basic_format_parse_context<_CharT>{__fmt, __args.__size()},
+  _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
   return _VSTD::move(__buffer).__result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, __fmt.get(), _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wformat_string<_Args...> __fmt,
             _Args&&... __args) {
   return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, __fmt.get(), _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
-  _VSTD::__format::__vformat_to(basic_format_parse_context<_CharT>{__fmt, __args.__size()},
+  _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
   return _VSTD::move(__buffer).__result();
 }
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
 formatted_size(format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(__fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});

 
 template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
     __vformat_to(
         _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
-        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
-        _VSTD::__format_context_create(_VSTD::move(__out_it), __args,
-                                       _VSTD::move(__loc)));
+        basic_format_parse_context{__fmt, __args.__size()},
+        _VSTD::__format_context_create(_VSTD::move(__out_it), __args, _VSTD::move(__loc)));
   else {
     __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
-        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
-        _VSTD::__format_context_create(__buffer.__make_output_iterator(),
-                                       __args, _VSTD::move(__loc)));
+        basic_format_parse_context{__fmt, __args.__size()},
+        _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
     return _VSTD::move(__buffer).__out_it();
   }
 }
 
 template <output_iterator<const char&> _OutIt>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(
     _OutIt __out_it, locale __loc, string_view __fmt, format_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,

 #endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 locale __loc, basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(
-      basic_format_parse_context<_CharT>{__fmt, __args.__size()},
+      basic_format_parse_context{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).__result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, format_string<_Args...> __fmt,
             _Args&&... __args) {
return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.get(),
                                                 _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(
-      basic_format_parse_context<_CharT>{__fmt, __args.__size()},
+      basic_format_parse_context{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).__result();
 }
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
 formatted_size(locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});

libcxx/include/__format/format_parse_context.h

 private:
   iterator __begin_;
   iterator __end_;
   enum _Indexing { __unknown, __manual, __automatic };
   _Indexing __indexing_;
   size_t __next_arg_id_;
   size_t __num_args_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_parse_context);
 
 using format_parse_context = basic_format_parse_context<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
 #endif
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_PARSE_CONTEXT_H

libcxx/include/__format/format_string.h

 
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS __parse_number_result {
   const _CharT* __ptr;
   uint32_t __value;
 };
 
 template <class _CharT>
+__parse_number_result(const _CharT*, uint32_t) -> __parse_number_result<_CharT>;
+
+template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
 __parse_number(const _CharT* __begin, const _CharT* __end);
 
 /**
  * The maximum value of a numeric argument.
  *
  * This is used for:
  * * arg-id

libcxx/include/__format/parser_std_format_spec.h

 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result< _CharT>
 __parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
   // This function is a wrapper to call the real parser. But it does the
   // validation for the pre-conditions and post-conditions.
   if (__begin == __end)
     __throw_format_error("End of input while parsing format-spec arg-id");
 
-  __format::__parse_number_result<_CharT> __r =
-      __format::__parse_arg_id(__begin, __end, __parse_ctx);
+  __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
     __throw_format_error("Invalid arg-id");
 
   ++__r.__ptr;
   return __r;
 }
 
_LIBCPP_HIDE_FROM_ABI constexpr bool __parse_zero_padding(const _CharT*& __begin) {
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(const _CharT*& __begin, const _CharT* __end, auto& __parse_ctx) {
     if (*__begin == _CharT('0'))
       __throw_format_error("A format-spec width field shouldn't have a leading zero");
 
     if (*__begin == _CharT('{')) {
-      __format::__parse_number_result<_CharT> __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
       __width_as_arg_ = true;
       __width_ = __r.__value;
       __begin = __r.__ptr;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
       return false;
 
-    __format::__parse_number_result<_CharT> __r = __format::__parse_number(__begin, __end);
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
     __width_ = __r.__value;
     _LIBCPP_ASSERT(__width_ != 0, "A zero value isn't allowed and should be impossible, "
                                   "due to validations in this function");
     __begin = __r.__ptr;
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(const _CharT*& __begin, const _CharT* __end,
                                                          auto& __parse_ctx) {
     if (*__begin != _CharT('.'))
       return false;
 
     ++__begin;
     if (__begin == __end)
       __throw_format_error("End of input while parsing format-spec precision");
 
     if (*__begin == _CharT('{')) {
-      __format::__parse_number_result<_CharT> __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
       __precision_as_arg_ = true;
       __precision_ = __arg_id.__value;
       __begin = __arg_id.__ptr;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
       __throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
 
-    __format::__parse_number_result<_CharT> __r = __format::__parse_number(__begin, __end);
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
     __precision_ = __r.__value;
     __precision_as_arg_ = false;
     __begin = __r.__ptr;
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_locale_specific_form(const _CharT*& __begin) {
     if (*__begin != _CharT('L'))
struct __column_width_result {
   /// The number of output columns.
   size_t __width_;
   /// One beyond the last code unit used in the estimation.
   ///
   /// This limits the original output to fit in the wanted number of columns.
   const _CharT* __last_;
 };
 
+template <class _CharT>
+__column_width_result(size_t, const _CharT*) -> __column_width_result<_CharT>;
+
 /// Since a column width can be two it's possible that the requested column
 /// width can't be achieved. Depending on the intended usage the policy can be
 /// selected.
 /// - When used as precision the maximum width may not be exceeded and the
 ///   result should be "rounded down" to the previous boundary.
 /// - When used as a width we're done once the minimum is reached, but
 ///   exceeding is not an issue. Rounding down is an issue since that will
 ///   result in writing fill characters. Therefore the result needs to be
do {
         break;
       }
     } while (__is_ascii(*__it));
     --__it;
     ++__maximum;
   }
 
   ptrdiff_t __ascii_size = __it - __str.begin();
-  __column_width_result<_CharT> __result =
+  __column_width_result __result =
       __detail::__estimate_column_width_grapheme_clustering(__it, __str.end(), __maximum, __rounding);
 
   __result.__width_ += __ascii_size;
   return __result;
 }
 #  else // !defined(_LIBCPP_HAS_NO_UNICODE)
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __column_width_result<_CharT>

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/advance_to.pass.cpp

 #include "test_macros.h"
 #include "test_format_context.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<OutIt, CharT> context =
-        test_format_context_create(OutIt{str[0]}, args);
+    std::basic_format_context context = test_format_context_create(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'));

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/arg.pass.cpp

 template <class OutIt, class CharT>
 void test() {
   std::basic_string<CharT> string = MAKE_STRING(CharT, "string");
   auto store = std::make_format_args<std::basic_format_context<OutIt, CharT>>(
       true, CharT('a'), 42, string);
   std::basic_format_args args = store;
 
   std::basic_string<CharT> output;
-  const std::basic_format_context<OutIt, CharT> context =
-      test_format_context_create(OutIt{output}, args);
+  const std::basic_format_context context = test_format_context_create(OutIt{output}, args);
   LIBCPP_ASSERT(args.__size() == 4);
   ASSERT_NOEXCEPT(context.arg(0));
   for (size_t i = 0, e = args.__size(); i != e; ++i) {
     assert(context.arg(i));
   }
   assert(!context.arg(args.__size()));
 
   assert(test_basic_format_arg(context.arg(0), true));

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/ctor.pass.cpp

void test() {
   // to extend the lifetype of the object since args stores a pointer to the
   // data in this object.
   auto format_arg_store = std::make_format_args<std::basic_format_context<OutIt, CharT>>(true, CharT('a'), 42, string);
   std::basic_format_args args = format_arg_store;
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args);
+    std::basic_format_context context = test_format_context_create(out_it, args);
     LIBCPP_ASSERT(args.__size() == 4);
 
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
 #ifndef TEST_HAS_NO_LOCALIZATION
     assert(context.locale() == std::locale());
 #endif
   }
 
 #ifndef TEST_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> output;
     OutIt out_it{output};
-    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, en_US);
+    std::basic_format_context context = test_format_context_create(out_it, args, en_US);
 
     LIBCPP_ASSERT(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
     assert(context.locale() != fr_FR);
     assert(context.locale() == en_US);
   }
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, fr_FR);
+    std::basic_format_context context = test_format_context_create(out_it, args, fr_FR);
 
     LIBCPP_ASSERT(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/locale.pass.cpp

void test() {
   // to extend the lifetype of the object since args stores a pointer to the
   // data in this object.
   auto format_arg_store = std::make_format_args<std::basic_format_context<OutIt, CharT>>(true, CharT('a'), 42, string);
   std::basic_format_args args = format_arg_store;
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, en_US);
+    std::basic_format_context context = test_format_context_create(out_it, args, en_US);
     assert(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
     assert(context.locale() != fr_FR);
     assert(context.locale() == en_US);
   }
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, fr_FR);
+    std::basic_format_context context = test_format_context_create(out_it, args, fr_FR);
     assert(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/out.pass.cpp

 #include "test_format_context.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<OutIt, CharT> context = test_format_context_create(out_it, args);
+    std::basic_format_context context = test_format_context_create(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'));

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

constexpr void test(const CharT* fmt) {
     context.advance_to(context.begin() + 1);
     assert(std::to_address(context.begin()) == fmt + 2);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context<CharT> context(view);
+    std::basic_format_parse_context context(view);
 
     context.advance_to(context.begin() + 1);
     assert(std::to_address(context.begin()) == fmt + 1);
 
     context.advance_to(context.begin() + 1);
     assert(std::to_address(context.begin()) == fmt + 2);
 
     context.advance_to(context.begin() + 1);

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(std::to_address(context.begin()) == &fmt[0]);
     ASSERT_NOEXCEPT(context.begin());
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context<CharT> context(view);
+    std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     ASSERT_NOEXCEPT(context.begin());
   }
 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

static_assert(
       !std::is_copy_assignable_v<std::basic_format_parse_context<CharT> >);
   // The move operations are implicitly deleted due to the
   // deleted copy operations.
   static_assert(
       !std::is_move_constructible_v<std::basic_format_parse_context<CharT> >);
   static_assert(
       !std::is_move_assignable_v<std::basic_format_parse_context<CharT> >);
 
-  ASSERT_NOEXCEPT(
-      std::basic_format_parse_context<CharT>{std::basic_string_view<CharT>{}});
-  ASSERT_NOEXCEPT(
-      std::basic_format_parse_context<CharT>{std::basic_string_view<CharT>{}, 42});
+  ASSERT_NOEXCEPT(std::basic_format_parse_context{std::basic_string_view<CharT>{}});
+  ASSERT_NOEXCEPT(std::basic_format_parse_context{std::basic_string_view<CharT>{}, 42});
 
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(std::to_address(context.begin()) == &fmt[0]);
     assert(std::to_address(context.end()) == &fmt[3]);
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context<CharT> context(view);
+    std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     assert(context.end() == view.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(std::to_address(context.end()) == &fmt[3]);
     ASSERT_NOEXCEPT(context.end());
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context<CharT> context(view);
+    std::basic_format_parse_context context(view);
     assert(context.end() == view.end());
     ASSERT_NOEXCEPT(context.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");