[libc++][format] Uglyfies format buffer.

[Mordante]

Summary

While working on D129964 I noticed some code hadn't been uglyfied, this
rectifies the issue.

Depends on D129964

libcxx/include/__format/buffer.h

 /// type-erasure for the formatting functions. This reduces the number to
 /// template instantiations.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __output_buffer {
 public:
   using value_type = _CharT;
 
   template <class _Tp>
-  _LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr,
-                                                 size_t __capacity, _Tp* __obj)
-      : __ptr_(__ptr), __capacity_(__capacity),
-        __flush_([](_CharT* __p, size_t __size, void* __o) {
-          static_cast<_Tp*>(__o)->flush(__p, __size);
-        }),
+  _LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr, size_t __capacity, _Tp* __obj)
+      : __ptr_(__ptr),
+        __capacity_(__capacity),
+        __flush_([](_CharT* __p, size_t __n, void* __o) { static_cast<_Tp*>(__o)->__flush(__p, __n); }),
         __obj_(__obj) {}
 
-  _LIBCPP_HIDE_FROM_ABI void reset(_CharT* __ptr, size_t __capacity) {
+  _LIBCPP_HIDE_FROM_ABI void __reset(_CharT* __ptr, size_t __capacity) {
     __ptr_ = __ptr;
     __capacity_ = __capacity;
   }
 
-  _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
-    return back_insert_iterator{*this};
-  }
+  _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return std::back_insert_iterator{*this}; }
 
+  // Used in std::back_insert_iterator.
   _LIBCPP_HIDE_FROM_ABI void push_back(_CharT __c) {
     __ptr_[__size_++] = __c;
 
     // Profiling showed flushing after adding is more efficient than flushing
     // when entering the function.
     if (__size_ == __capacity_)
-      flush();
+      __flush();
   }
 
   /// Copies the input __str to the buffer.
   ///
   /// Since some of the input is generated by std::to_chars, there needs to be a
   /// conversion when _CharT is wchar_t.
   template <__formatter::__char_type _InCharT>
   _LIBCPP_HIDE_FROM_ABI void __copy(basic_string_view<_InCharT> __str) {
_LIBCPP_HIDE_FROM_ABI void __copy(basic_string_view<_InCharT> __str) {
     _LIBCPP_ASSERT(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
     const _InCharT* __first = __str.data();
     do {
       size_t __chunk = _VSTD::min(__n, __capacity_);
       _VSTD::copy_n(__first, __chunk, _VSTD::addressof(__ptr_[__size_]));
       __size_ = __chunk;
       __first += __chunk;
       __n -= __chunk;
-      flush();
+      __flush();
     } while (__n);
   }
 
   /// A std::transform wrapper.
   ///
   /// Like @ref __copy it may need to do type conversion.
   template <__formatter::__char_type _InCharT, class _UnaryOperation>
   _LIBCPP_HIDE_FROM_ABI void __transform(const _InCharT* __first, const _InCharT* __last, _UnaryOperation __operation) {
_LIBCPP_HIDE_FROM_ABI void __transform(const _InCharT* __first, const _InCharT* __last, _UnaryOperation __operation) {
     // Transform the data in "__capacity_" sized chunks.
     _LIBCPP_ASSERT(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
     do {
       size_t __chunk = _VSTD::min(__n, __capacity_);
       _VSTD::transform(__first, __first + __chunk, _VSTD::addressof(__ptr_[__size_]), __operation);
       __size_ = __chunk;
       __first += __chunk;
       __n -= __chunk;
-      flush();
+      __flush();
     } while (__n);
   }
 
   /// A \c fill_n wrapper.
   _LIBCPP_HIDE_FROM_ABI void __fill(size_t __n, _CharT __value) {
     __flush_on_overflow(__n);
     if (__n <= __capacity_) {
       _VSTD::fill_n(_VSTD::addressof(__ptr_[__size_]), __n, __value);
       __size_ += __n;
       return;
     }
 
     // The output doesn't fit in the internal buffer.
     // Fill the buffer in "__capacity_" sized chunks.
     _LIBCPP_ASSERT(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
     do {
       size_t __chunk = _VSTD::min(__n, __capacity_);
       _VSTD::fill_n(_VSTD::addressof(__ptr_[__size_]), __chunk, __value);
       __size_ = __chunk;
       __n -= __chunk;
-      flush();
+      __flush();
     } while (__n);
   }
 
-  _LIBCPP_HIDE_FROM_ABI void flush() {
+  _LIBCPP_HIDE_FROM_ABI void __flush() {
     __flush_(__ptr_, __size_, __obj_);
     __size_ = 0;
   }
 
 private:
   _CharT* __ptr_;
   size_t __capacity_;
   size_t __size_{0};
   void (*__flush_)(_CharT*, size_t, void*);
   void* __obj_;
 
   /// Flushes the buffer when the output operation would overflow the buffer.
   ///
   /// A simple approach for the overflow detection would be something along the
   /// lines:
   /// \code
   /// // The internal buffer is large enough.
   /// if (__n <= __capacity_) {
   ///   // Flush when we really would overflow.
   ///   if (__size_ + __n >= __capacity_)
-  ///     flush();
+  ///     __flush();
   ///   ...
   /// }
   /// \endcode
   ///
   /// This approach works for all cases but one:
   /// A __format_to_n_buffer_base where \ref __enable_direct_output is true.
   /// In that case the \ref __capacity_ of the buffer changes during the first
-  /// \ref flush. During that operation the output buffer switches from its
+  /// \ref __flush. During that operation the output buffer switches from its
   /// __writer_ to its __storage_. The \ref __capacity_ of the former depends
   /// on the value of n, of the latter is a fixed size. For example:
   /// - a format_to_n call with a 10'000 char buffer,
   /// - the buffer is filled with 9'500 chars,
   /// - adding 1'000 elements would overflow the buffer so the buffer gets
   ///   changed and the \ref __capacity_ decreases from 10'000 to
   ///   __buffer_size (256 at the time of writing).
   ///
-  /// This means that the \ref flush for this class may need to copy a part of
+  /// This means that the \ref __flush for this class may need to copy a part of
   /// the internal buffer to the proper output. In this example there will be
   /// 500 characters that need this copy operation.
   ///
   /// Note it would be more efficient to write 500 chars directly and then swap
   /// the buffers. This would make the code more complex and \ref format_to_n is
   /// not the most common use case. Therefore the optimization isn't done.
   _LIBCPP_HIDE_FROM_ABI void __flush_on_overflow(size_t __n) {
     if (__size_ + __n >= __capacity_)
-      flush();
+      __flush();
   }
 };
 
 /// A storage using an internal buffer.
 ///
 /// This storage is used when writing a single element to the output iterator
 /// is expensive.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __internal_storage {
 public:
-  _LIBCPP_HIDE_FROM_ABI _CharT* begin() { return __buffer_; }
+  _LIBCPP_HIDE_FROM_ABI _CharT* __begin() { return __buffer_; }
 
   static constexpr size_t __buffer_size = 256 / sizeof(_CharT);
 
 private:
   _CharT __buffer_[__buffer_size];
 };
 
 /// A storage writing directly to the storage.

 
 /// Write policy for directly writing to the underlying output.
 template <class _OutIt, __formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_direct {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
       : __out_it_(__out_it) {}
 
-  _LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }
+  _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; }
 
-  _LIBCPP_HIDE_FROM_ABI void flush(_CharT*, size_t __size) {
+  _LIBCPP_HIDE_FROM_ABI void __flush(_CharT*, size_t __n) {
     // _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator
     // is adjusted.
-    __out_it_ += __size;
+    __out_it_ += __n;
   }
 
 private:
   _OutIt __out_it_;
 };
 
 /// Write policy for copying the buffer to the output.
 template <class _OutIt, __formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_iterator {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
       : __out_it_{_VSTD::move(__out_it)} {}
 
-  _LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }
+  _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; }
 
-  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
-    __out_it_ = _VSTD::copy_n(__ptr, __size, _VSTD::move(__out_it_));
+  _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
+    __out_it_ = _VSTD::copy_n(__ptr, __n, _VSTD::move(__out_it_));
   }
 
 private:
   _OutIt __out_it_;
 };
 
 /// Concept to see whether a \a _Container is insertable.
 ///

 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS __writer_container {
 public:
   using _CharT = typename _Container::value_type;
 
   _LIBCPP_HIDE_FROM_ABI explicit __writer_container(back_insert_iterator<_Container> __out_it)
       : __container_{__out_it.__get_container()} {}
 
-  _LIBCPP_HIDE_FROM_ABI auto out() { return back_inserter(*__container_); }
+  _LIBCPP_HIDE_FROM_ABI auto __out_it() { return std::back_inserter(*__container_); }
 
-  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
-    __container_->insert(__container_->end(), __ptr, __ptr + __size);
+  _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
+    __container_->insert(__container_->end(), __ptr, __ptr + __n);
   }
 
 private:
   _Container* __container_;
 };
 
 /// Selects the type of the writer used for the output iterator.
 template <class _OutIt, class _CharT>
requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS
     __format_buffer {
   using _Storage =
       conditional_t<__enable_direct_output<_OutIt, _CharT>,
                     __direct_storage<_CharT>, __internal_storage<_CharT>>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
     requires(same_as<_Storage, __internal_storage<_CharT>>)
-  : __output_(__storage_.begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {}
+      : __output_(__storage_.__begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {}
 
   _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) requires(
       same_as<_Storage, __direct_storage<_CharT>>)
       : __output_(_VSTD::__unwrap_iter(__out_it), size_t(-1), this),
         __writer_(_VSTD::move(__out_it)) {}
 
-  _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
-    return __output_.make_output_iterator();
-  }
+  _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return __output_.__make_output_iterator(); }
 
-  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
-    __writer_.flush(__ptr, __size);
-  }
+  _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) { __writer_.__flush(__ptr, __n); }
 
-  _LIBCPP_HIDE_FROM_ABI _OutIt out() && {
-    __output_.flush();
-    return _VSTD::move(__writer_).out();
+  _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() && {
+    __output_.__flush();
+    return _VSTD::move(__writer_).__out_it();
   }
 
 private:
   _LIBCPP_NO_UNIQUE_ADDRESS _Storage __storage_;
   __output_buffer<_CharT> __output_;
   typename __writer_selector<_OutIt, _CharT>::type __writer_;
 };
 
 /// A buffer that counts the number of insertions.
 ///
 /// Since \ref formatted_size only needs to know the size, the output itself is
 /// discarded.
 template <__formatter::__char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __formatted_size_buffer {
 public:
-  _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() { return __output_.make_output_iterator(); }
+  _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return __output_.__make_output_iterator(); }
 
-  _LIBCPP_HIDE_FROM_ABI void flush(const _CharT*, size_t __size) { __size_ += __size; }
+  _LIBCPP_HIDE_FROM_ABI void __flush(const _CharT*, size_t __n) { __size_ += __n; }
 
-  _LIBCPP_HIDE_FROM_ABI size_t result() && {
-    __output_.flush();
+  _LIBCPP_HIDE_FROM_ABI size_t __result() && {
+    __output_.__flush();
     return __size_;
   }
 
 private:
   __internal_storage<_CharT> __storage_;
-  __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
+  __output_buffer<_CharT> __output_{__storage_.__begin(), __storage_.__buffer_size, this};
   size_t __size_{0};
 };
 
 /// The base of a buffer that counts and limits the number of insertions.
 template <class _OutIt, __formatter::__char_type _CharT, bool>
   requires(output_iterator<_OutIt, const _CharT&>)
 struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base {
   using _Size = iter_difference_t<_OutIt>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
       : __writer_(_VSTD::move(__out_it)), __max_size_(_VSTD::max(_Size(0), __max_size)) {}
 
-  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
+  _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
     if (_Size(__size_) <= __max_size_)
-      __writer_.flush(__ptr, _VSTD::min(_Size(__size), __max_size_ - __size_));
-    __size_ += __size;
+      __writer_.__flush(__ptr, _VSTD::min(_Size(__n), __max_size_ - __size_));
+    __size_ += __n;
   }
 
 protected:
   __internal_storage<_CharT> __storage_;
-  __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
+  __output_buffer<_CharT> __output_{__storage_.__begin(), __storage_.__buffer_size, this};
   typename __writer_selector<_OutIt, _CharT>::type __writer_;
 
   _Size __max_size_;
   _Size __size_{0};
 };
 
 /// The base of a buffer that counts and limits the number of insertions.
 ///
 /// This version is used when \c __enable_direct_output<_OutIt, _CharT> == true.
 ///
 /// This class limits the size available to the direct writer so it will not
 /// exceed the maximum number of code units.
 template <class _OutIt, __formatter::__char_type _CharT>
   requires(output_iterator<_OutIt, const _CharT&>)
 class _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base<_OutIt, _CharT, true> {
   using _Size = iter_difference_t<_OutIt>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
       : __output_(_VSTD::__unwrap_iter(__out_it), __max_size, this),
         __writer_(_VSTD::move(__out_it)),
         __max_size_(__max_size) {
     if (__max_size <= 0) [[unlikely]]
-      __output_.reset(__storage_.begin(), __storage_.__buffer_size);
+      __output_.__reset(__storage_.__begin(), __storage_.__buffer_size);
   }
 
-  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
-    // A flush to the direct writer happens in the following occasions:
+  _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
+    // A __flush to the direct writer happens in the following occasions:
     // - The format function has written the maximum number of allowed code
     //   units. At this point it's no longer valid to write to this writer. So
     //   switch to the internal storage. This internal storage doesn't need to
-    //   be written anywhere so the flush for that storage writes no output.
+    //   be written anywhere so the __flush for that storage writes no output.
     // - Like above, but the next "mass write" operation would overflow the
     //   buffer. In that case the buffer is pre-emptively switched. The still
     //   valid code units will be written separately.
     // - The format_to_n function is finished. In this case there's no need to
     //   switch the buffer, but for simplicity the buffers are still switched.
     // When the __max_size <= 0 the constructor already switched the buffers.
-    if (__size_ == 0 && __ptr != __storage_.begin()) {
-      __writer_.flush(__ptr, __size);
-      __output_.reset(__storage_.begin(), __storage_.__buffer_size);
+    if (__size_ == 0 && __ptr != __storage_.__begin()) {
+      __writer_.__flush(__ptr, __n);
+      __output_.__reset(__storage_.__begin(), __storage_.__buffer_size);
     } else if (__size_ < __max_size_) {
       // Copies a part of the internal buffer to the output up to n characters.
       // See __output_buffer<_CharT>::__flush_on_overflow for more information.
-      _Size __s = _VSTD::min(_Size(__size), __max_size_ - __size_);
-      std::copy_n(__ptr, __s, __writer_.out());
-      __writer_.flush(__ptr, __s);
+      _Size __s = _VSTD::min(_Size(__n), __max_size_ - __size_);
+      std::copy_n(__ptr, __s, __writer_.__out_it());
+      __writer_.__flush(__ptr, __s);
     }
 
-    __size_ += __size;
+    __size_ += __n;
   }
 
 protected:
   __internal_storage<_CharT> __storage_;
   __output_buffer<_CharT> __output_;
   __writer_direct<_OutIt, _CharT> __writer_;
 
   _Size __max_size_;
   _Size __size_{0};
 };
 
 /// The buffer that counts and limits the number of insertions.
 template <class _OutIt, __formatter::__char_type _CharT>
   requires(output_iterator<_OutIt, const _CharT&>)
 struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer final
     : public __format_to_n_buffer_base< _OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>> {
   using _Base = __format_to_n_buffer_base<_OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>>;
   using _Size = iter_difference_t<_OutIt>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __max_size)
       : _Base(_VSTD::move(__out_it), __max_size) {}
-  _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() { return this->__output_.make_output_iterator(); }
+  _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return this->__output_.__make_output_iterator(); }
 
-  _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> result() && {
-    this->__output_.flush();
-    return {_VSTD::move(this->__writer_).out(), this->__size_};
+  _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __result() && {
+    this->__output_.__flush();
+    return {_VSTD::move(this->__writer_).__out_it(), this->__size_};
   }
 };
 } // namespace __format
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_BUFFER_H

libcxx/include/format

requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
   else {
     __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
-        _VSTD::__format_context_create(__buffer.make_output_iterator(),
+        _VSTD::__format_context_create(__buffer.__make_output_iterator(),
                                        __args));
-    return _VSTD::move(__buffer).out();
+    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>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _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{__fmt, __args.__size()},
-                                _VSTD::__format_context_create(__buffer.make_output_iterator(), __args));
-  return _VSTD::move(__buffer).result();
+                                _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{__fmt, __args.__size()},
-                                _VSTD::__format_context_create(__buffer.make_output_iterator(), __args));
-  return _VSTD::move(__buffer).result();
+                                _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...)});
 }
 
if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args,
                                        _VSTD::move(__loc)));
   else {
     __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
-        _VSTD::__format_context_create(__buffer.make_output_iterator(),
+        _VSTD::__format_context_create(__buffer.__make_output_iterator(),
                                        __args, _VSTD::move(__loc)));
-    return _VSTD::move(__buffer).out();
+    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,
                              __args);

 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 locale __loc, basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
-      _VSTD::__format_context_create(__buffer.make_output_iterator(), __args, _VSTD::move(__loc)));
-  return _VSTD::move(__buffer).result();
+      _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<format_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.get(),
                                                _VSTD::make_format_args(__args...));

 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
-      _VSTD::__format_context_create(__buffer.make_output_iterator(), __args, _VSTD::move(__loc)));
-  return _VSTD::move(__buffer).result();
+      _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...)});
 }