Mercurial > hg > CbC > CbC_gcc
comparison gcc/testsuite/g++.dg/expr/composite-ptr-type.C @ 152:2b5abeee2509
update gcc11
| author | anatofuz |
|---|---|
| date | Mon, 25 May 2020 07:50:57 +0900 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 145:1830386684a0 | 152:2b5abeee2509 |
|---|---|
| 1 // DR 1512 | |
| 2 // Test the composite pointer type of two operands. | |
| 3 // { dg-do compile { target c++11 } } | |
| 4 | |
| 5 using nullptr_t = decltype(nullptr); | |
| 6 | |
| 7 template <class T, class U> struct same; | |
| 8 template <class T> struct same<T,T> { }; | |
| 9 | |
| 10 template<typename T> | |
| 11 T fn () | |
| 12 { | |
| 13 } | |
| 14 | |
| 15 // Check that the composite pointer type of T and U is RES. | |
| 16 template<typename T, typename U, typename RES> | |
| 17 void test () | |
| 18 { | |
| 19 same<decltype(true ? fn<T>() : fn<U>()), RES> s; | |
| 20 } | |
| 21 | |
| 22 struct A { }; | |
| 23 struct B : A { }; | |
| 24 | |
| 25 // Test [expr.type]/3. | |
| 26 void | |
| 27 foo () | |
| 28 { | |
| 29 // if both p1 and p2 are null pointer constants -> std::nullptr_t. | |
| 30 test<nullptr_t, nullptr_t, nullptr_t>(); | |
| 31 | |
| 32 // if either p1 or p2 is a null pointer constant -> T2 or T1. | |
| 33 test<nullptr_t, const char **, const char **>(); | |
| 34 test<const char **, nullptr_t, const char **>(); | |
| 35 | |
| 36 // if T1 or T2 is 'pointer to cv1 void' and the other type is 'pointer | |
| 37 // to cv2 T', where T is an object type or void -> 'pointer to cv12 void', | |
| 38 // where cv12 is the union of cv1 and cv2. | |
| 39 test<const int *, volatile void *, const volatile void *>(); | |
| 40 test<const void *, volatile int *, const volatile void *>(); | |
| 41 | |
| 42 test<int *, const int *, const int *>(); | |
| 43 // Make sure that we propagate 'const' here as per [conv.qual]/3.3. | |
| 44 test<int **, const int **, const int *const *>(); | |
| 45 test<int *volatile *, const int **, const int *const volatile *>(); | |
| 46 test<int **, volatile int **, volatile int *const *>(); | |
| 47 | |
| 48 // if T1 is 'pointer to cv1 C1' and T2 is 'pointer to cv2 C2', where C1 is | |
| 49 // reference-related to C2 or C2 is reference-related to C1 -> the cv-combined | |
| 50 // type of T1 and T2 or the cv-combined type of T2 and T1, respectively. | |
| 51 test<const A*, volatile B*, const volatile A *>(); | |
| 52 test<const B*, volatile A*, const volatile A *>(); | |
| 53 | |
| 54 test<const int *A::*, volatile int *A::*, const volatile int *const A::*>(); | |
| 55 // FIXME: This doesn't work if they're reference-related but not same. | |
| 56 //test<const int *A::*, volatile int *B::*, const volatile int *const B::*>(); | |
| 57 //test<const int *B::*, volatile int *A::*, const volatile int *const B::*>(); | |
| 58 | |
| 59 // if T1 or T2 is 'pointer to noexcept function' and the other type is | |
| 60 // 'pointer to function', where the function types are otherwise the same | |
| 61 // -> 'pointer to function'. | |
| 62 test<int (*)() noexcept, int (*)(), int (*)()>(); | |
| 63 test<int (*)(), int (*)() noexcept, int (*)()>(); | |
| 64 | |
| 65 // if T1 or T2 is 'pointer to member of C1 of type function', the other type | |
| 66 // is 'pointer to member of C2 of type noexcept function', and C1 is | |
| 67 // reference-related to C2 or C2 is reference-related to C1, where the | |
| 68 // function types are otherwise the same -> 'pointer to member of C2 of type | |
| 69 // function' or 'pointer to member of C1 of type function', respectively. | |
| 70 test<int (A::*)() noexcept, int (A::*)(), int (A::*)()>(); | |
| 71 test<int (A::*)(), int (A::*)() noexcept, int (A::*)()>(); | |
| 72 } |