[libc++] Uses operator<=> in string.

[Mordante]

Summary

Implements part of:

• P1614R2 The Mothership has Landed

[Mordante]

Removes some tabs.

[Mordante]

libcxx/include/string

51

This was implemented in D130295.

4175

This is an optimization that gives a modest performance improvement 210051548ea01357cc834ce8917559ca32b7a137 so decided to keep it. But maybe something to consider during review.

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

64

Note basic_string basic_string_view comparison is part of the string_view header and tested in the string_view tests.

[avogelsgesang]

Thanks for working on this!

libcxx/include/string

49–55

also update the rest of the synopsis to using instead of typedef

50

indentation seems off

4194

_LIBCPP_STD_VER <= 17? would be more consistent with the _LIBCPP_STD_VER > 17 above...

4226

I would prefer to switch this #if around, such that the order of implementation matches the order in the synopsis. Not sure what the previous art/current guidelines are around this, though

4237

afaict, the standard does not declare this as noexcept

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

41

missing tests for the "mixed" comparison operators

AssertOrderAreNotNoexcept<T, CharT>
AssertOrderReturn<Ordering, T, CharT>

[avogelsgesang]

Please also update the SpaceshipProjects.csv

[Mordante]

Thanks for the review!

libcxx/include/string

50

yeah I noticed it to, already fixed.

4226

We don't have a real art/guidelines here. Personally I prefer to use the #if _LIBCPP_STD_VER > XX style.

4237

You're right, good catch.

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

41

I assume you mean const CharT*.

41

We usually don't test AssertOrderAreNotNoexcept; Standard libraries are allowed to mark functions noexcept when the Standard doesn't mandate it. MSVC STL uses this a lot, by adding that validation we would break this test for them. They are actively using our test to validate their implementation.

(Note that Standard libraries aren't allowed to mark functions constexpr when the Standard doesn't mandate it.)

[Mordante]

Addresses review comments.

[avogelsgesang]

libcxx/include/string

4166

we have that basic_string_view already available under the name __self_view

Here and other places.

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

41

I assume you mean const CharT*.

right

We usually don't test AssertOrderAreNotNoexcept; Standard libraries are allowed to mark functions noexcept when the Standard doesn't mandate it. [...]

Thanks for that clarification!

Afaict, AssertOrderReturn<Ordering, T, CharT>() still makes sense, though.

[Mordante]

libcxx/include/string

4166

I didn't know that. Still I prefer to keep the wording similar to that Standard. That makes it easier to verify we did the right thing. I like to use things like __self_view in places where the Standard specifies a behaviour without code.

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

41

Agreed, since CharT is defined on line 42 so that test has been placed on line 43.

[avogelsgesang]

LGTM. Thanks!

libcxx/include/string

4166

makes sense

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

41

Thanks for the pointer. Somehow, I missed that...

[philnik]

LGTM % nits.

libcxx/include/string

378

These shouldn't both be constexpr since C++20 and removed in C++20.

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

10–12

Why do you explain why the test is marked unsupported C++03 - C++17? AFAIK we do that nowhere else.

79

You don't have to return true here. Just from the main test function.

[Mordante]

Thanks for the review.

libcxx/include/string

378

That's how it's implemented at the moment so I prefer to keep the synopsis as is. But we can remove the _LIBCPP_CONSTEXPR_AFTER_CXX17 for the removed functions, that shouldn't affect the tests.

I'll make a followup for that.

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.pass.cpp

10–12

We don't do that often, but in this case I think the explanation is useful. Somebody might expect all comparisions for all C++ versions in this test.

(In general I think we could have more comments in libc++ ;-) )

79

Good point, I had only test before and refactored it to have an extra layer... and forgot to remove them here.

[Mordante]

libcxx/include/string

378

See D131857.

libcxx/docs/Status/SpaceshipProjects.csv

 | `variant <https://reviews.llvm.org/D131372>`_",None,Kent Ross,|In Progress|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| `unique_ptr <https://reviews.llvm.org/D130838>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[type.index.members] <https://wg21.link/type.index.members>`_,| `type_index <https://reviews.llvm.org/D131357>`_,None,Adrian Vogelsgesang,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| to_chars_result,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| from_chars_result,None,Mark de Wever,|Complete|
 | `[stacktrace.entry.cmp] <https://wg21.link/stacktrace.entry.cmp>`_,| stacktrace_entry,None,Unassigned,|Not Started|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| basic_stacktrace,[alg.three.way],Unassigned,|Not Started|
-| `[string.cmp] <https://wg21.link/string.cmp>`_,| basic_string,None,Mark de Wever,|In Progress|
+| `[string.cmp] <https://wg21.link/string.cmp>`_,| `basic_string <https://reviews.llvm.org/D131421>`,None,Mark de Wever,|Complete|
 | `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,| `basic_string_view <https://reviews.llvm.org/D130295>`_,None,Mark de Wever,|Complete|
 | `[array.syn] <https://wg21.link/array.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| array,[expos.only.func],Unassigned,|Not Started|
 | `[deque.syn] <https://wg21.link/deque.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| deque,[expos.only.func],Unassigned,|Not Started|
 | `[forward.list.syn] <https://wg21.link/forward.list.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| forward_list,[expos.only.func],Unassigned,|Not Started|
 | `[list.syn] <https://wg21.link/list.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| list,[expos.only.func],Unassigned,|Not Started|
 | `[vector.syn] <https://wg21.link/vector.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| vector,[expos.only.func],Unassigned,|Not Started|
 | `[associative.map.syn] <https://wg21.link/associative.map.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),"| map
 | multimap",[expos.only.func],Unassigned,|Not Started|

libcxx/include/string

 // -*- 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_STRING
 #define _LIBCPP_STRING
 
 /*
     string synopsis
 
+#include <compare>
+#include <initializer_list>
+
 namespace std
 {
 
 template <class stateT>
 class fpos
 {
 private:
     stateT st;

 template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y);
 
 template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y);
 template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y);
 
 template <class charT>
 struct char_traits
 {
-    typedef charT     char_type;
-    typedef ...       int_type;
-    typedef streamoff off_type;
-    typedef streampos pos_type;
-    typedef mbstate_t state_type;
+    using char_type           = charT;
+    using int_type            = ...;
+    using off_type            = streamoff;
+    using pos_type            = streampos;
+    using state_type          = mbstate_t;
+    using comparison_category = strong_ordering; // Since C++20 only for the specializations
+                                                 // char, wchar_t, char8_t, char16_t, and char32_t.
 
     static void assign(char_type& c1, const char_type& c2) noexcept;
     static constexpr bool eq(char_type c1, char_type c2) noexcept;
     static constexpr bool lt(char_type c1, char_type c2) noexcept;
 
     static int              compare(const char_type* s1, const char_type* s2, size_t n);
     static size_t           length(const char_type* s);
     static const char_type* find(const char_type* s, size_t n, const char_type& a);

 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);                        // constexpr since C++20
 
 template<class charT, class traits, class Allocator>
 bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                 const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
 
 template<class charT, class traits, class Allocator>
-bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20
+bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
 bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;    // constexpr since C++20
 
 template<class charT, class traits, class Allocator>
 bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
+                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20
+bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20
+bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
 bool operator< (const basic_string<charT, traits, Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
+                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20
+bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20
+bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
 bool operator> (const basic_string<charT, traits, Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
+                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20
+bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20
+bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
 bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
+                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20
+bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20
+bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
 bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
-                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
+                const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20
+bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;  // constexpr since C++20, removed in C++20
 
 template<class charT, class traits, class Allocator>
-bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20
+bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;  // constexpr since C++20, removed in C++20
+
+template<class charT, class traits, class Allocator>                                            // since C++20
+constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+                                const basic_string<charT, traits, Allocator>& rhs) noexcept;
+
+template<class charT, class traits, class Allocator>                                            // since C++20
+constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+                                const charT* rhs) noexcept;
 
 template<class charT, class traits, class Allocator>
 void swap(basic_string<charT, traits, Allocator>& lhs,
           basic_string<charT, traits, Allocator>& rhs)
             noexcept(noexcept(lhs.swap(rhs)));                                                  // constexpr since C++20
 
 template<class charT, class traits, class Allocator>
 basic_istream<charT, traits>&

 // operator==
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
+#if _LIBCPP_STD_VER > 17
+    return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
+#else
     size_t __lhs_sz = __lhs.size();
     return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
                                                         __rhs.data(),
                                                         __lhs_sz) == 0;
+#endif
 }
 
 template<class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
            const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
 {
     size_t __lhs_sz = __lhs.size();
     if (__lhs_sz != __rhs.size())
         return false;
     const char* __lp = __lhs.data();
     const char* __rp = __rhs.data();
     if (__lhs.__is_long())
         return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
     for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
         if (*__lp != *__rp)
             return false;
     return true;
 }
 
+#if _LIBCPP_STD_VER <= 17
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     typedef basic_string<_CharT, _Traits, _Allocator> _String;
     _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
     size_t __lhs_len = _Traits::length(__lhs);
     if (__lhs_len != __rhs.size()) return false;
     return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
 }
+#endif // _LIBCPP_STD_VER <= 17
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
 {
+#if _LIBCPP_STD_VER > 17
+    return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
+#else
     typedef basic_string<_CharT, _Traits, _Allocator> _String;
     _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
     size_t __rhs_len = _Traits::length(__rhs);
     if (__rhs_len != __lhs.size()) return false;
     return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
+#endif
+}
+
+#if _LIBCPP_STD_VER > 17
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
+    const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+    const basic_string<_CharT, _Traits, _Allocator>& __rhs) noexcept {
+    return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) {
+    return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
 }
 
+#else // _LIBCPP_STD_VER > 17
+
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
 bool
 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return !(__lhs == __rhs);
 }

 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
 bool
 operator>=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return !(__lhs < __rhs);
 }
+#endif // _LIBCPP_STD_VER > 17
 
 // operator +
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
           const basic_string<_CharT, _Traits, _Allocator>& __rhs)

libcxx/test/std/strings/basic.string/string.nonmembers/string.cmp/comparison.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
+//
+//===----------------------------------------------------------------------===//
+
+// Starting with C++20 the spaceship operator was included. This tests
+// comparison in that context, thus doesn't support older language versions.
+// These are tested per operator.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<class charT, class traits, class Allocator>
+//   see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+//                         const basic_string<charT, traits, Allocator>& rhs) noexcept;
+// template<class charT, class traits, class Allocator>
+//   see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+//                         const charT* rhs);
+
+#include <string>
+
+#include <array>
+#include <cassert>
+#include <string_view>
+
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+#include "test_comparisons.h"
+#include "test_macros.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class T, class Ordering = std::strong_ordering>
+constexpr void test() {
+  AssertOrderAreNoexcept<T>();
+  AssertOrderReturn<Ordering, T>();
+
+  using CharT = typename T::value_type;
+  AssertOrderReturn<Ordering, T, const CharT*>();
+
+  // sorted values
+  std::array v{
+      STR(""),
+      STR("abc"),
+      STR("abcdef"),
+      STR("acb"),
+  };
+
+  // sorted values with embedded NUL character
+  std::array vn{
+      STR("abc"),
+      STR("abc\0"),
+      STR("abc\0def"),
+      STR("acb\0"),
+  };
+  static_assert(v.size() == vn.size());
+
+  for (size_t i = 0; i < v.size(); ++i) {
+    for (size_t j = 0; j < v.size(); ++j) {
+      assert(testOrder(v[i], v[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
+
+      assert(testOrder(
+          v[i],
+          std::basic_string<CharT>{v[j]}.c_str(),
+          i == j  ? Ordering::equivalent
+          : i < j ? Ordering::less
+                  : Ordering::greater));
+
+      // NUL test omitted for c-strings since it will fail.
+      assert(testOrder(vn[i], vn[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
+    }
+  }
+}
+
+constexpr bool test_all_types() {
+  test<std::string>();
+  test<std::basic_string<char, constexpr_char_traits<char>>, std::weak_ordering>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<std::wstring>();
+  test<std::basic_string<wchar_t, constexpr_char_traits<wchar_t>>, std::weak_ordering>();
+#endif
+  test<std::u8string>();
+  test<std::basic_string<char8_t, constexpr_char_traits<char8_t>>, std::weak_ordering>();
+  test<std::u16string>();
+  test<std::basic_string<char16_t, constexpr_char_traits<char16_t>>, std::weak_ordering>();
+  test<std::u32string>();
+  test<std::basic_string<char32_t, constexpr_char_traits<char32_t>>, std::weak_ordering>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test_all_types();
+  static_assert(test_all_types());
+
+  return 0;
+}