[clang][Sema] `-Wshadow` warns about shadowings by static local variables

[hazohelet]

Summary

This patch makes -Wshadow warn about the shadowings by static local variables.

Fixes https://github.com/llvm/llvm-project/issues/62850

[tbaeder]

clang/docs/ReleaseNotes.rst

300

[shafik]

LGTM

clang/test/SemaCXX/warn-shadow.cpp

33

Note. it looks like gcc does not warn on shadowing for anonymous namespaces. I think it makes sense to warn in this case.

clang/docs/ReleaseNotes.rst

- ``-Wformat`` now recognizes ``%lb`` for the ``printf``/``scanf`` family of
   (`#62247: <https://github.com/llvm/llvm-project/issues/62247>`_).
 - Clang now diagnoses shadowing of lambda's template parameter by a capture.
   (`#61105: <https://github.com/llvm/llvm-project/issues/61105>`_).
 - Address a false positive in ``-Wpacked`` when applied to a non-pod type using
   Clang ABI >= 15.
   (`#62353: <https://github.com/llvm/llvm-project/issues/62353>`_,
   fallout from the non-POD packing ABI fix in LLVM 15).
 - Clang constexpr evaluator now prints subobject's name instead of its type in notes
   when a constexpr variable has uninitialized subobjects after its constructor call.
   (`#58601 <https://github.com/llvm/llvm-project/issues/58601>`_)
+- Clang's `-Wshadow` warning now warns about shadowings by static local variables
+  (`#62850: <https://github.com/llvm/llvm-project/issues/62850>`_).
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.

clang/lib/Sema/SemaDecl.cpp

 /// Return the declaration shadowed by the given variable \p D, or null
 /// if it doesn't shadow any declaration or shadowing warnings are disabled.
 NamedDecl *Sema::getShadowedDeclaration(const VarDecl *D,
                                         const LookupResult &R) {
   if (!shouldWarnIfShadowedDecl(Diags, R))
     return nullptr;
 
   // Don't diagnose declarations at file scope.
-  if (D->hasGlobalStorage())
+  if (D->hasGlobalStorage() && !D->isStaticLocal())
     return nullptr;
 
   NamedDecl *ShadowedDecl = R.getFoundDecl();
   return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
                                                             : nullptr;
 }
 
 /// Return the declaration shadowed by the given typedef \p D, or null

clang/test/Sema/warn-shadow.c

 // RUN: %clang_cc1 -verify -fsyntax-only -fblocks -Wshadow %s
 
-int i;          // expected-note 3 {{previous declaration is here}}
+int i;          // expected-note 4 {{previous declaration is here}}
+static int s;   // expected-note 2 {{previous declaration is here}}
 
 void foo(void) {
   int pass1;
   int i;        // expected-warning {{declaration shadows a variable in the global scope}} \
                 // expected-note {{previous declaration is here}}
+  int s;        // expected-warning {{declaration shadows a variable in the global scope}} \
+                // expected-note {{previous declaration is here}}
   {
     int pass2;
     int i;      // expected-warning {{declaration shadows a local variable}} \
                 // expected-note {{previous declaration is here}}
+    int s;      // expected-warning {{declaration shadows a local variable}} \
+                // expected-note {{previous declaration is here}}
     {
       int pass3;
       int i;    // expected-warning {{declaration shadows a local variable}}
+      int s;    // expected-warning {{declaration shadows a local variable}}
     }
   }
 
   int sin; // okay; 'sin' has not been declared, even though it's a builtin.
 }
 
 // <rdar://problem/7677531>
 void (^test1)(int) = ^(int i) { // expected-warning {{declaration shadows a variable in the global scope}} \

 }
 
 struct PR24718_3;
 struct PR24718_4 {
   enum {
     PR24718_3 // Does not shadow a type.
   };
 };
+
+void static_locals() {
+  static int i; // expected-warning {{declaration shadows a variable in the global scope}}
+                // expected-note@-1 {{previous definition is here}}
+                // expected-note@-2 {{previous declaration is here}}
+  int i;        // expected-error {{non-static declaration of 'i' follows static declaration}}
+  static int foo; // expected-note {{previous declaration is here}}
+  static int hoge; // expected-note {{previous declaration is here}}
+  int s; // expected-warning {{declaration shadows a variable in the global scope}}
+  {
+    static int foo; // expected-warning {{declaration shadows a local variable}}
+                    // expected-note@-1 {{previous declaration is here}}
+    static int i; // expected-warning {{declaration shadows a local variable}}
+                  // expected-note@-1 {{previous declaration is here}}
+    int hoge; // expected-warning {{declaration shadows a local variable}}
+    {
+      static int foo; // expected-warning {{declaration shadows a local variable}}
+      int i; // expected-warning {{declaration shadows a local variable}}
+      extern int hoge;
+    }
+  }
+}

clang/test/SemaCXX/warn-shadow-in-lambdas.cpp

 // RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -Wshadow -D AVOID %s
 // RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -Wshadow -Wshadow-uncaptured-local %s
 // RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -Wshadow-all %s
 // RUN: %clang_cc1 -std=c++17 -verify -fsyntax-only -Wshadow-all %s
 // RUN: %clang_cc1 -std=c++20 -verify -fsyntax-only -Wshadow-all %s
 
 void foo(int param) { // expected-note 1+ {{previous declaration is here}}
   int var = 0; // expected-note 1+ {{previous declaration is here}}
 
   // Avoid warnings for variables that aren't implicitly captured.
   {
 #ifdef AVOID
     auto f1 = [=] { int var = 1; };  // no warning
     auto f2 = [&] { int var = 2; };  // no warning
     auto f3 = [=] (int param) { ; }; // no warning
     auto f4 = [&] (int param) { ; }; // no warning
+    auto f5 = [=] { static int var = 1; };  // no warning
+    auto f6 = [&] { static int var = 2; };  // no warning
 #else
     auto f1 = [=] { int var = 1; };  // expected-warning {{declaration shadows a local variable}}
     auto f2 = [&] { int var = 2; };  // expected-warning {{declaration shadows a local variable}}
     auto f3 = [=] (int param) { ; }; // expected-warning {{declaration shadows a local variable}}
     auto f4 = [&] (int param) { ; }; // expected-warning {{declaration shadows a local variable}}
+    auto f5 = [=] { static int var = 1; };  // expected-warning {{declaration shadows a local variable}}
+    auto f6 = [&] { static int var = 2; };  // expected-warning {{declaration shadows a local variable}}
 #endif
   }
 
   // Warn for variables that are implicitly captured.
   {
     auto f1 = [=] () {
       {
         int var = 1; // expected-warning {{declaration shadows a local variable}}
#endif
 
   // Avoid warnings for variables that aren't explicitly captured.
   {
 #ifdef AVOID
     auto f1 = [] { int var = 1; }; // no warning
     auto f2 = [] (int param) { ; }; // no warning
     auto f3 = [param] () { int var = 1; }; // no warning
     auto f4 = [var] (int param) { ; }; // no warning
+    auto f5 = [param] () { static int var = 1; }; // no warning
+    auto f6 = [] { static int var = 1; }; // no warning
 #else
     auto f1 = [] { int var = 1; }; // expected-warning {{declaration shadows a local variable}}
     auto f2 = [] (int param) { ; }; // expected-warning {{declaration shadows a local variable}}
     auto f3 = [param] () { int var = 1; }; // expected-warning {{declaration shadows a local variable}}
     auto f4 = [var] (int param) { ; }; // expected-warning {{declaration shadows a local variable}}
+    auto f5 = [param] () { static int var = 1; }; // expected-warning {{declaration shadows a local variable}}
+    auto f6 = [] { static int var = 1; }; // expected-warning {{declaration shadows a local variable}}
 #endif
   };
 
   // Warn for variables that are explicitly captured.
   {
     auto f1 = [var] () { // expected-note {{variable 'var' is explicitly captured here}}
       int var = 1; // expected-warning {{declaration shadows a local variable}}
     };
auto f4 = [&] {
       int var = 2; // expected-warning {{declaration shadows a local variable}}
     };
   };
   auto l6 = [&] {
     auto f1 = [param] { // expected-note {{variable 'param' is explicitly captured here}}
       int param = 0; // expected-warning {{declaration shadows a local variable}}
     };
   };
+  auto l7 = [&] {
+    auto f1 = [param] { // expected-note {{variable 'param' is explicitly captured here}}
+      static int param = 0; // expected-warning {{declaration shadows a local variable}}
+    };
+  };
 
   // Generic lambda arguments should work.
 #ifdef AVOID
   auto g1 = [](auto param) { ; }; // no warning
   auto g2 = [=](auto param) { ; }; // no warning
 #else
   auto g1 = [](auto param) { ; }; // expected-warning {{declaration shadows a local variable}}
   auto g2 = [=](auto param) { ; }; // expected-warning {{declaration shadows a local variable}}

clang/test/SemaCXX/warn-shadow.cpp

 // RUN: %clang_cc1 -verify -fsyntax-only -std=c++17 -Wshadow-all %s
 
 namespace {
   int i; // expected-note {{previous declaration is here}}
+  static int s; // 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 yy {
   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'}}
+  static int s; // expected-warning {{declaration shadows a variable in namespace '(anonymous)'}}
   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}}
+  int f1, f2, f3, f4; // expected-note 9 {{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'}}
class A {
 
   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
+    static char *f1; // expected-warning {{declaration shadows a field of 'A'}}
   }
 
   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'}}
void test4() {
   {
     int a = 4; // expected-warning {{declaration shadows a structured binding}}
   }
   {
     const auto [a, b] = S(); // expected-warning 2 {{declaration shadows a structured binding}}
   }
 }
 
-}; // namespace structured_binding_tests
+}; // namespace structured_binding_tests