[libc++][format] Implements formattable concept.

[Mordante]

Summary

This concept is introduced in P2286, but was implemented in libc++
before. This implementation was used in the library internally. This
implementation lacked the resolution of LWG3636. The original formatter
had a non-const member function that wasn't trivial to make a const
member. The recent parser improvements made this member a const member
in preparation of LWG3636.

Note LWG3636 isn't voted in. Its status is Ready. P2286's concept has
been written as-if LWG3636 is accepted and refers to that LWG issue.

Updates some tests make format a const member function and removes a
tests that's mainly a duplicate of the formattable concept test.

Implements

• LWG3636 formatter<T>::format should be const-qualified

Implements parts of

• P2286R8 Formatting Ranges

[ldionne]

libcxx/docs/Status/Cxx2bIssues.csv

184

Commit message typo:

has be written as-if LWG3636 is accepted and refers to that LWG issue.

should be

has been written as-if LWG3636 is accepted and refers to that LWG issue.

libcxx/test/std/utilities/format/format.formattable/concept.formattable.compile.pass.cpp

8–9

As a general rule, we only test public APIs. If there's a problem with __formattable in C++20, we should have a C++20 test using public facing APIs that fails.

54–58

[Mordante]

Rebased and addresses review comments.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3705 <https://wg21.link/LWG3705>`__","Hashability shouldn't depend on basic_string's allocator","July 2022","|Complete|","16.0"
 "`3707 <https://wg21.link/LWG3707>`__","chunk_view::outer-iterator::value_type::size should return unsigned type","July 2022","","","|ranges|"
 "`3708 <https://wg21.link/LWG3708>`__","``take_while_view::sentinel``'s conversion constructor should move","July 2022","","","|ranges|"
 "`3709 <https://wg21.link/LWG3709>`__","LWG-3703 was underly ambitious","July 2022","",""
 "`3710 <https://wg21.link/LWG3710>`__","The ``end`` of ``chunk_view`` for input ranges can be ``const``","July 2022","","","|ranges|"
 "`3711 <https://wg21.link/LWG3711>`__","Missing preconditions for slide_view constructor","July 2022","","","|ranges|"
 "`3712 <https://wg21.link/LWG3712>`__","``chunk_view`` and ``slide_view`` should not be ``default_initializable``","July 2022","","","|ranges|"
 "`3713 <https://wg21.link/LWG3713>`__","Sorted with respect to comparator (only)","July 2022","",""
 "`3715 <https://wg21.link/LWG3715>`__","``view_interface::empty`` is overconstrained","July 2022","",""
 "`3719 <https://wg21.link/LWG3719>`__","Directory iterators should be usable with default sentinel","July 2022","",""
 "`3721 <https://wg21.link/LWG3721>`__","Allow an ``arg-id`` with a value of zero for ``width`` in ``std-format-spec``","July 2022","|Complete|","16.0","|format|"
 "`3724 <https://wg21.link/LWG3724>`__","``decay-copy`` should be constrained","July 2022","|Complete|","14.0"
 "","","","",""
 "`3629 <https://wg21.link/LWG3629>`__","``make_error_code`` and ``make_error_condition`` are customization points","Not voted in","|Complete|","16.0",""
 "`3631 <https://wg21.link/LWG3631>`__","``basic_format_arg(T&&)`` should use ``remove_cvref_t<T>`` throughout","Not voted in","|Complete|","15.0",""
 "`3645 <https://wg21.link/LWG3645>`__","``resize_and_overwrite`` is overspecified to call its callback with lvalues","Not voted in","|Complete|","14.0",""
+"`3636 <https://wg21.link/LWG3636>`__","``formatter<T>::format`` should be ``const``-qualified","Not voted in","|Complete|","16.0",""
 "","","","",""

libcxx/docs/Status/FormatPaper.csv

 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_day_last``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_weekday``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::year_month_weekday_last``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::hh_mm_ss<duration<Rep, Period>>``",,Mark de Wever,|In Progress|,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::sys_info``",A ``<chrono>`` implementation,Not assigned,,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::local_info``",A ``<chrono>`` implementation,Not assigned,,
 `[time.syn] <https://wg21.link/time.syn>`_,"Formatter ``chrono::zoned_time<Duration, TimeZonePtr>``",A ``<chrono>`` implementation,Not assigned,,
 `P2286R8 <https://wg21.link/P2286R8>`__,"Formatting ranges"
-`[format.syn] <https://wg21.link/format.syn>`_,"Concept ``formattable``",,Mark de Wever,|In Progress|,
+`[format.syn] <https://wg21.link/format.syn>`_,"Concept ``formattable``",,Mark de Wever,|Complete|, Clang 16
 `[format.string.std] <https://wg21.link/format.string.std>`_,"std-format-spec ``type`` debug",,Mark de Wever,|In Progress|,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: sequences",,Mark de Wever,|In Progress|,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: associative",,Mark de Wever,,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: container adaptors",,Mark de Wever,,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: ``pair`` and ``tuple``",,Mark de Wever,|In Progress|,
 `[format.range] <https://wg21.link/format.range>`_,"Formatting for ranges: ``vector<bool>``",,Mark de Wever,,

libcxx/include/__format/concepts.h

 
 // The output iterator isn't specified. A formatter should accept any
 // output_iterator. This iterator is a minimal iterator to test the concept.
 // (Note testing for (w)format_context would be a valid choice, but requires
 // selecting the proper one depending on the type of _CharT.)
 template <class _CharT>
 using __fmt_iter_for = _CharT*;
 
-// The concept is based on P2286R6
-// It lacks the const of __cf as required by, the not yet accepted, LWG-3636.
-// The current formatters can't be easily adapted, but that is WIP.
-// TODO FMT properly implement this concepts once accepted.
 template <class _Tp, class _CharT>
-concept __formattable = (semiregular<formatter<remove_cvref_t<_Tp>, _CharT>>) &&
-                        requires(formatter<remove_cvref_t<_Tp>, _CharT> __f,
-                                 formatter<remove_cvref_t<_Tp>, _CharT> __cf, _Tp __t,
-                                 basic_format_context<__fmt_iter_for<_CharT>, _CharT> __fc,
-                                 basic_format_parse_context<_CharT> __pc) {
-                          { __f.parse(__pc) } -> same_as<typename basic_format_parse_context<_CharT>::iterator>;
-                          { __cf.format(__t, __fc) } -> same_as<__fmt_iter_for<_CharT>>;
-                        };
+concept __formattable =
+    (semiregular<formatter<remove_cvref_t<_Tp>, _CharT>>) &&
+             const formatter<remove_cvref_t<_Tp>, _CharT> __cf,
+             _Tp __t,
 
+#  if _LIBCPP_STD_VER > 20
+template <class _Tp, class _CharT>
+concept formattable = __formattable<_Tp, _CharT>;
+#  endif //_LIBCPP_STD_VER > 20
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_CONCEPTS_H

libcxx/test/std/utilities/format/format.formattable/concept.formattable.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
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
-// TODO FMT Move to std after P2286 has been accepted.
-
 // <format>
 
 // template<class T, class charT>
 // concept formattable = ...
 
 #include <array>
 #include <bitset>
 #include <bitset>

 #  include <regex>
 #endif
 #ifndef TEST_HAS_NO_THREADS
 #  include <thread>
 #endif
 
 template <class T, class CharT>
 void assert_is_not_formattable() {
-  static_assert(!std::__formattable<T, CharT>);
+  static_assert(!std::formattable<T, CharT>);
 }
 
 template <class T, class CharT>
 void assert_is_formattable() {
   // Only formatters for CharT == char || CharT == wchar_t are enabled for the
   // standard formatters. When CharT is a different type the formatter should
   // be disabled.
   if constexpr (std::same_as<CharT, char>
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
                 || std::same_as<CharT, wchar_t>
 #endif
   )
-    static_assert(std::__formattable<T, CharT>);
+    static_assert(std::formattable<T, CharT>);
   else
     assert_is_not_formattable<T, CharT>();
 }
 
 // Tests for P0645 Text Formatting
 template <class CharT>
 void test_P0645() {
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.handle.pass.cpp

 #include "test_format_context.h"
 #include "test_macros.h"
 
 enum class color { black, red, gold };
 const char* color_names[] = {"black", "red", "gold"};
 
 template <>
 struct std::formatter<color> : std::formatter<const char*> {
-  auto format(color c, auto& ctx) { return formatter<const char*>::format(color_names[static_cast<int>(c)], ctx); }
+  auto format(color c, auto& ctx) const {
+    return formatter<const char*>::format(color_names[static_cast<int>(c)], ctx);
+  }
 };
 
 void test(std::string expected, std::string_view fmt, color arg) {
   auto parse_ctx = std::format_parse_context(fmt);
   std::formatter<color, char> formatter;
   static_assert(std::semiregular<decltype(formatter)>);
 
   auto it = formatter.parse(parse_ctx);

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/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
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// template <class _Tp, class _CharT = char>
-// struct formatter;
-
-// Tests the enabled and disabled requirements for std::formatter.
-
-#include <array>
-#include <bitset>
-#include <bitset>
-#include <chrono>
-#include <complex>
-#include <concepts>
-#include <deque>
-#include <format>
-#include <forward_list>
-#include <list>
-#include <memory>
-#include <map>
-#include <optional>
-#include <queue>
-#include <set>
-#include <stack>
-#include <span>
-#include <tuple>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <valarray>
-#include <variant>
-
-#include "test_macros.h"
-
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
-#  include <filesystem>
-#endif
-#ifndef TEST_HAS_NO_LOCALIZATION
-#  include <regex>
-#endif
-#ifndef TEST_HAS_NO_THREADS
-#  include <thread>
-#endif
-
-// Validate default template argument.
-static_assert(std::same_as<std::formatter<int>, std::formatter<int, char>>);
-
-// Concept for an enabled formatter.
-//
-// Since it's not possible to extract the T and CharT types from the formatter
-// they are specified and the proper formatter is always intended to be
-// defaulted.
-//
-// [formatter.requirements]/2
-// A type F meets the Formatter requirements if it meets the BasicFormatter
-// requirements and the expressions shown in Table 71 are valid and have the
-// indicated semantics.
-template <class T, class CharT, class F = std::formatter<T, CharT>>
-concept enabled =
-    // The basic BasicFormatter requirements:
-    std::default_initializable<F> && std::copyable<F> && std::destructible<F> && std::swappable<F> &&
-    // The expressions shown in Table 71
-    requires(F f, std::basic_format_parse_context<CharT> pc, T u, std::basic_format_context<CharT*, CharT> fc) {
-  { f.parse(pc) } -> std::same_as<typename decltype(pc)::iterator>;
-  { f.format(u, fc) } -> std::same_as<typename decltype(fc)::iterator>;
-};
-
-// Concept for a disabled formatter.
-//
-// This uses the same template arguments as enable. This isn't required since
-// the concept doesn't need to inspect T and CharT. This makes it easier for
-// future changes. For example P2286 formatting ranges intents to change
-// std::formatter<std::vector<int>> from disabled to enabled. The current way
-// makes it easy to define a macro like
-// #if TEST_STD_VER > 23
-//   TEST_ENABLED_AFTER_CXX23(T, CharT) enabled<T, CharT>
-// #else
-//   TEST_ENABLED_AFTER_CXX23(T, CharT) disabled<T, CharT>
-// #endif
-template <class T, class CharT, class F = std::formatter<T, CharT>>
-// [formatter.requirements]/5
-// If F is a disabled specialization of formatter, these values are false:
-concept disabled = !std::is_default_constructible_v<F> && !std::is_copy_constructible_v<F> &&
-                   !std::is_move_constructible_v<F> && !std::is_copy_assignable_v<F> && !std::is_move_assignable_v<F>;
-
-template <class T, class CharT>
-void assert_formatter_is_disabled() {
-  static_assert(disabled<T, CharT>);
-}
-
-template <class T, class CharT>
-void assert_formatter_is_enabled() {
-  // Only formatters for CharT == char || CharT == wchar_t are enabled for the
-  // standard formatters. When CharT is a different type the formatter should
-  // be disabled.
-  if constexpr (std::same_as<CharT, char>
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-                || std::same_as<CharT, wchar_t>
-#endif
-  )
-    static_assert(enabled<T, CharT>);
-  else
-    assert_formatter_is_disabled<T, CharT>();
-}
-
-// Tests for P0645 Text Formatting
-template <class CharT>
-void test_P0645() {
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  // Tests the special formatter that converts a char to a wchar_t.
-  assert_formatter_is_enabled<char, wchar_t>();
-#endif
-  assert_formatter_is_enabled<CharT, CharT>();
-
-  assert_formatter_is_enabled<CharT*, CharT>();
-  assert_formatter_is_enabled<const CharT*, CharT>();
-  assert_formatter_is_enabled<CharT[42], CharT>();
-  assert_formatter_is_enabled<const CharT[42], CharT>();
-  assert_formatter_is_enabled<std::basic_string<CharT>, CharT>();
-  assert_formatter_is_enabled<std::basic_string_view<CharT>, CharT>();
-
-  assert_formatter_is_enabled<bool, CharT>();
-
-  assert_formatter_is_enabled<signed char, CharT>();
-  assert_formatter_is_enabled<signed short, CharT>();
-  assert_formatter_is_enabled<signed int, CharT>();
-  assert_formatter_is_enabled<signed long, CharT>();
-  assert_formatter_is_enabled<signed long long, CharT>();
-#ifndef TEST_HAS_NO_INT128
-  assert_formatter_is_enabled<__int128_t, CharT>();
-#endif
-
-  assert_formatter_is_enabled<unsigned char, CharT>();
-  assert_formatter_is_enabled<unsigned short, CharT>();
-  assert_formatter_is_enabled<unsigned int, CharT>();
-  assert_formatter_is_enabled<unsigned long, CharT>();
-  assert_formatter_is_enabled<unsigned long long, CharT>();
-#ifndef TEST_HAS_NO_INT128
-  assert_formatter_is_enabled<__uint128_t, CharT>();
-#endif
-
-  assert_formatter_is_enabled<float, CharT>();
-  assert_formatter_is_enabled<double, CharT>();
-  assert_formatter_is_enabled<long double, CharT>();
-
-  assert_formatter_is_enabled<std::nullptr_t, CharT>();
-  assert_formatter_is_enabled<void*, CharT>();
-  assert_formatter_is_enabled<const void*, CharT>();
-}
-
-// Tests for P1361 Integration of chrono with text formatting
-//
-// Some tests are commented out since these types haven't been implemented in
-// chrono yet. After P1361 has been implemented these formatters should be all
-// enabled.
-template <class CharT>
-void test_P1361() {
-// The chrono formatters require localization support.
-// [time.format]/7
-//   If the chrono-specs is omitted, the chrono object is formatted as if by
-//   streaming it to std::ostringstream os with the formatting
-//   locale imbued and copying os.str() through the output iterator of the
-//   context with additional padding and adjustments as specified by the format
-//   specifiers.
-// In libc++ std:::ostringstream requires localization support.
-#ifndef TEST_HAS_NO_LOCALIZATION
-
-  assert_formatter_is_disabled<std::chrono::microseconds, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
-  //assert_formatter_is_enabled<std::chrono::utc_time<std::chrono::microseconds>, CharT>();
-  //assert_formatter_is_enabled<std::chrono::tai_time<std::chrono::microseconds>, CharT>();
-  //assert_formatter_is_enabled<std::chrono::gps_time<std::chrono::microseconds>, CharT>();
-  assert_formatter_is_disabled<std::chrono::file_time<std::chrono::microseconds>, CharT>();
-  assert_formatter_is_disabled<std::chrono::local_time<std::chrono::microseconds>, CharT>();
-
-  assert_formatter_is_enabled<std::chrono::day, CharT>();
-  assert_formatter_is_enabled<std::chrono::month, CharT>();
-  assert_formatter_is_enabled<std::chrono::year, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::weekday, CharT>();
-  assert_formatter_is_disabled<std::chrono::weekday_indexed, CharT>();
-  assert_formatter_is_disabled<std::chrono::weekday_last, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::month_day, CharT>();
-  assert_formatter_is_disabled<std::chrono::month_day_last, CharT>();
-  assert_formatter_is_disabled<std::chrono::month_weekday, CharT>();
-  assert_formatter_is_disabled<std::chrono::month_weekday_last, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::year_month, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_day, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_day_last, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_weekday, CharT>();
-  assert_formatter_is_disabled<std::chrono::year_month_weekday_last, CharT>();
-
-  assert_formatter_is_disabled<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
-
-  //assert_formatter_is_enabled<std::chrono::sys_info, CharT>();
-  //assert_formatter_is_enabled<std::chrono::local_info, CharT>();
-
-  //assert_formatter_is_enabled<std::chrono::zoned_time, CharT>();
-
-#endif // TEST_HAS_NO_LOCALIZATION
-}
-
-// Tests for P1636 Formatters for library types
-//
-// The paper hasn't been voted in so currently all formatters are disabled.
-// TODO validate whether the test is correct after the paper has been accepted.
-template <class CharT>
-void test_P1636() {
-  assert_formatter_is_disabled<std::basic_streambuf<CharT>, CharT>();
-  assert_formatter_is_disabled<std::bitset<42>, CharT>();
-  assert_formatter_is_disabled<std::complex<double>, CharT>();
-  assert_formatter_is_disabled<std::error_code, CharT>();
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
-  assert_formatter_is_disabled<std::filesystem::path, CharT>();
-#endif
-  assert_formatter_is_disabled<std::shared_ptr<int>, CharT>();
-#ifndef TEST_HAS_NO_LOCALIZATION
-  assert_formatter_is_disabled<std::sub_match<CharT*>, CharT>();
-#endif
-#ifndef TEST_HAS_NO_THREADS
-  assert_formatter_is_disabled<std::thread::id, CharT>();
-#endif
-  assert_formatter_is_disabled<std::unique_ptr<int>, CharT>();
-}
-
-// Tests for P2286 Formatting ranges
-//
-// The paper hasn't been voted in so currently all formatters are disabled.
-// TODO validate whether the test is correct after the paper has been accepted.
-template <class CharT>
-void test_P2286() {
-  assert_formatter_is_disabled<std::array<int, 42>, CharT>();
-  assert_formatter_is_disabled<std::vector<int>, CharT>();
-  assert_formatter_is_disabled<std::deque<int>, CharT>();
-  assert_formatter_is_disabled<std::forward_list<int>, CharT>();
-  assert_formatter_is_disabled<std::list<int>, CharT>();
-
-  assert_formatter_is_disabled<std::set<int>, CharT>();
-  assert_formatter_is_disabled<std::map<int, int>, CharT>();
-  assert_formatter_is_disabled<std::multiset<int>, CharT>();
-  assert_formatter_is_disabled<std::multimap<int, int>, CharT>();
-
-  assert_formatter_is_disabled<std::unordered_set<int>, CharT>();
-  assert_formatter_is_disabled<std::unordered_map<int, int>, CharT>();
-  assert_formatter_is_disabled<std::unordered_multiset<int>, CharT>();
-  assert_formatter_is_disabled<std::unordered_multimap<int, int>, CharT>();
-
-  assert_formatter_is_disabled<std::stack<int>, CharT>();
-  assert_formatter_is_disabled<std::queue<int>, CharT>();
-  assert_formatter_is_disabled<std::priority_queue<int>, CharT>();
-
-  assert_formatter_is_disabled<std::span<int>, CharT>();
-
-  assert_formatter_is_disabled<std::valarray<int>, CharT>();
-
-  assert_formatter_is_disabled<std::pair<int, int>, CharT>();
-  assert_formatter_is_disabled<std::tuple<int>, CharT>();
-}
-
-class c {
-  void f();
-  void fc() const;
-  static void sf();
-};
-enum e { a };
-enum class ec { a };
-template <class CharT>
-void test_disabled() {
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  assert_formatter_is_disabled<const char*, wchar_t>();
-#endif
-  assert_formatter_is_disabled<const char*, char8_t>();
-  assert_formatter_is_disabled<const char*, char16_t>();
-  assert_formatter_is_disabled<const char*, char32_t>();
-
-  assert_formatter_is_disabled<c, CharT>();
-  assert_formatter_is_disabled<const c, CharT>();
-  assert_formatter_is_disabled<volatile c, CharT>();
-  assert_formatter_is_disabled<const volatile c, CharT>();
-
-  assert_formatter_is_disabled<e, CharT>();
-  assert_formatter_is_disabled<const e, CharT>();
-  assert_formatter_is_disabled<volatile e, CharT>();
-  assert_formatter_is_disabled<const volatile e, CharT>();
-
-  assert_formatter_is_disabled<ec, CharT>();
-  assert_formatter_is_disabled<const ec, CharT>();
-  assert_formatter_is_disabled<volatile ec, CharT>();
-  assert_formatter_is_disabled<const volatile ec, CharT>();
-
-  assert_formatter_is_disabled<int*, CharT>();
-  assert_formatter_is_disabled<const int*, CharT>();
-  assert_formatter_is_disabled<volatile int*, CharT>();
-  assert_formatter_is_disabled<const volatile int*, CharT>();
-
-  assert_formatter_is_disabled<c*, CharT>();
-  assert_formatter_is_disabled<const c*, CharT>();
-  assert_formatter_is_disabled<volatile c*, CharT>();
-  assert_formatter_is_disabled<const volatile c*, CharT>();
-
-  assert_formatter_is_disabled<e*, CharT>();
-  assert_formatter_is_disabled<const e*, CharT>();
-  assert_formatter_is_disabled<volatile e*, CharT>();
-  assert_formatter_is_disabled<const volatile e*, CharT>();
-
-  assert_formatter_is_disabled<ec*, CharT>();
-  assert_formatter_is_disabled<const ec*, CharT>();
-  assert_formatter_is_disabled<volatile ec*, CharT>();
-  assert_formatter_is_disabled<const volatile ec*, CharT>();
-
-  assert_formatter_is_disabled<void (*)(), CharT>();
-  assert_formatter_is_disabled<void (c::*)(), CharT>();
-  assert_formatter_is_disabled<void (c::*)() const, CharT>();
-
-  assert_formatter_is_disabled<std::optional<int>, CharT>();
-  assert_formatter_is_disabled<std::variant<int>, CharT>();
-
-  assert_formatter_is_disabled<std::shared_ptr<c>, CharT>();
-  assert_formatter_is_disabled<std::unique_ptr<c>, CharT>();
-
-  assert_formatter_is_disabled<std::array<c, 42>, CharT>();
-  assert_formatter_is_disabled<std::vector<c>, CharT>();
-  assert_formatter_is_disabled<std::deque<c>, CharT>();
-  assert_formatter_is_disabled<std::forward_list<c>, CharT>();
-  assert_formatter_is_disabled<std::list<c>, CharT>();
-
-  assert_formatter_is_disabled<std::set<c>, CharT>();
-  assert_formatter_is_disabled<std::map<c, int>, CharT>();
-  assert_formatter_is_disabled<std::multiset<c>, CharT>();
-  assert_formatter_is_disabled<std::multimap<c, int>, CharT>();
-
-  assert_formatter_is_disabled<std::unordered_set<c>, CharT>();
-  assert_formatter_is_disabled<std::unordered_map<c, int>, CharT>();
-  assert_formatter_is_disabled<std::unordered_multiset<c>, CharT>();
-  assert_formatter_is_disabled<std::unordered_multimap<c, int>, CharT>();
-
-  assert_formatter_is_disabled<std::stack<c>, CharT>();
-  assert_formatter_is_disabled<std::queue<c>, CharT>();
-  assert_formatter_is_disabled<std::priority_queue<c>, CharT>();
-
-  assert_formatter_is_disabled<std::span<c>, CharT>();
-
-  assert_formatter_is_disabled<std::valarray<c>, CharT>();
-
-  assert_formatter_is_disabled<std::pair<c, int>, CharT>();
-  assert_formatter_is_disabled<std::tuple<c>, CharT>();
-
-  assert_formatter_is_disabled<std::optional<c>, CharT>();
-  assert_formatter_is_disabled<std::variant<c>, CharT>();
-}
-
-template <class CharT>
-void test() {
-  test_P0645<CharT>();
-  test_P1361<CharT>();
-  test_P1636<CharT>();
-  test_P2286<CharT>();
-  test_disabled<CharT>();
-}
-
-void test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-  test<char8_t>();
-  test<char16_t>();
-  test<char32_t>();
-
-  test<int>();
-}

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

 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <locale>
 #endif
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 struct std::formatter<MoveOnly, CharT> : std::formatter<int, CharT> {
-  // TODO FMT Make this a const member function after the base class has been adapted.
-  auto format(const MoveOnly& m, auto& ctx) -> decltype(ctx.out()) {
+  auto format(const MoveOnly& m, auto& ctx) const -> decltype(ctx.out()) {
     return std::formatter<int, CharT>::format(m.get(), ctx);
   }
 };
 
 template <class CharT>
 static void test() {
   MoveOnly m{10};
   CharT buffer[10];

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

constexpr auto parse(basic_format_parse_context<CharT>& parse_ctx) -> decltype(parse_ctx.begin()) {
     ++begin;
     if (begin != end && *begin != CharT('}'))
       throw_format_error("The format-spec should consume the input or end with a '}'");
 
     return begin;
   }
 
   template <class Out>
-  auto format(status s, basic_format_context<Out, CharT>& ctx) -> decltype(ctx.out()) {
+  auto format(status s, basic_format_context<Out, CharT>& ctx) const -> decltype(ctx.out()) {
     const char* names[] = {"foo", "bar", "foobar"};
     char buffer[7];
     const char* begin = names[0];
     const char* end = names[0];
     switch (type) {
     case 0:
       begin = buffer;
       buffer[0] = '0';