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 i1 ? throw 0 : throw 1;
79 i1 ? test() : throw 1;
80 i1 ? throw 0 : test();
81 i1 ? test() : test();
82 i1 = i1 ? throw 0 : 0;
83 i1 = i1 ? 0 : throw 0;
84 i1 ? 0 : test(); // expected-error {{right operand to ? is void, but left operand is of type 'int'}}
85 i1 ? test() : 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}}
86 (i1 ? throw 0 : i1) = 0; // expected-error {{expression is not assignable}}
87 (i1 ? i1 : throw 0) = 0; // expected-error {{expression is not assignable}}
88
89 // p3 (one or both class type, convert to each other)
90 // b1 (lvalues)
91 Base base;
92 Derived derived;
93 Convertible conv;
94 Base &bar1 = i1 ? base : derived;
95 Base &bar2 = i1 ? derived : base;
96 Base &bar3 = i1 ? base : conv;
97 Base &bar4 = i1 ? conv : base;
98 // these are ambiguous
99 BadBase bb;
100 BadDerived bd;
101 (void)(i1 ? bb : bd); // expected-error {{conditional expression is ambiguous; 'BadBase' can be converted to 'BadDerived' and vice versa}}
102 (void)(i1 ? bd : bb); // expected-error {{conditional expression is ambiguous}}
103 // curiously enough (and a defect?), these are not
104 // for rvalues, hierarchy takes precedence over other conversions
105 (void)(i1 ? BadBase() : BadDerived());
106 (void)(i1 ? BadDerived() : BadBase());
107
108 // b2.1 (hierarchy stuff)
109 extern const Base constret();
110 extern const Derived constder();
111 // should use const overload
112 A a1((i1 ? constret() : Base()).trick());
113 A a2((i1 ? Base() : constret()).trick());
114 A a3((i1 ? constret() : Derived()).trick());
115 A a4((i1 ? Derived() : constret()).trick());
116 // should use non-const overload
117 i1 = (i1 ? Base() : Base()).trick();
118 i1 = (i1 ? Base() : Base()).trick();
119 i1 = (i1 ? Base() : Derived()).trick();
120 i1 = (i1 ? Derived() : Base()).trick();
121 // should fail: const lost
122 (void)(i1 ? Base() : constder()); // expected-error {{incompatible operand types ('Base' and 'const Derived')}}
123 (void)(i1 ? constder() : Base()); // expected-error {{incompatible operand types ('const Derived' and 'Base')}}
124
125 Priv priv;
126 Fin fin;
127 (void)(i1 ? Base() : Priv()); // expected-error{{private base class}}
128 (void)(i1 ? Priv() : Base()); // expected-error{{private base class}}
129 (void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
130 (void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
131 (void)(i1 ? base : priv); // expected-error {{private base class}}
132 (void)(i1 ? priv : base); // expected-error {{private base class}}
133 (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
134 (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
135
136 // b2.2 (non-hierarchy)
137 i1 = i1 ? I() : i1;
138 i1 = i1 ? i1 : I();
139 I i2(i1 ? I() : J());
140 I i3(i1 ? J() : I());
141 // "the type [it] woud have if E2 were converted to an rvalue"
142 vfn pfn = i1 ? F() : test;
143 pfn = i1 ? test : F();
144 (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
145 (void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
146 (void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
147 (void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
148 // By the way, this isn't an lvalue:
149 &(i1 ? i1 : i2); // expected-error {{cannot take the address of an rvalue}}
150
151 // p4 (lvalue, same type)
152 Fields flds;
153 int &ir1 = i1 ? flds.i1 : flds.i2;
154 (i1 ? flds.b1 : flds.i2) = 0;
155 (i1 ? flds.i1 : flds.b2) = 0;
156 (i1 ? flds.b1 : flds.b2) = 0;
157
158 // p5 (conversion to built-in types)
159 // GCC 4.3 fails these
160 double d1 = i1 ? I() : K();
161 pfn = i1 ? F() : G();
162 DFnPtr pfm;
163 pfm = i1 ? DFnPtr() : &Base::fn1;
164 pfm = i1 ? &Base::fn1 : DFnPtr();
165
166 // p6 (final conversions)
167 i1 = i1 ? i1 : ir1;
168 int *pi1 = i1 ? &i1 : 0;
169 pi1 = i1 ? 0 : &i1;
170 i1 = i1 ? i1 : EVal;
171 i1 = i1 ? EVal : i1;
172 d1 = i1 ? 'c' : 4.0;
173 d1 = i1 ? 4.0 : 'c';
174 Base *pb = i1 ? (Base*)0 : (Derived*)0;
175 pb = i1 ? (Derived*)0 : (Base*)0;
176 pfm = i1 ? &Base::fn1 : &Derived::fn2;
177 pfm = i1 ? &Derived::fn2 : &Base::fn1;
178 pfm = i1 ? &Derived::fn2 : 0;
179 pfm = i1 ? 0 : &Derived::fn2;
180 const int (MixedFieldsDerived::*mp1) =
181 i1 ? &MixedFields::ci : &MixedFieldsDerived::i;
182 const volatile int (MixedFields::*mp2) =
183 i1 ? &MixedFields::ci : &MixedFields::cvi;
184 (void)(i1 ? &MixedFields::ci : &MixedFields::vi);
185 // Conversion of primitives does not result in an lvalue.
186 &(i1 ? i1 : d1); // expected-error {{cannot take the address of an rvalue}}
187
188 (void)&(i1 ? flds.b1 : flds.i1); // expected-error {{address of bit-field requested}}
189 (void)&(i1 ? flds.i1 : flds.b1); // expected-error {{address of bit-field requested}}
190
191
192 unsigned long test0 = 5;
193 test0 = test0 ? (long) test0 : test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}}
194 test0 = test0 ? (int) test0 : test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
195 test0 = test0 ? (short) test0 : test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}}
196 test0 = test0 ? test0 : (long) test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}}
197 test0 = test0 ? test0 : (int) test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
198 test0 = test0 ? test0 : (short) test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}}
199 test0 = test0 ? test0 : (long) 10;
200 test0 = test0 ? test0 : (int) 10;
201 test0 = test0 ? test0 : (short) 10;
202 test0 = test0 ? (long) 10 : test0;
203 test0 = test0 ? (int) 10 : test0;
204 test0 = test0 ? (short) 10 : test0;
205
206 int test1;
207 test0 = test0 ? EVal : test0;
208 test1 = test0 ? EVal : (int) test0;
209
210 test0 = test0 ? EVal : test1; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
211 test0 = test0 ? test1 : EVal; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
212
213 test1 = test0 ? EVal : (int) test0;
214 test1 = test0 ? (int) test0 : EVal;
215
216 // Note the thing that this does not test: since DR446, various situations
217 // *must* create a separate temporary copy of class objects. This can only
218 // be properly tested at runtime, though.
219
220 const Abstract &a = true ? static_cast<const Abstract&>(Derived1()) : Derived2(); // expected-error {{allocating an object of abstract class type 'const Abstract'}}
221 true ? static_cast<const Abstract&>(Derived1()) : throw 3; // expected-error {{allocating an object of abstract class type 'const Abstract'}}
222 }
223
224 namespace PR6595 {
225 struct OtherString {
226 OtherString();
227 OtherString(const char*);
228 };
229
230 struct String {
231 String(const char *);
232 String(const OtherString&);
233 operator const char*() const;
234 };
235
f(bool Cond,String S,OtherString OS)236 void f(bool Cond, String S, OtherString OS) {
237 (void)(Cond? S : "");
238 (void)(Cond? "" : S);
239 const char a[1] = {'a'};
240 (void)(Cond? S : a);
241 (void)(Cond? a : S);
242 (void)(Cond? OS : S);
243 }
244 }
245
246 namespace PR6757 {
247 struct Foo1 {
248 Foo1();
249 Foo1(const Foo1&);
250 };
251
252 struct Foo2 { };
253
254 struct Foo3 {
255 Foo3();
256 Foo3(Foo3&); // expected-note{{would lose const qualifier}}
257 };
258
259 struct Bar {
260 operator const Foo1&() const;
261 operator const Foo2&() const;
262 operator const Foo3&() const;
263 };
264
f()265 void f() {
266 (void)(true ? Bar() : Foo1()); // okay
267 (void)(true ? Bar() : Foo2()); // okay
268 (void)(true ? Bar() : Foo3()); // expected-error{{no viable constructor copying temporary}}
269 }
270 }
271
272 // Reduced from selfhost.
273 namespace test1 {
274 struct A {
275 enum Foo {
276 fa, fb, fc, fd, fe, ff
277 };
278
279 Foo x();
280 };
281
282 void foo(int);
283
test(A * a)284 void test(A *a) {
285 foo(a ? a->x() : 0);
286 }
287 }
288
289 namespace rdar7998817 {
290 class X {
291 X(X&); // expected-note{{declared private here}}
292
293 struct ref { };
294
295 public:
296 X();
297 X(ref);
298
299 operator ref();
300 };
301
f(bool B)302 void f(bool B) {
303 X x;
304 (void)(B? x // expected-error{{calling a private constructor of class 'rdar7998817::X'}}
305 : X());
306 }
307 }
308
309 namespace PR7598 {
310 enum Enum {
311 v = 1,
312 };
313
g()314 const Enum g() {
315 return v;
316 }
317
g2()318 const volatile Enum g2() {
319 return v;
320 }
321
f()322 void f() {
323 const Enum v2 = v;
324 Enum e = false ? g() : v;
325 Enum e2 = false ? v2 : v;
326 Enum e3 = false ? g2() : v;
327 }
328
329 }
330
331 namespace PR9236 {
332 #define NULL 0L
f()333 void f() {
334 int i;
335 (void)(true ? A() : NULL); // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
336 (void)(true ? NULL : A()); // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
337 (void)(true ? 0 : A()); // expected-error{{incompatible operand types}}
338 (void)(true ? nullptr : A()); // expected-error{{non-pointer operand type 'A' incompatible with nullptr}}
339 (void)(true ? nullptr : i); // expected-error{{non-pointer operand type 'int' incompatible with nullptr}}
340 (void)(true ? __null : A()); // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
341 (void)(true ? (void*)0 : A()); // expected-error{{incompatible operand types}}
342 }
343 }
344
345 namespace DR587 {
346 template<typename T>
f(bool b)347 const T *f(bool b) {
348 static T t1 = T();
349 static const T t2 = T();
350 return &(b ? t1 : t2);
351 }
352 struct S {};
353 template const int *f(bool);
354 template const S *f(bool);
355
356 extern bool b;
357 int i = 0;
358 const int ci = 0;
359 volatile int vi = 0;
360 const volatile int cvi = 0;
361
362 const int &cir = b ? i : ci;
363 volatile int &vir = b ? vi : i;
364 const volatile int &cvir1 = b ? ci : cvi;
365 const volatile int &cvir2 = b ? cvi : vi;
366 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'}}
367 }
368