1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify=expected,expected-cxx11 -std=c++11 -Wsign-conversion %s
2 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify=expected,expected-cxx17 -std=c++17 -Wsign-conversion %s
3
4 // C++ rules for ?: are a lot stricter than C rules, and have to take into
5 // account more conversion options.
6 // This test runs in C++11 mode for the contextual conversion of the condition.
7
8 struct ToBool { explicit operator bool(); };
9
10 struct B;
11 struct A {
12 A();
13 A(const B&); // expected-note 2 {{candidate constructor}}
14 };
15 struct B { operator A() const; }; // expected-note 2 {{candidate function}}
16 struct I { operator int(); };
17 struct J { operator I(); };
18 struct K { operator double(); };
19 typedef void (*vfn)();
20 struct F { operator vfn(); };
21 struct G { operator vfn(); };
22
23 struct Base {
24 int trick();
25 A trick() const;
26 void fn1();
27 };
28 struct Derived : Base {
29 void fn2();
30 };
31 struct Convertible { operator Base&(); };
32 struct Priv : private Base {}; // expected-note 4 {{declared private here}}
33 struct Mid : Base {};
34 struct Fin : Mid, Derived {};
35 typedef void (Derived::*DFnPtr)();
36 struct ToMemPtr { operator DFnPtr(); };
37
38 struct BadDerived;
39 struct BadBase { operator BadDerived&(); };
40 struct BadDerived : BadBase {};
41
42 struct Fields {
43 int i1, i2, b1 : 3, b2 : 3;
44 };
45 struct MixedFields {
46 int i;
47 volatile int vi;
48 const int ci;
49 const volatile int cvi;
50 };
51 struct MixedFieldsDerived : MixedFields {
52 };
53
54 enum Enum { EVal };
55
56 struct Ambig {
57 operator short(); // expected-note 2 {{candidate function}}
58 operator signed char(); // expected-note 2 {{candidate function}}
59 };
60
61 struct Abstract {
62 virtual ~Abstract() = 0; // expected-note {{unimplemented pure virtual method '~Abstract' in 'Abstract'}}
63 };
64
65 struct Derived1: Abstract {
66 };
67
68 struct Derived2: Abstract {
69 };
70
test()71 void test()
72 {
73 // This function tests C++0x 5.16
74
75 // p1 (contextually convert to bool)
76 int i1 = ToBool() ? 0 : 1;
77
78 // p2 (one or both void, and throwing)
79 Fields flds;
80 i1 ? throw 0 : throw 1;
81 i1 ? test() : throw 1;
82 i1 ? throw 0 : test();
83 i1 ? test() : test();
84 i1 = i1 ? throw 0 : 0;
85 i1 = i1 ? 0 : throw 0;
86 i1 = i1 ? (throw 0) : 0;
87 i1 = i1 ? 0 : (throw 0);
88 i1 ? 0 : test(); // expected-error {{right operand to ? is void, but left operand is of type 'int'}}
89 i1 ? test() : 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}}
90 (i1 ? throw 0 : i1) = 0;
91 (i1 ? i1 : throw 0) = 0;
92 (i1 ? (throw 0) : i1) = 0;
93 (i1 ? i1 : (throw 0)) = 0;
94 (i1 ? (void)(throw 0) : i1) = 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}}
95 (i1 ? i1 : (void)(throw 0)) = 0; // expected-error {{right operand to ? is void, but left operand is of type 'int'}}
96 int &throwRef1 = (i1 ? flds.i1 : throw 0);
97 int &throwRef2 = (i1 ? throw 0 : flds.i1);
98 int &throwRef3 = (i1 ? flds.b1 : throw 0); // expected-error {{non-const reference cannot bind to bit-field}}
99 int &throwRef4 = (i1 ? throw 0 : flds.b1); // expected-error {{non-const reference cannot bind to bit-field}}
100
101 // p3 (one or both class type, convert to each other)
102 // b1 (lvalues)
103 Base base;
104 Derived derived;
105 Convertible conv;
106 Base &bar1 = i1 ? base : derived;
107 Base &bar2 = i1 ? derived : base;
108 Base &bar3 = i1 ? base : conv;
109 Base &bar4 = i1 ? conv : base;
110 // these are ambiguous
111 BadBase bb;
112 BadDerived bd;
113 (void)(i1 ? bb : bd); // expected-error {{conditional expression is ambiguous; 'BadBase' can be converted to 'BadDerived' and vice versa}}
114 (void)(i1 ? bd : bb); // expected-error {{conditional expression is ambiguous}}
115 // curiously enough (and a defect?), these are not
116 // for rvalues, hierarchy takes precedence over other conversions
117 (void)(i1 ? BadBase() : BadDerived());
118 (void)(i1 ? BadDerived() : BadBase());
119
120 // b2.1 (hierarchy stuff)
121 extern const Base constret();
122 extern const Derived constder();
123 // should use const overload
124 A a1((i1 ? constret() : Base()).trick());
125 A a2((i1 ? Base() : constret()).trick());
126 A a3((i1 ? constret() : Derived()).trick());
127 A a4((i1 ? Derived() : constret()).trick());
128 // should use non-const overload
129 i1 = (i1 ? Base() : Base()).trick();
130 i1 = (i1 ? Base() : Base()).trick();
131 i1 = (i1 ? Base() : Derived()).trick();
132 i1 = (i1 ? Derived() : Base()).trick();
133 // should fail: const lost
134 (void)(i1 ? Base() : constder()); // expected-error {{incompatible operand types ('Base' and 'const Derived')}}
135 (void)(i1 ? constder() : Base()); // expected-error {{incompatible operand types ('const Derived' and 'Base')}}
136
137 Priv priv;
138 Fin fin;
139 (void)(i1 ? Base() : Priv()); // expected-error{{private base class}}
140 (void)(i1 ? Priv() : Base()); // expected-error{{private base class}}
141 (void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
142 (void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
143 (void)(i1 ? base : priv); // expected-error {{private base class}}
144 (void)(i1 ? priv : base); // expected-error {{private base class}}
145 (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
146 (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
147
148 // b2.2 (non-hierarchy)
149 i1 = i1 ? I() : i1;
150 i1 = i1 ? i1 : I();
151 I i2(i1 ? I() : J());
152 I i3(i1 ? J() : I());
153 // "the type [it] would have if E2 were converted to an rvalue"
154 vfn pfn = i1 ? F() : test;
155 pfn = i1 ? test : F();
156 (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
157 (void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
158 (void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
159 (void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
160 // By the way, this isn't an lvalue:
161 &(i1 ? i1 : i2); // expected-error {{cannot take the address of an rvalue}}
162
163 // p4 (lvalue, same type)
164 int &ir1 = i1 ? flds.i1 : flds.i2;
165 (i1 ? flds.b1 : flds.i2) = 0;
166 (i1 ? flds.i1 : flds.b2) = 0;
167 (i1 ? flds.b1 : flds.b2) = 0;
168
169 // p5 (conversion to built-in types)
170 // GCC 4.3 fails these
171 double d1 = i1 ? I() : K();
172 pfn = i1 ? F() : G();
173 DFnPtr pfm;
174 pfm = i1 ? DFnPtr() : &Base::fn1;
175 pfm = i1 ? &Base::fn1 : DFnPtr();
176
177 // p6 (final conversions)
178 i1 = i1 ? i1 : ir1;
179 int *pi1 = i1 ? &i1 : 0;
180 pi1 = i1 ? 0 : &i1;
181 i1 = i1 ? i1 : EVal;
182 i1 = i1 ? EVal : i1;
183 d1 = i1 ? 'c' : 4.0;
184 d1 = i1 ? 4.0 : 'c';
185 Base *pb = i1 ? (Base*)0 : (Derived*)0;
186 pb = i1 ? (Derived*)0 : (Base*)0;
187 pfm = i1 ? &Base::fn1 : &Derived::fn2;
188 pfm = i1 ? &Derived::fn2 : &Base::fn1;
189 pfm = i1 ? &Derived::fn2 : 0;
190 pfm = i1 ? 0 : &Derived::fn2;
191 const int (MixedFieldsDerived::*mp1) =
192 i1 ? &MixedFields::ci : &MixedFieldsDerived::i;
193 const volatile int (MixedFields::*mp2) =
194 i1 ? &MixedFields::ci : &MixedFields::cvi;
195 (void)(i1 ? &MixedFields::ci : &MixedFields::vi);
196 // Conversion of primitives does not result in an lvalue.
197 &(i1 ? i1 : d1); // expected-error {{cannot take the address of an rvalue}}
198
199 (void)&(i1 ? flds.b1 : flds.i1); // expected-error {{address of bit-field requested}}
200 (void)&(i1 ? flds.i1 : flds.b1); // expected-error {{address of bit-field requested}}
201
202
203 unsigned long test0 = 5;
204 test0 = test0 ? (long) test0 : test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}}
205 test0 = test0 ? (int) test0 : test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
206 test0 = test0 ? (short) test0 : test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}}
207 test0 = test0 ? test0 : (long) test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}}
208 test0 = test0 ? test0 : (int) test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
209 test0 = test0 ? test0 : (short) test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}}
210 test0 = test0 ? test0 : (long) 10;
211 test0 = test0 ? test0 : (int) 10;
212 test0 = test0 ? test0 : (short) 10;
213 test0 = test0 ? (long) 10 : test0;
214 test0 = test0 ? (int) 10 : test0;
215 test0 = test0 ? (short) 10 : test0;
216
217 int test1;
218 test0 = test0 ? EVal : test0;
219 test1 = test0 ? EVal : (int) test0;
220
221 test0 = test0 ? EVal : test1; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
222 test0 = test0 ? test1 : EVal; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
223
224 test1 = test0 ? EVal : (int) test0;
225 test1 = test0 ? (int) test0 : EVal;
226
227 // Note the thing that this does not test: since DR446, various situations
228 // *must* create a separate temporary copy of class objects. This can only
229 // be properly tested at runtime, though.
230
231 const Abstract &abstract1 = true ? static_cast<const Abstract&>(Derived1()) : Derived2(); // expected-error {{allocating an object of abstract class type 'const Abstract'}}
232 const Abstract &abstract2 = true ? static_cast<const Abstract&>(Derived1()) : throw 3;
233 }
234
235 namespace PR6595 {
236 struct OtherString {
237 OtherString();
238 OtherString(const char*);
239 };
240
241 struct String {
242 String(const char *);
243 String(const OtherString&);
244 operator const char*() const;
245 };
246
f(bool Cond,String S,OtherString OS)247 void f(bool Cond, String S, OtherString OS) {
248 (void)(Cond? S : "");
249 (void)(Cond? "" : S);
250 const char a[1] = {'a'};
251 (void)(Cond? S : a);
252 (void)(Cond? a : S);
253 (void)(Cond? OS : S);
254 }
255 }
256
257 namespace PR6757 {
258 struct Foo1 {
259 Foo1();
260 Foo1(const Foo1&);
261 };
262
263 struct Foo2 { };
264
265 struct Foo3 {
266 Foo3(); // expected-note{{requires 0 arguments}}
267 Foo3(Foo3&); // expected-note{{would lose const qualifier}}
268 };
269
270 struct Bar {
271 operator const Foo1&() const;
272 operator const Foo2&() const;
273 operator const Foo3&() const;
274 };
275
f()276 void f() {
277 (void)(true ? Bar() : Foo1()); // okay
278 (void)(true ? Bar() : Foo2()); // okay
279 (void)(true ? Bar() : Foo3()); // expected-error{{no viable constructor copying temporary}}
280 }
281 }
282
283 // Reduced from selfhost.
284 namespace test1 {
285 struct A {
286 enum Foo {
287 fa, fb, fc, fd, fe, ff
288 };
289
290 Foo x();
291 };
292
293 void foo(int);
294
test(A * a)295 void test(A *a) {
296 foo(a ? a->x() : 0);
297 }
298 }
299
300 namespace rdar7998817 {
301 class X {
302 X(X&); // expected-note{{declared private here}}
303
304 struct ref { };
305
306 public:
307 X();
308 X(ref);
309
310 operator ref();
311 };
312
f(bool B)313 void f(bool B) {
314 X x;
315 (void)(B? x // expected-error{{calling a private constructor of class 'rdar7998817::X'}}
316 : X());
317 }
318 }
319
320 namespace PR7598 {
321 enum Enum {
322 v = 1,
323 };
324
g()325 const Enum g() {
326 return v;
327 }
328
g2()329 const volatile Enum g2() {
330 return v;
331 }
332
f()333 void f() {
334 const Enum v2 = v;
335 Enum e = false ? g() : v;
336 Enum e2 = false ? v2 : v;
337 Enum e3 = false ? g2() : v;
338 }
339
340 }
341
342 namespace PR9236 {
343 #define NULL 0L
f()344 void f() {
345 int i;
346 (void)(true ? A() : NULL); // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
347 (void)(true ? NULL : A()); // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
348 (void)(true ? 0 : A()); // expected-error{{incompatible operand types}}
349 (void)(true ? nullptr : A()); // expected-error{{non-pointer operand type 'A' incompatible with nullptr}}
350 (void)(true ? nullptr : i); // expected-error{{non-pointer operand type 'int' incompatible with nullptr}}
351 (void)(true ? __null : A()); // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
352 (void)(true ? (void*)0 : A()); // expected-error{{incompatible operand types}}
353 }
354 }
355
356 namespace DR587 {
357 template<typename T>
f(bool b)358 const T *f(bool b) {
359 static T t1 = T();
360 static const T t2 = T();
361 return &(b ? t1 : t2);
362 }
363 struct S {};
364 template const int *f(bool);
365 template const S *f(bool);
366
367 extern bool b;
368 int i = 0;
369 const int ci = 0;
370 volatile int vi = 0;
371 const volatile int cvi = 0;
372
373 const int &cir = b ? i : ci;
374 volatile int &vir = b ? vi : i;
375 const volatile int &cvir1 = b ? ci : cvi;
376 const volatile int &cvir2 = b ? cvi : vi;
377 const volatile int &cvir3 = b ? ci : vi; // expected-error{{volatile lvalue reference to type 'const volatile int' cannot bind to a temporary of type 'int'}}
378 }
379
380 namespace PR17052 {
381 struct X {
382 int i_;
383 bool b_;
384
testPR17052::X385 int &test() { return b_ ? i_ : throw 1; }
386 };
387 }
388
389 namespace PR26448 {
390 struct Base {};
391 struct Derived : Base {};
392 Base b;
393 Derived d;
394 typedef decltype(true ? static_cast<Base&&>(b) : static_cast<Derived&&>(d)) x;
395 typedef Base &&x;
396 }
397
398 namespace lifetime_extension {
399 struct A {};
400 struct B : A { B(); ~B(); };
401 struct C : A { C(); ~C(); };
402
f(bool b)403 void f(bool b) {
404 A &&r = b ? static_cast<A&&>(B()) : static_cast<A&&>(C());
405 }
406
407 struct D { A &&a; };
f_indirect(bool b)408 void f_indirect(bool b) {
409 D d = b ? D{B()} // expected-cxx11-warning {{temporary whose address is used as value of local variable 'd' will be destroyed at the end of the full-expression}}
410 : D{C()}; // expected-cxx11-warning {{temporary whose address is used as value of local variable 'd' will be destroyed at the end of the full-expression}}
411 }
412 }
413
414 namespace PR46484 {
415 // expected-error@+4{{expected ':'}}
416 // expected-note@+3{{to match this '?'}}
417 // expected-warning@+2{{variable 'b' is uninitialized}}
418 // expected-error@+1 2 {{expected ';' after top level declarator}}
419 int a long b = a = b ? throw 0 1
420
421 void g() {
422 extern int a;
423 extern long b;
424 long c = a = b ? throw 0 : 1;
425 long d = a = b ? 1 : throw 0;
426 // expected-error@+1 {{assigning to 'int' from incompatible type 'void'}}
427 long e = a = b ? throw 0 : throw 1;
428 }
429 } // namespace PR46484
430