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