[include-cleaner] Respect IWYU pragmas during analyze

[kadircet]

Summary

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

[hokein]

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

184

add the export case as well.

[kadircet]

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

184

i don't think we should be testing the behaviour of PragmaIncludes::shouldKeep here, hence i think one example is enough.

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

walkUsed(ASTRoots, MacroRefs, PI, SM,
              }
              if (!Satisfied && !Providers.empty() &&
                  Ref.RT == RefType::Explicit)
                Missing.insert(spellHeader(Providers.front(), HS, MainFile));
            });
 
   AnalysisResults Results;
   for (const Include &I : Inc.all())
-    if (!Used.contains(&I))
+    if (!Used.contains(&I) && PI && !PI->shouldKeep(I.Line))
       Results.Unused.push_back(&I);
   for (llvm::StringRef S : Missing.keys())
     Results.Missing.push_back(S.str());
   llvm::sort(Results.Missing);
   return Results;
 }
 
 std::string fixIncludes(const AnalysisResults &Results, llvm::StringRef Code,

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

 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Testing/Support/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 
 namespace clang::include_cleaner {
 namespace {
+using testing::AllOf;
 using testing::Contains;
 using testing::ElementsAre;
-using testing::AllOf;
 using testing::Pair;
 using testing::UnorderedElementsAre;
 
 std::string guard(llvm::StringRef Code) {
   return "#pragma once\n" + Code.str();
 }
 
 class WalkUsedTest : public testing::Test {
EXPECT_THAT(
           Pair(Code.point("2"), UnorderedElementsAre(HdrFile))));
 }
 
 TEST(Analyze, Basic) {
   TestInputs Inputs;
   Inputs.Code = R"cpp(
 #include "a.h"
 #include "b.h"
+#include "keep.h" // IWYU pragma: keep
 
 int x = a + c;
 )cpp";
   Inputs.ExtraFiles["a.h"] = guard("int a;");
   Inputs.ExtraFiles["b.h"] = guard(R"cpp(
     #include "c.h"
     int b;
   )cpp");
   Inputs.ExtraFiles["c.h"] = guard("int c;");
+  Inputs.ExtraFiles["keep.h"] = guard("");
 
   RecordedPP PP;
-  Inputs.MakeAction = [&PP] {
+  PragmaIncludes PI;
+  Inputs.MakeAction = [&PP, &PI] {
     struct Hook : public SyntaxOnlyAction {
     public:
-      Hook(RecordedPP &PP) : PP(PP) {}
+      Hook(RecordedPP &PP, PragmaIncludes &PI) : PP(PP), PI(PI) {}
       bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
         CI.getPreprocessor().addPPCallbacks(PP.record(CI.getPreprocessor()));
+        PI.record(CI);
         return true;
       }
 
       RecordedPP &PP;
+      PragmaIncludes &PI;
     };
-    return std::make_unique<Hook>(PP);
+    return std::make_unique<Hook>(PP, PI);
   };
 
   TestAST AST(Inputs);
   auto Decls = AST.context().getTranslationUnitDecl()->decls();
   auto Results =
       analyze(std::vector<Decl *>{Decls.begin(), Decls.end()},
-              PP.MacroReferences, PP.Includes, /*PragmaIncludes=*/nullptr,
-              AST.sourceManager(), AST.preprocessor().getHeaderSearchInfo());
+              PP.MacroReferences, PP.Includes, &PI, AST.sourceManager(),
+              AST.preprocessor().getHeaderSearchInfo());
 
   const Include *B = PP.Includes.atLine(3);
   ASSERT_EQ(B->Spelled, "b.h");
   EXPECT_THAT(Results.Missing, ElementsAre("\"c.h\""));
   EXPECT_THAT(Results.Unused, ElementsAre(B));
 }
 
 TEST(FixIncludes, Basic) {