1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10 
11 // template<class Derived, class Base>
12 // concept derived_from;
13 
14 #include <concepts>
15 #include <type_traits>
16 
17 struct Base1 {};
18 struct Derived1 : Base1 {};
19 struct Derived2 : Base1 {};
20 
21 struct DerivedPrivate : private Base1 {};
22 struct Derived3 : DerivedPrivate {};
23 
24 struct DerivedProtected : protected DerivedPrivate {};
25 struct Derived4 : DerivedProtected {};
26 struct Derived5 : Derived4 {};
27 
28 template <typename From, typename To>
29 constexpr void CheckNotDerivedFromPointer() {
30   { // From as pointer
31     static_assert(!std::derived_from<From*, To>);
32     static_assert(!std::derived_from<From*, const To>);
33     static_assert(!std::derived_from<From*, volatile To>);
34     static_assert(!std::derived_from<From*, const volatile To>);
35 
36     if constexpr (!std::same_as<To, void>) {
37       static_assert(!std::derived_from<From*, To&>);
38       static_assert(!std::derived_from<From*, const To&>);
39       static_assert(!std::derived_from<From*, volatile To&>);
40       static_assert(!std::derived_from<From*, const volatile To&>);
41 
42       static_assert(!std::derived_from<From*, To&&>);
43       static_assert(!std::derived_from<From*, const To&&>);
44       static_assert(!std::derived_from<From*, volatile To&&>);
45       static_assert(!std::derived_from<From*, const volatile To&&>);
46 
47       static_assert(!std::derived_from<const From*, To&>);
48       static_assert(!std::derived_from<const From*, const To&>);
49       static_assert(!std::derived_from<const From*, volatile To&>);
50       static_assert(!std::derived_from<const From*, const volatile To&>);
51 
52       static_assert(!std::derived_from<const From*, To&&>);
53       static_assert(!std::derived_from<const From*, const To&&>);
54       static_assert(!std::derived_from<const From*, volatile To&&>);
55       static_assert(!std::derived_from<const From*, const volatile To&&>);
56 
57       static_assert(!std::derived_from<volatile From*, To&>);
58       static_assert(!std::derived_from<volatile From*, const To&>);
59       static_assert(!std::derived_from<volatile From*, volatile To&>);
60       static_assert(!std::derived_from<volatile From*, const volatile To&>);
61 
62       static_assert(!std::derived_from<volatile From*, To&&>);
63       static_assert(!std::derived_from<volatile From*, const To&&>);
64       static_assert(!std::derived_from<volatile From*, volatile To&&>);
65       static_assert(!std::derived_from<volatile From*, const volatile To&&>);
66 
67       static_assert(!std::derived_from<const volatile From*, To&>);
68       static_assert(!std::derived_from<const volatile From*, const To&>);
69       static_assert(!std::derived_from<const volatile From*, volatile To&>);
70       static_assert(
71           !std::derived_from<const volatile From*, const volatile To&>);
72 
73       static_assert(!std::derived_from<const volatile From*, To&&>);
74       static_assert(!std::derived_from<const volatile From*, const To&&>);
75       static_assert(!std::derived_from<const volatile From*, volatile To&&>);
76       static_assert(
77           !std::derived_from<const volatile From*, const volatile To&&>);
78     }
79   }
80   { // To as pointer
81     static_assert(!std::derived_from<From, To*>);
82     static_assert(!std::derived_from<From, const To*>);
83     static_assert(!std::derived_from<From, volatile To*>);
84     static_assert(!std::derived_from<From, const volatile To*>);
85 
86     if constexpr (!std::same_as<From, void>) {
87       static_assert(!std::derived_from<From&, To*>);
88       static_assert(!std::derived_from<From&, const To*>);
89       static_assert(!std::derived_from<From&, volatile To*>);
90       static_assert(!std::derived_from<From&, const volatile To*>);
91 
92       static_assert(!std::derived_from<From&&, To*>);
93       static_assert(!std::derived_from<From&&, const To*>);
94       static_assert(!std::derived_from<From&&, volatile To*>);
95       static_assert(!std::derived_from<From&&, const volatile To*>);
96 
97       static_assert(!std::derived_from<const From&, To*>);
98       static_assert(!std::derived_from<const From&, const To*>);
99       static_assert(!std::derived_from<const From&, volatile To*>);
100       static_assert(!std::derived_from<const From&, const volatile To*>);
101 
102       static_assert(!std::derived_from<const From&&, To*>);
103       static_assert(!std::derived_from<const From&&, const To*>);
104       static_assert(!std::derived_from<const From&&, volatile To*>);
105       static_assert(!std::derived_from<const From&&, const volatile To*>);
106 
107       static_assert(!std::derived_from<volatile From&, To*>);
108       static_assert(!std::derived_from<volatile From&, const To*>);
109       static_assert(!std::derived_from<volatile From&, volatile To*>);
110       static_assert(!std::derived_from<volatile From&, const volatile To*>);
111 
112       static_assert(!std::derived_from<volatile From&&, To*>);
113       static_assert(!std::derived_from<volatile From&&, const To*>);
114       static_assert(!std::derived_from<volatile From&&, volatile To*>);
115       static_assert(!std::derived_from<volatile From&&, const volatile To*>);
116 
117       static_assert(!std::derived_from<const volatile From&, To*>);
118       static_assert(!std::derived_from<const volatile From&, const To*>);
119       static_assert(!std::derived_from<const volatile From&, volatile To*>);
120       static_assert(
121           !std::derived_from<const volatile From&, const volatile To*>);
122 
123       static_assert(!std::derived_from<const volatile From&&, To*>);
124       static_assert(!std::derived_from<const volatile From&&, const To*>);
125       static_assert(!std::derived_from<const volatile From&&, volatile To*>);
126       static_assert(
127           !std::derived_from<const volatile From&&, const volatile To*>);
128     }
129   }
130   { // Both as pointers
131     static_assert(!std::derived_from<From*, To*>);
132     static_assert(!std::derived_from<From*, const To*>);
133     static_assert(!std::derived_from<From*, volatile To*>);
134     static_assert(!std::derived_from<From*, const volatile To*>);
135 
136     static_assert(!std::derived_from<const From*, To*>);
137     static_assert(!std::derived_from<const From*, const To*>);
138     static_assert(!std::derived_from<const From*, volatile To*>);
139     static_assert(!std::derived_from<const From*, const volatile To*>);
140 
141     static_assert(!std::derived_from<volatile From*, To*>);
142     static_assert(!std::derived_from<volatile From*, const To*>);
143     static_assert(!std::derived_from<volatile From*, volatile To*>);
144     static_assert(!std::derived_from<volatile From*, const volatile To*>);
145 
146     static_assert(!std::derived_from<const volatile From*, To*>);
147     static_assert(!std::derived_from<const volatile From*, const To*>);
148     static_assert(!std::derived_from<const volatile From*, volatile To*>);
149     static_assert(!std::derived_from<const volatile From*, const volatile To*>);
150   }
151 
152   // From as the return type of a pointer-to-function
153   if constexpr (!std::is_array_v<From>) {
154     static_assert(!std::derived_from<From (*)(), To>);
155     static_assert(!std::derived_from<From (*)(int), To>);
156   }
157 
158   // To as the return type of a pointer-to-function
159   if constexpr (!std::is_array_v<To>) {
160     static_assert(!std::derived_from<From, To (*)()>);
161     static_assert(!std::derived_from<From, To (*)(double)>);
162   }
163 
164   // Both as the return type of a pointer-to-function
165   if constexpr (!std::is_array_v<From> && !std::is_array_v<To>) {
166     static_assert(!std::derived_from<From (*)(), To (*)()>);
167     static_assert(!std::derived_from<From (*)(int), To (*)(double)>);
168   }
169   { // pointer-to-member
170     if constexpr (std::is_class_v<From> && !std::same_as<To, void>) {
171       static_assert(!std::derived_from<To From::*, To>);
172     }
173 
174     if constexpr (std::is_class_v<To> && !std::same_as<From, void>) {
175       static_assert(!std::derived_from<From To::*, From>);
176     }
177   }
178   { // pointer-to-member-functions
179     if constexpr (std::is_class_v<From>) {
180       static_assert(!std::derived_from<From (From::*)(), To>);
181     }
182 
183     if constexpr (std::is_class_v<To>) {
184       static_assert(!std::derived_from<To (To::*)(), From>);
185     }
186   }
187 }
188 
189 template <typename From, typename To>
190 constexpr void CheckNotDerivedFromReference() {
191   if constexpr (!std::same_as<To, void>) {
192     static_assert(!std::derived_from<From, To&>);
193     static_assert(!std::derived_from<From, const To&>);
194     static_assert(!std::derived_from<From, volatile To&>);
195     static_assert(!std::derived_from<From, const volatile To&>);
196 
197     static_assert(!std::derived_from<From, To&&>);
198     static_assert(!std::derived_from<From, const To&&>);
199     static_assert(!std::derived_from<From, volatile To&&>);
200     static_assert(!std::derived_from<From, const volatile To&&>);
201   }
202 
203   if constexpr (!std::same_as<From, void>) {
204     static_assert(!std::derived_from<From&, To>);
205     static_assert(!std::derived_from<From&, To>);
206     static_assert(!std::derived_from<From&, To>);
207     static_assert(!std::derived_from<From&, To>);
208 
209     static_assert(!std::derived_from<From&&, To>);
210     static_assert(!std::derived_from<From&&, To>);
211     static_assert(!std::derived_from<From&&, To>);
212     static_assert(!std::derived_from<From&&, To>);
213   }
214 
215   // From as lvalue references
216   if constexpr (!std::same_as<From, void> && !std::same_as<To, void>) {
217     static_assert(!std::derived_from<From&, To&>);
218     static_assert(!std::derived_from<From&, const To&>);
219     static_assert(!std::derived_from<From&, volatile To&>);
220     static_assert(!std::derived_from<From&, const volatile To&>);
221 
222     static_assert(!std::derived_from<From&, To&&>);
223     static_assert(!std::derived_from<From&, const To&&>);
224     static_assert(!std::derived_from<From&, volatile To&&>);
225     static_assert(!std::derived_from<From&, const volatile To&&>);
226 
227     static_assert(!std::derived_from<const From&, To&>);
228     static_assert(!std::derived_from<const From&, const To&>);
229     static_assert(!std::derived_from<const From&, volatile To&>);
230     static_assert(!std::derived_from<const From&, const volatile To&>);
231 
232     static_assert(!std::derived_from<const From&, To&&>);
233     static_assert(!std::derived_from<const From&, const To&&>);
234     static_assert(!std::derived_from<const From&, volatile To&&>);
235     static_assert(!std::derived_from<const From&, const volatile To&&>);
236 
237     static_assert(!std::derived_from<volatile From&, To&>);
238     static_assert(!std::derived_from<volatile From&, const To&>);
239     static_assert(!std::derived_from<volatile From&, volatile To&>);
240     static_assert(!std::derived_from<volatile From&, const volatile To&>);
241 
242     static_assert(!std::derived_from<volatile From&, To&&>);
243     static_assert(!std::derived_from<volatile From&, const To&&>);
244     static_assert(!std::derived_from<volatile From&, volatile To&&>);
245     static_assert(!std::derived_from<volatile From&, const volatile To&&>);
246 
247     static_assert(!std::derived_from<const volatile From&, To&>);
248     static_assert(!std::derived_from<const volatile From&, const To&>);
249     static_assert(!std::derived_from<const volatile From&, volatile To&>);
250     static_assert(!std::derived_from<const volatile From&, const volatile To&>);
251 
252     static_assert(!std::derived_from<const volatile From&, To&&>);
253     static_assert(!std::derived_from<const volatile From&, const To&&>);
254     static_assert(!std::derived_from<const volatile From&, volatile To&&>);
255     static_assert(
256         !std::derived_from<const volatile From&, const volatile To&&>);
257 
258     // From as rvalue references
259     static_assert(!std::derived_from<From&&, To&>);
260     static_assert(!std::derived_from<From&&, const To&>);
261     static_assert(!std::derived_from<From&&, volatile To&>);
262     static_assert(!std::derived_from<From&&, const volatile To&>);
263 
264     static_assert(!std::derived_from<From&&, To&&>);
265     static_assert(!std::derived_from<From&&, const To&&>);
266     static_assert(!std::derived_from<From&&, volatile To&&>);
267     static_assert(!std::derived_from<From&&, const volatile To&&>);
268 
269     static_assert(!std::derived_from<const From&&, To&>);
270     static_assert(!std::derived_from<const From&&, const To&>);
271     static_assert(!std::derived_from<const From&&, volatile To&>);
272     static_assert(!std::derived_from<const From&&, const volatile To&>);
273 
274     static_assert(!std::derived_from<const From&&, To&&>);
275     static_assert(!std::derived_from<const From&&, const To&&>);
276     static_assert(!std::derived_from<const From&&, volatile To&&>);
277     static_assert(!std::derived_from<const From&&, const volatile To&&>);
278 
279     static_assert(!std::derived_from<volatile From&&, To&>);
280     static_assert(!std::derived_from<volatile From&&, const To&>);
281     static_assert(!std::derived_from<volatile From&&, volatile To&>);
282     static_assert(!std::derived_from<volatile From&&, const volatile To&>);
283 
284     static_assert(!std::derived_from<volatile From&&, To&&>);
285     static_assert(!std::derived_from<volatile From&&, const To&&>);
286     static_assert(!std::derived_from<volatile From&&, volatile To&&>);
287     static_assert(!std::derived_from<volatile From&&, const volatile To&&>);
288 
289     static_assert(!std::derived_from<const volatile From&&, To&>);
290     static_assert(!std::derived_from<const volatile From&&, const To&>);
291     static_assert(!std::derived_from<const volatile From&&, volatile To&>);
292     static_assert(
293         !std::derived_from<const volatile From&&, const volatile To&>);
294 
295     static_assert(!std::derived_from<const volatile From&&, To&&>);
296     static_assert(!std::derived_from<const volatile From&&, const To&&>);
297     static_assert(!std::derived_from<const volatile From&&, volatile To&&>);
298     static_assert(
299         !std::derived_from<const volatile From&&, const volatile To&&>);
300   }
301 
302   // From as the return type of a reference-to-function
303   if constexpr (!std::is_array_v<From>) {
304     static_assert(!std::derived_from<From (&)(), To>);
305     static_assert(!std::derived_from<From (&)(int), To>);
306   }
307   // To as the return type of a reference-to-function
308   if constexpr (!std::is_array_v<To>) {
309     static_assert(!std::derived_from<From, To (&)()>);
310     static_assert(!std::derived_from<From, To (&)(double)>);
311   }
312   // Both as the return type of a reference-to-function
313   if constexpr (!std::is_array_v<From> && !std::is_array_v<To>) {
314     static_assert(!std::derived_from<From (&)(), To (&)()>);
315     static_assert(!std::derived_from<From (&)(int), To (&)(double)>);
316   }
317 }
318 
319 template <typename From, typename To>
320 constexpr void CheckDerivedFrom() {
321   static_assert(std::derived_from<From, To>);
322 
323   static_assert(std::derived_from<From, const To>);
324   static_assert(std::derived_from<From, volatile To>);
325   static_assert(std::derived_from<From, const volatile To>);
326 
327   static_assert(std::derived_from<const From, const To>);
328   static_assert(std::derived_from<const From, volatile To>);
329   static_assert(std::derived_from<const From, const volatile To>);
330 
331   static_assert(std::derived_from<volatile From, const To>);
332   static_assert(std::derived_from<volatile From, volatile To>);
333   static_assert(std::derived_from<volatile From, const volatile To>);
334 
335   static_assert(std::derived_from<const volatile From, const To>);
336   static_assert(std::derived_from<const volatile From, volatile To>);
337   static_assert(std::derived_from<const volatile From, const volatile To>);
338 
339   CheckNotDerivedFromPointer<From, To>();
340   CheckNotDerivedFromReference<From, To>();
341 }
342 
343 template <typename From, typename To>
344 constexpr void CheckNotDerivedFrom() {
345   static_assert(!std::derived_from<From, To>);
346 
347   static_assert(!std::derived_from<From, const To>);
348   static_assert(!std::derived_from<From, volatile To>);
349   static_assert(!std::derived_from<From, const volatile To>);
350 
351   static_assert(!std::derived_from<const From, const To>);
352   static_assert(!std::derived_from<const From, volatile To>);
353   static_assert(!std::derived_from<const From, const volatile To>);
354 
355   static_assert(!std::derived_from<volatile From, const To>);
356   static_assert(!std::derived_from<volatile From, volatile To>);
357   static_assert(!std::derived_from<volatile From, const volatile To>);
358 
359   static_assert(!std::derived_from<const volatile From, const To>);
360   static_assert(!std::derived_from<const volatile From, volatile To>);
361   static_assert(!std::derived_from<const volatile From, const volatile To>);
362 
363   CheckNotDerivedFromPointer<From, To>();
364   CheckNotDerivedFromReference<From, To>();
365 }
366 
367 enum Enumeration { Yes, No };
368 enum class ScopedEnumeration : int { No, Yes };
369 
370 int main(int, char**) {
371   { // Fundamentals shouldn't be derived from anything
372     CheckNotDerivedFrom<int, long>();
373     CheckNotDerivedFrom<signed char, char>();
374     CheckNotDerivedFrom<double, Base1>();
375 
376     CheckNotDerivedFrom<int, Enumeration>();
377     CheckNotDerivedFrom<int, ScopedEnumeration>();
378 
379     CheckNotDerivedFrom<void, void>();
380     CheckNotDerivedFrom<int, int>();
381   }
382   { // Nothing should be derived from a fundamental type
383     CheckNotDerivedFrom<Enumeration, int>();
384     CheckNotDerivedFrom<ScopedEnumeration, int>();
385 
386     CheckNotDerivedFrom<Base1, int>();
387     CheckNotDerivedFrom<Base1, double>();
388     CheckNotDerivedFrom<Derived1, char>();
389     CheckNotDerivedFrom<DerivedPrivate, long long>();
390   }
391   { // Other built-in things shouldn't have derivations
392     CheckNotDerivedFrom<Enumeration, Enumeration>();
393     CheckNotDerivedFrom<ScopedEnumeration, ScopedEnumeration>();
394 
395     CheckNotDerivedFrom<Enumeration, ScopedEnumeration>();
396     CheckNotDerivedFrom<ScopedEnumeration, Enumeration>();
397 
398     CheckNotDerivedFrom<Base1[5], Base1>();
399     CheckNotDerivedFrom<Derived1[5], Base1>();
400 
401     CheckNotDerivedFrom<Base1, Base1[5]>();
402     CheckNotDerivedFrom<Derived1, Base1[5]>();
403   }
404 
405   { // Base1 is the subject.
406     CheckDerivedFrom<Base1, Base1>();
407 
408     CheckNotDerivedFrom<Base1, void>();
409     CheckNotDerivedFrom<Base1, DerivedPrivate>();
410     CheckNotDerivedFrom<Base1, DerivedProtected>();
411     CheckNotDerivedFrom<Base1, Derived1>();
412     CheckNotDerivedFrom<Base1, Derived2>();
413     CheckNotDerivedFrom<Base1, Derived3>();
414     CheckNotDerivedFrom<Base1, Derived4>();
415   }
416 
417   { // Derived1 is the subject.
418     CheckDerivedFrom<Derived1, Base1>();
419     CheckDerivedFrom<Derived1, Derived1>();
420 
421     CheckNotDerivedFromPointer<Derived1, void>();
422     CheckNotDerivedFrom<Derived1, DerivedPrivate>();
423     CheckNotDerivedFrom<Derived1, DerivedProtected>();
424     CheckNotDerivedFrom<Derived1, Derived2>();
425     CheckNotDerivedFrom<Derived1, Derived3>();
426     CheckNotDerivedFrom<Derived1, Derived4>();
427   }
428 
429   { // Derived2 is the subject.
430     CheckDerivedFrom<Derived2, Base1>();
431     CheckDerivedFrom<Derived2, Derived2>();
432 
433     CheckNotDerivedFrom<Derived2, DerivedPrivate>();
434     CheckNotDerivedFrom<Derived2, DerivedProtected>();
435     CheckNotDerivedFrom<Derived2, Derived1>();
436     CheckNotDerivedFrom<Derived2, Derived3>();
437     CheckNotDerivedFrom<Derived2, Derived4>();
438   }
439 
440   { // DerivedPrivate is the subject.
441     CheckDerivedFrom<DerivedPrivate, DerivedPrivate>();
442 
443     CheckNotDerivedFrom<DerivedPrivate, Base1>();
444     CheckNotDerivedFrom<DerivedPrivate, DerivedProtected>();
445     CheckNotDerivedFrom<DerivedPrivate, Derived1>();
446     CheckNotDerivedFrom<DerivedPrivate, Derived2>();
447     CheckNotDerivedFrom<DerivedPrivate, Derived3>();
448     CheckNotDerivedFrom<DerivedPrivate, Derived4>();
449   }
450 
451   { // Derived3 is the subject.
452     CheckDerivedFrom<Derived3, DerivedPrivate>();
453     CheckDerivedFrom<Derived3, Derived3>();
454 
455     CheckNotDerivedFrom<Derived3, Base1>();
456     CheckNotDerivedFrom<Derived3, DerivedProtected>();
457     CheckNotDerivedFrom<Derived3, Derived1>();
458     CheckNotDerivedFrom<Derived3, Derived2>();
459     CheckNotDerivedFrom<Derived3, Derived4>();
460   }
461 
462   { // DerivedProtected is the subject.
463     CheckDerivedFrom<DerivedProtected, DerivedProtected>();
464 
465     CheckNotDerivedFromPointer<DerivedProtected, Base1>();
466     CheckNotDerivedFromPointer<DerivedProtected, DerivedPrivate>();
467     CheckNotDerivedFromPointer<DerivedProtected, Derived1>();
468     CheckNotDerivedFromPointer<DerivedProtected, Derived2>();
469     CheckNotDerivedFromPointer<DerivedProtected, Derived3>();
470     CheckNotDerivedFromPointer<DerivedProtected, Derived4>();
471   }
472 
473   { // Derived4 is the subject.
474     CheckDerivedFrom<Derived4, DerivedProtected>();
475     CheckDerivedFrom<Derived4, Derived4>();
476 
477     CheckNotDerivedFrom<Derived4, Base1>();
478     CheckNotDerivedFrom<Derived4, DerivedPrivate>();
479     CheckNotDerivedFrom<Derived4, Derived1>();
480     CheckNotDerivedFrom<Derived4, Derived2>();
481     CheckNotDerivedFrom<Derived4, Derived3>();
482   }
483 
484   { // Derived5 is the subject.
485     CheckDerivedFrom<Derived5, DerivedProtected>();
486     CheckDerivedFrom<Derived5, Derived4>();
487     CheckDerivedFrom<Derived5, Derived5>();
488 
489     CheckNotDerivedFrom<Derived5, Base1>();
490     CheckNotDerivedFrom<Derived5, DerivedPrivate>();
491     CheckNotDerivedFrom<Derived5, Derived1>();
492     CheckNotDerivedFrom<Derived5, Derived2>();
493     CheckNotDerivedFrom<Derived5, Derived3>();
494   }
495 
496   return 0;
497 }
498