[libcxx] adds std::ranges::swap, std::swappable, and std::swappable_with

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

Depends on D96742

[cjdb]

I'm committing swappable independently from swappable_with so that I can get movable, copyable, semiregular and regular out first (all of which are arguably more important than swappable_with).

[cjdb]

fixes lambdas that weren't called

[miscco]

I find the tests really hard to read and follow. I think giving the lambdas an explicit name would be really beneficial.

libcxx/include/concepts

268

I think this is already covered by the explicit _Size parameter

296

I *think* this should not be done. We would lose a tone of throughput due to the additional checking done inside ranges::swap_ranges.

Is there a measurable benefit in using ranges::swap_ranges

307

While this is what the standard says, it boils down to the conventional swap implementation, which is better known. So should we simply avoid the function call and directly open code swap?

312

This *think* this must be inside another inline namespace _meow I tend to happily forget the exact reason

In general I would say we should put the whole CPO into the ranges namespace and then use an inline namespace here. It is a bit strange that the CPO itself lives outside of ranges

libcxx/test/std/concepts/lang/swappable.pass.cpp

39–40

I find this supper hard to read I think we should enforce some linebreaks with //

68

Please wrap this into a separate function with a descriptive name

[cjdb]

rebases to activate CI

[cjdb]

• applies @miscco's feedback
• adds std::swappable_with

[• Quuxplusone]

Not a real review, just a couple drive-by comments. I'm unlikely to do a real review. :)

libcxx/include/concepts

307

IMO yes; and also std::move should be _VSTD::move.

312

One thing that might be affected by this comment, and should certainly be tested, is whether swap itself is swappable:

decltype(std::ranges::swap) s1, s2;
std::ranges::swap(s1, s2);

I don't know whether it should be or not, but ISTR that this was the trouble spot for range-v3 swap a couple years ago.

[cjdb]

libcxx/include/concepts

268

Nice catch :-)

296

http://eel.is/c++draft/concept.swappable#2.2 explicitly mentions it as the call, but if we can skip the call, I'm all for it.

307

I'd prefer to faithfully follow the standard and trust an optimising compiler will deal with this appropriately :-)

312

The type lives in namespace std::ranges::__swap. I don't see any wording in [[customization.point.object]][1] or [[concepts.swappable]][2] that mandates this, though I do recall that range-v3 (and possibly cmcstl2) needed to do this in C++14 mode since there weren't inline variables at the time.

[1]: http://eel.is/c++draft/customization.point.object
[2]: http://eel.is/c++draft/concepts.swappable

libcxx/test/std/concepts/lang/swappable.pass.cpp

39–40

clang-format, why you do dis?

[tcanens]

libcxx/include/concepts

312

[concepts.syn] mandates it.

This is required because otherwise you can't declare hidden friend swaps for anything in namespace ranges; the same namespace member can't be both a variable and a function, even if the function is otherwise invisible to ordinary lookup.

[cjdb]

puts ranges::swap in an inline sub-namespace

[cjdb]

adds test to see if ranges::swap is swappable

[cjdb]

libcxx/include/concepts

312

Yep, makes sense, done.

312

Test added.

[cjdb]

s/std::move/_VSTD::move/

[cjdb]

libcxx/include/concepts

307

_VSTD::move done, but I'd still prefer to follow the standard wording.

[miscco]

Not a maintainer, but this looks good to me

libcxx/include/concepts

312

Note, that this does not really make sense, as the standard requires, that there is only a single instance of each CPO, but It definitly does not hurt

[cjdb]

libcxx/include/concepts

312

as the standard requires, that there is only a single instance of each CPO

Where does it say that? [customization.point.object]/3 says that all instances must be equal, but that doesn't preclude having a two of the same CPO (not being allowed to copy would make passing CPOs to algorithms illegal).

It's still a good idea to test, since we need to check that the CPO satisfies semiregular.

[EricWF]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

565

Why are these commented out?

[EricWF]

LGTM assuming the inline comments get addressed.

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

594

Can we write these tests in a way that makes them non-threading dependent.

[ldionne]

libcxx/include/concepts

296

I don't understand Michael's comment about the loss of throughput for using swap_ranges here. It seems to me like that would be the correct way of implementing this. Why reinvent the wheel?

309

// end namespace ranges::__swap

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

594

I don't think so since he's explicitly trying to exercise these types, which aren't provided when _LIBCPP_HAS_NO_THREADS. Better would be to have a test-suite version of the macro (to express the fact that the test suite supports being used when threads are not available), but that's for a different patch.

[ldionne]

libcxx/include/concepts

296

Thinking further, obviously we can't use ranges::swap_ranges before it has been implemented. I think we should add a TODO and come fix it later once it's implemented so that we are in line with the spec.

[cjdb]

adds union to definition (and tests), uncomments tests, adds TODO

[cjdb]

Will commit tomorrow.

libcxx/include/concepts

309

Also for the namespace below.

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

565

Uncommented.

594

How about I do that patch just before announcing P0898 is implemented?

[cjdb]

fixes union swap

[• Quuxplusone]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

594

Peanut gallery says: Other alternatives include

• test a made-up struct Immobile instead of specifically std::mutex; we can assume that std::mutex is equally immobile

• move tests of std::mutex's own properties into test/std/thread/thread.mutex/ (because if someone were somehow to break the immobility of std::mutex, I'd hope that it's the mutex tests that fail, not some random concept's tests)

But I have no particular stake in the outcome.

[cjdb]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

594

Reason for having std::mutex over immobile is because @ldionne asked if I could test some standard types too, and I couldn't think of any non-thread based nonmovable types at the time. @EricWF and I agreed to change the mutex ones to some streams.

[cjdb]

replaces std::mutex and std::lock_guard with std::ios_base and std::basic_ios

[cjdb]

CI sanity check before submitting (hopefully a flake)

[ldionne]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

594

I think you'll have the same problem with _LIBCPP_HAS_NO_LOCALIZATION now, unless I'm mistaken. You could move the test to the mutex tests instead if you wanted. Or remove those - they do provide nice testing coverage but they're not worth creating a ruckus over IMO!

[cjdb]

libcxx/test/std/concepts/lang/swappable_with.compile.pass.cpp

594

Okay, so that's why CI failed this time, thanks for the clarity there :-)

In that case, I'll take Arthur's suggestion and make an immobile type, and in a later patch, make a test for thread and stream types.

[cjdb]

replaces immovable types

libcxx/include/concepts

 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
 template<class _Tp>
 concept move_constructible =
   constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
+// [concept.swappable]
+namespace ranges::__swap {
+  // Deleted to inhibit ADL
+  template<class _Tp>
+  void swap(_Tp&, _Tp&) = delete;
+
+  template<class _Tp>
+  concept __class_or_enum = is_class_v<_Tp> || is_enum_v<_Tp>;
+
+  // [1]
+  template<class _Tp, class _Up>
+  concept __unqualified_swappable_with =
+    (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
+    requires(_Tp&& __t, _Up&& __u) {
+      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+    };
+
+  struct __fn;
+
+  template<class _Tp, class _Up, size_t _Size>
+  concept __swappable_arrays =
+    !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
+    extent_v<_Tp> == extent_v<_Up> &&
+    requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
+      __swap(__t[0], __u[0]);
+    };
+
+  template<class _Tp>
+  concept __exchangeable =
+    !__unqualified_swappable_with<_Tp&, _Tp&> &&
+    move_constructible<_Tp> &&
+    assignable_from<_Tp&, _Tp>;
+
+  struct __fn {
+    // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
+    // *The name `swap` is used here unqualified.
+    template<class _Tp, class _Up>
+    requires __unqualified_swappable_with<_Tp, _Up>
+    constexpr void operator()(_Tp&& __t, _Up&& __u) const
+    noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
+    {
+      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+    }
+
+    // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
+    template<class _Tp, class _Up, size_t _Size>
+    requires __swappable_arrays<_Tp, _Up, _Size>
+    constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
+    noexcept(noexcept((*this)(*__t, *__u)))
+    {
+      for (size_t __i = 0; __i < _Size; ++__i) {
+        (*this)(__t[__i], __u[__i]);
+      }
+    }
+
+    // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
+    template<__exchangeable _Tp>
+    constexpr void operator()(_Tp& __x, _Tp& __y) const
+    noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
+    {
+      __y = _VSTD::exchange(__x, std::move(__y));
+    }
+  };
+}
+
+namespace ranges {
+  inline constexpr auto swap = __swap::__fn{};
+}
+
+template<class _Tp>
+concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
+
+template<class _Tp, class _Up>
+concept swappable_with =
+  common_reference_with<_Tp&, _Up&> &&
+  requires(_Tp&& __t, _Up&& __u) {
+    ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
+    ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
+    ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+    ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
+  };
+
 // [concept.copyconstructible]
 template<class _Tp>
 concept copy_constructible =
   move_constructible<_Tp> &&
   constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
 

libcxx/test/std/concepts/lang/swappable.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_CONCEPTS_LANG_SWAPPABLE_H
+#define TEST_STD_CONCEPTS_LANG_SWAPPABLE_H
+
+#include <concepts>
+
+// `adl_swappable` indicates it's been swapped using ADL by maintaining a pointer to itself that
+// isn't a part of the exchange. This is well-formed since we say that two `adl_swappable` objects
+// are equal only if their respective `value` subobjects are equal and their respective `this`
+// subobjects store the addresses of those respective `adl_swappable` objects.
+class lvalue_adl_swappable {
+public:
+  lvalue_adl_swappable() = default;
+
+  constexpr lvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr lvalue_adl_swappable(lvalue_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr lvalue_adl_swappable(lvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr lvalue_adl_swappable&
+  operator=(lvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(lvalue_adl_swappable& x,
+                             lvalue_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool operator==(lvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  lvalue_adl_swappable* this_ = this;
+};
+
+class lvalue_rvalue_adl_swappable {
+public:
+  lvalue_rvalue_adl_swappable() = default;
+
+  constexpr lvalue_rvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr
+  lvalue_rvalue_adl_swappable(lvalue_rvalue_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr
+  lvalue_rvalue_adl_swappable(lvalue_rvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr lvalue_rvalue_adl_swappable&
+  operator=(lvalue_rvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(lvalue_rvalue_adl_swappable& x,
+                             lvalue_rvalue_adl_swappable&& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(lvalue_rvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  lvalue_rvalue_adl_swappable* this_ = this;
+};
+
+class rvalue_lvalue_adl_swappable {
+public:
+  rvalue_lvalue_adl_swappable() = default;
+
+  constexpr rvalue_lvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr
+  rvalue_lvalue_adl_swappable(rvalue_lvalue_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr
+  rvalue_lvalue_adl_swappable(rvalue_lvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr rvalue_lvalue_adl_swappable&
+  operator=(rvalue_lvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(rvalue_lvalue_adl_swappable&& x,
+                             rvalue_lvalue_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(rvalue_lvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  rvalue_lvalue_adl_swappable* this_ = this;
+};
+
+class rvalue_adl_swappable {
+public:
+  rvalue_adl_swappable() = default;
+
+  constexpr rvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr rvalue_adl_swappable(rvalue_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr rvalue_adl_swappable(rvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr rvalue_adl_swappable&
+  operator=(rvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(rvalue_adl_swappable&& x,
+                             rvalue_adl_swappable&& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool operator==(rvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  rvalue_adl_swappable* this_ = this;
+};
+
+class non_move_constructible_adl_swappable {
+public:
+  non_move_constructible_adl_swappable() = default;
+
+  constexpr non_move_constructible_adl_swappable(int value) noexcept
+      : value_(value) {}
+
+  constexpr non_move_constructible_adl_swappable(
+      non_move_constructible_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr non_move_constructible_adl_swappable(
+      non_move_constructible_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr non_move_constructible_adl_swappable&
+  operator=(non_move_constructible_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(non_move_constructible_adl_swappable& x,
+                             non_move_constructible_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(non_move_constructible_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  non_move_constructible_adl_swappable* this_ = this;
+};
+
+class non_move_assignable_adl_swappable {
+public:
+  non_move_assignable_adl_swappable() = default;
+
+  constexpr non_move_assignable_adl_swappable(int value) noexcept
+      : value_(value) {}
+
+  non_move_assignable_adl_swappable(non_move_assignable_adl_swappable&& other) =
+      delete;
+
+  constexpr non_move_assignable_adl_swappable(
+      non_move_assignable_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr non_move_assignable_adl_swappable&
+  operator=(non_move_assignable_adl_swappable&& other) noexcept = delete;
+
+  constexpr friend void swap(non_move_assignable_adl_swappable& x,
+                             non_move_assignable_adl_swappable& y) noexcept {
+    std::ranges::swap(x.value_, y.value_);
+  }
+
+  constexpr bool
+  operator==(non_move_assignable_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  non_move_assignable_adl_swappable* this_ = this;
+};
+
+class throwable_adl_swappable {
+public:
+  throwable_adl_swappable() = default;
+
+  constexpr throwable_adl_swappable(int value) noexcept : value_(value) {}
+
+  constexpr throwable_adl_swappable(throwable_adl_swappable&& other) noexcept
+      : value_(std::move(other.value_)),
+        this_(this) {}
+
+  constexpr
+  throwable_adl_swappable(throwable_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr throwable_adl_swappable&
+  operator=(throwable_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  constexpr friend void swap(throwable_adl_swappable& X,
+                             throwable_adl_swappable& Y) noexcept(false) {
+    std::ranges::swap(X.value_, Y.value_);
+  }
+
+  constexpr bool
+  operator==(throwable_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  throwable_adl_swappable* this_ = this;
+};
+
+#endif // TEST_STD_CONCEPTS_LANG_SWAPPABLE_H

libcxx/test/std/concepts/lang/swappable.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
+
+// template<class T>
+// concept swappable = // see below
+
+#include <concepts>
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <map>
+#include <memory>
+#include <string>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include "test_macros.h"
+#include "swappable.h"
+
+template <class T>
+struct expected {
+  T x;
+  T y;
+};
+
+// clang-format off
+// Checks [concept.swappable]/2.1
+template <class T, class U>
+requires std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U> > &&
+         std::swappable<std::remove_cvref_t<T> >
+constexpr bool check_swap_21(T&& x, U&& y) {
+  expected<std::remove_cvref_t<T> > const e{y, x};
+  std::ranges::swap(std::forward<T>(x), std::forward<U>(y));
+  return x == e.x && y == e.y;
+}
+
+// Checks [concept.swappable]/2.2
+template <std::swappable T, std::size_t N>
+constexpr bool check_swap_22(T (&x)[N], T (&y)[N]) {
+  expected<T[N]> e;
+  std::copy(y, y + N, e.x);
+  std::copy(x, x + N, e.y);
+
+  std::ranges::swap(x, y);
+  return std::equal(x, x + N, e.x, e.x + N) &&
+         std::equal(y, y + N, e.y, e.y + N);
+}
+
+// Checks [concept.swappable]/2.3
+template <std::swappable T>
+requires std::copy_constructible<std::remove_cvref_t<T> >
+constexpr bool check_swap_23(T x, T y) {
+  expected<std::remove_cvref_t<T> > const e{y, x};
+  std::ranges::swap(x, y);
+  return x == e.x && y == e.y;
+}
+// clang-format on
+
+constexpr bool check_lvalue_adl_swappable() {
+  auto x = lvalue_adl_swappable(0);
+  auto y = lvalue_adl_swappable(1);
+  constexpr auto is_noexcept = noexcept(std::ranges::swap(x, y));
+  return check_swap_21(x, y) && is_noexcept;
+}
+static_assert(check_lvalue_adl_swappable());
+
+constexpr bool check_rvalue_adl_swappable() {
+  constexpr auto is_noexcept = noexcept(std::ranges::swap(
+      rvalue_adl_swappable_with(0), rvalue_adl_swappable_with(1)));
+  return check_swap_21(rvalue_adl_swappable_with(0),
+                       rvalue_adl_swappable_with(1)) &&
+         is_noexcept;
+}
+static_assert(check_rvalue_adl_swappable());
+
+constexpr bool check_lvalue_rvalue_adl_swappable_with() {
+  auto x = lvalue_rvalue_adl_swappable_with(0);
+  constexpr auto is_noexcept =
+      noexcept(std::ranges::swap(x, lvalue_rvalue_adl_swappable_with(1)));
+  return check_swap_21(x, lvalue_rvalue_adl_swappable_with(1)) && is_noexcept;
+}
+static_assert(check_lvalue_rvalue_adl_swappable_with());
+
+constexpr bool check_rvalue_lvalue_adl_swappable_with() {
+  auto x = rvalue_lvalue_adl_swappable_with(0);
+  constexpr auto is_noexcept =
+      noexcept(std::ranges::swap(rvalue_lvalue_adl_swappable_with(1), x));
+  return check_swap_21(rvalue_lvalue_adl_swappable_with(1), x) && is_noexcept;
+}
+static_assert(check_rvalue_lvalue_adl_swappable_with());
+
+constexpr bool check_throwable_swappable() {
+  auto x = throwable_adl_swappable{0};
+  auto y = throwable_adl_swappable{1};
+  constexpr auto not_noexcept = !noexcept(std::ranges::swap(x, y));
+  return check_swap_21(x, y) && not_noexcept;
+}
+static_assert(check_throwable_swappable());
+
+constexpr bool check_non_move_constructible_adl_swappable() {
+  auto x = non_move_constructible_adl_swappable{0};
+  auto y = non_move_constructible_adl_swappable{1};
+  constexpr auto is_noexcept = noexcept(std::ranges::swap(x, y));
+  return check_swap_21(x, y) && is_noexcept;
+}
+static_assert(check_non_move_constructible_adl_swappable());
+
+constexpr bool check_non_move_assignable_adl_swappable() {
+  auto x = non_move_assignable_adl_swappable{0};
+  auto y = non_move_assignable_adl_swappable{1};
+  return check_swap_21(x, y) && noexcept(std::ranges::swap(x, y));
+}
+static_assert(check_non_move_assignable_adl_swappable());
+
+namespace swappable_namespace {
+enum unscoped { hello, world };
+void swap(unscoped&, unscoped&);
+
+enum class scoped { hello, world };
+void swap(scoped&, scoped&);
+} // namespace swappable_namespace
+
+static_assert(std::swappable<swappable_namespace::unscoped>);
+static_assert(std::swappable<swappable_namespace::scoped>);
+
+constexpr bool check_swap_arrays() {
+  int x[] = {0, 1, 2, 3, 4};
+  int y[] = {5, 6, 7, 8, 9};
+  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+}
+static_assert(check_swap_arrays());
+
+constexpr bool check_lvalue_adl_swappable_arrays() {
+  lvalue_adl_swappable x[] = {{0}, {1}, {2}, {3}};
+  lvalue_adl_swappable y[] = {{4}, {5}, {6}, {7}};
+  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+}
+static_assert(check_lvalue_adl_swappable_arrays());
+
+constexpr bool check_throwable_adl_swappable_arrays() {
+  throwable_adl_swappable x[] = {{0}, {1}, {2}, {3}};
+  throwable_adl_swappable y[] = {{4}, {5}, {6}, {7}};
+  return check_swap_22(x, y) && !noexcept(std::ranges::swap(x, y));
+}
+static_assert(check_throwable_adl_swappable_arrays());
+
+inline auto global_x = 0;
+static_assert(check_swap_23(0, 0) &&
+              noexcept(std::ranges::swap(global_x, global_x)));
+static_assert(check_swap_23(0, 1) &&
+              noexcept(std::ranges::swap(global_x, global_x)));
+static_assert(check_swap_23(1, 0) &&
+              noexcept(std::ranges::swap(global_x, global_x)));
+
+constexpr bool check_swappable_references() {
+  int x = 42;
+  int y = 64;
+  return check_swap_23<int&>(x, y) && noexcept(std::ranges::swap(x, y));
+}
+static_assert(check_swappable_references());
+
+constexpr bool check_swappable_pointers() {
+  char const* x = "hello";
+  return check_swap_23<char const*>(x, nullptr) &&
+         noexcept(std::ranges::swap(x, x));
+}
+static_assert(check_swappable_pointers());
+
+// All tests for std::swappable<T> are implicitly confirmed by `check_swap`, so we only need to
+// sanity check for a few positive cases.
+static_assert(std::swappable<int volatile&>);
+static_assert(std::swappable<int&&>);
+static_assert(std::swappable<int (*)()>);
+static_assert(std::swappable<int rvalue_adl_swappable_with::*>);
+static_assert(std::swappable<int (rvalue_adl_swappable_with::*)()>);
+static_assert(std::swappable<std::unique_ptr<int> >);
+
+static_assert(!std::swappable<void>);
+static_assert(!std::swappable<int const>);
+static_assert(!std::swappable<int const&>);
+static_assert(!std::swappable<int const&&>);
+static_assert(!std::swappable<int const volatile>);
+static_assert(!std::swappable<int const volatile&>);
+static_assert(!std::swappable<int const volatile&&>);
+static_assert(!std::swappable<int (&)()>);
+
+struct non_move_constructible {
+  non_move_constructible(non_move_constructible&&) = delete;
+  non_move_constructible& operator=(non_move_constructible&&);
+};
+static_assert(!std::move_constructible<non_move_constructible>);
+static_assert(
+    std::assignable_from<non_move_constructible&, non_move_constructible>);
+static_assert(!std::swappable<non_move_constructible>);
+
+struct non_move_assignable {
+  non_move_assignable(non_move_assignable&&);
+  non_move_assignable& operator=(non_move_assignable&&) = delete;
+};
+static_assert(std::move_constructible<non_move_assignable>);
+static_assert(!std::assignable_from<non_move_assignable&, non_move_assignable>);
+static_assert(!std::swappable<non_move_assignable>);
+
+template <bool is_noexcept, std::swappable T>
+void check_swap(expected<T> const& e) {
+  auto a = e.y;
+  auto b = e.x;
+
+  std::ranges::swap(a, b);
+  assert(a == e.x);
+  assert(b == e.y);
+
+  std::ranges::swap(a, b);
+  assert(a == e.y);
+  assert(b == e.x);
+
+  static_assert(noexcept(std::ranges::swap(a, b)) == is_noexcept);
+}
+
+int main(int, char**) {
+  {
+    auto const e = expected<std::deque<int> >{
+        .x = {6, 7, 8, 9},
+        .y = {0, 1, 2, 3, 4, 5},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::map<int, std::string> >{
+        .x = {{0, "whole"}, {1, "cashews"}},
+        .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::string>{
+        .x = "hello there",
+        .y = "general kenobi",
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::optional<lvalue_adl_swappable> >{
+        .x = {10},
+        .y = {20},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::optional<throwable_adl_swappable> >{
+        .x = {10},
+        .y = {20},
+    };
+    check_swap</*is_noexcept=*/false>(e);
+  }
+  {
+    auto const e = expected<std::unordered_map<int, std::string> >{
+        .x = {{0, "whole"}, {1, "cashews"}},
+        .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
+    };
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  {
+    auto const e = expected<std::vector<int> >{
+        .x = {0, 1, 2, 3, 4, 5},
+        .y = {6, 7, 8, 9},
+    };
+
+    check_swap</*is_noexcept=*/true>(e);
+  }
+  return 0;
+}

libcxx/test/std/concepts/lang/swappable_with.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
+
+// template<class T, class U>
+// concept swappable_with = // see below
+
+#include <concepts>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "swappable.h"
+
+template <class T, class U>
+constexpr bool check_swappable_with_impl() {
+  static_assert(std::swappable_with<T, U> == std::swappable_with<U, T>);
+  return std::swappable_with<T, U>;
+}
+
+template <class T, class U>
+constexpr bool check_swappable_with() {
+  static_assert(!check_swappable_with_impl<T, U>());
+  static_assert(!check_swappable_with_impl<T, U const>());
+  static_assert(!check_swappable_with_impl<T const, U>());
+  static_assert(!check_swappable_with_impl<T const, U const>());
+
+  static_assert(!check_swappable_with_impl<T, U&>());
+  static_assert(!check_swappable_with_impl<T, U const&>());
+  static_assert(!check_swappable_with_impl<T, U volatile&>());
+  static_assert(!check_swappable_with_impl<T, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const, U&>());
+  static_assert(!check_swappable_with_impl<T const, U const&>());
+  static_assert(!check_swappable_with_impl<T const, U volatile&>());
+  static_assert(!check_swappable_with_impl<T const, U const volatile&>());
+
+  static_assert(!check_swappable_with_impl<T&, U>());
+  static_assert(!check_swappable_with_impl<T&, U const>());
+  static_assert(!check_swappable_with_impl<T const&, U>());
+  static_assert(!check_swappable_with_impl<T const&, U const>());
+  static_assert(!check_swappable_with_impl<T volatile&, U>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U const>());
+
+  static_assert(!check_swappable_with_impl<T&, U const&>());
+  static_assert(!check_swappable_with_impl<T&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const&, U&>());
+  static_assert(!check_swappable_with_impl<T const&, U const&>());
+  static_assert(!check_swappable_with_impl<T const&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T const&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U const&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U volatile&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&, U const volatile&>());
+
+  static_assert(!check_swappable_with_impl<T, U&&>());
+  static_assert(!check_swappable_with_impl<T, U const&&>());
+  static_assert(!check_swappable_with_impl<T, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const, U&&>());
+  static_assert(!check_swappable_with_impl<T const, U const&&>());
+  static_assert(!check_swappable_with_impl<T const, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T const, U const volatile&&>());
+
+  static_assert(!check_swappable_with_impl<T&&, U>());
+  static_assert(!check_swappable_with_impl<T&&, U const>());
+  static_assert(!check_swappable_with_impl<T const&&, U>());
+  static_assert(!check_swappable_with_impl<T const&&, U const>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U const>());
+
+  static_assert(!check_swappable_with_impl<T&, U&&>());
+  static_assert(!check_swappable_with_impl<T&, U const&&>());
+  static_assert(!check_swappable_with_impl<T&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&, U&&>());
+  static_assert(!check_swappable_with_impl<T const&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U volatile&&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&, U const volatile&&>());
+
+  static_assert(!check_swappable_with_impl<T&&, U&>());
+  static_assert(!check_swappable_with_impl<T&&, U const&>());
+  static_assert(!check_swappable_with_impl<T&&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T&&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const&&, U&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const&>());
+  static_assert(!check_swappable_with_impl<T const&&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U const&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U volatile&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&&, U const volatile&>());
+
+  static_assert(!check_swappable_with_impl<T&&, U&&>());
+  static_assert(!check_swappable_with_impl<T&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T&&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T&&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U volatile&&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&&, U const volatile&&>());
+  return check_swappable_with_impl<T&, U&>();
+}
+
+template <class T, class U>
+constexpr bool check_swappable_with_including_lvalue_ref_to_volatile() {
+  constexpr auto result = check_swappable_with<T, U>();
+  static_assert(check_swappable_with_impl<T volatile&, U volatile&>() ==
+                result);
+  return result;
+}
+
+namespace fundamental {
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<int, int>());
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<double, double>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, double>());
+
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<int*, int*>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, int*>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (*)(), int (*)()>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, int (*)()>());
+
+struct S {};
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int, S>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int S::*, int S::*>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, int S::*>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)(), int (S::*)()>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() noexcept, int (S::*)() noexcept>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() noexcept, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const, int (S::*)() const>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const noexcept, int (S::*)() const noexcept>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const, int (S::*)() const noexcept>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() volatile, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const volatile, int (S::*)() const volatile>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const volatile, int (S::*)()>());
+
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<int[5], int[5]>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int[5], int[6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5], double[5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5], double[6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int[5][6],
+                                                                     int[5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int[5][6],
+                                                                     int[6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[6]>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], int[5][6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], int[5][4]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], int[6][5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[5][6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[6][5]>());
+
+// always false
+static_assert(!check_swappable_with_impl<void, void>());
+static_assert(!check_swappable_with_impl<int, void>());
+static_assert(!check_swappable_with_impl<int&, void>());
+static_assert(!check_swappable_with_impl<void, int>());
+static_assert(!check_swappable_with_impl<void, int&>());
+static_assert(!check_swappable_with_impl<int, int()>());
+static_assert(!check_swappable_with_impl<int, int (&)()>());
+} // namespace fundamental
+
+namespace adl {
+static_assert(
+    check_swappable_with<lvalue_adl_swappable, lvalue_adl_swappable>());
+static_assert(check_swappable_with<lvalue_rvalue_adl_swappable,
+                                   lvalue_rvalue_adl_swappable>());
+static_assert(check_swappable_with<rvalue_lvalue_adl_swappable,
+                                   rvalue_lvalue_adl_swappable>());
+static_assert(
+    check_swappable_with_impl<rvalue_adl_swappable, rvalue_adl_swappable>());
+static_assert(!check_swappable_with_impl<lvalue_rvalue_adl_swappable&,
+                                         lvalue_rvalue_adl_swappable&&>());
+
+struct s1 {};
+struct no_common_reference_with_s1 {
+  friend void swap(s1&, no_common_reference_with_s1&);
+  friend void swap(no_common_reference_with_s1&, s1&);
+};
+static_assert(!check_swappable_with<s1, no_common_reference_with_s1>());
+
+struct one_way_swappable_with_s1 {
+  friend void swap(s1&, one_way_swappable_with_s1&);
+  operator s1();
+};
+static_assert(std::common_reference_with<one_way_swappable_with_s1, s1>);
+static_assert(!check_swappable_with<one_way_swappable_with_s1, s1>());
+
+struct one_way_swappable_with_s1_other_way {
+  friend void swap(one_way_swappable_with_s1_other_way&, s1&);
+  operator s1();
+};
+static_assert(
+    std::common_reference_with<one_way_swappable_with_s1_other_way, s1>);
+static_assert(!check_swappable_with<one_way_swappable_with_s1_other_way, s1>());
+
+struct can_swap_with_s1_but_not_swappable {
+  can_swap_with_s1_but_not_swappable(can_swap_with_s1_but_not_swappable&&) =
+      delete;
+  friend void swap(s1&, can_swap_with_s1_but_not_swappable&);
+  friend void swap(can_swap_with_s1_but_not_swappable&, s1&);
+
+  operator s1() const;
+};
+static_assert(
+    std::common_reference_with<can_swap_with_s1_but_not_swappable, s1>);
+static_assert(!std::swappable<can_swap_with_s1_but_not_swappable>);
+static_assert(
+    !check_swappable_with<can_swap_with_s1_but_not_swappable&, s1&>());
+
+struct swappable_with_s1 {
+  friend void swap(s1&, swappable_with_s1&);
+  friend void swap(swappable_with_s1&, s1&);
+  operator s1() const;
+};
+static_assert(check_swappable_with<swappable_with_s1, s1>());
+
+struct swappable_with_const_s1_but_not_swappable {
+  swappable_with_const_s1_but_not_swappable(
+      swappable_with_const_s1_but_not_swappable const&);
+  swappable_with_const_s1_but_not_swappable(
+      swappable_with_const_s1_but_not_swappable const&&);
+  swappable_with_const_s1_but_not_swappable&
+  operator=(swappable_with_const_s1_but_not_swappable const&);
+  swappable_with_const_s1_but_not_swappable&
+  operator=(swappable_with_const_s1_but_not_swappable const&&);
+
+  friend void swap(s1 const&, swappable_with_const_s1_but_not_swappable const&);
+  friend void swap(swappable_with_const_s1_but_not_swappable const&, s1 const&);
+
+  operator s1 const &() const;
+};
+static_assert(
+    !std::swappable<swappable_with_const_s1_but_not_swappable const&>);
+static_assert(!std::swappable_with<
+              swappable_with_const_s1_but_not_swappable const&, s1 const&>);
+
+struct swappable_with_volatile_s1_but_not_swappable {
+  swappable_with_volatile_s1_but_not_swappable(
+      swappable_with_volatile_s1_but_not_swappable volatile&);
+  swappable_with_volatile_s1_but_not_swappable(
+      swappable_with_volatile_s1_but_not_swappable volatile&&);
+  swappable_with_volatile_s1_but_not_swappable&
+  operator=(swappable_with_volatile_s1_but_not_swappable volatile&);
+  swappable_with_volatile_s1_but_not_swappable&
+  operator=(swappable_with_volatile_s1_but_not_swappable volatile&&);
+
+  friend void swap(s1 volatile&,
+                   swappable_with_volatile_s1_but_not_swappable volatile&);
+  friend void swap(swappable_with_volatile_s1_but_not_swappable volatile&,
+                   s1 volatile&);
+
+  operator s1 volatile &() volatile;
+};
+static_assert(
+    !std::swappable<swappable_with_volatile_s1_but_not_swappable volatile&>);
+static_assert(
+    !std::swappable_with<swappable_with_volatile_s1_but_not_swappable volatile&,
+                         s1 volatile&>);
+
+struct swappable_with_cv_s1_but_not_swappable {
+  swappable_with_cv_s1_but_not_swappable(
+      swappable_with_cv_s1_but_not_swappable const volatile&);
+  swappable_with_cv_s1_but_not_swappable(
+      swappable_with_cv_s1_but_not_swappable const volatile&&);
+  swappable_with_cv_s1_but_not_swappable&
+  operator=(swappable_with_cv_s1_but_not_swappable const volatile&);
+  swappable_with_cv_s1_but_not_swappable&
+  operator=(swappable_with_cv_s1_but_not_swappable const volatile&&);
+
+  friend void swap(s1 const volatile&,
+                   swappable_with_cv_s1_but_not_swappable const volatile&);
+  friend void swap(swappable_with_cv_s1_but_not_swappable const volatile&,
+                   s1 const volatile&);
+
+  operator s1 const volatile &() const volatile;
+};
+static_assert(
+    !std::swappable<swappable_with_cv_s1_but_not_swappable const volatile&>);
+static_assert(
+    !std::swappable_with<swappable_with_cv_s1_but_not_swappable const volatile&,
+                         s1 const volatile&>);
+
+struct s2 {
+  friend void swap(s2 const&, s2 const&);
+  friend void swap(s2 volatile&, s2 volatile&);
+  friend void swap(s2 const volatile&, s2 const volatile&);
+};
+
+struct swappable_with_const_s2 {
+  swappable_with_const_s2(swappable_with_const_s2 const&);
+  swappable_with_const_s2(swappable_with_const_s2 const&&);
+  swappable_with_const_s2& operator=(swappable_with_const_s2 const&);
+  swappable_with_const_s2& operator=(swappable_with_const_s2 const&&);
+
+  friend void swap(swappable_with_const_s2 const&,
+                   swappable_with_const_s2 const&);
+  friend void swap(s2 const&, swappable_with_const_s2 const&);
+  friend void swap(swappable_with_const_s2 const&, s2 const&);
+
+  operator s2 const &() const;
+};
+static_assert(std::swappable_with<swappable_with_const_s2 const&, s2 const&>);
+
+struct swappable_with_volatile_s2 {
+  swappable_with_volatile_s2(swappable_with_volatile_s2 volatile&);
+  swappable_with_volatile_s2(swappable_with_volatile_s2 volatile&&);
+  swappable_with_volatile_s2& operator=(swappable_with_volatile_s2 volatile&);
+  swappable_with_volatile_s2& operator=(swappable_with_volatile_s2 volatile&&);
+
+  friend void swap(swappable_with_volatile_s2 volatile&,
+                   swappable_with_volatile_s2 volatile&);
+  friend void swap(s2 volatile&, swappable_with_volatile_s2 volatile&);
+  friend void swap(swappable_with_volatile_s2 volatile&, s2 volatile&);
+
+  operator s2 volatile &() volatile;
+};
+static_assert(
+    std::swappable_with<swappable_with_volatile_s2 volatile&, s2 volatile&>);
+
+struct swappable_with_cv_s2 {
+  swappable_with_cv_s2(swappable_with_cv_s2 const volatile&);
+  swappable_with_cv_s2(swappable_with_cv_s2 const volatile&&);
+  swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&);
+  swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&&);
+
+  friend void swap(swappable_with_cv_s2 const volatile&,
+                   swappable_with_cv_s2 const volatile&);
+  friend void swap(s2 const volatile&, swappable_with_cv_s2 const volatile&);
+  friend void swap(swappable_with_cv_s2 const volatile&, s2 const volatile&);
+
+  operator s2 const volatile &() const volatile;
+};
+static_assert(std::swappable_with<swappable_with_cv_s2 const volatile&,
+                                  s2 const volatile&>);
+
+struct swappable_with_rvalue_ref_to_s1_but_not_swappable {
+  friend void swap(swappable_with_rvalue_ref_to_s1_but_not_swappable&&,
+                   swappable_with_rvalue_ref_to_s1_but_not_swappable&&);
+  friend void swap(s1&&, swappable_with_rvalue_ref_to_s1_but_not_swappable&&);
+  friend void swap(swappable_with_rvalue_ref_to_s1_but_not_swappable&&, s1&&);
+
+  operator s1() const;
+};
+static_assert(
+    !std::swappable<swappable_with_rvalue_ref_to_s1_but_not_swappable const&&>);
+static_assert(
+    !std::swappable_with<
+        swappable_with_rvalue_ref_to_s1_but_not_swappable const&&, s1 const&&>);
+
+struct swappable_with_rvalue_ref_to_const_s1_but_not_swappable {
+  friend void
+  swap(s1 const&&,
+       swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&);
+  friend void
+  swap(swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&,
+       s1 const&&);
+
+  operator s1 const() const;
+};
+static_assert(!std::swappable<
+              swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&>);
+static_assert(!std::swappable_with<
+              swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&,
+              s1 const&&>);
+
+struct swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable {
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&);
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&);
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
+
+  friend void
+  swap(s1 volatile&&,
+       swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
+  friend void
+  swap(swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&,
+       s1 volatile&&);
+
+  operator s1 volatile &&() volatile&&;
+};
+static_assert(
+    !std::swappable<
+        swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&>);
+static_assert(
+    !std::swappable_with<
+        swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&,
+        s1 volatile&&>);
+
+struct swappable_with_rvalue_ref_to_cv_s1_but_not_swappable {
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&);
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&);
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
+
+  friend void
+  swap(s1 const volatile&&,
+       swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
+  friend void
+  swap(swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&,
+       s1 const volatile&&);
+
+  operator s1 const volatile &&() const volatile&&;
+};
+static_assert(
+    !std::swappable<
+        swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&>);
+static_assert(
+    !std::swappable_with<
+        swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&,
+        s1 const volatile&&>);
+
+struct s3 {
+  friend void swap(s3&&, s3&&);
+  friend void swap(s3 const&&, s3 const&&);
+  friend void swap(s3 volatile&&, s3 volatile&&);
+  friend void swap(s3 const volatile&&, s3 const volatile&&);
+};
+
+struct swappable_with_rvalue_ref_to_s3 {
+  friend void swap(swappable_with_rvalue_ref_to_s3&&,
+                   swappable_with_rvalue_ref_to_s3&&);
+  friend void swap(s3&&, swappable_with_rvalue_ref_to_s3&&);
+  friend void swap(swappable_with_rvalue_ref_to_s3&&, s3&&);
+
+  operator s3() const;
+};
+static_assert(std::swappable_with<swappable_with_rvalue_ref_to_s3&&, s3&&>);
+
+struct swappable_with_rvalue_ref_to_const_s3 {
+  swappable_with_rvalue_ref_to_const_s3(
+      swappable_with_rvalue_ref_to_const_s3 const&);
+  swappable_with_rvalue_ref_to_const_s3(
+      swappable_with_rvalue_ref_to_const_s3 const&&);
+  swappable_with_rvalue_ref_to_const_s3&
+  operator=(swappable_with_rvalue_ref_to_const_s3 const&);
+  swappable_with_rvalue_ref_to_const_s3&
+  operator=(swappable_with_rvalue_ref_to_const_s3 const&&);
+
+  friend void swap(swappable_with_rvalue_ref_to_const_s3 const&&,
+                   swappable_with_rvalue_ref_to_const_s3 const&&);
+  friend void swap(s3 const&&, swappable_with_rvalue_ref_to_const_s3 const&&);
+  friend void swap(swappable_with_rvalue_ref_to_const_s3 const&&, s3 const&&);
+
+  operator s3() const;
+};
+static_assert(std::swappable_with<swappable_with_rvalue_ref_to_const_s3 const&&,
+                                  s3 const&&>);
+
+struct swappable_with_rvalue_ref_to_volatile_s3 {
+  swappable_with_rvalue_ref_to_volatile_s3(
+      swappable_with_rvalue_ref_to_volatile_s3 volatile&);
+  swappable_with_rvalue_ref_to_volatile_s3(
+      swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+  swappable_with_rvalue_ref_to_volatile_s3&
+  operator=(swappable_with_rvalue_ref_to_volatile_s3 volatile&);
+  swappable_with_rvalue_ref_to_volatile_s3&
+  operator=(swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+
+  friend void swap(swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
+                   swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+  friend void swap(s3 volatile&&,
+                   swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+  friend void swap(swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
+                   s3 volatile&&);
+
+  operator s3 volatile &() volatile;
+};
+static_assert(
+    std::swappable_with<swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
+                        s3 volatile&&>);
+
+// struct swappable_with_cv_s2 {
+//   swappable_with_cv_s2(swappable_with_cv_s2 const volatile&);
+//   swappable_with_cv_s2(swappable_with_cv_s2 const volatile&&);
+//   swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&);
+//   swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&&);
+
+//   friend void swap(swappable_with_cv_s2 const volatile&, swappable_with_cv_s2 const volatile&);
+//   friend void swap(s2 const volatile&, swappable_with_cv_s2 const volatile&);
+//   friend void swap(swappable_with_cv_s2 const volatile&, s2 const volatile&);
+
+//   operator s2 const volatile&() const volatile;
+// };
+// static_assert(std::swappable_with<swappable_with_cv_s2 const volatile&, s2 const volatile&>);
+} // namespace adl
+
+namespace standard_types {
+static_assert(
+    check_swappable_with<std::array<int, 10>, std::array<int, 10> >());
+static_assert(
+    !check_swappable_with<std::array<int, 10>, std::array<double, 10> >());
+static_assert(check_swappable_with<std::deque<int>, std::deque<int> >());
+static_assert(!check_swappable_with<std::deque<int>, std::vector<int> >());
+static_assert(
+    check_swappable_with<std::forward_list<int>, std::forward_list<int> >());
+static_assert(
+    !check_swappable_with<std::forward_list<int>, std::vector<int> >());
+static_assert(check_swappable_with<std::list<int>, std::list<int> >());
+static_assert(!check_swappable_with<std::list<int>, std::vector<int> >());
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+static_assert(!check_swappable_with<std::lock_guard<std::mutex>,
+                                    std::lock_guard<std::mutex> >());
+static_assert(
+    !check_swappable_with<std::lock_guard<std::mutex>, std::vector<int> >());
+static_assert(!check_swappable_with<std::mutex, std::mutex>());
+static_assert(!check_swappable_with<std::mutex, std::vector<int> >());
+#endif
+
+static_assert(
+    check_swappable_with<std::map<int, void*>, std::map<int, void*> >());
+static_assert(!check_swappable_with<std::map<int, void*>, std::vector<int> >());
+static_assert(check_swappable_with<std::optional<std::vector<int> >,
+                                   std::optional<std::vector<int> > >());
+static_assert(!check_swappable_with<std::optional<std::vector<int> >,
+                                    std::vector<int> >());
+static_assert(check_swappable_with<std::vector<int>, std::vector<int> >());
+static_assert(!check_swappable_with<std::vector<int>, int>());
+} // namespace standard_types
+
+int main(int, char**) { return 0; }