clang/test/SemaCXX/conditional-expr.cpp

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