[include-cleaner] Initial version for the "Location=>Header" step

[hokein]

Summary

This patch implements the initial version of "Location => Header" step:

• define the interface;
• integrate into the existing workflow, and use the PragmaIncludes;

[kadircet]

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

115

can you add comments here describing what this case is used for

145

let's move this to AnalysisInternal.h, as it isn't used in any of the public apis.

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

84

nit: if (auto *Loc = std::get_if<SourceLocation>(&SLoc))

94

what about exporters here?

97

not sure i follow the fixme here, are you suggesting we should also compute transitive exporters?

102

nit: if (auto *Sym = std::get<tooling::stdlib::Symbol>(&SLoc))

clang-tools-extra/include-cleaner/lib/AnalysisInternal.h

52

this is fine for the initial version, but we'll likely lose a lot of performance here going forward. we can address it later on though, as this is an internal api and those performance concerns won't be a problem until this is used more widely.

we're likely going to call this function multiple times for each symbol, and also despite having different sourcelocations, there'll probably be lots of declarations that're originating from the same FileID.
Hence we'll want to accumulate outputs on a single container, rather than returning a new container at each call, and also have some sort of file-id based cache.

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

113

can we use findIncludeHeaders directly?

that way we don't need to set up a referencing file, e.g. you can directly create a SourceLocation inside private.h (in this case even the decl is not important).

(same for the export test)

132

calling this private is somewhat confusing, maybe call it Detail?

[hokein]

address comments

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

145

I'm not quite sure about this --the SymbolLocation is an important concept and API, even though it is not used in public APIs. Moved anyway.

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

94

based on our previous discussion, we decided to initially treat the spelling header in the IWYU private pragma as the final public header, so no need to do the exporters here.

97

Yeah, rephrased the FIXME.

clang-tools-extra/include-cleaner/lib/AnalysisInternal.h

52

Acked, agree that this is likely a hot function, we should not be concern about it at the moment.

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

113

the intention was to do an end-to-end test of the walkUsed API.

but you're right, we should have a unittest for findIncludeHeaders, added one, and simplified the end-to-end walkUsed test.

[kadircet]

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

116

nit: . at the end of comment

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

94

yeah SG, can you put a comment about that though? saying // Note that we might need to look for exporters in this case as well.

97

i see, i am not sure if that's desired though.

e.g. if we have foo.h exporting bar.h exporting baz.h, I don't think baz.h counts (or should count) as an alternative to foo.h. do we have information proving otherwise?

106

can you actually put an llvm_unreachable here?

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

113

the intention was to do an end-to-end test of the walkUsed API.

We can update the Basic test above for that purpose (and turn it into a smoke test instead).

but you're right, we should have a unittest for findIncludeHeaders, added one, and simplified the end-to-end walkUsed test.

Since these are all trying to test specific IWYU pragma behaviour, I still think it's better to test them in isolation, both for test brevity but also for debuggability in the future when something breaks.
Also making sure majority of the tests are smaller is good for incremental progress as well, when we update ast walking logic, we shouldn't be updating these tests for whatever reasons (+ arguments around test times).

131

you can still use the same fixture here, if you want a different name you can always do: using FindIncludeHeaders = WalkUsedTest; or class FindIncludeHeaders : public WalkUsedTest {};

[hokein]

address comments

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

97

The classical IWYU tool has this semantic, see the nested_export test in https://github.com/include-what-you-use/include-what-you-use/commit/9945e543d894e90fab5ebd0b685cabd5aa8dd21f.

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

113

ok, moved to WalkUsedTest.Basic. now the test is just a smoke test for IWYU pragma.

131

There is not much code being shared between these two tests (only the MakeAction, walk() is not used) -- the FindIncludeHeaders test is simpler than the WalkUsedTest, we don't need to build an AST or traverse the AST nodes.

[kadircet]

thanks, lgtm!

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

97

wow, that's surprising. but i guess is a valid point.

[hokein]

rebase

[sammccall]

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

145

FWIW +1 to the idea that this belongs in Types.h even if it's not used in public APIs at present, as discussed offline.

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

33

@kadircet gentle reminder - you wanted to defer this, this patch adds a copy/paste of the test setup - want me to try to pull something out before this gets out of hand?

[sammccall]

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

33

disregard, I misread this, the new test isn't calling walkUsed at all so belongs somewhere else

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Analysis.h

 //===--- Analysis.h - Analyze symbol references in AST ------------- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// A library that provides usage analysis for symbols based on AST analysis.
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSIS_H
 #define CLANG_INCLUDE_CLEANER_ANALYSIS_H
 
+#include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include <variant>
 
 namespace clang {
 class SourceLocation;
 class Decl;

 /// of a single source file.
 /// The references to macros must be recorded separately and provided.
 ///
 /// This is the main entrypoint of the include-cleaner library, and can be used:
 ///  - to diagnose missing includes: a referenced symbol is provided by
 ///    headers which don't match any #include in the main file
 ///  - to diagnose unused includes: an #include in the main file does not match
 ///    the headers for any referenced symbol
-/// FIXME: Take in an include structure to improve location to header mappings
-/// (e.g. IWYU pragmas).
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
-              llvm::ArrayRef<SymbolReference> MacroRefs, const SourceManager &,
-              UsedSymbolCB CB);
+              llvm::ArrayRef<SymbolReference> MacroRefs,
+              const PragmaIncludes &PI, const SourceManager &, UsedSymbolCB CB);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

 /// Represents a file that provides some symbol. Might not be includeable, e.g.
 /// built-in or main-file itself.
 struct Header {
   enum Kind {
     /// A source file parsed by clang. (May also be a <built-in> buffer).
     Physical,
     /// A recognized standard library header, like <string>.
     Standard,
+    /// A verbatim header spelling, a string quoted with <> or "" that can be
+    /// #included directly.
+    VerbatimSpelling,
   };
 
   Header(const FileEntry *FE) : Storage(FE) {}
   Header(tooling::stdlib::Header H) : Storage(H) {}
+  Header(StringRef VerbatimSpelling) : Storage(VerbatimSpelling) {}
 
   Kind kind() const { return static_cast<Kind>(Storage.index()); }
   bool operator==(const Header &RHS) const { return Storage == RHS.Storage; }
 
   const FileEntry *physical() const { return std::get<Physical>(Storage); }
   tooling::stdlib::Header standard() const {
     return std::get<Standard>(Storage);
   }
+  StringRef verbatimSpelling() const {
+    return std::get<VerbatimSpelling>(Storage);
+  }
 
 private:
-  // FIXME: Handle verbatim spellings.
   // Order must match Kind enum!
-  std::variant<const FileEntry *, tooling::stdlib::Header> Storage;
+  std::variant<const FileEntry *, tooling::stdlib::Header, StringRef> Storage;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Header &);
 
 /// A single #include directive written in the main file.
 struct Include {
   llvm::StringRef Spelled;             // e.g. vector
   const FileEntry *Resolved = nullptr; // e.g. /path/to/c++/v1/vector
                                        // nullptr if the header was not found
   SourceLocation HashLocation;         // of hash in #include <vector>
   unsigned Line = 0;                   // 1-based line number for #include
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Include &);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

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

 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace clang::include_cleaner {
-namespace {
-llvm::SmallVector<Header>
-toHeader(llvm::ArrayRef<tooling::stdlib::Header> Headers) {
-  llvm::SmallVector<Header> Result;
-  llvm::for_each(Headers, [&](tooling::stdlib::Header H) {
-    Result.emplace_back(Header(H));
-  });
-  return Result;
-}
-} // namespace
 
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
               llvm::ArrayRef<SymbolReference> MacroRefs,
-              const SourceManager &SM, UsedSymbolCB CB) {
+              const PragmaIncludes &PI, const SourceManager &SM,
+              UsedSymbolCB CB) {
   tooling::stdlib::Recognizer Recognizer;
   for (auto *Root : ASTRoots) {
     auto &SM = Root->getASTContext().getSourceManager();
     walkAST(*Root, [&](SourceLocation Loc, NamedDecl &ND, RefType RT) {
       if (auto SS = Recognizer(&ND)) {
         // FIXME: Also report forward decls from main-file, so that the caller
         // can decide to insert/ignore a header.
-        return CB({Loc, Symbol(*SS), RT}, toHeader(SS->headers()));
+        return CB({Loc, Symbol(*SS), RT}, findIncludeHeaders({*SS}, SM, PI));
       }
       // FIXME: Extract locations from redecls.
-      // FIXME: Handle IWYU pragmas, non self-contained files.
-      // FIXME: Handle macro locations.
-      if (auto *FE = SM.getFileEntryForID(SM.getFileID(ND.getLocation())))
-        return CB({Loc, Symbol(ND), RT}, {Header(FE)});
+      return CB({Loc, Symbol(ND), RT},
+                findIncludeHeaders({ND.getLocation()}, SM, PI));
     });
   }
   for (const SymbolReference &MacroRef : MacroRefs) {
     assert(MacroRef.Target.kind() == Symbol::Macro);
-    // FIXME: Handle IWYU pragmas, non self-contained files.
     // FIXME: Handle macro locations.
-    if (auto *FE = SM.getFileEntryForID(
-            SM.getFileID(MacroRef.Target.macro().Definition)))
-      CB(MacroRef, {Header(FE)});
+    return CB(MacroRef,
+              findIncludeHeaders(MacroRef.Target.macro().Definition, SM, PI));
+  }
+}
+
+llvm::SmallVector<Header> findIncludeHeaders(const SymbolLocation &SLoc,
+                                             const SourceManager &SM,
+                                             const PragmaIncludes &PI) {
+  llvm::SmallVector<Header> Results;
+  if (auto *Loc = std::get_if<SourceLocation>(&SLoc)) {
+    // FIXME: Handle non self-contained files.
+    FileID FID = SM.getFileID(*Loc);
+    const auto *FE = SM.getFileEntryForID(FID);
+    if (!FE)
+      return {};
+
+    // We treat the spelling header in the IWYU pragma as the final public
+    // header.
+    // FIXME: look for exporters if the public header is exported by another
+    // header.
+    llvm::StringRef VerbatimSpelling = PI.getPublic(FE);
+    if (!VerbatimSpelling.empty())
+      return {{VerbatimSpelling}};
+
+    Results = {{FE}};
+    // FIXME: compute transitive exporter headers.
+    for (const auto *Export : PI.getExporters(FE, SM.getFileManager()))
+      Results.push_back(Export);
+    return Results;
+  }
+  if (auto *Sym = std::get_if<tooling::stdlib::Symbol>(&SLoc)) {
+    for (const auto &H : Sym->headers())
+      Results.push_back(H);
+    return Results;
   }
+  llvm_unreachable("unhandled SymbolLocation kind!");
 }
 
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/lib/AnalysisInternal.h

 // The individual steps are declared here.
 // (AST => AST Node => Symbol is one API to avoid materializing DynTypedNodes).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSISINTERNAL_H
 #define CLANG_INCLUDE_CLEANER_ANALYSISINTERNAL_H
 
+#include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 
 namespace clang {
 class ASTContext;
 class Decl;
 class NamedDecl;

 /// - the RefType describes the relation between the SourceLocation and the
 ///   NamedDecl.
 ///
 /// walkAST is typically called once per top-level declaration in the file
 /// being analyzed, in order to find all references within it.
 void walkAST(Decl &Root,
              llvm::function_ref<void(SourceLocation, NamedDecl &, RefType)>);
 
+/// A location where a symbol can be provided.
+/// It is either a physical file of the TU (SourceLocation) or a logical
+/// location in the standard library (stdlib::Symbol).
+// FIXME: use a real Class!
+using SymbolLocation = std::variant<SourceLocation, tooling::stdlib::Symbol>;
+
+/// Finds the headers that provide the symbol location.
+// FIXME: expose signals
+llvm::SmallVector<Header> findIncludeHeaders(const SymbolLocation &Loc,
+                                             const SourceManager &SM,
+                                             const PragmaIncludes &PI);
+
 /// Write an HTML summary of the analysis to the given stream.
 /// FIXME: Once analysis has a public API, this should be public too.
 void writeHTMLReport(FileID File, llvm::ArrayRef<Decl *> Roots, ASTContext &Ctx,
                      llvm::raw_ostream &OS);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

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

RecordedPP::RecordedIncludes::match(Header H) const {
   case Header::Physical:
     for (unsigned I : ByFile.lookup(H.physical()))
       Result.push_back(&All[I]);
     break;
   case Header::Standard:
     for (unsigned I : BySpelling.lookup(H.standard().name().trim("<>")))
       Result.push_back(&All[I]);
     break;
+  case Header::VerbatimSpelling:
+    for (unsigned I : BySpelling.lookup(H.verbatimSpelling().trim("\"<>")))
+      Result.push_back(&All[I]);
+    break;
   }
   return Result;
 }
 
 std::unique_ptr<PPCallbacks> RecordedPP::record(const Preprocessor &PP) {
   return std::make_unique<PPRecorder>(*this, PP);
 }
 
 } // namespace clang::include_cleaner

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

 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Header &H) {
   switch (H.kind()) {
   case Header::Physical:
     return OS << H.physical()->getName();
   case Header::Standard:
     return OS << H.standard().name();
+  case Header::VerbatimSpelling:
+    return OS << H.verbatimSpelling();
   }
   llvm_unreachable("Unhandled Header kind");
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Include &I) {
   return OS << I.Line << ": " << I.Spelled << " => "
             << (I.Resolved ? I.Resolved->getName() : "<missing>");
 }

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

 //===--- AnalysisTest.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-include-cleaner/Analysis.h"
+#include "AnalysisInternal.h"
+#include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/FrontendActions.h"
 #include "clang/Testing/TestAST.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Testing/Support/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 
 namespace clang::include_cleaner {
 namespace {
 using testing::Pair;
 using testing::UnorderedElementsAre;
 
 TEST(WalkUsed, Basic) {
   // FIXME: Have a fixture for setting up tests.
-  llvm::Annotations HeaderCode(R"cpp(
-  void foo();
-  namespace std { class vector {}; })cpp");
   llvm::Annotations Code(R"cpp(
-  void $bar^bar() {
+  #include "header.h"
+  #include "private.h"
+
+  void $bar^bar($private^Private) {
     $foo^foo();
     std::$vector^vector $vconstructor^v;
   }
   )cpp");
   TestInputs Inputs(Code.code());
-  Inputs.ExtraFiles["header.h"] = HeaderCode.code().str();
-  Inputs.ExtraArgs.push_back("-include");
-  Inputs.ExtraArgs.push_back("header.h");
+  Inputs.ExtraFiles["header.h"] = R"cpp(
+  void foo();
+  namespace std { class vector {}; }
+  )cpp";
+  Inputs.ExtraFiles["private.h"] = R"cpp(
+    // IWYU pragma: private, include "path/public.h"
+    class Private {};
+  )cpp";
+
+  PragmaIncludes PI;
+  Inputs.MakeAction = [&PI] {
+    struct Hook : public SyntaxOnlyAction {
+    public:
+      Hook(PragmaIncludes *Out) : Out(Out) {}
+      bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
+        Out->record(CI);
+        return true;
+      }
+
+      PragmaIncludes *Out;
+    };
+    return std::make_unique<Hook>(&PI);
+  };
   TestAST AST(Inputs);
 
   llvm::SmallVector<Decl *> TopLevelDecls;
   for (Decl *D : AST.context().getTranslationUnitDecl()->decls()) {
     TopLevelDecls.emplace_back(D);
   }
 
   auto &SM = AST.sourceManager();
   llvm::DenseMap<size_t, std::vector<Header>> OffsetToProviders;
-  walkUsed(TopLevelDecls, /*MacroRefs=*/{}, SM,
+  walkUsed(TopLevelDecls, /*MacroRefs=*/{}, PI, SM,
            [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
              auto [FID, Offset] = SM.getDecomposedLoc(Ref.RefLocation);
              EXPECT_EQ(FID, SM.getMainFileID());
              OffsetToProviders.try_emplace(Offset, Providers.vec());
            });
   auto HeaderFile = Header(AST.fileManager().getFile("header.h").get());
   auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
   auto VectorSTL = Header(tooling::stdlib::Header::named("<vector>").value());
   EXPECT_THAT(
       OffsetToProviders,
       UnorderedElementsAre(
           Pair(Code.point("bar"), UnorderedElementsAre(MainFile)),
+          Pair(Code.point("private"),
+               UnorderedElementsAre(Header("\"path/public.h\""))),
           Pair(Code.point("foo"), UnorderedElementsAre(HeaderFile)),
           Pair(Code.point("vector"), UnorderedElementsAre(VectorSTL)),
           Pair(Code.point("vconstructor"), UnorderedElementsAre(VectorSTL))));
 }
 
 TEST(WalkUsed, MacroRefs) {
   llvm::Annotations Hdr(R"cpp(
     #define ^ANSWER 42
   )cpp");
   llvm::Annotations Main(R"cpp(
     #include "hdr.h"
     int x = ^ANSWER;
   )cpp");
 
   SourceManagerForFile SMF("main.cpp", Main.code());
   auto &SM = SMF.get();
   const FileEntry *HdrFile =
       SM.getFileManager().getVirtualFile("hdr.h", Hdr.code().size(), 0);
   SM.overrideFileContents(HdrFile,
                           llvm::MemoryBuffer::getMemBuffer(Hdr.code().str()));
   FileID HdrID = SM.createFileID(HdrFile, SourceLocation(), SrcMgr::C_User);
 
   IdentifierTable Idents;
   Symbol Answer =
       Macro{&Idents.get("ANSWER"), SM.getComposedLoc(HdrID, Hdr.point())};
   llvm::DenseMap<size_t, std::vector<Header>> OffsetToProviders;
+  PragmaIncludes PI;
   walkUsed(/*ASTRoots=*/{}, /*MacroRefs=*/
            {SymbolReference{SM.getComposedLoc(SM.getMainFileID(), Main.point()),
                             Answer, RefType::Explicit}},
-           SM,
+           PI, SM,
            [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
              auto [FID, Offset] = SM.getDecomposedLoc(Ref.RefLocation);
              EXPECT_EQ(FID, SM.getMainFileID());
              OffsetToProviders.try_emplace(Offset, Providers.vec());
            });
 
   EXPECT_THAT(
       OffsetToProviders,
       UnorderedElementsAre(Pair(Main.point(), UnorderedElementsAre(HdrFile))));
 }
 
+TEST(FindIncludeHeaders, IWYU) {
+  TestInputs Inputs;
+  PragmaIncludes PI;
+  Inputs.MakeAction = [&PI] {
+    struct Hook : public PreprocessOnlyAction {
+    public:
+      Hook(PragmaIncludes *Out) : Out(Out) {}
+      bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
+        Out->record(CI);
+        return true;
+      }
+
+      PragmaIncludes *Out;
+    };
+    return std::make_unique<Hook>(&PI);
+  };
+
+  Inputs.Code = R"cpp(
+    #include "header1.h"
+    #include "header2.h"
+  )cpp";
+  Inputs.ExtraFiles["header1.h"] = R"cpp(
+    // IWYU pragma: private, include "path/public.h"
+  )cpp";
+  Inputs.ExtraFiles["header2.h"] = R"cpp(
+    #include "detail1.h" // IWYU pragma: export
+
+    // IWYU pragma: begin_exports
+    #include "detail2.h"
+    // IWYU pragma: end_exports
+
+    #include "normal.h"
+  )cpp";
+  Inputs.ExtraFiles["normal.h"] = Inputs.ExtraFiles["detail1.h"] =
+      Inputs.ExtraFiles["detail2.h"] = "";
+  TestAST AST(Inputs);
+  const auto &SM = AST.sourceManager();
+  auto &FM = SM.getFileManager();
+  // Returns the source location for the start of the file.
+  auto SourceLocFromFile = [&](llvm::StringRef FileName) {
+    return SM.translateFileLineCol(FM.getFile(FileName).get(),
+                                   /*Line=*/1, /*Col=*/1);
+  };
+
+  EXPECT_THAT(findIncludeHeaders(SourceLocFromFile("header1.h"), SM, PI),
+              UnorderedElementsAre(Header("\"path/public.h\"")));
+
+  EXPECT_THAT(findIncludeHeaders(SourceLocFromFile("detail1.h"), SM, PI),
+              UnorderedElementsAre(Header(FM.getFile("header2.h").get()),
+                                   Header(FM.getFile("detail1.h").get())));
+  EXPECT_THAT(findIncludeHeaders(SourceLocFromFile("detail2.h"), SM, PI),
+              UnorderedElementsAre(Header(FM.getFile("header2.h").get()),
+                                   Header(FM.getFile("detail2.h").get())));
+
+  EXPECT_THAT(findIncludeHeaders(SourceLocFromFile("normal.h"), SM, PI),
+              UnorderedElementsAre(Header(FM.getFile("normal.h").get())));
+}
+
 } // namespace
 } // namespace clang::include_cleaner