1 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-defaulted-function-deleted
2 
3 // expected-no-diagnostics
4 
5 template<typename T, bool B> struct trivially_copyable_check {
6   static_assert(B == __has_trivial_copy(T), "");
7   static_assert(B == __is_trivially_constructible(T, T), "");
8   static_assert(B == __is_trivially_constructible(T, const T &), "");
9   static_assert(B == __is_trivially_constructible(T, T &&), "");
10   typedef void type;
11 };
12 template<typename T> using trivially_copyable =
13   typename trivially_copyable_check<T, true>::type;
14 template<typename T> using not_trivially_copyable =
15   typename trivially_copyable_check<T, false>::type;
16 
17 struct Trivial {};
18 using _ = trivially_copyable<Trivial>;
19 
20 // A copy/move constructor for class X is trivial if it is not user-provided,
21 struct UserProvided {
22   UserProvided(const UserProvided &);
23 };
24 using _ = not_trivially_copyable<UserProvided>;
25 
26 // its declared parameter type is the same as if it had been implicitly
27 // declared,
28 struct NonConstCopy {
29   NonConstCopy(NonConstCopy &) = default;
30 };
31 using _ = not_trivially_copyable<NonConstCopy>;
32 
33 // class X has no virtual functions
34 struct VFn {
35   virtual void f();
36 };
37 using _ = not_trivially_copyable<VFn>;
38 
39 // and no virtual base classes
40 struct VBase : virtual Trivial {};
41 using _ = not_trivially_copyable<VBase>;
42 
43 // and the constructor selected to copy/move each [direct subobject] is trivial
44 struct TemplateCtor {
45   template<typename T> TemplateCtor(T &);
46 };
47 using _ = trivially_copyable<TemplateCtor>;
48 struct TemplateCtorMember {
49   TemplateCtor tc;
50 };
51 using _ = trivially_copyable<TemplateCtorMember>;
52 
53 // We can select a non-trivial copy ctor even if there is a trivial one.
54 struct MutableTemplateCtorMember {
55   mutable TemplateCtor mtc;
56 };
57 static_assert(!__is_trivially_constructible(MutableTemplateCtorMember, const MutableTemplateCtorMember &), "");
58 static_assert(__is_trivially_constructible(MutableTemplateCtorMember, MutableTemplateCtorMember &&), "");
59 struct MutableTemplateCtorMember2 {
60   MutableTemplateCtorMember2(const MutableTemplateCtorMember2 &) = default;
61   MutableTemplateCtorMember2(MutableTemplateCtorMember2 &&) = default;
62   mutable TemplateCtor mtc;
63 };
64 static_assert(!__is_trivially_constructible(MutableTemplateCtorMember2, const MutableTemplateCtorMember2 &), "");
65 static_assert(__is_trivially_constructible(MutableTemplateCtorMember2, MutableTemplateCtorMember2 &&), "");
66 
67 // Both trivial and non-trivial special members.
68 struct TNT {
69   TNT(const TNT &) = default; // trivial
70   TNT(TNT &); // non-trivial
71 
72   TNT(TNT &&) = default; // trivial
73   TNT(const TNT &&); // non-trivial
74 };
75 
76 static_assert(!__has_trivial_copy(TNT), "lie deliberately for gcc compatibility");
77 static_assert(__is_trivially_constructible(TNT, TNT), "");
78 static_assert(!__is_trivially_constructible(TNT, TNT &), "");
79 static_assert(__is_trivially_constructible(TNT, const TNT &), "");
80 static_assert(!__is_trivially_constructible(TNT, volatile TNT &), "");
81 static_assert(__is_trivially_constructible(TNT, TNT &&), "");
82 static_assert(!__is_trivially_constructible(TNT, const TNT &&), "");
83 static_assert(!__is_trivially_constructible(TNT, volatile TNT &&), "");
84 
85 // This has only trivial special members.
86 struct DerivedFromTNT : TNT {};
87 
88 static_assert(__has_trivial_copy(DerivedFromTNT), "");
89 static_assert(__is_trivially_constructible(DerivedFromTNT, DerivedFromTNT), "");
90 static_assert(__is_trivially_constructible(DerivedFromTNT, DerivedFromTNT &), "");
91 static_assert(__is_trivially_constructible(DerivedFromTNT, const DerivedFromTNT &), "");
92 static_assert(!__is_trivially_constructible(DerivedFromTNT, volatile DerivedFromTNT &), "");
93 static_assert(__is_trivially_constructible(DerivedFromTNT, DerivedFromTNT &&), "");
94 static_assert(__is_trivially_constructible(DerivedFromTNT, const DerivedFromTNT &&), "");
95 static_assert(!__is_trivially_constructible(DerivedFromTNT, volatile DerivedFromTNT &&), "");
96 
97 // This has only trivial special members.
98 struct TNTMember {
99   TNT tnt;
100 };
101 
102 static_assert(__has_trivial_copy(TNTMember), "");
103 static_assert(__is_trivially_constructible(TNTMember, TNTMember), "");
104 static_assert(__is_trivially_constructible(TNTMember, TNTMember &), "");
105 static_assert(__is_trivially_constructible(TNTMember, const TNTMember &), "");
106 static_assert(!__is_trivially_constructible(TNTMember, volatile TNTMember &), "");
107 static_assert(__is_trivially_constructible(TNTMember, TNTMember &&), "");
108 static_assert(__is_trivially_constructible(TNTMember, const TNTMember &&), "");
109 static_assert(!__is_trivially_constructible(TNTMember, volatile TNTMember &&), "");
110 
111 struct NCCTNT : NonConstCopy, TNT {};
112 
113 static_assert(!__has_trivial_copy(NCCTNT), "");
114 static_assert(!__is_trivially_constructible(NCCTNT, NCCTNT), "");
115 static_assert(!__is_trivially_constructible(NCCTNT, NCCTNT &), "");
116 static_assert(!__is_trivially_constructible(NCCTNT, const NCCTNT &), "");
117 static_assert(!__is_trivially_constructible(NCCTNT, volatile NCCTNT &), "");
118 static_assert(!__is_trivially_constructible(NCCTNT, NCCTNT &&), "");
119 static_assert(!__is_trivially_constructible(NCCTNT, const NCCTNT &&), "");
120 static_assert(!__is_trivially_constructible(NCCTNT, volatile NCCTNT &&), "");
121 
122 struct TemplateCtorNoMove {
123   TemplateCtorNoMove(const TemplateCtorNoMove &) = default;
124   template<typename T> TemplateCtorNoMove(T &&);
125 };
126 static_assert(__is_trivially_constructible(TemplateCtorNoMove, const TemplateCtorNoMove &), "");
127 static_assert(!__is_trivially_constructible(TemplateCtorNoMove, TemplateCtorNoMove &&), "");
128 
129 struct UseTemplateCtorNoMove {
130   TemplateCtorNoMove tcnm;
131 };
132 static_assert(__is_trivially_constructible(UseTemplateCtorNoMove, const UseTemplateCtorNoMove &), "");
133 static_assert(!__is_trivially_constructible(UseTemplateCtorNoMove, UseTemplateCtorNoMove &&), "");
134 
135 struct TemplateCtorNoMoveSFINAE {
136   TemplateCtorNoMoveSFINAE(const TemplateCtorNoMoveSFINAE &) = default;
137   template<typename T, typename U = typename T::error> TemplateCtorNoMoveSFINAE(T &&);
138 };
139 static_assert(__is_trivially_constructible(TemplateCtorNoMoveSFINAE, const TemplateCtorNoMoveSFINAE &), "");
140 static_assert(__is_trivially_constructible(TemplateCtorNoMoveSFINAE, TemplateCtorNoMoveSFINAE &&), "");
141 
142 struct UseTemplateCtorNoMoveSFINAE {
143   TemplateCtorNoMoveSFINAE tcnm;
144 };
145 static_assert(__is_trivially_constructible(UseTemplateCtorNoMoveSFINAE, const UseTemplateCtorNoMoveSFINAE &), "");
146 static_assert(__is_trivially_constructible(UseTemplateCtorNoMoveSFINAE, UseTemplateCtorNoMoveSFINAE &&), "");
147 
148 namespace TrivialityDependsOnImplicitDeletion {
149   struct PrivateMove {
150     PrivateMove(const PrivateMove &) = default;
151   private:
152     PrivateMove(PrivateMove &&);
153     friend class Access;
154   };
155   static_assert(__is_trivially_constructible(PrivateMove, const PrivateMove &), "");
156   static_assert(!__is_trivially_constructible(PrivateMove, PrivateMove &&), "");
157 
158   struct NoAccess {
159     PrivateMove pm;
160     // NoAccess's move is deleted, so moves of it use PrivateMove's copy ctor,
161     // which is trivial.
162   };
163   static_assert(__is_trivially_constructible(NoAccess, const NoAccess &), "");
164   static_assert(__is_trivially_constructible(NoAccess, NoAccess &&), "");
165   struct TopNoAccess : NoAccess {};
166   static_assert(__is_trivially_constructible(TopNoAccess, const TopNoAccess &), "");
167   static_assert(__is_trivially_constructible(TopNoAccess, TopNoAccess &&), "");
168 
169   struct Access {
170     PrivateMove pm;
171     // NoAccess's move would *not* be deleted, so is *not* suppressed,
172     // so moves of it use PrivateMove's move ctor, which is not trivial.
173   };
174   static_assert(__is_trivially_constructible(Access, const Access &), "");
175   static_assert(!__is_trivially_constructible(Access, Access &&), "");
176   struct TopAccess : Access {};
177   static_assert(__is_trivially_constructible(TopAccess, const TopAccess &), "");
178   static_assert(!__is_trivially_constructible(TopAccess, TopAccess &&), "");
179 }
180 
181 namespace TrivialityDependsOnDestructor {
182   class HasInaccessibleDestructor { ~HasInaccessibleDestructor() = default; };
183   struct HasImplicitlyDeletedDestructor : HasInaccessibleDestructor {};
184   struct HasImplicitlyDeletedCopyCtor : HasImplicitlyDeletedDestructor {
185     HasImplicitlyDeletedCopyCtor() = default;
186     template<typename T> HasImplicitlyDeletedCopyCtor(T &&);
187     // Copy ctor is deleted but trivial.
188     // Move ctor is suppressed.
189     HasImplicitlyDeletedCopyCtor(const HasImplicitlyDeletedCopyCtor&) = default;
190     HasImplicitlyDeletedCopyCtor(HasImplicitlyDeletedCopyCtor&&) = default;
191   };
192   struct Test : HasImplicitlyDeletedCopyCtor {
193     Test(const Test&) = default;
194     Test(Test&&) = default;
195   };
196   // Implicit copy ctor calls deleted trivial copy ctor.
197   static_assert(__has_trivial_copy(Test), "");
198   // This is false because the destructor is deleted.
199   static_assert(!__is_trivially_constructible(Test, const Test &), "");
200   // Implicit move ctor calls template ctor.
201   static_assert(!__is_trivially_constructible(Test, Test &&), "");
202 
203   struct HasAccessibleDestructor { ~HasAccessibleDestructor() = default; };
204   struct HasImplicitlyDefaultedDestructor : HasAccessibleDestructor {};
205   struct HasImplicitlyDefaultedCopyCtor : HasImplicitlyDefaultedDestructor {
206     template<typename T> HasImplicitlyDefaultedCopyCtor(T &&);
207     // Copy ctor is trivial.
208     // Move ctor is trivial.
209   };
210   struct Test2 : HasImplicitlyDefaultedCopyCtor {};
211   // Implicit copy ctor calls trivial copy ctor.
212   static_assert(__has_trivial_copy(Test2), "");
213   static_assert(__is_trivially_constructible(Test2, const Test2 &), "");
214   // Implicit move ctor calls trivial move ctor.
215   static_assert(__is_trivially_constructible(Test2, Test2 &&), "");
216 }
217