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