[libc++][format] Adds range-default-formatter.

[Mordante]

Summary

This adds an incomplete version where the specializations for the
format_kinds are disabled dummy formatters.

Implements part of

• P2585R0 Improving default container formatting

[Mordante]

Remove copy pasted non-ASCII

[Mordante]

Try to fix CI.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes

[Mordante]

Rebased and CI fix

[Mordante]

Rebase and CI fixes.

[Mordante]

CI fixes.

[Mordante]

Attempt to fix CI

[Mordante]

Try to fix CI.

[Mordante]

Rebased and add a link to an LWG issue.

[Mordante]

CI fixes.

[vitaut]

libcxx/include/__format/concepts.h

63–66

We definitely don't want to use the concept from P2165 because it includes array (maybe clarify this in the comment). The naming they took is very unfortunate but at least it's exposition-only.

68–70

This is actually not tuple-like but pair-like so I suggest renaming to __fmt_pair_like.

libcxx/include/__format/range_default_formatter.h

40–41

What does this shadow?

58

nit: __get_format_format looks a bit repetitive, maybe rename to __get_range_format (since it only applies to ranges) or something else?

libcxx/include/__type_traits/is_specialization.h

36–40

This is not related to formatting and should probably be split into a separate diff.

[Mordante]

Thanks for the review!

libcxx/include/__format/concepts.h

63–66

Correct, I added comment to avoid possible confusion between the two concepts.

68–70

Good point!

libcxx/include/__format/range_default_formatter.h

40–41

set, map and string. Not all of them now, but they will once the other specializations are implemented. Since it raises questions I've added a comment.

58

Good catch, it should have been __get_range_format in the first place.

libcxx/include/__type_traits/is_specialization.h

36–40

I will do that before committing. Adding the trait without a use-case also looks odd.

[Mordante]

Addresses review comments.

[ldionne]

Looks pretty good to me, just a few comments.

libcxx/include/__format/concepts.h

63

Thanks for adding this comment! I would suggest linking to the section of the standard that defines that concept instead of the paper.

68–70

Can you make sure to have a test that would fail if we were using the concept from P2165?

libcxx/include/__format/range_default_formatter.h

55–56

If that works, that would be a bit nicer and it would remove the need for the additional type + comment.

65

Can you ensure that you have a test with a range where the reference type is the same as the range, without depending on filesystem? You should also keep your current test for filesystem::path.

84

FWIW I wouldn't mind if you used an immediately-invoked lambda expression here. Not a request, just a suggestion.

86–93

After consideration, I'm fine with this. I'd much rather remove the offending formatter but let's wait for the LWG issue resolution before we do that.

99

libcxx/test/libcxx/type_traits/is_specialization.compile.pass.cpp

46

[Mordante]

Thanks for the review!

libcxx/include/__format/concepts.h

68–70

As discussed I added a TODO for that.

libcxx/include/__format/range_default_formatter.h

55–56

This works. Thanks for the suggestion!
(I changed the type back to range_format to avoid another error.)

65

I added a test to libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp.

libcxx/include/__type_traits/is_specialization.h

36–40

I discussed with @ldionne and he likes to do it in the same commit.

[Mordante]

Rebased and address review comments.
Make sure the CI still passes.

[Mordante]

CI fixes.

libcxx/include/CMakeLists.txt

set(files
   __format/formatter_char.h
   __format/formatter_floating_point.h
   __format/formatter_integer.h
   __format/formatter_integral.h
   __format/formatter_output.h
   __format/formatter_pointer.h
   __format/formatter_string.h
   __format/parser_std_format_spec.h
+  __format/range_default_formatter.h
   __format/unicode.h
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind.h
   __functional/bind_back.h
   __functional/bind_front.h
   __functional/binder1st.h
   __functional/binder2nd.h
set(files
   __type_traits/is_reference.h
   __type_traits/is_reference_wrapper.h
   __type_traits/is_referenceable.h
   __type_traits/is_same.h
   __type_traits/is_scalar.h
   __type_traits/is_scoped_enum.h
   __type_traits/is_signed.h
   __type_traits/is_signed_integer.h
+  __type_traits/is_specialization.h
   __type_traits/is_standard_layout.h
   __type_traits/is_swappable.h
   __type_traits/is_trivial.h
   __type_traits/is_trivially_assignable.h
   __type_traits/is_trivially_constructible.h
   __type_traits/is_trivially_copy_assignable.h
   __type_traits/is_trivially_copy_constructible.h
   __type_traits/is_trivially_copyable.h

libcxx/include/__format/concepts.h

 #ifndef _LIBCPP___FORMAT_CONCEPTS_H
 #define _LIBCPP___FORMAT_CONCEPTS_H
 
 #include <__concepts/same_as.h>
 #include <__concepts/semiregular.h>
 #include <__config>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
+#include <__type_traits/is_specialization.h>
+#include <__utility/pair.h>
+#include <tuple>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
requires(formatter<remove_cvref_t<_Tp>, _CharT> __f,
              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>>;
     };
 
 #  if _LIBCPP_STD_VER > 20
 template <class _Tp, class _CharT>
 concept formattable = __formattable<_Tp, _CharT>;
+
+// The paper P2165 "Compatibility between tuple, pair and tuple-like objects"
+// has a "tuple-like" concept, but that is not the same as this concept. That
+// paper doesn't affect the format header. Therefore use a different name for
+// the concept.
+template <class _Tp>
+concept __fmt_tuple_like = __is_specialization_v<_Tp, pair> ||
+                           // Use a requires since tuple_size_v may fail to instantiate,
+                           (__is_specialization_v<_Tp, tuple> && requires { tuple_size_v<_Tp> == 2; });
+
 #  endif //_LIBCPP_STD_VER > 20
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_CONCEPTS_H

libcxx/include/__format/range_default_formatter.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
+#define _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#include <__availability>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__format/concepts.h>
+#include <__format/formatter.h>
+#include <__ranges/concepts.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/pair.h>
+#include <tuple>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 20
+
+template <class _Rp, class _CharT>
+concept __const_formattable_range =
+    ranges::input_range<const _Rp> && formattable<ranges::range_reference_t<const _Rp>, _CharT>;
+
+template <class _Rp, class _CharT>
+using __fmt_maybe_const = conditional_t<__const_formattable_range<_Rp, _CharT>, const _Rp, _Rp>;
+
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wshadow")
+_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wshadow")
+enum class range_format { disabled, map, set, sequence, string, debug_string };
+_LIBCPP_DIAGNOSTIC_POP
+
+// There is no definition of this struct, it's purely intended to be used to
+// generate diagnostics.
+template <class _Rp>
+struct _LIBCPP_TEMPLATE_VIS __instantiated_the_primary_template_of_format_kind;
+
+// Instantiation of the primary template is ill-formed.
+// This fails since the templated struct can't be instantiated. When the type
+// of format_kind is the templated struct it will generate two diagnostics per
+// instantiation. By using int as a type there's only one diagnostic.
+template <class _Rp>
+constexpr int format_kind = __instantiated_the_primary_template_of_format_kind<_Rp>{};
+
+template <ranges::input_range _Rp>
+consteval range_format __get_format_format() {
+  // [format.range.fmtkind]/2
+
+  // 2.1 If same_as<remove_cvref_t<ranges::range_reference_t<R>>, R> is true,
+  // Otherwise format_kind<R> is range_format::disabled.
+  if constexpr (same_as<remove_cvref_t<ranges::range_reference_t<_Rp>>, _Rp>)
+    return range_format::disabled;
+  // 2.2 Otherwise, if the qualified-id R::key_type is valid and denotes a type:
+  else if constexpr (requires { typename _Rp::key_type; }) {
+    // 2.2.1 If the qualified-id R::mapped_type is valid and denotes a type ...
+    if constexpr (requires { typename _Rp::mapped_type; } &&
+                  // 2.2.1 ... If either U is a specialization of pair or U is a specialization
+                  // of tuple and tuple_size_v<U> == 2
+                  __fmt_tuple_like<remove_cvref_t<ranges::range_reference_t<_Rp>>>)
+      return range_format::map;
+    else
+      // 2.2.2 Otherwise format_kind<R> is range_format::set.
+      return range_format::set;
+  } else
+    // 2.3 Otherwise, format_kind<R> is range_format::sequence.
+    return range_format::sequence;
+}
+
+template <ranges::input_range _Rp>
+  requires same_as<_Rp, remove_cvref_t<_Rp>>
+inline constexpr range_format format_kind<_Rp> = __get_format_format<_Rp>();
+
+// This is a non-standard work-around to fix instantiation of
+//   formatter<const _CharT[N], _CharT>
+// const _CharT[N] satisfies the ranges::input_range concept.
+// remove_cvref_t<const _CharT[N]> is _CharT[N] so it does not satisfy the
+// requirement of the above specialization. Instead it will instantiate the
+// primary template, which is ill-formed.
+//
+// An alternative solution is to remove the offending formatter.
+//
+// https://godbolt.org/z/bqjhhaexx
+template <class _CharT, size_t N>
+inline constexpr range_format format_kind<const _CharT[N]> = range_format::disabled;
+
+template <range_format _Kp, ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter;
+
+// Required specializations
+
+template <ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::sequence, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+template <ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::map, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+template <ranges::input_range _Rp, class _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<range_format::set, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+template <range_format _Kp, ranges::input_range _Rp, class _CharT>
+  requires(_Kp == range_format::string || _Kp == range_format::debug_string)
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<_Kp, _Rp, _CharT> {
+  __range_default_formatter() = delete; // TODO FMT Implement
+};
+
+// Dispatcher to select the specialization based on the type of the range.
+
+template <ranges::input_range _Rp, class _CharT>
+  requires(format_kind<_Rp> != range_format::disabled && formattable<ranges::range_reference_t<_Rp>, _CharT>)
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_Rp, _CharT>
+    : __range_default_formatter<format_kind<_Rp>, _Rp, _CharT> {};
+
+#endif //_LIBCPP_STD_VER > 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H

libcxx/include/__type_traits/is_specialization.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION
+#define _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION
+
+// This contains parts of P2098R1 but is based on MSVC STL's implementation.
+//
+// The paper has been rejected
+//   We will not pursue P2098R0 (std::is_specialization_of) at this time; we'd
+//   like to see a solution to this problem, but it requires language evolution
+//   too.
+//
+// Since it is expected a real solution will be provided in the future only the
+// minimal part is implemented.
+//
+// Note a cvref qualified _Tp is never considered a specialization.
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 14
+
+template <class _Tp, template <class...> class _Template>
+inline constexpr bool __is_specialization_v = false; // true if and only if _Tp is a specialization of _Template
+
+template <template <class...> class _Template, class... _Args>
+inline constexpr bool __is_specialization_v<_Template<_Args...>, _Template> = true;
+
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION

libcxx/include/format

namespace std {
   // [format.formatter], formatter
   template<class T, class charT = char> struct formatter;
 
   // [format.parse.ctx], class template basic_format_parse_context
   template<class charT> class basic_format_parse_context;
   using format_parse_context = basic_format_parse_context<char>;
   using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
+  // [format.range], formatting of ranges
+  // [format.range.fmtkind], variable template format_kind
+  enum class range_format {                                     // since C++23
+    disabled,
+    map,
+    set,
+    sequence,
+    string,
+    debug_string
+  };
+
+  template<class R>
+    constexpr unspecified format_kind = unspecified;            // since C++23
+
+  template<ranges::input_range R>
+      requires same_as<R, remove_cvref_t<R>>
+    constexpr range_format format_kind<R> = see below;          // since C++23
+
+  // [format.range.fmtdef], class template range-default-formatter
+  template<range_format K, ranges::input_range R, class charT>
+    struct range-default-formatter;                             // exposition only, since C++23
+
+  // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr],
+  // specializations for maps, sets, and strings
+  template<ranges::input_range R, class charT>
+    requires (format_kind<R> != range_format::disabled) &&
+             formattable<ranges::range_reference_t<R>, charT>
+  struct formatter<R, charT> : range-default-formatter<format_kind<R>, R, charT> { }; // since C++23
+
   // [format.arguments], arguments
   // [format.arg], class template basic_format_arg
   template<class Context> class basic_format_arg;
 
   template<class Visitor, class Context>
     see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
 
   // [format.arg.store], class template format-arg-store

 #include <__format/formatter.h>
 #include <__format/formatter_bool.h>
 #include <__format/formatter_char.h>
 #include <__format/formatter_floating_point.h>
 #include <__format/formatter_integer.h>
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
 #include <__format/parser_std_format_spec.h>
+#include <__format/range_default_formatter.h>
 #include <__format/unicode.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 
 #endif // _LIBCPP_FORMAT

libcxx/include/module.modulemap.in

module __format {
       module formatter_char                  { private header "__format/formatter_char.h" }
       module formatter_floating_point        { private header "__format/formatter_floating_point.h" }
       module formatter_integer               { private header "__format/formatter_integer.h" }
       module formatter_integral              { private header "__format/formatter_integral.h" }
       module formatter_output                { private header "__format/formatter_output.h" }
       module formatter_pointer               { private header "__format/formatter_pointer.h" }
       module formatter_string                { private header "__format/formatter_string.h" }
       module parser_std_format_spec          { private header "__format/parser_std_format_spec.h" }
+      module range_default_formatter         { private header "__format/range_default_formatter.h" }
       module unicode                         { private header "__format/unicode.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
module type_traits {
     module is_reference                        { private header "__type_traits/is_reference.h" }
     module is_reference_wrapper                { private header "__type_traits/is_reference_wrapper.h" }
     module is_referenceable                    { private header "__type_traits/is_referenceable.h" }
     module is_same                             { private header "__type_traits/is_same.h" }
     module is_scalar                           { private header "__type_traits/is_scalar.h" }
     module is_scoped_enum                      { private header "__type_traits/is_scoped_enum.h" }
     module is_signed                           { private header "__type_traits/is_signed.h" }
     module is_signed_integer                   { private header "__type_traits/is_signed_integer.h" }
+    module is_specialization                   { private header "__type_traits/is_specialization.h" }
     module is_standard_layout                  { private header "__type_traits/is_standard_layout.h" }
     module is_swappable                        { private header "__type_traits/is_swappable.h" }
     module is_trivial                          { private header "__type_traits/is_trivial.h" }
     module is_trivially_assignable             { private header "__type_traits/is_trivially_assignable.h" }
     module is_trivially_constructible          { private header "__type_traits/is_trivially_constructible.h" }
     module is_trivially_copy_assignable        { private header "__type_traits/is_trivially_copy_assignable.h" }
     module is_trivially_copy_constructible     { private header "__type_traits/is_trivially_copy_constructible.h" }
     module is_trivially_copyable               { private header "__type_traits/is_trivially_copyable.h" }

libcxx/include/type_traits

 #include <__type_traits/is_polymorphic.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_reference_wrapper.h>
 #include <__type_traits/is_referenceable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_scalar.h>
 #include <__type_traits/is_scoped_enum.h>
 #include <__type_traits/is_signed.h>
+#include <__type_traits/is_specialization.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivial.h>
 #include <__type_traits/is_trivially_assignable.h>
 #include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_copy_assignable.h>
 #include <__type_traits/is_trivially_copy_constructible.h>
 #include <__type_traits/is_trivially_copyable.h>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__format/formatter_char.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_char.h'}}
 #include <__format/formatter_floating_point.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_floating_point.h'}}
 #include <__format/formatter_integer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integer.h'}}
 #include <__format/formatter_integral.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integral.h'}}
 #include <__format/formatter_output.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_output.h'}}
 #include <__format/formatter_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_pointer.h'}}
 #include <__format/formatter_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_string.h'}}
 #include <__format/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__format/parser_std_format_spec.h'}}
+#include <__format/range_default_formatter.h> // expected-error@*:* {{use of private header from outside its module: '__format/range_default_formatter.h'}}
 #include <__format/unicode.h> // expected-error@*:* {{use of private header from outside its module: '__format/unicode.h'}}
 #include <__functional/binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_function.h'}}
 #include <__functional/binary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_negate.h'}}
 #include <__functional/bind.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind.h'}}
 #include <__functional/bind_back.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_back.h'}}
 #include <__functional/bind_front.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_front.h'}}
 #include <__functional/binder1st.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binder1st.h'}}
 #include <__functional/binder2nd.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binder2nd.h'}}

 #include <__type_traits/is_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_reference.h'}}
 #include <__type_traits/is_reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_reference_wrapper.h'}}
 #include <__type_traits/is_referenceable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_referenceable.h'}}
 #include <__type_traits/is_same.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_same.h'}}
 #include <__type_traits/is_scalar.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_scalar.h'}}
 #include <__type_traits/is_scoped_enum.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_scoped_enum.h'}}
 #include <__type_traits/is_signed.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_signed.h'}}
 #include <__type_traits/is_signed_integer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_signed_integer.h'}}
+#include <__type_traits/is_specialization.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_specialization.h'}}
 #include <__type_traits/is_standard_layout.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_standard_layout.h'}}
 #include <__type_traits/is_swappable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_swappable.h'}}
 #include <__type_traits/is_trivial.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivial.h'}}
 #include <__type_traits/is_trivially_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_assignable.h'}}
 #include <__type_traits/is_trivially_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_constructible.h'}}
 #include <__type_traits/is_trivially_copy_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_copy_assignable.h'}}
 #include <__type_traits/is_trivially_copy_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_copy_constructible.h'}}
 #include <__type_traits/is_trivially_copyable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_copyable.h'}}

libcxx/test/libcxx/type_traits/is_specialization.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
+
+// template <class _Tp, template <class...> class _Template>
+// inline constexpr bool __is_specialization_v = true if and only if _Tp is a specialization of _Template
+//
+// Note instantiation for certain type combinations are ill-formed. These are
+// tested in is_specialization.verify.cpp.
+
+#include <type_traits>
+
+#include <array>
+#include <concepts>
+#include <string_view>
+#include <tuple>
+#include <utility>
+
+#include "test_macros.h"
+
+// Simple types
+static_assert(std::__is_specialization_v<std::pair<int, int>, std::pair>);
+static_assert(!std::__is_specialization_v<std::pair<int, int>, std::tuple>);
+static_assert(!std::__is_specialization_v<std::pair<int, int>, std::basic_string_view>);
+
+static_assert(std::__is_specialization_v<std::tuple<int>, std::tuple>);
+static_assert(std::__is_specialization_v<std::tuple<int, float>, std::tuple>);
+static_assert(std::__is_specialization_v<std::tuple<int, float, void*>, std::tuple>);
+
+static_assert(std::__is_specialization_v<std::string_view, std::basic_string_view>);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(std::__is_specialization_v<std::wstring_view, std::basic_string_view>);
+#endif
+
+// Nested types
+static_assert(std::__is_specialization_v<std::pair<std::tuple<int>, int>, std::pair>);
+static_assert(!std::__is_specialization_v<std::pair<std::tuple<int>, int>, std::tuple>);
+
+// cvref _Tp is no specialization.
+static_assert(!std::__is_specialization_v<const std::pair<int, int>, std::pair>);
+static_assert(!std::__is_specialization_v<volatile std::pair<int, int>, std::pair>);
+static_assert(!std::__is_specialization_v<const volatile std::pair<int, int>, std::pair>);
+
+static_assert(!std::__is_specialization_v<std::pair<int, int>&, std::pair>);
+static_assert(!std::__is_specialization_v<const std::pair<int, int>&, std::pair>);
+static_assert(!std::__is_specialization_v<volatile std::pair<int, int>&, std::pair>);
+static_assert(!std::__is_specialization_v<const volatile std::pair<int, int>&, std::pair>);
+
+static_assert(!std::__is_specialization_v<std::pair<int, int>&&, std::pair>);
+static_assert(!std::__is_specialization_v<const std::pair<int, int>&&, std::pair>);
+static_assert(!std::__is_specialization_v<volatile std::pair<int, int>&&, std::pair>);
+static_assert(!std::__is_specialization_v<const volatile std::pair<int, int>&&, std::pair>);

libcxx/test/libcxx/type_traits/is_specialization.verify.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
+
+// template <class _Tp, template <class...> class _Template>
+// inline constexpr bool __is_specialization_v = true if and only if _Tp is a specialization of _Template
+//
+// Tests the ill-formed instantiations.
+
+#include <type_traits>
+
+#include <array>
+#include <utility>
+
+// expected-error@+1 {{template template argument has different template parameters than its corresponding template template parameter}}
+static_assert(!std::__is_specialization_v<std::pair<int, size_t>, std::array>);

libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// template<ranges::input_range R>
+//     requires same_as<R, remove_cvref_t<R>>
+//  constexpr range_format format_kind<R> = see below;
+
+#include <format>
+
+#include <array>
+#include <deque>
+#include <format>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <span>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#  include <filesystem>
+#endif
+
+#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(std::format_kind<std::filesystem::path> == std::range_format::disabled);
+#endif
+
+static_assert(std::format_kind<std::map<int, int>> == std::range_format::map);
+static_assert(std::format_kind<std::multimap<int, int>> == std::range_format::map);
+static_assert(std::format_kind<std::unordered_map<int, int>> == std::range_format::map);
+static_assert(std::format_kind<std::unordered_multimap<int, int>> == std::range_format::map);
+
+static_assert(std::format_kind<std::set<int>> == std::range_format::set);
+static_assert(std::format_kind<std::multiset<int>> == std::range_format::set);
+static_assert(std::format_kind<std::unordered_set<int>> == std::range_format::set);
+static_assert(std::format_kind<std::unordered_multiset<int>> == std::range_format::set);
+
+static_assert(std::format_kind<std::array<int, 1>> == std::range_format::sequence);
+static_assert(std::format_kind<std::vector<int>> == std::range_format::sequence);
+static_assert(std::format_kind<std::deque<int>> == std::range_format::sequence);
+static_assert(std::format_kind<std::forward_list<int>> == std::range_format::sequence);
+static_assert(std::format_kind<std::list<int>> == std::range_format::sequence);
+
+static_assert(std::format_kind<std::span<int>> == std::range_format::sequence);
+
+static_assert(std::format_kind<std::valarray<int>> == std::range_format::sequence);
+
+// [format.range.fmtkind]/3
+//   Remarks: Pursuant to [namespace.std], users may specialize format_kind for
+//   cv-unqualified program-defined types that model ranges::input_range. Such
+//   specializations shall be usable in constant expressions ([expr.const]) and
+//   have type const range_format.
+// Note only test the specializing, not all constraints.
+struct no_specialization : std::ranges::view_base {
+  using key_type = void;
+  int* begin() const;
+  int* end() const;
+};
+static_assert(std::format_kind<no_specialization> == std::range_format::set);
+
+// The struct's "contents" are the same as no_specialization.
+struct specialized : std::ranges::view_base {
+  using key_type = void;
+  int* begin() const;
+  int* end() const;
+};
+
+template <>
+constexpr std::range_format std::format_kind<specialized> = std::range_format::sequence;
+static_assert(std::format_kind<specialized> == std::range_format::sequence);

libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.verify.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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// template<ranges::input_range R>
+//   requires same_as<R, remove_cvref_t<R>>
+// constexpr range_format format_kind<R> = see below;
+
+#include <format>
+
+#include <array>
+#include <queue>
+#include <stack>
+#include <tuple>
+#include <utility>
+
+#include "test_macros.h"
+
+constexpr std::range_format valid = std::format_kind<std::array<int, 1>>;
+
+// TODO FMT Simplify after dropping support for Clang 14 and Clang 15
+#if defined(TEST_CLANG_VER) && TEST_CLANG_VER < 1600
+// Clang 14 and Clang 15 only errors.
+// expected-error@*:*11 {{cannot initialize a variable of type 'const std::range_format' with an lvalue of type 'const int'}}
+#endif
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<const std::array<int, 1>>}}
+constexpr std::range_format invalid_due_to_const = std::format_kind<const std::array<int, 1>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<volatile std::array<int, 1>>}}
+constexpr std::range_format invalid_due_to_volatile = std::format_kind<volatile std::array<int, 1>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::array<int, 1> &>}}
+constexpr std::range_format invalid_due_to_reference = std::format_kind<std::array<int, 1>&>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<int>}}
+constexpr std::range_format invalid_no_input_range = std::format_kind<int>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::stack<int>>}}
+constexpr std::range_format not_a_range_stack = std::format_kind<std::stack<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::queue<int>>}}
+constexpr std::range_format not_a_range_queue = std::format_kind<std::queue<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::priority_queue<int, std::vector<int>, std::less<int>>}}
+constexpr std::range_format not_a_range_priority_queue = std::format_kind<std::priority_queue<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::pair<int, int>>}}
+constexpr std::range_format not_a_range_pair = std::format_kind<std::pair<int, int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::tuple<int>>}}
+constexpr std::range_format not_a_range_tuple_1 = std::format_kind<std::tuple<int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::tuple<int, int>>}}
+constexpr std::range_format not_a_range_tuple_2 = std::format_kind<std::tuple<int, int>>;
+
+// expected-error@*:* {{std::__instantiated_the_primary_template_of_format_kind<std::tuple<int, int, int>>}}
+constexpr std::range_format not_a_range_tuple_3 = std::format_kind<std::tuple<int, int, int>>;

libcxx/test/std/utilities/format/format.range/format.range.fmtkind/range_format.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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// enum class range_format {
+//   disabled,
+//   map,
+//   set,
+//   sequence,
+//   string,
+//   debug_string
+// };
+
+#include <format>
+
+// test that the enumeration values exist
+static_assert(requires { std::range_format::disabled; });
+static_assert(requires { std::range_format::map; });
+static_assert(requires { std::range_format::set; });
+static_assert(requires { std::range_format::sequence; });
+static_assert(requires { std::range_format::string; });
+static_assert(requires { std::range_format::debug_string; });