1 // RUN: %clang_cc1 -verify -fsyntax-only -std=c++17 -Wshadow-all %s
2
3 namespace {
4 int i; // expected-note {{previous declaration is here}}
5 }
6
7 namespace one {
8 namespace two {
9 int j; // expected-note {{previous declaration is here}}
10 typedef int jj; // expected-note 2 {{previous declaration is here}}
11 using jjj=int; // expected-note 2 {{previous declaration is here}}
12 }
13 }
14
15 namespace xx {
16 int m;
17 typedef int mm;
18 using mmm=int;
19
20 }
21 namespace yy {
22 int m;
23 typedef char mm;
24 using mmm=char;
25 }
26
27 using namespace one::two;
28 using namespace xx;
29 using namespace yy;
30
foo()31 void foo() {
32 int i; // expected-warning {{declaration shadows a variable in namespace '(anonymous)'}}
33 int j; // expected-warning {{declaration shadows a variable in namespace 'one::two'}}
34 int m;
35 int mm;
36 int mmm;
37 }
38
39 class A {
40 static int data; // expected-note 1 {{previous declaration}}
41 // expected-note@+1 1 {{previous declaration}}
42 int field;
43 int f1, f2, f3, f4; // expected-note 8 {{previous declaration is here}}
44
45 typedef int a1; // expected-note 2 {{previous declaration}}
46 using a2=int; // expected-note 2 {{previous declaration}}
47
48 // The initialization is safe, but the modifications are not.
A(int f1,int f2,int f3,int f4)49 A(int f1, int f2, int f3, int f4) // expected-note-re 4 {{variable 'f{{[0-4]}}' is declared here}}
50 : f1(f1) {
51 f1 = 3; // expected-warning {{modifying constructor parameter 'f1' that shadows a field of 'A'}}
52 f1 = 4; // one warning per shadow
53 f2++; // expected-warning {{modifying constructor parameter 'f2' that shadows a field of 'A'}}
54 --f3; // expected-warning {{modifying constructor parameter 'f3' that shadows a field of 'A'}}
55 f4 += 2; // expected-warning {{modifying constructor parameter 'f4' that shadows a field of 'A'}}
56 }
57
58 // The initialization is safe, but the modifications are not.
59 // expected-warning-re@+1 4 {{constructor parameter 'f{{[0-4]}}' shadows the field 'f{{[0-9]}}' of 'A'}}
A(int f1,int f2,int f3,int f4,double overload_dummy)60 A(int f1, int f2, int f3, int f4, double overload_dummy) {}
61
test()62 void test() {
63 char *field; // expected-warning {{declaration shadows a field of 'A'}}
64 char *data; // expected-warning {{declaration shadows a static data member of 'A'}}
65 char *a1; // no warning
66 char *a2; // no warning
67 char *jj; // no warning
68 char *jjj; // no warning
69 }
70
test2()71 void test2() {
72 typedef char field; // no warning
73 typedef char data; // no warning
74 typedef char a1; // expected-warning {{declaration shadows a typedef in 'A'}}
75 typedef char a2; // expected-warning {{declaration shadows a type alias in 'A'}}
76 typedef char jj; // expected-warning {{declaration shadows a typedef in namespace 'one::two'}}
77 typedef char jjj; // expected-warning {{declaration shadows a type alias in namespace 'one::two'}}
78 }
79
test3()80 void test3() {
81 using field=char; // no warning
82 using data=char; // no warning
83 using a1=char; // expected-warning {{declaration shadows a typedef in 'A'}}
84 using a2=char; // expected-warning {{declaration shadows a type alias in 'A'}}
85 using jj=char; // expected-warning {{declaration shadows a typedef in namespace 'one::two'}}
86 using jjj=char; // expected-warning {{declaration shadows a type alias in namespace 'one::two'}}
87 }
88 };
89
90 struct path {
91 using value_type = char;
92 typedef char value_type2;
93 struct iterator {
94 using value_type = path; // no warning
95 typedef path value_type2; // no warning
96 };
97 };
98
99
100 // TODO: this should warn, <rdar://problem/5018057>
101 class B : A {
102 int data;
103 static int field;
104 };
105
106 // rdar://8900456
107 namespace rdar8900456 {
108 struct Foo {
109 static void Baz();
110 static void Baz1();
111 static void Baz2();
112 private:
113 int Bar;
114 };
115
Baz()116 void Foo::Baz() {
117 double Bar = 12; // Don't warn.
118 }
119
Baz1()120 void Foo::Baz1() {
121 typedef int Bar; // Don't warn.
122 }
123
Baz2()124 void Foo::Baz2() {
125 using Bar=int; // Don't warn.
126 }
127 }
128
129 // http://llvm.org/PR9160
130 namespace PR9160 {
131 struct V {
132 V(int);
133 };
134 struct S {
135 V v;
mPR9160::S136 static void m() {
137 if (1) {
138 V v(0);
139 }
140 }
141 };
142 }
143
144 extern int bob; // expected-note 1 {{previous declaration is here}}
145 typedef int bob1; // expected-note 2 {{previous declaration is here}}
146 using bob2=int; // expected-note 2 {{previous declaration is here}}
147
148 // rdar://8883302
rdar8883302()149 void rdar8883302() {
150 extern int bob; // don't warn for shadowing.
151 }
152
test8()153 void test8() {
154 int bob; // expected-warning {{declaration shadows a variable in the global namespace}}
155 int bob1; //no warning
156 int bob2; // no warning
157 }
158
test9()159 void test9() {
160 typedef int bob; // no warning
161 typedef int bob1; // expected-warning {{declaration shadows a typedef in the global namespace}}
162 typedef int bob2; // expected-warning {{declaration shadows a type alias in the global namespace}}
163 }
164
test10()165 void test10() {
166 using bob=int; // no warning
167 using bob1=int; // expected-warning {{declaration shadows a typedef in the global namespace}}
168 using bob2=int; // expected-warning {{declaration shadows a type alias in the global namespace}}
169 }
170
171 namespace rdar29067894 {
172
avoidWarningWhenRedefining(int b)173 void avoidWarningWhenRedefining(int b) { // expected-note {{previous definition is here}}
174 int a = 0; // expected-note {{previous definition is here}}
175 int a = 1; // expected-error {{redefinition of 'a'}}
176 int b = 2; // expected-error {{redefinition of 'b'}}
177
178 using c=char; // expected-note {{previous definition is here}}
179 using c=int; // expected-error {{type alias redefinition with different types ('int' vs 'char')}}
180
181 typedef char d; // expected-note {{previous definition is here}}
182 typedef int d; // expected-error {{typedef redefinition with different types ('int' vs 'char')}}
183
184 using e=char; // expected-note {{previous definition is here}}
185 typedef int e; // expected-error {{type alias redefinition with different types ('int' vs 'char')}}
186
187 int f; // expected-note {{previous definition is here}}
188 using f=int; // expected-error {{redefinition of 'f'}}
189
190 using g=int; // expected-note {{previous definition is here}}
191 int g; // expected-error {{redefinition of 'g'}}
192
193 typedef int h; // expected-note {{previous definition is here}}
194 int h; // expected-error {{redefinition of 'h'}}
195
196 int k; // expected-note {{previous definition is here}}
197 typedef int k; // expected-error {{redefinition of 'k'}}
198
199 using l=char; // no warning or error.
200 using l=char; // no warning or error.
201 typedef char l; // no warning or error.
202
203 typedef char n; // no warning or error.
204 typedef char n; // no warning or error.
205 using n=char; // no warning or error.
206 }
207
208 }
209
210 extern "C" {
211 typedef int externC; // expected-note {{previous declaration is here}}
212 }
handleLinkageSpec()213 void handleLinkageSpec() {
214 typedef void externC; // expected-warning {{declaration shadows a typedef in the global namespace}}
215 }
216
217 namespace PR33947 {
f(int a)218 void f(int a) {
219 struct A {
220 void g(int a) {}
221 A() { int a; }
222 };
223 }
224 }
225
226 namespace PR34120 {
227 struct A {
228 int B; // expected-note 2 {{declared here}}
229 };
230
231 class C : public A {
D(int B)232 void D(int B) {} // expected-warning {{parameter 'B' shadows member inherited from type 'A'}}
E()233 void E() {
234 extern void f(int B); // Ok
235 }
236 void F(int B); // Ok, declaration; not definition.
237 void G(int B);
238 };
239
G(int B)240 void C::G(int B) { // expected-warning {{parameter 'B' shadows member inherited from type 'A'}}
241 }
242
243 class Private {
244 int B;
245 };
246 class Derived : Private {
D(int B)247 void D(int B) {} // Ok
248 };
249
250 struct Static {
251 static int B;
252 };
253
254 struct Derived2 : Static {
DPR34120::Derived2255 void D(int B) {}
256 };
257 }
258
259 int PR24718;
260 enum class X { PR24718 }; // Ok, not shadowing
261
262 struct PR24718_1;
263 struct PR24718_2 {
264 enum {
265 PR24718_1 // Does not shadow a type.
266 };
267 };
268
269 namespace structured_binding_tests {
270 int x; // expected-note {{previous declaration is here}}
271 int y; // expected-note {{previous declaration is here}}
272 struct S {
273 int a, b;
274 };
275
test1()276 void test1() {
277 const auto [x, y] = S(); // expected-warning 2 {{declaration shadows a variable in namespace 'structured_binding_tests'}}
278 }
279
test2()280 void test2() {
281 int a; // expected-note {{previous declaration is here}}
282 bool b; // expected-note {{previous declaration is here}}
283 {
284 auto [a, b] = S(); // expected-warning 2 {{declaration shadows a local variable}}
285 }
286 }
287
288 class A
289 {
290 int m_a; // expected-note {{previous declaration is here}}
291 int m_b; // expected-note {{previous declaration is here}}
292
test3()293 void test3() {
294 auto [m_a, m_b] = S(); // expected-warning 2 {{declaration shadows a field of 'structured_binding_tests::A'}}
295 }
296 };
297
test4()298 void test4() {
299 const auto [a, b] = S(); // expected-note 3 {{previous declaration is here}}
300 {
301 int a = 4; // expected-warning {{declaration shadows a structured binding}}
302 }
303 {
304 const auto [a, b] = S(); // expected-warning 2 {{declaration shadows a structured binding}}
305 }
306 }
307
308 }; // namespace structured_binding_tests