clang/test/SemaCXX/warn-shadow.cpp

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