This is an archive of the discontinued LLVM Phabricator instance.

Differential D117434

[libc++] [test] Improve the tests for std::assignable_from
ClosedPublic

Authored by • Quuxplusone on Jan 16 2022, 9:39 AM.

Details

Reviewers
ldionne
Mordante
Group Reviewers
Restricted Project
Commits
rGd96a5042d69a: [libc++] [test] Improve the tests for std::assignable_from.
Summary

Fixes https://github.com/llvm/llvm-project/issues/50060 .
Looking into this file gave me a wtf moment. So I rewrote this whole test so that it actually tests the stuff we're trying to test. For each subexpression of the concept, test what happens when it fails. Also, test some types that mimic weird standard types, such as std::locale (returns by const reference) and std::tuple-of-references.

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.Jan 16 2022, 9:39 AM
• Quuxplusone created this revision.
Herald added 1 blocking reviewer(s): Restricted Project. · View Herald TranscriptJan 16 2022, 9:39 AM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B143686: Diff 400391.Jan 16 2022, 10:34 AM
ldionne accepted this revision.Jan 17 2022, 8:25 AM

LGTM with nitpick comment.

libcxx/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp
12–20

We've never done it that way, and I don't think we should start now.

442

Some of the complexity in this test comes from the fact that we're doing conformance testing for several standard types, which is something I had required when we first started working on concepts. In retrospect, I think the complexity/value tradeoff of these tests is not as high as I thought.

This revision is now accepted and ready to land.Jan 17 2022, 8:25 AM
• Quuxplusone marked an inline comment as done.Jan 17 2022, 9:11 AM
Closed by commit rGd96a5042d69a: [libc++] [test] Improve the tests for std::assignable_from. (authored by • arthur.j.odwyer). · Explain WhyJan 17 2022, 9:12 AM
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rGd96a5042d69a: [libc++] [test] Improve the tests for std::assignable_from..

Revision Contents

PathSize
libcxx/
test/
std/
concepts/
concepts.lang/
concept.assignable/
618 lines

Diff 400574

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// template<class From, class To> // template<class LHS, class RHS>
// concept assignable_from; // concept assignable_from =
// std::is_lvalue_reference_v<LHS> &&
// std::common_reference_with<
// const std::remove_reference_t<LHS>&,
// const std::remove_reference_t<RHS>&> &&
// requires (LHS lhs, RHS&& rhs) {
// { lhs = std::forward<RHS>(rhs) } -> std::same_as<LHS>;
// };
ldionneUnsubmitted
Done
ReplyInline Actions
// UNSUPPORTED: libcpp-no-concepts
- // template< class LHS, class RHS >
+ // template<class LHS, class RHS>
// concept assignable_from =

We've never done it that way, and I don't think we should start now.

ldionne: We've never done it that way, and I don't think we should start now.
#include <concepts> #include <concepts>
#include <type_traits>
#include <deque> #include "MoveOnly.h"
#include <forward_list>
#include <list>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
#ifndef _LIBCPP_HAS_NO_THREADS
# include <mutex>
#endif
#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 bool 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 bool 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>());
struct NoCommonRef {
NoCommonRef& operator=(const int&);
};
static_assert(std::is_assignable_v<NoCommonRef&, const int&>);
static_assert(!std::assignable_from<NoCommonRef&, const int&>); // no common reference type
struct Base {};
struct Derived : Base {};
static_assert(!std::assignable_from<Base*, Derived*>);
static_assert( std::assignable_from<Base*&, Derived*>);
static_assert( std::assignable_from<Base*&, Derived*&>);
static_assert( std::assignable_from<Base*&, Derived*&&>);
static_assert( std::assignable_from<Base*&, Derived* const>);
static_assert( std::assignable_from<Base*&, Derived* const&>);
static_assert( std::assignable_from<Base*&, Derived* const&&>);
static_assert(!std::assignable_from<Base*&, const Derived*>);
static_assert(!std::assignable_from<Base*&, const Derived*&>);
static_assert(!std::assignable_from<Base*&, const Derived*&&>);
static_assert(!std::assignable_from<Base*&, const Derived* const>);
static_assert(!std::assignable_from<Base*&, const Derived* const&>);
static_assert(!std::assignable_from<Base*&, const Derived* const&&>);
static_assert( std::assignable_from<const Base*&, Derived*>);
static_assert( std::assignable_from<const Base*&, Derived*&>);
static_assert( std::assignable_from<const Base*&, Derived*&&>);
static_assert( std::assignable_from<const Base*&, Derived* const>);
static_assert( std::assignable_from<const Base*&, Derived* const&>);
static_assert( std::assignable_from<const Base*&, Derived* const&&>);
static_assert( std::assignable_from<const Base*&, const Derived*>);
static_assert( std::assignable_from<const Base*&, const Derived*&>);
static_assert( std::assignable_from<const Base*&, const Derived*&&>);
static_assert( std::assignable_from<const Base*&, const Derived* const>);
static_assert( std::assignable_from<const Base*&, const Derived* const&>);
static_assert( std::assignable_from<const Base*&, const Derived* const&&>);
struct VoidResultType {
void operator=(const VoidResultType&);
};
static_assert(std::is_assignable_v<VoidResultType&, const VoidResultType&>);
static_assert(!std::assignable_from<VoidResultType&, const VoidResultType&>);
struct ValueResultType {
ValueResultType operator=(const ValueResultType&);
};
static_assert(std::is_assignable_v<ValueResultType&, const ValueResultType&>);
static_assert(!std::assignable_from<ValueResultType&, const ValueResultType&>);
struct Locale {
const Locale& operator=(const Locale&);
};
static_assert(std::is_assignable_v<Locale&, const Locale&>);
static_assert(!std::assignable_from<Locale&, const Locale&>);
struct Tuple {
Tuple& operator=(const Tuple&);
const Tuple& operator=(const Tuple&) const;
};
static_assert(!std::assignable_from<Tuple, const Tuple&>);
static_assert( std::assignable_from<Tuple&, const Tuple&>);
static_assert(!std::assignable_from<Tuple&&, const Tuple&>);
static_assert(!std::assignable_from<const Tuple, const Tuple&>);
static_assert( std::assignable_from<const Tuple&, const Tuple&>);
static_assert(!std::assignable_from<const Tuple&&, const Tuple&>);
// Finally, check a few simple cases.
static_assert( std::assignable_from<int&, int>);
static_assert( std::assignable_from<int&, int&>);
static_assert( std::assignable_from<int&, int&&>);
static_assert(!std::assignable_from<const int&, int>);
static_assert(!std::assignable_from<const int&, int&>);
static_assert(!std::assignable_from<const int&, int&&>);
static_assert( std::assignable_from<volatile int&, int>);
static_assert( std::assignable_from<volatile int&, int&>);
static_assert( std::assignable_from<volatile int&, int&&>);
static_assert(!std::assignable_from<int(&)[10], int>);
static_assert(!std::assignable_from<int(&)[10], int(&)[10]>);
static_assert( std::assignable_from<MoveOnly&, MoveOnly>);
static_assert(!std::assignable_from<MoveOnly&, MoveOnly&>);
static_assert( std::assignable_from<MoveOnly&, MoveOnly&&>);
static_assert(!std::assignable_from<void, int>); static_assert(!std::assignable_from<void, int>);
static_assert(!std::assignable_from<void, void>); 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 {
ldionneUnsubmitted
Done
ReplyInline Actions

Some of the complexity in this test comes from the fact that we're doing conformance testing for several standard types, which is something I had required when we first started working on concepts. In retrospect, I think the complexity/value tradeoff of these tests is not as high as I thought.

ldionne: Some of the complexity in this test comes from the fact that we're doing conformance testing…
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::deque<int>,
std::deque<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; }