• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
388 namespace PR26448 {
389 struct Base {};
390 struct Derived : Base {};
391 Base b;
392 Derived d;
393 typedef decltype(true ? static_cast<Base&&>(b) : static_cast<Derived&&>(d)) x;
394 typedef Base &&x;
395 }
396