// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wno-inaccessible-base %s
// Tests for implicit (non-)declaration of move constructor and
// assignment: p9, p11, p20, p23.
// This class, used as a member, allows to distinguish move from copy because
// move operations are no-throw, copy operations aren't.
struct ThrowingCopy {
ThrowingCopy() noexcept;
ThrowingCopy(ThrowingCopy &&) noexcept;
ThrowingCopy(const ThrowingCopy &) noexcept(false);
ThrowingCopy & operator =(ThrowingCopy &&) noexcept;
ThrowingCopy & operator =(const ThrowingCopy &) noexcept(false);
};
struct HasCopyConstructor {
ThrowingCopy tc;
HasCopyConstructor() noexcept;
HasCopyConstructor(const HasCopyConstructor &) noexcept(false);
};
struct HasCopyAssignment {
ThrowingCopy tc;
HasCopyAssignment() noexcept;
HasCopyAssignment & operator =(const HasCopyAssignment &) noexcept(false);
};
struct HasMoveConstructor {
ThrowingCopy tc;
HasMoveConstructor() noexcept;
HasMoveConstructor(HasMoveConstructor &&) noexcept; // expected-note {{copy assignment operator is implicitly deleted because 'HasMoveConstructor' has a user-declared move constructor}}
};
struct HasMoveAssignment { // expected-note {{implicit copy constructor}}
ThrowingCopy tc;
HasMoveAssignment() noexcept;
HasMoveAssignment & operator =(HasMoveAssignment &&) noexcept;
};
struct HasDestructor {
ThrowingCopy tc;
HasDestructor() noexcept;
~HasDestructor() noexcept;
};
void test_basic_exclusion() {
static_assert(!noexcept(HasCopyConstructor((HasCopyConstructor()))), "");
HasCopyConstructor hcc;
static_assert(!noexcept(hcc = HasCopyConstructor()), "");
static_assert(!noexcept(HasCopyAssignment((HasCopyAssignment()))), "");
HasCopyAssignment hca;
static_assert(!noexcept(hca = HasCopyAssignment()), "");
static_assert(noexcept(HasMoveConstructor((HasMoveConstructor()))), "");
HasMoveConstructor hmc;
hmc = HasMoveConstructor(); // expected-error {{object of type 'HasMoveConstructor' cannot be assigned because its copy assignment operator is implicitly deleted}}
(HasMoveAssignment(HasMoveAssignment())); // expected-error {{uses deleted function}}
HasMoveAssignment hma;
static_assert(noexcept(hma = HasMoveAssignment()), "");
static_assert(!noexcept(HasDestructor((HasDestructor()))), "");
HasDestructor hd;
static_assert(!noexcept(hd = HasDestructor()), "");
}
struct PrivateMove {
PrivateMove() noexcept;
PrivateMove(const PrivateMove &) noexcept(false);
PrivateMove & operator =(const PrivateMove &) noexcept(false);
private:
PrivateMove(PrivateMove &&) noexcept;
PrivateMove & operator =(PrivateMove &&) noexcept;
};
struct InheritsPrivateMove : PrivateMove {};
struct ContainsPrivateMove {
PrivateMove pm;
};
struct PrivateDestructor {
PrivateDestructor() noexcept;
PrivateDestructor(const PrivateDestructor &) noexcept(false);
PrivateDestructor(PrivateDestructor &&) noexcept;
private:
~PrivateDestructor() noexcept;
};
struct InheritsPrivateDestructor : PrivateDestructor {}; // expected-note{{base class 'PrivateDestructor' has an inaccessible destructor}}
struct ContainsPrivateDestructor {
PrivateDestructor pd; // expected-note{{field 'pd' has an inaccessible destructor}}
};
struct NonTrivialCopyOnly {
NonTrivialCopyOnly() noexcept;
NonTrivialCopyOnly(const NonTrivialCopyOnly &) noexcept(false);
NonTrivialCopyOnly & operator =(const NonTrivialCopyOnly &) noexcept(false);
};
struct InheritsNonTrivialCopyOnly : NonTrivialCopyOnly {};
struct ContainsNonTrivialCopyOnly {
NonTrivialCopyOnly ntco;
};
struct ContainsConst {
const int i;
ContainsConst() noexcept;
ContainsConst & operator =(ContainsConst &); // expected-note {{not viable}}
};
struct ContainsRef {
int &i;
ContainsRef() noexcept;
ContainsRef & operator =(ContainsRef &); // expected-note {{not viable}}
};
struct Base {
Base & operator =(Base &);
};
struct DirectVirtualBase : virtual Base {}; // expected-note {{copy assignment operator) not viable}}
struct IndirectVirtualBase : DirectVirtualBase {}; // expected-note {{copy assignment operator) not viable}}
void test_deletion_exclusion() {
// FIXME: How to test the union thing?
static_assert(!noexcept(InheritsPrivateMove(InheritsPrivateMove())), "");
static_assert(!noexcept(ContainsPrivateMove(ContainsPrivateMove())), "");
InheritsPrivateMove ipm;
static_assert(!noexcept(ipm = InheritsPrivateMove()), "");
ContainsPrivateMove cpm;
static_assert(!noexcept(cpm = ContainsPrivateMove()), "");
(InheritsPrivateDestructor(InheritsPrivateDestructor())); // expected-error {{call to implicitly-deleted default constructor}}
(ContainsPrivateDestructor(ContainsPrivateDestructor())); // expected-error {{call to implicitly-deleted default constructor}}
static_assert(!noexcept(InheritsNonTrivialCopyOnly(InheritsNonTrivialCopyOnly())), "");
static_assert(!noexcept(ContainsNonTrivialCopyOnly(ContainsNonTrivialCopyOnly())), "");
InheritsNonTrivialCopyOnly intco;
static_assert(!noexcept(intco = InheritsNonTrivialCopyOnly()), "");
ContainsNonTrivialCopyOnly cntco;
static_assert(!noexcept(cntco = ContainsNonTrivialCopyOnly()), "");
ContainsConst cc;
cc = ContainsConst(); // expected-error {{no viable}}
ContainsRef cr;
cr = ContainsRef(); // expected-error {{no viable}}
DirectVirtualBase dvb;
dvb = DirectVirtualBase(); // expected-error {{no viable}}
IndirectVirtualBase ivb;
ivb = IndirectVirtualBase(); // expected-error {{no viable}}
}
struct ContainsRValueRef {
int&& ri;
ContainsRValueRef() noexcept;
};
void test_contains_rref() {
(ContainsRValueRef(ContainsRValueRef()));
}
namespace DR1402 {
struct NonTrivialCopyCtor {
NonTrivialCopyCtor(const NonTrivialCopyCtor &);
};
struct NonTrivialCopyAssign {
NonTrivialCopyAssign &operator=(const NonTrivialCopyAssign &);
};
struct NonTrivialCopyCtorVBase : virtual NonTrivialCopyCtor {
NonTrivialCopyCtorVBase(NonTrivialCopyCtorVBase &&);
NonTrivialCopyCtorVBase &operator=(NonTrivialCopyCtorVBase &&) = default;
};
struct NonTrivialCopyAssignVBase : virtual NonTrivialCopyAssign {
NonTrivialCopyAssignVBase(NonTrivialCopyAssignVBase &&);
NonTrivialCopyAssignVBase &operator=(NonTrivialCopyAssignVBase &&) = default;
};
struct NonTrivialMoveAssign {
NonTrivialMoveAssign(NonTrivialMoveAssign&&);
NonTrivialMoveAssign &operator=(NonTrivialMoveAssign &&);
};
struct NonTrivialMoveAssignVBase : virtual NonTrivialMoveAssign {
NonTrivialMoveAssignVBase(NonTrivialMoveAssignVBase &&);
NonTrivialMoveAssignVBase &operator=(NonTrivialMoveAssignVBase &&) = default;
};
// DR1402: A non-movable, non-trivially-copyable class type as a subobject no
// longer inhibits the declaration of a move operation.
struct NoMove1 { NonTrivialCopyCtor ntcc; };
struct NoMove2 { NonTrivialCopyAssign ntcc; };
struct NoMove3 : NonTrivialCopyCtor {};
struct NoMove4 : NonTrivialCopyAssign {};
struct NoMove5 : virtual NonTrivialCopyCtor {};
struct NoMove6 : virtual NonTrivialCopyAssign {};
struct NoMove7 : NonTrivialCopyCtorVBase {};
struct NoMove8 : NonTrivialCopyAssignVBase {};
// DR1402: A non-trivially-move-assignable virtual base class no longer
// inhibits the declaration of a move assignment (even though it might
// move-assign the base class multiple times).
struct NoMove9 : NonTrivialMoveAssign {};
struct NoMove10 : virtual NonTrivialMoveAssign {};
struct NoMove11 : NonTrivialMoveAssignVBase {};
template<typename T> void test(T t) {
(void)T(static_cast<T&&>(t)); // ok
t = static_cast<T&&>(t); // ok
}
template void test(NoMove1);
template void test(NoMove2);
template void test(NoMove3);
template void test(NoMove4);
template void test(NoMove5);
template void test(NoMove6);
template void test(NoMove7);
template void test(NoMove8);
template void test(NoMove9);
template void test(NoMove10);
template void test(NoMove11);
struct CopyOnly {
CopyOnly(const CopyOnly&);
CopyOnly &operator=(const CopyOnly&);
};
struct MoveOnly {
MoveOnly(MoveOnly&&); // expected-note {{user-declared move}}
MoveOnly &operator=(MoveOnly&&);
};
template void test(CopyOnly); // ok, copies
template void test(MoveOnly); // ok, moves
struct CopyAndMove { // expected-note {{implicitly deleted}}
CopyOnly co;
MoveOnly mo; // expected-note {{deleted copy}}
};
template void test(CopyAndMove); // ok, copies co, moves mo
void test2(CopyAndMove cm) {
(void)CopyAndMove(cm); // expected-error {{deleted}}
cm = cm; // expected-error {{deleted}}
}
namespace VbaseMove {
struct A {};
struct B { B &operator=(B&&); };
struct C { C &operator=(const C&); };
struct D { B b; };
template<typename T, unsigned I, bool NonTrivialMove = false>
struct E : virtual T {};
template<typename T, unsigned I>
struct E<T, I, true> : virtual T { E &operator=(E&&); };
template<typename T>
struct F :
E<T, 0>, // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
E<T, 1> {}; // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
template<typename T>
struct G : E<T, 0, true>, E<T, 0> {};
template<typename T>
struct H : E<T, 0, true>, E<T, 1, true> {};
template<typename T>
struct I : E<T, 0>, T {};
template<typename T>
struct J :
E<T, 0>, // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
virtual T {}; // expected-note-re 2{{virtual base class '{{[BD]}}' declared here}}
template<typename T> void move(T t) { t = static_cast<T&&>(t); }
// expected-warning-re@-1 4{{defaulted move assignment operator of {{.*}} will move assign virtual base class '{{[BD]}}' multiple times}}
template void move(F<A>);
template void move(F<B>); // expected-note {{in instantiation of}}
template void move(F<C>);
template void move(F<D>); // expected-note {{in instantiation of}}
template void move(G<A>);
template void move(G<B>);
template void move(G<C>);
template void move(G<D>);
template void move(H<A>);
template void move(H<B>);
template void move(H<C>);
template void move(H<D>);
template void move(I<A>);
template void move(I<B>);
template void move(I<C>);
template void move(I<D>);
template void move(J<A>);
template void move(J<B>); // expected-note {{in instantiation of}}
template void move(J<C>);
template void move(J<D>); // expected-note {{in instantiation of}}
}
}
namespace PR12625 {
struct X; // expected-note {{forward decl}}
struct Y {
X x; // expected-error {{incomplete}}
} y = Y();
}
Codebase Browser
llvm