[include-cleaner] Unify behaviour for static & instance members

[kadircet]

Summary

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

[hokein]

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

128–134

We have two handled cases, it is not quite obvious to spot the difference between them. It would be nice to add a comment clarifying this is for accessing the static member instance.

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

117

can you add a testcase for static-member-call as well?

[kadircet]

• Adress review comments
• Handle Qualifier being null

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
     }
     for (auto *Arg : S->arguments())
       if (!TraverseStmt(Arg))
         return false;
     return true;
   }
 
   bool VisitDeclRefExpr(DeclRefExpr *DRE) {
+    // Static class members are handled here, as they don't produce MemberExprs.
+    if (DRE->getFoundDecl()->isCXXClassMember()) {
+      if (auto *Qual = DRE->getQualifier())
+        report(DRE->getLocation(), Qual->getAsRecordDecl(), RefType::Implicit);
+    } else {
       report(DRE->getLocation(), DRE->getFoundDecl());
+    }
     return true;
   }
 
   bool VisitMemberExpr(MemberExpr *E) {
     // Reporting a usage of the member decl would cause issues (e.g. force
     // including the base class for inherited members). Instead, we report a
     // usage of the base type of the MemberExpr, so that e.g. code
     // `returnFoo().bar` can keep #include "foo.h" (rather than inserting

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

if (!DiagBuf.empty())
     ADD_FAILURE() << DiagBuf << "\nfrom code:\n" << ReferencingCode;
   return TargetDecls;
 }
 
 TEST(WalkAST, DeclRef) {
   testWalk("int $explicit^x;", "int y = ^x;");
   testWalk("int $explicit^foo();", "int y = ^foo();");
   testWalk("namespace ns { int $explicit^x; }", "int y = ns::^x;");
-  testWalk("struct S { static int $explicit^x; };", "int y = S::^x;");
+  testWalk("struct $implicit^S { static int x; };", "int y = S::^x;");
   // Canonical declaration only.
   testWalk("extern int $explicit^x; int x;", "int y = ^x;");
   // Return type of `foo` isn't used.
   testWalk("struct S{}; S $explicit^foo();", "auto bar() { return ^foo(); }");
 }
 
 TEST(WalkAST, TagType) {
   testWalk("struct $explicit^S {};", "^S *y;");
TEST(WalkAST, TemplateNames) {
   testWalk("template<typename> struct $explicit^S {};",
            R"cpp(
       template <template <typename> typename> struct X {};
       X<^S> x;)cpp");
   testWalk("template<typename T> struct $explicit^S { S(T); };", "^S s(42);");
 }
 
 TEST(WalkAST, MemberExprs) {
+  testWalk("struct $implicit^S { static int f; };", "void foo() { S::^f; }");
+  testWalk("struct B { static int f; }; struct $implicit^S : B {};",
+           "void foo() { S::^f; }");
+  testWalk("struct B { static void f(); }; struct $implicit^S : B {};",
+           "void foo() { S::^f; }");
+  testWalk("struct B { static void f(); }; ",
+           "struct S : B { void foo() { ^f(); } };");
   testWalk("struct $implicit^S { void foo(); };", "void foo() { S{}.^foo(); }");
   testWalk(
       "struct S { void foo(); }; struct $implicit^X : S { using S::foo; };",
       "void foo() { X{}.^foo(); }");
   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "void fun(Derived d) { d.^a; }");
   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "void fun(Derived* d) { d->^a; }");