1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++20 -x objective-c++ -fobjc-arc -fenable-matrix -triple i686-pc-win32 2 3 enum class N {}; 4 5 using B1 = int; 6 using X1 = B1; 7 using Y1 = B1; 8 9 using B2 = void; 10 using X2 = B2; 11 using Y2 = B2; 12 13 using A3 = char __attribute__((vector_size(4))); 14 using B3 = A3; 15 using X3 = B3; 16 using Y3 = B3; 17 18 using A4 = float; 19 using B4 = A4 __attribute__((matrix_type(4, 4))); 20 using X4 = B4; 21 using Y4 = B4; 22 23 using X5 = A4 __attribute__((matrix_type(3, 4))); 24 using Y5 = A4 __attribute__((matrix_type(4, 3))); 25 26 N t1 = 0 ? X1() : Y1(); // expected-error {{rvalue of type 'B1'}} 27 N t2 = 0 ? X2() : Y2(); // expected-error {{rvalue of type 'B2'}} 28 29 const X1 &xt3 = 0; 30 const Y1 &yt3 = 0; 31 N t3 = 0 ? xt3 : yt3; // expected-error {{lvalue of type 'const B1'}} 32 33 N t4 = X3() + Y3(); // expected-error {{rvalue of type 'B3'}} 34 35 N t5 = A3() ? X3() : Y3(); // expected-error {{rvalue of type 'B3'}} 36 N t6 = A3() ? X1() : Y1(); // expected-error {{vector condition type 'A3' (vector of 4 'char' values) and result type '__attribute__((__vector_size__(4 * sizeof(B1)))) B1' (vector of 4 'B1' values) do not have elements of the same size}} 37 38 N t7 = X4() + Y4(); // expected-error {{rvalue of type 'B4'}} 39 N t8 = X4() * Y4(); // expected-error {{rvalue of type 'B4'}} 40 N t9 = X5() * Y5(); // expected-error {{rvalue of type 'A4 __attribute__((matrix_type(3, 3)))'}} 41 42 template <class T> struct S1 { 43 template <class U> struct S2 {}; 44 }; 45 46 N t10 = 0 ? S1<X1>() : S1<Y1>(); // expected-error {{from 'S1<B1>' (aka 'S1<int>')}} 47 N t11 = 0 ? S1<X1>::S2<X2>() : S1<Y1>::S2<Y2>(); // expected-error {{from 'S1<int>::S2<B2>' (aka 'S2<void>')}} 48 49 template <class T> using Al = S1<T>; 50 51 N t12 = 0 ? Al<X1>() : Al<Y1>(); // expected-error {{from 'Al<B1>' (aka 'S1<int>')}} 52 53 #define AS1 __attribute__((address_space(1))) 54 #define AS2 __attribute__((address_space(1))) 55 using AS1X1 = AS1 B1; 56 using AS1Y1 = AS1 B1; 57 using AS2Y1 = AS2 B1; 58 N t13 = 0 ? (AS1X1){} : (AS1Y1){}; // expected-error {{rvalue of type 'AS1 B1' (aka '__attribute__((address_space(1))) int')}} 59 N t14 = 0 ? (AS1X1){} : (AS2Y1){}; // expected-error {{rvalue of type '__attribute__((address_space(1))) B1' (aka '__attribute__((address_space(1))) int')}} 60 61 using FX1 = X1 (); 62 using FY1 = Y1 (); 63 N t15 = 0 ? (FX1*){} : (FY1*){}; // expected-error {{rvalue of type 'B1 (*)()' (aka 'int (*)()')}} 64 65 struct SS1 {}; 66 using SB1 = SS1; 67 using SX1 = SB1; 68 using SY1 = SB1; 69 70 using MFX1 = X1 SX1::*(); 71 using MFY1 = Y1 SY1::*(); 72 73 N t16 = 0 ? (MFX1*){} : (MFY1*){}; // expected-error {{rvalue of type 'B1 SB1::*(*)()'}} 74 75 N t17 = 0 ? (FX1 SX1::*){} : (FY1 SY1::*){}; // expected-error {{rvalue of type 'B1 (SB1::*)() __attribute__((thiscall))'}} 76 77 N t18 = 0 ? (__typeof(X1*)){} : (__typeof(Y1*)){}; // expected-error {{rvalue of type 'typeof(B1 *)' (aka 'int *')}} 78 79 struct Enums { 80 enum X : B1; 81 enum Y : ::B1; 82 }; 83 using EnumsB = Enums; 84 using EnumsX = EnumsB; 85 using EnumsY = EnumsB; 86 87 N t19 = 0 ? (__underlying_type(EnumsX::X)){} : (__underlying_type(EnumsY::Y)){}; 88 // expected-error@-1 {{rvalue of type 'B1' (aka 'int')}} 89 90 N t20 = 0 ? (__underlying_type(EnumsX::X)){} : (__underlying_type(EnumsY::X)){}; 91 // expected-error@-1 {{rvalue of type '__underlying_type(Enums::X)' (aka 'int')}} 92 93 using QX = const SB1 *; 94 using QY = const ::SB1 *; 95 N t23 = 0 ? (QX){} : (QY){}; // expected-error {{rvalue of type 'const SB1 *' (aka 'const SS1 *')}} 96 97 template <class T> using Alias = short; 98 N t24 = 0 ? (Alias<X1>){} : (Alias<Y1>){}; // expected-error {{rvalue of type 'Alias<B1>' (aka 'short')}} 99 N t25 = 0 ? (Alias<X1>){} : (Alias<X2>){}; // expected-error {{rvalue of type 'short'}} 100 101 template <class T, class U> concept C1 = true; 102 template <class T, class U> concept C2 = true; 103 C1<X1> auto t26_1 = (SB1){}; 104 C1<X2> auto t26_2 = (::SB1){}; 105 C2<X2> auto t26_3 = (::SB1){}; 106 N t26 = 0 ? t26_1 : t26_2; // expected-error {{from 'SB1' (aka 'SS1')}} 107 N t27 = 0 ? t26_1 : t26_3; // expected-error {{from 'SB1' (aka 'SS1')}} 108 109 using RPB1 = X1*; 110 using RPX1 = RPB1; 111 using RPB1 = Y1*; // redeclared 112 using RPY1 = RPB1; 113 N t28 = *(RPB1){}; // expected-error {{lvalue of type 'Y1' (aka 'int')}} 114 auto t29 = 0 ? (RPX1){} : (RPY1){}; 115 N t30 = t29; // expected-error {{lvalue of type 'RPB1' (aka 'int *')}} 116 N t31 = *t29; // expected-error {{lvalue of type 'B1' (aka 'int')}} 117 118 namespace A { using type1 = X1*; }; 119 namespace C { using A::type1; }; 120 using UPX1 = C::type1; 121 namespace A { using type1 = Y1*; }; // redeclared 122 namespace C { using A::type1; }; // redeclared 123 using UPY1 = C::type1; 124 auto t32 = 0 ? (UPX1){} : (UPY1){}; 125 N t33 = t32; // expected-error {{lvalue of type 'C::type1' (aka 'int *')}} 126 N t34 = *t32; // expected-error {{lvalue of type 'B1' (aka 'int')}} 127 128 // See https://github.com/llvm/llvm-project/issues/61419 129 namespace PR61419 { 130 template <class T0, class T1> struct pair { 131 T0 first; 132 T1 second; 133 }; 134 135 extern const pair<id, id> p; 136 id t = false ? p.first : p.second; 137 } // namespace PR61419 138 139 namespace GH67603 { 140 template <class> using A = long; 141 template <class B> void h() { 142 using C = B; 143 using D = B; 144 N t = 0 ? A<decltype(C())>() : A<decltype(D())>(); 145 // expected-error@-1 {{rvalue of type 'A<decltype(C())>' (aka 'long')}} 146 } 147 template void h<int>(); 148 } // namespace GH67603 149