// RUN: %clang_cc1 -verify -std=c++20 %s
template <int N>
concept C0 = (N == 0);
template <int N>
concept C1 = (N == 1);
template <int N>
concept C2 = (N == 2);
// Checks are indexed by:
// Definition:
// 1. Explicitly defaulted definition
// 2. Deleted definition
// 3. User provided definition
// We have a less constrained user provided method that should not disable
// the (copyable) triviality of the type.
// Note that because Clang does not implement DRs 1496 and 1734, we say some
// classes are trivial when the SMFs are deleted.
template <int N>
struct DefaultConstructorChecker {
DefaultConstructorChecker() requires C0<N> = default;
DefaultConstructorChecker() requires C1<N> = delete;
DefaultConstructorChecker() requires C2<N>;
DefaultConstructorChecker();
};
static_assert(__is_trivially_copyable(DefaultConstructorChecker<0>));
static_assert(__is_trivially_copyable(DefaultConstructorChecker<1>));
static_assert(__is_trivially_copyable(DefaultConstructorChecker<2>));
static_assert(__is_trivially_copyable(DefaultConstructorChecker<3>));
static_assert(__is_trivial(DefaultConstructorChecker<0>));
// FIXME: DR1496
static_assert(__is_trivial(DefaultConstructorChecker<1>));
static_assert(!__is_trivial(DefaultConstructorChecker<2>));
static_assert(!__is_trivial(DefaultConstructorChecker<3>));
template <int N>
struct CopyConstructorChecker {
CopyConstructorChecker(const CopyConstructorChecker&) requires C0<N> = default;
CopyConstructorChecker(const CopyConstructorChecker&) requires C1<N> = delete;
CopyConstructorChecker(const CopyConstructorChecker&) requires C2<N>;
CopyConstructorChecker(const CopyConstructorChecker&);
};
static_assert(__is_trivially_copyable(CopyConstructorChecker<0>));
// FIXME: DR1734
static_assert(__is_trivially_copyable(CopyConstructorChecker<1>));
static_assert(!__is_trivially_copyable(CopyConstructorChecker<2>));
static_assert(!__is_trivially_copyable(CopyConstructorChecker<3>));
static_assert(!__is_trivial(CopyConstructorChecker<0>));
static_assert(!__is_trivial(CopyConstructorChecker<1>));
static_assert(!__is_trivial(CopyConstructorChecker<2>));
static_assert(!__is_trivial(CopyConstructorChecker<3>));
template <int N>
struct MoveConstructorChecker {
MoveConstructorChecker(MoveConstructorChecker&&) requires C0<N> = default;
MoveConstructorChecker(MoveConstructorChecker&&) requires C1<N> = delete;
MoveConstructorChecker(MoveConstructorChecker&&) requires C2<N>;
MoveConstructorChecker(MoveConstructorChecker&&);
};
static_assert(__is_trivially_copyable(MoveConstructorChecker<0>));
// FIXME: DR1734
static_assert(__is_trivially_copyable(MoveConstructorChecker<1>));
static_assert(!__is_trivially_copyable(MoveConstructorChecker<2>));
static_assert(!__is_trivially_copyable(MoveConstructorChecker<3>));
static_assert(!__is_trivial(MoveConstructorChecker<0>));
static_assert(!__is_trivial(MoveConstructorChecker<1>));
static_assert(!__is_trivial(MoveConstructorChecker<2>));
static_assert(!__is_trivial(MoveConstructorChecker<3>));
template <int N>
struct MoveAssignmentChecker {
MoveAssignmentChecker& operator=(MoveAssignmentChecker&&) requires C0<N> = default;
MoveAssignmentChecker& operator=(MoveAssignmentChecker&&) requires C1<N> = delete;
MoveAssignmentChecker& operator=(MoveAssignmentChecker&&) requires C2<N>;
MoveAssignmentChecker& operator=(MoveAssignmentChecker&&);
};
static_assert(__is_trivially_copyable(MoveAssignmentChecker<0>));
// FIXME: DR1734.
static_assert(__is_trivially_copyable(MoveAssignmentChecker<1>));
static_assert(!__is_trivially_copyable(MoveAssignmentChecker<2>));
static_assert(!__is_trivially_copyable(MoveAssignmentChecker<3>));
static_assert(__is_trivial(MoveAssignmentChecker<0>));
// FIXME: DR1734.
static_assert(__is_trivial(MoveAssignmentChecker<1>));
static_assert(!__is_trivial(MoveAssignmentChecker<2>));
static_assert(!__is_trivial(MoveAssignmentChecker<3>));
template <int N>
struct CopyAssignmentChecker {
CopyAssignmentChecker& operator=(const CopyAssignmentChecker&) requires C0<N> = default;
CopyAssignmentChecker& operator=(const CopyAssignmentChecker&) requires C1<N> = delete;
CopyAssignmentChecker& operator=(const CopyAssignmentChecker&) requires C2<N>;
CopyAssignmentChecker& operator=(const CopyAssignmentChecker&);
};
static_assert(__is_trivially_copyable(CopyAssignmentChecker<0>));
// FIXME: DR1734.
static_assert(__is_trivially_copyable(CopyAssignmentChecker<1>));
static_assert(!__is_trivially_copyable(CopyAssignmentChecker<2>));
static_assert(!__is_trivially_copyable(CopyAssignmentChecker<3>));
static_assert(__is_trivial(CopyAssignmentChecker<0>));
// FIXME: DR1734.
static_assert(__is_trivial(CopyAssignmentChecker<1>));
static_assert(!__is_trivial(CopyAssignmentChecker<2>));
static_assert(!__is_trivial(CopyAssignmentChecker<3>));
template <int N>
struct KindComparisonChecker1 {
KindComparisonChecker1& operator=(const KindComparisonChecker1&) requires C0<N> = default;
KindComparisonChecker1& operator=(KindComparisonChecker1&);
};
template <int N>
struct KindComparisonChecker2 {
KindComparisonChecker2& operator=(const KindComparisonChecker2&) requires C0<N> = default;
const KindComparisonChecker2& operator=(KindComparisonChecker2&) const;
};
template <int N>
struct KindComparisonChecker3 {
using Alias = KindComparisonChecker3;
Alias& operator=(const Alias&) requires C0<N> = default;
KindComparisonChecker3& operator=(const KindComparisonChecker3&);
};
static_assert(!__is_trivial(KindComparisonChecker1<0>));
static_assert(!__is_trivially_copyable(KindComparisonChecker1<0>));
static_assert(!__is_trivial(KindComparisonChecker2<0>));
static_assert(!__is_trivially_copyable(KindComparisonChecker2<0>));
static_assert(__is_trivial(KindComparisonChecker3<0>));
static_assert(__is_trivially_copyable(KindComparisonChecker3<0>));
template <class T>
concept HasA = requires(T t) {
{ t.a() };
};
template <class T>
concept HasAB = HasA<T> && requires(T t) {
{ t.b() };
};
template <class T>
concept HasAC = HasA<T> && requires(T t) {
{ t.c() };
};
template <class T>
concept HasABC = HasAB<T> && HasAC<T> && requires(T t) {
{ t.c() };
};
template <class T>
struct ComplexConstraints {
ComplexConstraints() requires HasABC<T> = default;
ComplexConstraints() requires HasAB<T>;
ComplexConstraints() requires HasAC<T>;
ComplexConstraints() requires HasA<T> = delete;
ComplexConstraints();
};
struct A {
void a();
};
struct AB {
void a();
void b();
};
struct ABC {
void a();
void b();
void c();
};
struct AC {
void a();
void c();
};
static_assert(__is_trivial(ComplexConstraints<ABC>), "");
static_assert(!__is_trivial(ComplexConstraints<AB>), "");
static_assert(!__is_trivial(ComplexConstraints<AC>), "");
static_assert(__is_trivial(ComplexConstraints<A>), "");
static_assert(!__is_trivial(ComplexConstraints<int>), "");
// This is evaluated at the completion of CRTPBase, while `T` is not yet completed.
// This is probably correct behavior.
template <class T>
struct CRTPBase {
CRTPBase() requires (sizeof(T) > 0);
CRTPBase() = default;
};
struct Child : CRTPBase<Child> { int x; };
static Child c;
namespace GH57046 {
template<unsigned N>
struct Foo {
Foo() requires (N==1) {} // expected-note {{declared here}}
Foo() requires (N==2) = default;
};
template <unsigned N, unsigned M>
struct S {
Foo<M> data;
S() requires (N==1) {}
consteval S() requires (N==2) = default; // expected-note {{non-constexpr constructor 'Foo' cannot be used in a constant expression}}
};
void func() {
S<2, 1> s1; // expected-error {{is not a constant expression}} expected-note {{in call to 'S()'}}
S<2, 2> s2;
}
}
namespace GH59206 {
struct A {
A() = default; //eligible, second constructor unsatisfied
template<class... Args>
A(Args&&... args) requires (sizeof...(Args) > 0) {}
};
struct B {
B() = default; //ineligible, second constructor more constrained
template<class... Args>
B(Args&&... args) requires (sizeof...(Args) == 0) {}
};
struct C {
C() = default; //eligible, but
template<class... Args> //also eligible and non-trivial
C(Args&&... args) {}
};
struct D : B {};
static_assert(__is_trivially_copyable(A), "");
static_assert(__is_trivially_copyable(B), "");
static_assert(__is_trivially_copyable(C), "");
static_assert(__is_trivially_copyable(D), "");
// FIXME: Update when https://github.com/llvm/llvm-project/issues/59206 is
// resolved.
static_assert(!__is_trivial(A), "");
static_assert(!__is_trivial(B), "");
static_assert(!__is_trivial(C), "");
static_assert(__is_trivial(D), "");
static_assert(__is_trivially_constructible(A), "");
static_assert(__is_trivially_constructible(B), "");
static_assert(__is_trivially_constructible(C), "");
static_assert(__is_trivially_constructible(D), "");
}
namespace GH60697 {
template <class T>
struct X {
X() requires false = default;
};
static_assert(!__is_trivial(X<int>));
template <class T>
struct S {
S() requires(__is_trivially_constructible(T)) = default;
S() requires(!__is_trivially_constructible(T) &&
__is_constructible(T)) {}
T t;
};
struct D {
D(int i) : i(i) {}
int i;
};
static_assert(!__is_trivially_constructible(D));
static_assert(!__is_constructible(D));
static_assert(!__is_trivial(D));
static_assert(!__is_trivially_constructible(S<D>));
static_assert(!__is_constructible(S<D>));
static_assert(__is_trivial(S<int>));
static_assert(!__is_trivial(S<D>));
}
namespace GH62555 {
template <bool B>
struct ExplicitTemplateArgs {
ExplicitTemplateArgs(ExplicitTemplateArgs&&) = default;
ExplicitTemplateArgs(ExplicitTemplateArgs<false>&&) requires B {};
};
static_assert(__is_trivially_copyable(ExplicitTemplateArgs<false>));
static_assert(__is_trivially_copyable(ExplicitTemplateArgs<true>));
}
Codebase Browser
llvm