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 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 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 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 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 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 324 const Enum g() { 325 return v; 326 } 327 328 const volatile Enum g2() { 329 return v; 330 } 331 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 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> 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 384 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
