[libc++][format] Disable default formatter.

[Mordante]

Summary

[format.formatter.spec]/5 lists the requirements for the default
formatter. The original implementation didn't implement this. This
implements the default formatter according to the Standard.

This adds additional test to validate the default formatter is disabled
and the required standard formatters are enabled.

While adding the tests it seems the formatters needed a constraint for the
character types they were valid for.

Implements parts of:

• P0645 Text Formatting

Depends on D115988

[Mordante]

Qualify std::nullptr_t to fix a CI error.

[Mordante]

Attempt to fix CI issues. They are due to not all headers available in all compilation modi.

[Mordante]

Adds some missing includes in the tests.

[vitaut]

LGTM

[• Quuxplusone]

Test nits. I assume the code is correct.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

68–69

Would it be useful to verify here that std::as_const(f).format(u, fc) is also OK?
(Recall our earlier discussion of how standard formatters should be const-friendly because eventually they'll be required to be constexpr-friendly. This could be tucked behind an #ifdef _LIBCPP_VER.)

82

Isn't it equally easy to

#define TEST_ENABLED_AFTER_CXX23(T, CharT) disabled<std::formatter<T, CharT>>

?

113–115

This (non-template-dependent) test seems out of place, but whatever.
As long as it's not a typo for assert_formatter_is_enabled<CharT, wchar_t>();.

250

For all of these, once the int versions are enabled, I assume you'll also need to check that the e.g. struct Widget versions are still disabled:

assert_formatter_is_disabled<std::array<Widget, 42>, CharT>();

etc.

269

assert_formatter_is_disabled<const int*, CharT>();
assert_formatter_is_disabled<c, CharT>();
assert_formatter_is_disabled<c*, CharT>();
assert_formatter_is_disabled<const c*, CharT>();
assert_formatter_is_disabled<const char*, wchar_t>();
assert_formatter_is_disabled<const char*, char8_t>();  // ?

[Mordante]

Thanks for the reviews!

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

68–69

No that's not useful since at the moment those functions aren't const and can't be const.
When the width is formatting argument its value is resolved in format and modifies the object. This obviously needs to be resolved when your LWG3636 gets accepted. But even if it doesn't get accepted that change probably is useful when implementing P2286 "Formatting ranges".

So I've already investigated how I want to resolve this. However I first like to know the final resolution for LWG3576 "Clarifying fill character in std::format". When implementing its resolution it's a good time to make sure these functions can be const.

82

That's also an option. For now I just want to explain why I've taken the current approach for disable. How I'm doing the final macro is for a later review. (Basically the current approach makes it easy to test for enabled based on the language Standard used.)

113–115

Guess some comment would be good ;-) It's intended and executes twice. This formatter converts a char to a wchar_t. It's a one of a kind and specified in the Standard. Since it's part of P0645 I wanted to keep it here.

250

Yes there can be a lot more tests. But I think you have a good point about Widget and it should still be disabled. I only prefer not to add them here. I think test_disabled is a better place.

[Mordante]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

68–69

@Quuxplusone Fun fact I just see P2286R4 already cites and assumes LWG3636 will be accepted and requires the format function to be const qualified.

[vitaut]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

269

Maybe also test volatile int* for completeness?

[Mordante]

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

269

I added these tests and some more.

[Mordante]

Addresses review comments
Adds an additional test testing the proper template default argument.

libcxx/include/__format/formatter.h

 #if _LIBCPP_STD_VER > 17
 
 // TODO FMT Remove this once we require compilers with proper C++20 support.
 // If the compiler has no concepts support, the format header will be disabled.
 // Without concepts support enable_if needs to be used and that too much effort
 // to support compilers with partial C++20 support.
 #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
-// Currently not implemented specializations throw an exception when used. This
-// does not conform to the Standard. However not all Standard defined formatters
-// have been implemented yet. Until that time the current behavior is intended.
-// TODO FMT Disable the default template.
+/// The default formatter template.
+///
+/// [format.formatter.spec]/5
+/// If F is a disabled specialization of formatter, these values are false:
+/// - is_default_constructible_v<F>,
+/// - is_copy_constructible_v<F>,
+/// - is_move_constructible_v<F>,
+/// - is_copy_assignable<F>, and
+/// - is_move_assignable<F>.
 template <class _Tp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
-  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto parse(auto& __parse_ctx)
-      -> decltype(__parse_ctx.begin()) {
-    __throw();
-  }
-
-  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto format(_Tp, auto& __ctx)
-      -> decltype(__ctx.out()) {
-    __throw();
-  }
-
-private:
-  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw() {
-    __throw_format_error("Argument type not implemented yet");
-  }
+  formatter() = delete;
+  formatter(const formatter&) = delete;
+  formatter& operator=(const formatter&) = delete;
 };
 
 namespace __format_spec {
 
 _LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative,
                                                  _Flags::_Sign __sign) {
   if (__negative)
     *__buf++ = '-';

libcxx/include/__format/formatter_bool.h

 using __formatter_bool = __formatter_integral<__parser_bool<_CharT>>;
 
 } //namespace __format_spec
 
 // [format.formatter.spec]/2.3
 // For each charT, for each cv-unqualified arithmetic type ArithmeticT other
 // than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
 
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<bool, _CharT>
     : public __format_spec::__formatter_bool<_CharT> {
   using _Base = __format_spec::__formatter_bool<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto format(bool __value, auto& __ctx)
       -> decltype(__ctx.out()) {
     if (this->__type != __format_spec::_Flags::_Type::__string)
       return _Base::format(static_cast<unsigned char>(__value), __ctx);

libcxx/include/__format/formatter_integer.h

 
 } // namespace __format_spec
 
 // [format.formatter.spec]/2.3
 // For each charT, for each cv-unqualified arithmetic type ArithmeticT other
 // than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
 
 // Signed integral types.
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<signed char, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<short, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<int, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<long long, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
 #ifndef _LIBCPP_HAS_NO_INT128
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<__int128_t, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {
   using _Base = __format_spec::__formatter_integer<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto format(__int128_t __value, auto& __ctx)
       -> decltype(__ctx.out()) {
     // TODO FMT Implement full 128 bit support.
     using _To = long long;
     if (__value < numeric_limits<_To>::min() ||
         __value > numeric_limits<_To>::max())
       __throw_format_error("128-bit value is outside of implemented range");
 
     return _Base::format(static_cast<_To>(__value), __ctx);
   }
 };
 #endif
 
 // Unsigned integral types.
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<unsigned char, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<unsigned short, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<unsigned, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<unsigned long, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<unsigned long long, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {};
 #ifndef _LIBCPP_HAS_NO_INT128
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<__uint128_t, _CharT>
     : public __format_spec::__formatter_integer<_CharT> {
   using _Base = __format_spec::__formatter_integer<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto format(__uint128_t __value, auto& __ctx)
       -> decltype(__ctx.out()) {
     // TODO FMT Implement full 128 bit support.

libcxx/include/__format/formatter_string.h

public:
   }
 };
 
 } //namespace __format_spec
 
 // [format.formatter.spec]/2.2 For each charT, the string type specializations
 
 // Formatter const char*.
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<const _CharT*, _CharT>
     : public __format_spec::__formatter_string<_CharT> {
   using _Base = __format_spec::__formatter_string<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx)
       -> decltype(__ctx.out()) {
     _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
_LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx)
     auto __out_it = __ctx.out();
     while (*__str)
       *__out_it++ = *__str++;
     return __out_it;
   }
 };
 
 // Formatter char*.
-template <class _CharT>
+template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<_CharT*, _CharT> : public formatter<const _CharT*, _CharT> {
   using _Base = formatter<const _CharT*, _CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx)
       -> decltype(__ctx.out()) {
     return _Base::format(__str, __ctx);
   }
 };
 
 // Formatter const char[].
-template <class _CharT, size_t _Size>
+template <__formatter::__char_type _CharT, size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<const _CharT[_Size], _CharT>
     : public __format_spec::__formatter_string<_CharT> {
   using _Base = __format_spec::__formatter_string<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx)
       -> decltype(__ctx.out()) {
     return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx);
   }
 };
 
 // Formatter std::string.
-template <class _CharT, class _Traits, class _Allocator>
+template <__formatter::__char_type _CharT, class _Traits, class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
     : public __format_spec::__formatter_string<_CharT> {
   using _Base = __format_spec::__formatter_string<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto
   format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx)
       -> decltype(__ctx.out()) {
     // drop _Traits and _Allocator
     return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
   }
 };
 
 // Formatter std::string_view.
-template <class _CharT, class _Traits>
+template <__formatter::__char_type _CharT, class _Traits>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<basic_string_view<_CharT, _Traits>, _CharT>
     : public __format_spec::__formatter_string<_CharT> {
   using _Base = __format_spec::__formatter_string<_CharT>;
 
   _LIBCPP_HIDE_FROM_ABI auto
   format(basic_string_view<_CharT, _Traits> __str, auto& __ctx)
       -> decltype(__ctx.out()) {
     // drop _Traits

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-no-concepts
+// 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>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#  include <filesystem>
+#endif
+#include <format>
+#include <forward_list>
+#include <list>
+#include <memory>
+#include <map>
+#include <optional>
+#include <queue>
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  include <regex>
+#endif
+#include <set>
+#include <stack>
+#include <span>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <thread>
+#endif
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+#include <variant>
+
+#include "test_macros.h"
+
+// 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<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 _LIBCPP_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 _LIBCPP_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() {
+  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_disabled<std::chrono::day, CharT>();
+  assert_formatter_is_disabled<std::chrono::month, CharT>();
+  assert_formatter_is_disabled<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>();
+}
+
+// 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 _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+  assert_formatter_is_disabled<std::filesystem::path, CharT>();
+#endif
+  assert_formatter_is_disabled<std::shared_ptr<int>, CharT>();
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  assert_formatter_is_disabled<std::sub_match<CharT*>, CharT>();
+#endif
+#ifndef _LIBCPP_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>();
+}