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