[NFC][libc++][format] Improves naming.

[Mordante]

Summary

Based on review comments in D110499.

Depends on D110499

[ldionne]

libcxx/include/__format/buffer.h

107–108

Should we expose a public static size_t __buffer_size() method instead? Otherwise we could also drop the trailing underscore from __buffer_size_, which makes it look like a data member, and use __buffer_size directly. No strong opinion.

[Mordante]

libcxx/include/__format/buffer.h

107–108

I have a slight preference to use a static data member, I'll drop the trailing underscore.

[Mordante]

Rebased and addresses review comments.

libcxx/include/__format/buffer.h

 /// 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 size_t capacity() { return __buffer_size_; }
+
+  static constexpr size_t __buffer_size = 256 / sizeof(_CharT);
 
 private:
-  static constexpr size_t __buffer_size_ = 256 / sizeof(_CharT);
-  _CharT __buffer_[__buffer_size_];
+  _CharT __buffer_[__buffer_size];
 };
 
 /// A storage writing directly to the storage.
 ///
 /// This requires the storage to be a contiguous buffer of \a _CharT.
 /// Since the output is directly written to the underlying storage this class
 /// is just an empty class.
 template <__formatter::__char_type _CharT>

 template <class _OutIt, __formatter::__char_type _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_.capacity(), this),
-        __writer_(_VSTD::move(__out_it)) {}
+  _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)) {}
 
   _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();
public:
 
   _LIBCPP_HIDE_FROM_ABI size_t result() && {
     __output_.flush();
     return __size_;
   }
 
 private:
   __internal_storage<_CharT> __storage_;
-  __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.capacity(), 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 __n)
       : __writer_(_VSTD::move(__out_it)), __n_(_VSTD::max(_Size(0), __n)) {}
 
   _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
     if (_Size(__size_) <= __n_)
       __writer_.flush(__ptr, _VSTD::min(_Size(__size), __n_ - __size_));
     __size_ += __size;
   }
 
 protected:
   __internal_storage<_CharT> __storage_;
-  __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.capacity(), this};
+  __output_buffer<_CharT> __output_{__storage_.begin(), __storage_.__buffer_size, this};
   typename __writer_selector<_OutIt, _CharT>::type __writer_;
 
   _Size __n_;
   _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 the 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 __n)
       : __output_(_VSTD::__unwrap_iter(__out_it), __n, this), __writer_(_VSTD::move(__out_it)) {
     if (__n <= 0) [[unlikely]]
-      __output_.reset(__storage_.begin(), __storage_.capacity());
+      __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 two 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.
     // - 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 __n <= 0 the constructor already switched the buffers.
     if (__size_ == 0 && __ptr != __storage_.begin()) {
       __writer_.flush(__ptr, __size);
-      __output_.reset(__storage_.begin(), __storage_.capacity());
+      __output_.reset(__storage_.begin(), __storage_.__buffer_size);
     }
 
     __size_ += __size;
   }
 
 protected:
   __internal_storage<_CharT> __storage_;
   __output_buffer<_CharT> __output_;