[include-cleaner] Visit the VarDecl in ASTWalker.

[hokein]

Summary

Fixes https://github.com/clangd/clangd/issues/1554

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

public:
   }
 
   bool VisitFunctionDecl(FunctionDecl *FD) {
     // Mark declaration from definition as it needs type-checking.
     if (FD->isThisDeclarationADefinition())
       report(FD->getLocation(), FD);
     return true;
   }
+  bool VisitVarDecl(VarDecl *VD) {
+    // Mark declaration from definition as it needs type-checking.
+    if (VD->isThisDeclarationADefinition())
+      report(VD->getLocation(), VD);
+    return true;
+  }
 
   bool VisitEnumDecl(EnumDecl *D) {
     // Definition of an enum with an underlying type references declaration for
     // type-checking purposes.
     if (D->isThisDeclarationADefinition() && D->getIntegerTypeSourceInfo())
       report(D->getLocation(), D);
     return true;
   }

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

Inputs.MakeAction = [this] {
         }
 
         PragmaIncludes *Out;
       };
       return std::make_unique<Hook>(&PI);
     };
   }
 
-  llvm::DenseMap<size_t, std::vector<Header>>
+  std::multimap<size_t, std::vector<Header>>
   offsetToProviders(TestAST &AST, SourceManager &SM,
                     llvm::ArrayRef<SymbolReference> MacroRefs = {}) {
     llvm::SmallVector<Decl *> TopLevelDecls;
     for (Decl *D : AST.context().getTranslationUnitDecl()->decls()) {
       if (!SM.isWrittenInMainFile(SM.getExpansionLoc(D->getLocation())))
         continue;
       TopLevelDecls.emplace_back(D);
     }
-    llvm::DenseMap<size_t, std::vector<Header>> OffsetToProviders;
+    std::multimap<size_t, std::vector<Header>> OffsetToProviders;
     walkUsed(TopLevelDecls, MacroRefs, &PI, SM,
              [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
                auto [FID, Offset] = SM.getDecomposedLoc(Ref.RefLocation);
                if (FID != SM.getMainFileID())
                  ADD_FAILURE() << "Reference outside of the main file!";
-               OffsetToProviders.try_emplace(Offset, Providers.vec());
+               OffsetToProviders.emplace(Offset, Providers.vec());
              });
     return OffsetToProviders;
   }
 };
 
 TEST_F(WalkUsedTest, Basic) {
   llvm::Annotations Code(R"cpp(
   #include "header.h"
   #include "private.h"
 
-  void $bar^bar($private^Private) {
+  void $bar^bar($private^Private $p^p) {
     $foo^foo();
-    std::$vector^vector $vconstructor^v;
+    std::$vector^vector $vconstructor^$v^v;
   }
   )cpp");
   Inputs.Code = Code.code();
   Inputs.ExtraFiles["header.h"] = guard(R"cpp(
   void foo();
   namespace std { class vector {}; }
   )cpp");
   Inputs.ExtraFiles["private.h"] = guard(R"cpp(
     // IWYU pragma: private, include "path/public.h"
     class Private {};
   )cpp");
 
   TestAST AST(Inputs);
   auto &SM = AST.sourceManager();
   auto HeaderFile = Header(AST.fileManager().getFile("header.h").get());
   auto PrivateFile = Header(AST.fileManager().getFile("private.h").get());
   auto PublicFile = Header("\"path/public.h\"");
   auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
   auto VectorSTL = Header(*tooling::stdlib::Header::named("<vector>"));
   EXPECT_THAT(
       offsetToProviders(AST, SM),
       UnorderedElementsAre(
           Pair(Code.point("bar"), UnorderedElementsAre(MainFile)),
+          Pair(Code.point("p"), UnorderedElementsAre(MainFile)),
           Pair(Code.point("private"),
                UnorderedElementsAre(PublicFile, PrivateFile)),
           Pair(Code.point("foo"), UnorderedElementsAre(HeaderFile)),
           Pair(Code.point("vector"), UnorderedElementsAre(VectorSTL)),
-          Pair(Code.point("vconstructor"), UnorderedElementsAre(VectorSTL))));
+          Pair(Code.point("vconstructor"), UnorderedElementsAre(VectorSTL)),
+          Pair(Code.point("v"), UnorderedElementsAre(MainFile))
+          ));
 }
 
 TEST_F(WalkUsedTest, MultipleProviders) {
   llvm::Annotations Code(R"cpp(
   #include "header1.h"
   #include "header2.h"
   void foo();
 
EXPECT_THAT(
       offsetToProviders(AST, SM),
       Contains(Pair(Code.point("foo"),
                     UnorderedElementsAre(HeaderFile1, HeaderFile2, MainFile))));
 }
 
 TEST_F(WalkUsedTest, MacroRefs) {
   llvm::Annotations Code(R"cpp(
     #include "hdr.h"
-    int x = $1^ANSWER;
-    int y = $2^ANSWER;
+    int $3^x = $1^ANSWER;
+    int $4^y = $2^ANSWER;
   )cpp");
   llvm::Annotations Hdr(guard("#define ^ANSWER 42"));
   Inputs.Code = Code.code();
   Inputs.ExtraFiles["hdr.h"] = Hdr.code();
   TestAST AST(Inputs);
   auto &SM = AST.sourceManager();
   const auto *HdrFile = SM.getFileManager().getFile("hdr.h").get();
+  auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
+
   auto HdrID = SM.translateFile(HdrFile);
 
   IdentifierTable Idents;
   Symbol Answer1 =
       Macro{&Idents.get("ANSWER"), SM.getComposedLoc(HdrID, Hdr.point())};
   Symbol Answer2 =
       Macro{&Idents.get("ANSWER"), SM.getComposedLoc(HdrID, Hdr.point())};
   EXPECT_THAT(
       offsetToProviders(AST, SM,
                         {SymbolReference{SM.getComposedLoc(SM.getMainFileID(),
                                                            Code.point("1")),
                                          Answer1, RefType::Explicit},
                          SymbolReference{SM.getComposedLoc(SM.getMainFileID(),
                                                            Code.point("2")),
                                          Answer2, RefType::Explicit}}),
       UnorderedElementsAre(
           Pair(Code.point("1"), UnorderedElementsAre(HdrFile)),
-          Pair(Code.point("2"), UnorderedElementsAre(HdrFile))));
+          Pair(Code.point("2"), UnorderedElementsAre(HdrFile)),
+          Pair(Code.point("3"), UnorderedElementsAre(MainFile)),
+          Pair(Code.point("4"), UnorderedElementsAre(MainFile))
+              ));
 }
 
 class AnalyzeTest : public testing::Test {
 protected:
   TestInputs Inputs;
   PragmaIncludes PI;
   RecordedPP PP;
   AnalyzeTest() {

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

TEST(WalkAST, Operator) {
   testWalk("struct string {}; int operator+(string, string);",
            "int k = string() ^+ string();");
   testWalk("struct string {int operator+(string); }; ",
            "int k = string() ^+ string();");
   testWalk("struct string { friend int operator+(string, string); }; ",
            "int k = string() ^+ string();");
 }
 
+TEST(WalkAST, VarDecls) {
+  // Definition uses declaration, not the other way around.
+  testWalk("extern int $explicit^x;", "int ^x = 1;");
+  testWalk("int x = 1;", "extern int ^x;");
+}
+
 TEST(WalkAST, Functions) {
   // Definition uses declaration, not the other way around.
   testWalk("void $explicit^foo();", "void ^foo() {}");
   testWalk("void foo() {}", "void ^foo();");
 
   // Unresolved calls marks all the overloads.
   testWalk("void $ambiguous^foo(int); void $ambiguous^foo(char);",
            "template <typename T> void bar() { ^foo(T{}); }");