[libcxx] adds concept `std::assignable_from`

[cjdb]

Summary

Implements parts of:

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

Depends on D96660

[Mordante]

libcxx/include/concepts

218

Why do you deviate from the wording in the standard? _Rhs __rhs versus _Rhs&& __rhs.

[cjdb]

fixes the (very important) typo @Mordante pointed out

[cjdb]

libcxx/include/concepts

218

Whoops! Thanks for catching this :-)

[ldionne]

The implementation matches the spec closely. I didn't look at the tests in careful detail, however as a general high-level comment: is there value in testing these concepts on a few common types like std::string, std::vector, etc. just to make sure they behave as we'd expect them?

Those are the first types that users are going to use concepts with, so I tend to see value in making sure they work as expected (not that I see any reason they wouldn't, but catching bad surprises is the whole point). Basically, it's as if we had a few compilable examples of how to use the Standard Library.

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

22

Should we use the trick that Casey mentioned in another patch where we basically test static_assert(std::assignable_from<T1, const T2> == std::assignable_from<T1, T2>);?

That way, you could use something like this below: static_assert(!ModelsAssignableFrom<int*&, const int*>());

[cjdb]

In D96742#2575630, @ldionne wrote:

The implementation matches the spec closely. I didn't look at the tests in careful detail, however as a general high-level comment: is there value in testing these concepts on a few common types like std::string, std::vector, etc. just to make sure they behave as we'd expect them?

Those are the first types that users are going to use concepts with, so I tend to see value in making sure they work as expected (not that I see any reason they wouldn't, but catching bad surprises is the whole point). Basically, it's as if we had a few compilable examples of how to use the Standard Library.

Agreed. I'll add a few for vector<int> and string. Any other commonly used types that we should care about (e.g. map) or are vector and string "good enough"?

[ldionne]

In D96742#2575636, @cjdb wrote:

Agreed. I'll add a few for vector<int> and string. Any other commonly used types that we should care about (e.g. map) or are vector and string "good enough"?

The more the better, IMO. map, deque, unique_ptr, variant (?), just a few of the common ones. I doubt it'll actually help us find any issues with the concepts themselves, but it could potentially find us issues with those types!

[cjdb]

In D96742#2575681, @ldionne wrote:

In D96742#2575636, @cjdb wrote:

Agreed. I'll add a few for vector<int> and string. Any other commonly used types that we should care about (e.g. map) or are vector and string "good enough"?

The more the better, IMO. map, deque, unique_ptr, variant (?), just a few of the common ones. I doubt it'll actually help us find any issues with the concepts themselves, but it could potentially find us issues with those types!

I think it's a great idea, and one I'm happy to take on; but if we do it right now, any latent bugs in other types that we uncover will become blockers for getting the rest of the concepts merged into libc++ (see my recent email for a potentially large blocker). I propose making a separate patch for each concept where we test all the frequently used standard types. Those patches can be indefinitely blocked, which isn't great, but at least it doesn't prevent libc++ from being C++20 feature-complete in a reasonable amount of time.

To reiterate: I'm not shrugging off this work, but I'd like to defer it to after __cpp_lib_concepts is defined. If someone is motivated to pick it up before then, feel free to do so: I can confirm at least one major issue will fall out of std::ranges::swap.

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

22

(Note: this is from D88131).

I thought I was emulating Casey's stuff, but seems it can be improved :-)

[cjdb]

applies @ldionne's feedback

[cjdb]

In D96742#2576896, @cjdb wrote:

In D96742#2575681, @ldionne wrote:

In D96742#2575636, @cjdb wrote:

Agreed. I'll add a few for vector<int> and string. Any other commonly used types that we should care about (e.g. map) or are vector and string "good enough"?

The more the better, IMO. map, deque, unique_ptr, variant (?), just a few of the common ones. I doubt it'll actually help us find any issues with the concepts themselves, but it could potentially find us issues with those types!

I think it's a great idea, and one I'm happy to take on; but if we do it right now, any latent bugs in other types that we uncover will become blockers for getting the rest of the concepts merged into libc++ (see my recent email for a potentially large blocker). I propose making a separate patch for each concept where we test all the frequently used standard types. Those patches can be indefinitely blocked, which isn't great, but at least it doesn't prevent libc++ from being C++20 feature-complete in a reasonable amount of time.

To reiterate: I'm not shrugging off this work, but I'd like to defer it to after __cpp_lib_concepts is defined. If someone is motivated to pick it up before then, feel free to do so: I can confirm at least one major issue will fall out of std::ranges::swap.

I decided it's better to do it here and now, so done.

[cjdb]

isolates std::mutex

[ldionne]

In D96742#2580902, @cjdb wrote:

[...]

I decided it's better to do it here and now, so done.

When we encounter these issues, I think we can disable the failing tests with a comment saying "re-enable once <bad issue> is fixed". At least the structure of the tests will be there, so it'll be easy to come back and fix it.

[ldionne]

Pending CI, of course. I think CI might be failing because it's trying to apply your patch without applying the pre-requisites.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI (bad gateway)

[• Quuxplusone]

LGTM mod nits. (Seems like too many tests. The code change itself looks like a correct transliteration of the paper standard.)
aaand whoop, it's already landed :)

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

139

This auto means bool, right? I'd like to see bool here if that's the intention.
(ditto throughout)

548

Here and line 535: is it actually cromulent to create a container with a const (key/element) type? If this is sort of "library IFNDR" then we shouldn't be doing it in tests. But I don't think anything of value would be lost by removing these two lines, anyway, right?

[ldionne]

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

139

Nitpicky but +1, I'm not a huge fan of using auto for simple types.

548

Hmm, I had missed that indeed but std::vector<T const> isn't allowed because T const isn't movable. I think we should remove it. @cjdb did you do this in other tests too? If so, we should fix them too.

[cjdb]

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

139

Sure, I'll get a patch ready.

548

I'm a bit confused as to why we say that std::vector<T const> isn't allowed. It shouldn't be because T const isn't movable: that'd mean std::vector<std::mutex> is also disallowed (and as frustrating as it is to use, that type works "fine").

[• Quuxplusone]

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

548

FWIW: I've looked at similar issues before (sadly don't remember exactly which containers — probably set or map) where ultimately the pragmatic problem was that two member functions ended up with the same signature — e.g. if you had void foo(iterator) and void foo(const_iterator), and both of those types were const T* (or iteratorImpl<const T> or something), then boom, collision. I don't know if formal wording exists to make it ill-formed. I do agree with you that vector<[non-const] mutex> is supported in practice; I'm only objecting to explicitly cv-qualified element types.

libcxx/include/concepts

 concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
 
 template<class _Tp>
 concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
 
 template<class _Tp>
 concept floating_point = is_floating_point_v<_Tp>;
 
+// [concept.assignable]
+template<class _Lhs, class _Rhs>
+concept assignable_from =
+  is_lvalue_reference_v<_Lhs> &&
+  common_reference_with<const remove_reference_t<_Lhs>&, const remove_reference_t<_Rhs>&> &&
+  requires (_Lhs __lhs, _Rhs&& __rhs) {
+    { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
+  };
+
 // [concept.destructible]
 
 template<class _Tp>
 concept destructible = _VSTD::is_nothrow_destructible_v<_Tp>;
 
 // [concept.constructible]
 template<class _Tp, class... _Args>
 concept constructible_from =

libcxx/test/std/concepts/lang/assignable.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 From, class To>
+// concept assignable_from;
+
+#include <concepts>
+
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+#include "../support/allocators.h"
+
+// Note: is_lvalue_reference is checked in all ModelsAssignableFrom calls.
+template <typename T1, typename T2>
+constexpr void NeverAssignableFrom() {
+  static_assert(!std::assignable_from<T1, T2>);
+  static_assert(!std::assignable_from<T1, const T2>);
+  static_assert(!std::assignable_from<T1, T2&>);
+  static_assert(!std::assignable_from<T1, const T2&>);
+  static_assert(!std::assignable_from<T1, volatile T2&>);
+  static_assert(!std::assignable_from<T1, const volatile T2&>);
+  static_assert(!std::assignable_from<T1, T2&&>);
+  static_assert(!std::assignable_from<T1, const T2&&>);
+  static_assert(!std::assignable_from<T1, volatile T2&&>);
+  static_assert(!std::assignable_from<T1, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const volatile T1&, T2>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2>);
+  static_assert(!std::assignable_from<const volatile T1&, T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<T1&&, T2>);
+  static_assert(!std::assignable_from<T1&&, const T2>);
+  static_assert(!std::assignable_from<T1&&, T2&>);
+  static_assert(!std::assignable_from<T1&&, const T2&>);
+  static_assert(!std::assignable_from<T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<T1&&, T2&&>);
+  static_assert(!std::assignable_from<T1&&, const T2&&>);
+  static_assert(!std::assignable_from<T1&&, volatile T2&&>);
+  static_assert(!std::assignable_from<T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const T1&&, T2>);
+  static_assert(!std::assignable_from<const T1&&, const T2>);
+  static_assert(!std::assignable_from<const T1&&, T2&>);
+  static_assert(!std::assignable_from<const T1&&, const T2&>);
+  static_assert(!std::assignable_from<const T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<const T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<const T1&&, T2&&>);
+  static_assert(!std::assignable_from<const T1&&, const T2&&>);
+  static_assert(!std::assignable_from<const T1&&, volatile T2&&>);
+  static_assert(!std::assignable_from<const T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<volatile T1&&, T2>);
+  static_assert(!std::assignable_from<volatile T1&&, const T2>);
+  static_assert(!std::assignable_from<volatile T1&&, T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, const T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<volatile T1&&, T2&&>);
+  static_assert(!std::assignable_from<volatile T1&&, const T2&&>);
+  static_assert(!std::assignable_from<volatile T1&&, volatile T2&&>);
+  static_assert(!std::assignable_from<volatile T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const volatile T1&&, T2>);
+  static_assert(!std::assignable_from<const volatile T1&&, const T2>);
+  static_assert(!std::assignable_from<const volatile T1&&, T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, const T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, const volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&&, T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&&, const T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&&, volatile T2&&>);
+  static_assert(
+      !std::assignable_from<const volatile T1&&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const T1&, T2>);
+  static_assert(!std::assignable_from<const T1&, const T2>);
+  static_assert(!std::assignable_from<const T1&, T2&>);
+  static_assert(!std::assignable_from<const T1&, const T2&>);
+  static_assert(!std::assignable_from<const T1&, volatile T2&>);
+  static_assert(!std::assignable_from<const T1&, const volatile T2&>);
+  static_assert(!std::assignable_from<const T1&, T2&&>);
+  static_assert(!std::assignable_from<const T1&, const T2&&>);
+  static_assert(!std::assignable_from<const T1&, volatile T2&&>);
+  static_assert(!std::assignable_from<const T1&, const volatile T2&&>);
+
+  static_assert(!std::assignable_from<const volatile T1&, T2>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2>);
+  static_assert(!std::assignable_from<const volatile T1&, T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
+  static_assert(!std::assignable_from<const volatile T1&, T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
+  static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
+}
+
+template <typename T1, typename T2>
+constexpr bool CheckAssignableFromRvalues() {
+  NeverAssignableFrom<T1, T2>();
+
+  constexpr auto Result = std::assignable_from<T1&, T2>;
+  static_assert(std::assignable_from<T1&, T2&&> == Result);
+
+  return Result;
+}
+
+template <typename T1, typename T2>
+constexpr bool CheckAssignableFromLvalues() {
+  NeverAssignableFrom<T1, T2>();
+
+  constexpr auto Result = std::assignable_from<T1&, const T2&>;
+  static_assert(std::assignable_from<T1&, T2&> == Result);
+  static_assert(std::assignable_from<T1&, const T2&> == Result);
+
+  return Result;
+}
+
+template <typename T1, typename T2>
+constexpr bool CheckAssignableFromLvaluesAndRvalues() {
+  return CheckAssignableFromLvalues<T1, T2>() &&
+         CheckAssignableFromRvalues<T1, T2>();
+}
+
+namespace BuiltinTypes {
+static_assert(CheckAssignableFromLvaluesAndRvalues<int, int>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<int, double>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<double, int>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<int*, int*>());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<int*, const int*>());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<int*, volatile int*>());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<int*, const volatile int*>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<const int*, int*>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<const int*, const int*>());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<const int*, volatile int*>());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<const int*, const volatile int*>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<volatile int*, int*>());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<volatile int*, const int*>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<volatile int*, volatile int*>());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<volatile int*,
+                                                    const volatile int*>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<const volatile int*, int*>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<const volatile int*, const int*>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<const volatile int*, volatile int*>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<const volatile int*,
+                                                   const volatile int*>());
+
+static_assert(CheckAssignableFromLvaluesAndRvalues<int (*)(), int (*)()>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<int (*)(), int (*)() noexcept>());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<int (*)() noexcept, int (*)()>());
+
+struct S {};
+static_assert(CheckAssignableFromLvaluesAndRvalues<int S::*, int S::*>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<const int S::*, int S::*>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<int (S::*)(), int (S::*)()>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)(),
+                                                   int (S::*)() noexcept>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)() const,
+                                                   int (S::*)() const>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<
+              int (S::*)() const, int (S::*)() const noexcept>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)() volatile,
+                                                   int (S::*)() volatile>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<
+              int (S::*)() volatile, int (S::*)() volatile noexcept>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<
+              int (S::*)() const volatile, int (S::*)() const volatile>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<
+        int (S::*)() const volatile, int (S::*)() const volatile noexcept>());
+
+static_assert(!std::assignable_from<void, int>);
+static_assert(!std::assignable_from<void, void>);
+static_assert(!std::assignable_from<int*&, long*>);
+static_assert(!std::assignable_from<int (&)[5], int[5]>);
+static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() const>);
+static_assert(!std::assignable_from<int (S::*&)() const, int (S::*)()>);
+static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() volatile>);
+static_assert(!std::assignable_from<int (S::*&)() volatile, int (S::*)()>);
+static_assert(
+    !std::assignable_from<int (S::*&)(), int (S::*)() const volatile>);
+static_assert(
+    !std::assignable_from<int (S::*&)() const volatile, int (S::*)()>);
+static_assert(!std::assignable_from<int (S::*&)() noexcept, int (S::*)()>);
+static_assert(
+    !std::assignable_from<int (S::*&)() const noexcept, int (S::*)() const>);
+static_assert(!std::assignable_from<int (S::*&)() volatile noexcept,
+                                    int (S::*)() volatile>);
+static_assert(!std::assignable_from<int (S::*&)() const volatile noexcept,
+                                    int (S::*)() const volatile>);
+} // namespace BuiltinTypes
+
+namespace TypesFitForPurpose {
+struct T1 {};
+
+struct NoCommonReference {};
+static_assert(!std::common_reference_with<const T1&, const NoCommonReference&>);
+static_assert(!std::assignable_from<NoCommonReference&, T1>);
+
+struct AssignmentReturnsNonReference {
+  AssignmentReturnsNonReference operator=(T1);
+  operator T1() const;
+};
+static_assert(std::common_reference_with<const T1&,
+                                         const AssignmentReturnsNonReference&>);
+static_assert(!std::assignable_from<AssignmentReturnsNonReference&, T1>);
+
+struct NonCVAssignmentOnly {
+  NonCVAssignmentOnly& operator=(T1);
+  operator T1() const;
+};
+static_assert(
+    std::common_reference_with<const T1&, const NonCVAssignmentOnly&>);
+static_assert(std::assignable_from<NonCVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const NonCVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<volatile NonCVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const volatile NonCVAssignmentOnly&, T1>);
+
+struct NonCVAssignmentOnlyConstQualified {
+  NonCVAssignmentOnlyConstQualified& operator=(T1) const;
+  operator T1() const;
+};
+static_assert(std::common_reference_with<
+              const T1&, const NonCVAssignmentOnlyConstQualified&>);
+static_assert(std::assignable_from<NonCVAssignmentOnlyConstQualified&, T1>);
+static_assert(
+    !std::assignable_from<const NonCVAssignmentOnlyConstQualified&, T1>);
+static_assert(
+    !std::assignable_from<volatile NonCVAssignmentOnlyConstQualified&, T1>);
+static_assert(!std::assignable_from<
+              const volatile NonCVAssignmentOnlyConstQualified&, T1>);
+
+struct NonCVAssignmentVolatileQualified {
+  NonCVAssignmentVolatileQualified& operator=(T1) volatile;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<
+              const T1&, const NonCVAssignmentVolatileQualified&>);
+static_assert(std::assignable_from<NonCVAssignmentVolatileQualified&, T1>);
+static_assert(
+    !std::assignable_from<const NonCVAssignmentVolatileQualified&, T1>);
+static_assert(
+    !std::assignable_from<volatile NonCVAssignmentVolatileQualified&, T1>);
+static_assert(!std::assignable_from<
+              const volatile NonCVAssignmentVolatileQualified&, T1>);
+
+struct NonCVAssignmentOnlyCVQualified {
+  NonCVAssignmentOnlyCVQualified& operator=(T1) const volatile;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<
+              const T1&, const NonCVAssignmentOnlyCVQualified&>);
+static_assert(std::assignable_from<NonCVAssignmentOnlyCVQualified&, T1>);
+static_assert(!std::assignable_from<const NonCVAssignmentOnlyCVQualified&, T1>);
+static_assert(
+    !std::assignable_from<volatile NonCVAssignmentOnlyCVQualified&, T1>);
+static_assert(
+    !std::assignable_from<const volatile NonCVAssignmentOnlyCVQualified&, T1>);
+
+struct ConstAssignmentOnly {
+  const ConstAssignmentOnly& operator=(T1) const;
+  operator T1() const;
+};
+static_assert(
+    std::common_reference_with<const T1&, const ConstAssignmentOnly&>);
+static_assert(std::assignable_from<const ConstAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<ConstAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<volatile ConstAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const volatile ConstAssignmentOnly&, T1>);
+
+struct VolatileAssignmentOnly {
+  volatile VolatileAssignmentOnly& operator=(T1) volatile;
+  operator T1() const volatile;
+};
+static_assert(
+    std::common_reference_with<const T1&, const VolatileAssignmentOnly&>);
+static_assert(!std::assignable_from<VolatileAssignmentOnly&, T1>);
+static_assert(std::assignable_from<volatile VolatileAssignmentOnly&, T1>);
+
+struct CVAssignmentOnly {
+  const volatile CVAssignmentOnly& operator=(T1) const volatile;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<const T1&, const CVAssignmentOnly&>);
+static_assert(std::assignable_from<const volatile CVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<CVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<const CVAssignmentOnly&, T1>);
+static_assert(!std::assignable_from<volatile CVAssignmentOnly&, T1>);
+
+struct LvalueRefQualifiedWithRvalueT1Only {
+  LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) &;
+  const LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const&;
+  volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) volatile&;
+  const volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const
+      volatile&;
+  operator T1() const volatile;
+};
+static_assert(std::common_reference_with<
+              const T1&, const LvalueRefQualifiedWithRvalueT1Only&>);
+static_assert(std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(
+    std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(
+    std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
+static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(
+    !std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(
+    !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(!std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const T1&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
+static_assert(!std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    volatile T1&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          volatile T1&>);
+static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&>);
+static_assert(
+    !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const T1&&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
+static_assert(!std::assignable_from<
+              const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
+static_assert(
+    !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    volatile T1&&>);
+static_assert(!std::assignable_from<
+              volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          volatile T1&&>);
+static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&&>);
+static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
+                                    const volatile T1&&>);
+static_assert(
+    !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&&>);
+static_assert(
+    !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
+                          const volatile T1&&>);
+
+struct NoLvalueRefAssignment {
+  NoLvalueRefAssignment& operator=(T1) &&;
+  const NoLvalueRefAssignment& operator=(T1) const&&;
+  volatile NoLvalueRefAssignment& operator=(T1) volatile&&;
+  const volatile NoLvalueRefAssignment& operator=(T1) const volatile&&;
+  operator T1() const volatile;
+};
+static_assert(
+    std::common_reference_with<const T1&, const NoLvalueRefAssignment&>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, T1>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, const T1>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, volatile T1>);
+static_assert(!std::assignable_from<NoLvalueRefAssignment&, const volatile T1>);
+static_assert(!std::assignable_from<const NoLvalueRefAssignment&, T1>);
+static_assert(!std::assignable_from<const NoLvalueRefAssignment&, const T1>);
+static_assert(!std::assignable_from<const NoLvalueRefAssignment&, volatile T1>);
+static_assert(
+    !std::assignable_from<const NoLvalueRefAssignment&, const volatile T1>);
+static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, T1>);
+static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, const T1>);
+static_assert(
+    !std::assignable_from<volatile NoLvalueRefAssignment&, volatile T1>);
+static_assert(
+    !std::assignable_from<volatile NoLvalueRefAssignment&, const volatile T1>);
+static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&, T1>);
+static_assert(
+    !std::assignable_from<const volatile NoLvalueRefAssignment&, const T1>);
+static_assert(
+    !std::assignable_from<const volatile NoLvalueRefAssignment&, volatile T1>);
+static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&,
+                                    const volatile T1>);
+} // namespace TypesFitForPurpose
+
+namespace StandardTypes {
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::deque<int>, std::deque<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
+                                                    std::deque<const int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::deque<int>, std::deque<int, A1<int> > >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
+                                                    std::vector<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>, int>());
+
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>,
+                                                   std::forward_list<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::forward_list<int>, std::forward_list<const int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::forward_list<int>, std::forward_list<int, A1<int> > >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>,
+                                                    std::vector<int> >());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>, int>());
+
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::list<int>, std::list<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::list<int>,
+                                                    std::list<const int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::list<int>, std::list<int, A1<int> > >());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<std::list<int>, std::vector<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::list<int>, int>());
+
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::map<int, void*>,
+                                                   std::map<int, void*> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::map<int, void*>, std::map<const int, void*> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::map<int, void*>,
+              std::map<int, void*, A1<std::pair<int, void*> > > >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::map<int, void*>, std::unordered_map<int, void*> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::map<int, void*>,
+                                                    std::pair<int, void*> >());
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+static_assert(!CheckAssignableFromRvalues<std::mutex, std::mutex>());
+static_assert(!CheckAssignableFromLvalues<std::mutex, std::mutex>());
+#endif
+
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::optional<int>, int>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::optional<int>, double>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::optional<int>,
+                                                   std::optional<int> >());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<int, std::optional<int> >());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<double, std::optional<int> >());
+
+static_assert(
+    !std::common_reference_with<std::optional<int>, std::optional<double> >);
+static_assert(
+    !CheckAssignableFromRvalues<std::optional<int>, std::optional<double> >());
+static_assert(
+    !CheckAssignableFromLvalues<std::optional<int>, std::optional<double> >());
+
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, std::string>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::string, std::string_view>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, char*>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, const char*>());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::string, std::basic_string<wchar_t> >());
+static_assert(
+    !CheckAssignableFromLvaluesAndRvalues<std::string, std::vector<char> >());
+
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::string_view, std::string_view>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::string_view, std::string>());
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::string_view, char*>());
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::string_view, const char*>());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::string_view, std::basic_string_view<wchar_t> >());
+
+static_assert(
+    CheckAssignableFromRvalues<std::unique_ptr<int>, std::unique_ptr<int> >());
+static_assert(
+    !CheckAssignableFromLvalues<std::unique_ptr<int>, std::unique_ptr<int> >());
+
+static_assert(
+    CheckAssignableFromLvaluesAndRvalues<std::unordered_map<int, void*>,
+                                         std::unordered_map<int, void*> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::unordered_map<int, void*>,
+              std::unordered_map<const int, void*> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::unordered_map<int, void*>,
+              std::unordered_map<int, void*, A1<std::pair<int, void*> > > >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::unordered_map<int, void*>, std::map<int, void*> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::unordered_map<int, void*>, std::pair<int, void*> >());
+
+static_assert(CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
+                                                   std::vector<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
+                                                    std::vector<const int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<
+              std::vector<int>, std::vector<int, A1<int> > >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
+                                                    std::deque<int> >());
+static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>, int>());
+} // namespace StandardTypes
+
+int main(int, char**) { return 0; }