clang/test/SemaCXX/warn-bool-conversion.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify=expected,expected-cxx11 %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
   3 // RUN: %clang_cc1 -fsyntax-only -verify=expected,expected-cxx11 -std=c++11 %s
   4
   5 namespace BooleanFalse {
   6 int* j = false;
   7 #if __cplusplus <= 199711L
   8 // expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
   9 #else
  10 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'bool'}}
  11 #endif
  12
  13 #if __cplusplus <= 199711L
  14 // expected-warning@+5 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
  15 #else
  16 // expected-error@+3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'bool'}}
  17 // expected-note@+2 {{passing argument to parameter 'j' here}}
  18 #endif
  19 void bar(int *j = false);
  20
  21 #if __cplusplus > 199711L
  22 // expected-note@+2 4{{candidate function not viable: no known conversion}}
  23 #endif
  24 void foo(int *i)
  25 {
  26   foo(false);
  27 #if __cplusplus <= 199711L
  28 // expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
  29 #else
  30 // expected-error@-4 {{no matching function for call to 'foo'}}
  31 #endif
  32
  33   foo((int*)false); // OK: explicit cast
  34   foo(0); // OK: not a bool, even though it's convertible to bool
  35
  36   foo(false == true);
  37 #if __cplusplus <= 199711L
  38 // expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
  39 #else
  40 // expected-error@-4 {{no matching function for call to 'foo'}}
  41 #endif
  42
  43   foo((42 + 24) < 32);
  44 #if __cplusplus <= 199711L
  45 // expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
  46 #else
  47 // expected-error@-4 {{no matching function for call to 'foo'}}
  48 #endif
  49
  50   const bool kFlag = false;
  51   foo(kFlag);
  52 #if __cplusplus <= 199711L
  53 // expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
  54 #else
  55 // expected-error@-4 {{no matching function for call to 'foo'}}
  56 #endif
  57 }
  58
  59 char f(struct Undefined*);
  60 double f(...);
  61
  62 // Ensure that when using false in metaprogramming machinery its conversion
  63 // isn't flagged.
  64 template <int N> struct S {};
  65 S<sizeof(f(false))> s;
  66
  67 }
  68
  69 namespace Function {
  70 void f1();
  71
  72 struct S {
  73   static void f2();
  74 };
  75
  76 extern void f3() __attribute__((weak_import));
  77
  78 struct S2 {
  79   static void f4() __attribute__((weak_import));
  80 };
  81
  82 bool f5();
  83 bool f6(int);
  84
  85 void bar() {
  86   bool b;
  87
  88   b = f1; // expected-warning {{address of function 'f1' will always evaluate to 'true'}} \
  89              expected-note {{prefix with the address-of operator to silence this warning}}
  90   if (f1) {} // expected-warning {{address of function 'f1' will always evaluate to 'true'}} \
  91                 expected-note {{prefix with the address-of operator to silence this warning}}
  92   b = S::f2; // expected-warning {{address of function 'S::f2' will always evaluate to 'true'}} \
  93                 expected-note {{prefix with the address-of operator to silence this warning}}
  94   if (S::f2) {} // expected-warning {{address of function 'S::f2' will always evaluate to 'true'}} \
  95                    expected-note {{prefix with the address-of operator to silence this warning}}
  96   b = f5; // expected-warning {{address of function 'f5' will always evaluate to 'true'}} \
  97              expected-note {{prefix with the address-of operator to silence this warning}} \
  98              expected-note {{suffix with parentheses to turn this into a function call}}
  99   b = f6; // expected-warning {{address of function 'f6' will always evaluate to 'true'}} \
 100              expected-note {{prefix with the address-of operator to silence this warning}}
 101
 102   // implicit casts of weakly imported symbols are ok:
 103   b = f3;
 104   if (f3) {}
 105   b = S2::f4;
 106   if (S2::f4) {}
 107 }
 108 }
 109
 110 namespace Array {
 111   #define GetValue(ptr)  ((ptr) ? ptr[0] : 0)
 112   extern int a[] __attribute__((weak));
 113   int b[] = {8,13,21};
 114   struct {
 115     int x[10];
 116   } c;
 117   const char str[] = "text";
 118   void ignore() {
 119     if (a) {}
 120     if (a) {}
 121     (void)GetValue(b);
 122   }
 123   void test() {
 124     if (b) {}
 125     // expected-warning@-1{{address of array 'b' will always evaluate to 'true'}}
 126     if (b) {}
 127     // expected-warning@-1{{address of array 'b' will always evaluate to 'true'}}
 128     if (c.x) {}
 129     // expected-warning@-1{{address of array 'c.x' will always evaluate to 'true'}}
 130     if (str) {}
 131     // expected-warning@-1{{address of array 'str' will always evaluate to 'true'}}
 132   }
 133 }
 134
 135 namespace Pointer {
 136   extern int a __attribute__((weak));
 137   int b;
 138   static int c;
 139   class S {
 140   public:
 141     static int a;
 142     int b;
 143   };
 144   void ignored() {
 145     if (&a) {}
 146   }
 147   void test() {
 148     S s;
 149     if (&b) {}
 150     // expected-warning@-1{{address of 'b' will always evaluate to 'true'}}
 151     if (&c) {}
 152     // expected-warning@-1{{address of 'c' will always evaluate to 'true'}}
 153     if (&s.a) {}
 154     // expected-warning@-1{{address of 's.a' will always evaluate to 'true'}}
 155     if (&s.b) {}
 156     // expected-warning@-1{{address of 's.b' will always evaluate to 'true'}}
 157     if (&S::a) {}
 158     // expected-warning@-1{{address of 'S::a' will always evaluate to 'true'}}
 159   }
 160 }
 161
 162 namespace macros {
 163   #define assert(x) if (x) {}
 164   #define zero_on_null(x) ((x) ? *(x) : 0)
 165
 166   int array[5];
 167   void fun();
 168   int x;
 169
 170   void test() {
 171     assert(array);
 172     assert(array && "expecting null pointer");
 173     // expected-warning@-1{{address of array 'array' will always evaluate to 'true'}}
 174
 175     assert(fun);
 176     assert(fun && "expecting null pointer");
 177     // expected-warning@-1{{address of function 'fun' will always evaluate to 'true'}}
 178     // expected-note@-2 {{prefix with the address-of operator to silence this warning}}
 179
 180     // TODO: warn on assert(&x) while not warning on zero_on_null(&x)
 181     zero_on_null(&x);
 182     assert(zero_on_null(&x));
 183     assert(&x);
 184     assert(&x && "expecting null pointer");
 185     // expected-warning@-1{{address of 'x' will always evaluate to 'true'}}
 186   }
 187 }
 188
 189 namespace Template {
 190   // FIXME: These cases should not warn.
 191   template<int *p> void f() { if (p) {} } // expected-warning 2{{will always evaluate to 'true'}} expected-cxx11-warning {{implicit conversion of nullptr}}
 192   template<int (*p)[3]> void g() { if (p) {} } // expected-warning 2{{will always evaluate to 'true'}} expected-cxx11-warning {{implicit conversion of nullptr}}
 193   template<int (*p)()> void h() { if (p) {} }
 194
 195   int a, b[3], c[3][3], d();
 196   template void f<&a>(); // expected-note {{instantiation of}}
 197   template void f<b>(); // expected-note {{instantiation of}}
 198 #if __cplusplus >= 201103L
 199   template void f<(int*)nullptr>(); // expected-note {{instantiation of}}
 200 #endif
 201   template void g<&b>(); // expected-note {{instantiation of}}
 202   template void g<c>(); // expected-note {{instantiation of}}
 203 #if __cplusplus >= 201103L
 204   template void g<(int(*)[3])nullptr>(); // expected-note {{instantiation of}}
 205 #endif
 206   template void h<d>();
 207 }