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
foo(int * i)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
bar()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";
ignore()118 void ignore() {
119 if (a) {}
120 if (a) {}
121 (void)GetValue(b);
122 }
test()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 };
ignored()144 void ignored() {
145 if (&a) {}
146 }
test()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
test()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.
f()191 template<int *p> void f() { if (p) {} } // expected-warning 2{{will always evaluate to 'true'}} expected-cxx11-warning {{implicit conversion of nullptr}}
g()192 template<int (*p)[3]> void g() { if (p) {} } // expected-warning 2{{will always evaluate to 'true'}} expected-cxx11-warning {{implicit conversion of nullptr}}
h()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 }
208