[include-cleaner] Add export IWYU pragma support.

[hokein]

Summary

• add support to PragmaIncludes to handle IWYU export/begin_exports/end_exports pragma;
• implement an API to retrieve the direct exporter headers;

[kadircet]

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

90

what about a smallvector, instead of a denseset here?

90

nit: instead of UniqueIDs, you can directly store StringRefs in the values, if you use an Arena/StringSaver for storing full paths. that should save you from doing one extra lookup at query time.

94

i think it's important to mention why we're storing a string to the full path here:
There's no way to get a path for a UniqueID, especially when it hasn't been opened before. So store the full path and convert it to a FileEntry by opening the file again through a FileManager.

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

151

this has the nasty downside of:

// IWYU pragma: export
void foo();
#include "bar.h"

now bar.h will be considered exported :/ i think we have to store the line-number for the pragma as well and compare it (we can store 0 for block comments).

156

well, i've just noticed we're not actually doing anything specific to the include here (or for the keep equivalent) as we're just storing the line number we've seen the comment on.
so what about moving this logic (and the pragma keep one) into the HandleComment callback instead?

223

can you also assert that Stack top and current Range are from the same file id?

247

maybe call this ExportPragma instead of State?

249

what about just Location or SeenAt?

286

i think this is also a harsh assert. the file might get deleted from disk between indexing (e.g. clangd's preamble build) and query (e.g. clangd's AST built). so maybe log this occurrence instead and continue?

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

287–289

nit: indentation looks weird, maybe:

for(llvm::StringRef File : {"keep1.h", ...}) {
  Inputs.ExtraFiles[File] = "";
}

297

i think we should also EXPECT_TRUE for line 6 and 9.

346

can you also assert that for export1, export2 and mainfile?

371–373

nit: same indentation comment as above

[hokein]

address review comments

[hokein]

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

90

this is a good point. Thinking more about it, I think we don't even need RealPathNamesByUIDat all, if we store the Path as the value.

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

151

yeah, this is an invalid case, I think we should not put too much effort on handling all invalid cases, but this one is trivial to support, added line-number to the State.

156

right, but with the new implementation, we use the # line number to make sure the #include is within the export range, this logic needs to be here, otherwise the semantic of ShouldKeep will change to track all lines that have IWYU pragmas, even for lines without #include directive.

223

this assert makes sense for matching begin/end_exports case, but it is too strong for invalid cases, as the current code doesn't proper recover the unmatched begin/end exports cases at the moment (we might want to add some basic recovery mechanisms, but I think it is not a high priority).

e.g. for the case

good.h

// IWYU pragma: begin_exports
#include "bad.h"
// IWYU pragma: end_exports

bad.h

// IWYU pragma: end_exports

247

ExportPragma seems more confusing than State, it doesn't express that we're tracking the state of the export pragma.

249

renamed to SeenAt.

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

297

for these two cases it is false, based on the semantic of ShouldKeep, there is no #include directive on Line 6&9, so line 6&9 is not in the set, it will return false.

If there are #include directives on these lines, these are corner cases, multiple combinations:

• /* IWYU Pragma: begin_exports*/ #include "keep.h"
• #include "nokeep.h" /*IWYU Pragma: begin_exports*/
• /* IWYU Pragma: end_exports*/ #include "nokeep.h"
• #include "keep.h" /* IWYU Pragma: end_exports*/

Fully supporting these requires some effort and code complexity, and I believe these are rare cases, I would ignore these cases for now.

[kadircet]

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

150

do you mind extracting this into a method and re-flow in a early-exit friendly way, it's getting a little bit hard to follow. e.g:

void checkForExport(FileID IncludingFile, FileEntryRef IncludedFile) {
  if (ExportStack.etmpy()) return;
  auto &Top = ExportStack.top();
  if (Top.SeenAtFile != IncludingFile) return;
  ...
}

151

nit: auto &Top = ... to prevent the copy

154

can you move the comment to be above the if statement instead? nesting seems weird here. we can say make sure current include is covered by the export pragma.

155

unfortunately File is Optional.

156

track all lines that have IWYU pragmas, even for lines without #include directive

i am not sure what's so bad about this. i think it'll make the code less complicated, as inclusion directive doesn't need to care about mutating ShouldKeep anymore, and public api for the class doesn't actually care about include-directives for shouldKeep operation, it just operates on lines. so saying "yes" to preserving lines that have // IWYU keep/export but no associated inclusion directive, doesn't seem so confusing (i agree, it'd be better not to have, but i don't think is an important enough use case, i.e. people trying to make decisions for lines that don't have includes via include-cleaner is unlikely and possibly wrong enough that we shouldn't care).

up to you though, especially if you extract the export handling into a separate method, this shouldn't be too much of an issue.

156

nit: i'd actually make FullPath part of State and use it directly from there, rather than possibly calling tryGetRealPathName and save multiple times here.

195

nit: s/Handle/Record

247

i think State doesn't emphasize the fact that it's about exports specifically, hence i was trying to suggest including Export in the name somehow.

moreover, i don't think we're tracking the state of the export pragma, we're literally recording occurrence of an export pragma, the state is rather tracked via ExportStack itself. hence i'd still suggest renaming this to ExportPragma and if you want change the ExportStack to ExportState, but i think ExportStack is fine as is.

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

349

nit: re-order export3 and export2

[hokein]

address remaining comments.

[kadircet]

thanks for bearing with me, LG!

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

155

FileSeenHash feels a little bit confusing (sounds like hash of an entity), why not directly call it as the IncludingFile? (similarly instead of HashLine, IncludeLine or DirectiveLine ?)

167

i guess we should just use Top.FullPath here instead?

[hokein]

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

167

oops, I added the FullPath, but forgot to update the usage here.

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_RECORD_H
 #define CLANG_INCLUDE_CLEANER_RECORD_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/FileSystem/UniqueID.h"
 #include "clang-include-cleaner/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 class ASTConsumer;
 class ASTContext;
 class CompilerInstance;
 class Decl;
 class FileEntry;
 class Preprocessor;
 class PPCallbacks;
+class FileManager;
 
 namespace include_cleaner {
 
 /// Captures #include mapping information. It analyses IWYU Pragma comments and
 /// other use-instead-like mechanisms (#pragma include_instead) on included
 /// files.
 ///
 /// This is a low-level piece being used in the "Location => Header" analysis
public:
   bool shouldKeep(unsigned HashLineNumber) const {
     return ShouldKeep.find(HashLineNumber) != ShouldKeep.end();
   }
 
   /// Returns the public mapping include for the given physical header file.
   /// Returns "" if there is none.
   llvm::StringRef getPublic(const FileEntry *File) const;
 
+  /// Returns all direct exporter headers for the given header file.
+  /// Returns empty if there is none.
+  llvm::SmallVector<const FileEntry *> getExporters(const FileEntry *File,
+                                                    FileManager &FM) const;
+
 private:
   class RecordPragma;
   /// 1-based Line numbers for the #include directives of the main file that
   /// should always keep (e.g. has the `IWYU pragma: keep` or `IWYU pragma:
   /// export` right after).
   llvm::DenseSet</*LineNumber*/ unsigned> ShouldKeep;
 
   /// The public header mapping by the IWYU private pragma.
   //
   // !!NOTE: instead of using a FileEntry* to identify the physical file, we
   // deliberately use the UniqueID to ensure the result is stable across
   // FileManagers (for clangd's preamble and main-file builds).
-  llvm::DenseMap<llvm::sys::fs::UniqueID, std::string /*VerbatimSpelling*/>
+  llvm::DenseMap<llvm::sys::fs::UniqueID, llvm::StringRef /*VerbatimSpelling*/>
       IWYUPublic;
 
-  // FIXME: add other IWYU supports (export etc)
+  /// A reverse map from the underlying header to its exporter headers.
+  //
+  //  There's no way to get a FileEntry from a UniqueID, especially when it
+  //  hasn't been opened before. So store the full path and convert it to a
+  //  FileEntry by opening the file again through a FileManager.
+  llvm::DenseMap<llvm::sys::fs::UniqueID,
+                 llvm::SmallVector</*RealPathNames*/ llvm::StringRef>>
+      IWYUExportBy;
+
+  /// Owns the strings.
+  llvm::BumpPtrAllocator Arena;
+
   // FIXME: add support for clang use_instead pragma
   // FIXME: add selfcontained file.
 };
 
 /// Recorded main-file parser events relevant to include-cleaner.
 struct RecordedAST {
   /// The consumer (when installed into clang) tracks declarations in `*this`.
   std::unique_ptr<ASTConsumer> record();

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

static llvm::Optional<StringRef> parseIWYUPragma(const char *Text) {
   while (*End != 0 && *End != '\n')
     ++End;
   return StringRef(Text, End - Text);
 }
 
 class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
 public:
   RecordPragma(const CompilerInstance &CI, PragmaIncludes *Out)
-      : SM(CI.getSourceManager()), Out(Out) {}
+      : SM(CI.getSourceManager()), Out(Out), UniqueStrings(Arena) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     InMainFile = SM.isWrittenInMainFile(Loc);
   }
 
+  void EndOfMainFile() override {
+    for (auto &It : Out->IWYUExportBy) {
+      llvm::sort(It.getSecond());
+      It.getSecond().erase(
+          std::unique(It.getSecond().begin(), It.getSecond().end()),
+          It.getSecond().end());
+    }
+    Out->Arena = std::move(Arena);
+  }
+
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
                           CharSourceRange /*FilenameRange*/,
                           Optional<FileEntryRef> File,
                           llvm::StringRef /*SearchPath*/,
                           llvm::StringRef /*RelativePath*/,
                           const clang::Module * /*Imported*/,
                           SrcMgr::CharacteristicKind FileKind) override {
-    if (!InMainFile)
+    FileID HashFID = SM.getFileID(HashLoc);
+    int HashLine = SM.getLineNumber(HashFID, SM.getFileOffset(HashLoc));
+    checkForExport(HashFID, HashLine, File ? &File->getFileEntry() : nullptr);
+
+    if (InMainFile && LastPragmaKeepInMainFileLine == HashLine)
+      Out->ShouldKeep.insert(HashLine);
+  }
+
+  void checkForExport(FileID IncludingFile, int HashLine,
+                      const FileEntry *IncludedHeader) {
+    if (ExportStack.empty())
+      return;
+    auto &Top = ExportStack.back();
+    if (Top.SeenAtFile != IncludingFile)
       return;
-    int HashLine =
-        SM.getLineNumber(SM.getMainFileID(), SM.getFileOffset(HashLoc));
-    if (LastPragmaKeepInMainFileLine == HashLine)
+    // Make sure current include is covered by the export pragma.
+    if ((Top.Block && HashLine > Top.SeenAtLine) ||
+        Top.SeenAtLine == HashLine) {
+      if (IncludedHeader)
+        Out->IWYUExportBy[IncludedHeader->getUniqueID()].push_back(
+            Top.FullPath);
+      // main-file #include with export pragma should never be removed.
+      if (Top.SeenAtFile == SM.getMainFileID())
         Out->ShouldKeep.insert(HashLine);
     }
+    if (!Top.Block) // Pop immediately for single-line export pragma.
+      ExportStack.pop_back();
+  }
 
   bool HandleComment(Preprocessor &PP, SourceRange Range) override {
     auto &SM = PP.getSourceManager();
     auto Pragma = parseIWYUPragma(SM.getCharacterData(Range.getBegin()));
     if (!Pragma)
       return false;
 
     if (Pragma->consume_front("private, include ")) {
       // We always insert using the spelling from the pragma.
       if (auto *FE = SM.getFileEntryForID(SM.getFileID(Range.getBegin())))
         Out->IWYUPublic.insert(
             {FE->getLastRef().getUniqueID(),
-             Pragma->startswith("<") || Pragma->startswith("\"")
-                 ? Pragma->str()
-                 : ("\"" + *Pragma + "\"").str()});
+             save(Pragma->startswith("<") || Pragma->startswith("\"")
+                      ? (*Pragma)
+                      : ("\"" + *Pragma + "\"").str())});
       return false;
     }
+    FileID CommentFID = SM.getFileID(Range.getBegin());
+    int CommentLine = SM.getLineNumber(SM.getFileID(Range.getBegin()),
+                                       SM.getFileOffset(Range.getBegin()));
+    // Record export pragma.
+    if (Pragma->startswith("export")) {
+      ExportStack.push_back(
+          {CommentLine, CommentFID,
+           save(SM.getFileEntryForID(CommentFID)->tryGetRealPathName()),
+           false});
+    } else if (Pragma->startswith("begin_exports")) {
+      ExportStack.push_back(
+          {CommentLine, CommentFID,
+           save(SM.getFileEntryForID(CommentFID)->tryGetRealPathName()), true});
+    } else if (Pragma->startswith("end_exports")) {
+      // FIXME: be robust on unmatching cases. We should only pop the stack if
+      // the begin_exports and end_exports is in the same file.
+      if (!ExportStack.empty()) {
+        assert(ExportStack.back().Block);
+        ExportStack.pop_back();
+      }
+    }
 
     if (InMainFile) {
       if (!Pragma->startswith("keep"))
         return false;
       // Given:
       //
       // #include "foo.h"
       // #include "bar.h" // IWYU pragma: keep
       //
       // The order in which the callbacks will be triggered:
       //
       // 1. InclusionDirective("foo.h")
       // 2. handleCommentInMainFile("// IWYU pragma: keep")
       // 3. InclusionDirective("bar.h")
       //
       // This code stores the last location of "IWYU pragma: keep" (or export)
       // comment in the main file, so that when next InclusionDirective is
       // called, it will know that the next inclusion is behind the IWYU pragma.
-      LastPragmaKeepInMainFileLine = SM.getLineNumber(
-          SM.getMainFileID(), SM.getFileOffset(Range.getBegin()));
+      LastPragmaKeepInMainFileLine = CommentLine;
     }
     return false;
   }
 
 private:
+  StringRef save(llvm::StringRef S) { return UniqueStrings.save(S); }
+
   bool InMainFile = false;
   const SourceManager &SM;
   PragmaIncludes *Out;
+  llvm::BumpPtrAllocator Arena;
+  /// Intern table for strings. Contents are on the arena.
+  llvm::StringSaver UniqueStrings;
   // Track the last line "IWYU pragma: keep" was seen in the main file, 1-based.
   int LastPragmaKeepInMainFileLine = -1;
+  struct ExportPragma {
+    // The line number where we saw the begin_exports or export pragma.
+    int SeenAtLine = 0; // 1-based line number.
+    // The file where we saw the pragma.
+    FileID SeenAtFile;
+    // FullPath of the file SeenAtFile.
+    StringRef FullPath;
+    // true if it is a block begin/end_exports pragma; false if it is a
+    // single-line export pragma.
+    bool Block = false;
+  };
+  // A stack for tracking all open begin_exports or single-line export.
+  std::vector<ExportPragma> ExportStack;
 };
 
 void PragmaIncludes::record(const CompilerInstance &CI) {
   auto Record = std::make_unique<RecordPragma>(CI, this);
   CI.getPreprocessor().addCommentHandler(Record.get());
   CI.getPreprocessor().addPPCallbacks(std::move(Record));
 }
 
 llvm::StringRef PragmaIncludes::getPublic(const FileEntry *F) const {
   auto It = IWYUPublic.find(F->getUniqueID());
   if (It == IWYUPublic.end())
     return "";
   return It->getSecond();
 }
 
+llvm::SmallVector<const FileEntry *>
+PragmaIncludes::getExporters(const FileEntry *File, FileManager &FM) const {
+  auto It = IWYUExportBy.find(File->getUniqueID());
+  if (It == IWYUExportBy.end())
+    return {};
+
+  llvm::SmallVector<const FileEntry *> Results;
+  for (auto Export : It->getSecond()) {
+    // FIMXE: log the failing cases?
+    if (auto FE = expectedToOptional(FM.getFileRef(Export)))
+      Results.push_back(*FE);
+  }
+  return Results;
+}
+
 std::unique_ptr<ASTConsumer> RecordedAST::record() {
   class Recorder : public ASTConsumer {
     RecordedAST *Out;
 
   public:
     Recorder(RecordedAST *Out) : Out(Out) {}
     void Initialize(ASTContext &Ctx) override { Out->Ctx = &Ctx; }
     bool HandleTopLevelDecl(DeclGroupRef DG) override {

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

 //===-- RecordTest.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/Record.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Testing/TestAST.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Testing/Support/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang::include_cleaner {
 namespace {
 using testing::ElementsAre;
 using testing::ElementsAreArray;
 using testing::IsEmpty;
 
 // Matches a Decl* if it is a NamedDecl with the given name.
 MATCHER_P(named, N, "") {
   if (const NamedDecl *ND = llvm::dyn_cast<NamedDecl>(arg)) {
     if (N == ND->getNameAsString())
       return true;
   }
   std::string S;
   llvm::raw_string_ostream OS(S);
   arg->dump(OS);
   *result_listener << S;
   return false;
 }
 
+MATCHER_P(FileNamed, N, "") {
+  if (arg->tryGetRealPathName() == N)
+    return true;
+  *result_listener << arg->tryGetRealPathName().str();
+  return false;
+}
+
 class RecordASTTest : public ::testing::Test {
 protected:
   TestInputs Inputs;
   RecordedAST Recorded;
 
   RecordASTTest() {
     struct RecordAction : public ASTFrontendAction {
       RecordedAST &Out;
Inputs.MakeAction = [this] {
         }
         PragmaIncludes *Out;
       };
       return std::make_unique<Hook>(&PI);
     };
   }
 
   TestAST build() { return TestAST(Inputs); }
+
+  void createEmptyFiles(llvm::ArrayRef<StringRef> FileNames) {
+    for (llvm::StringRef File : FileNames)
+      Inputs.ExtraFiles[File] = "";
+  }
 };
 
 TEST_F(PragmaIncludeTest, IWYUKeep) {
   Inputs.Code = R"cpp(// Line 1
     #include "keep1.h" // IWYU pragma: keep
     #include "keep2.h" /* IWYU pragma: keep */
-    #include "normal.h"
+
+    #include "export1.h" // IWYU pragma: export // line 5
+    // IWYU pragma: begin_exports
+    #include "export2.h" // Line 7
+    #include "export3.h"
+    // IWYU pragma: end_exports
+
+    #include "normal.h" // Line 11
   )cpp";
-  Inputs.ExtraFiles["keep1.h"] = Inputs.ExtraFiles["keep2.h"] =
-      Inputs.ExtraFiles["normal.h"] = "";
+  createEmptyFiles({"keep1.h", "keep2.h", "export1.h", "export2.h", "export3.h",
+                    "normal.h"});
 
   TestAST Processed = build();
   EXPECT_FALSE(PI.shouldKeep(1));
+  // Keep
   EXPECT_TRUE(PI.shouldKeep(2));
   EXPECT_TRUE(PI.shouldKeep(3));
-  EXPECT_FALSE(PI.shouldKeep(4));
+
+  // Exports
+  EXPECT_TRUE(PI.shouldKeep(5));
+  EXPECT_TRUE(PI.shouldKeep(7));
+  EXPECT_TRUE(PI.shouldKeep(8));
+  EXPECT_FALSE(PI.shouldKeep(6)); // no # directive
+  EXPECT_FALSE(PI.shouldKeep(9)); // no # directive
+
+  EXPECT_FALSE(PI.shouldKeep(11));
 }
 
 TEST_F(PragmaIncludeTest, IWYUPrivate) {
   Inputs.Code = R"cpp(
     #include "public.h"
   )cpp";
   Inputs.ExtraFiles["public.h"] = "#include \"private.h\"";
   Inputs.ExtraFiles["private.h"] = R"cpp(
     // IWYU pragma: private, include "public2.h"
     class Private {};
   )cpp";
   TestAST Processed = build();
   auto PrivateFE = Processed.fileManager().getFile("private.h");
   assert(PrivateFE);
   EXPECT_EQ(PI.getPublic(PrivateFE.get()), "\"public2.h\"");
   auto PublicFE = Processed.fileManager().getFile("public.h");
   assert(PublicFE);
   EXPECT_EQ(PI.getPublic(PublicFE.get()), ""); // no mapping.
 }
 
+TEST_F(PragmaIncludeTest, IWYUExport) {
+  Inputs.Code = R"cpp(// Line 1
+    #include "export1.h"
+    #include "export2.h"
+  )cpp";
+  Inputs.ExtraFiles["export1.h"] = R"cpp(
+    #include "private.h" // IWYU pragma: export
+  )cpp";
+  Inputs.ExtraFiles["export2.h"] = R"cpp(
+    #include "export3.h"
+  )cpp";
+  Inputs.ExtraFiles["export3.h"] = R"cpp(
+    #include "private.h" // IWYU pragma: export
+  )cpp";
+  Inputs.ExtraFiles["private.h"] = "";
+  TestAST Processed = build();
+  const auto &SM = Processed.sourceManager();
+  auto &FM = Processed.fileManager();
+
+  EXPECT_THAT(PI.getExporters(FM.getFile("private.h").get(), FM),
+              testing::UnorderedElementsAre(FileNamed("export1.h"),
+                                            FileNamed("export3.h")));
+
+  EXPECT_TRUE(PI.getExporters(FM.getFile("export1.h").get(), FM).empty());
+  EXPECT_TRUE(PI.getExporters(FM.getFile("export2.h").get(), FM).empty());
+  EXPECT_TRUE(PI.getExporters(FM.getFile("export3.h").get(), FM).empty());
+  EXPECT_TRUE(
+      PI.getExporters(SM.getFileEntryForID(SM.getMainFileID()), FM).empty());
+}
+
+TEST_F(PragmaIncludeTest, IWYUExportBlock) {
+  Inputs.Code = R"cpp(// Line 1
+   #include "normal.h"
+  )cpp";
+  Inputs.ExtraFiles["normal.h"] = R"cpp(
+    #include "foo.h"
+
+    // IWYU pragma: begin_exports
+    #include "export1.h"
+    #include "private1.h"
+    // IWYU pragma: end_exports
+  )cpp";
+  Inputs.ExtraFiles["export1.h"] = R"cpp(
+    // IWYU pragma: begin_exports
+    #include "private1.h"
+    #include "private2.h"
+    // IWYU pragma: end_exports
+
+    #include "bar.h"
+    #include "private3.h" // IWYU pragma: export
+  )cpp";
+  createEmptyFiles(
+      {"private1.h", "private2.h", "private3.h", "foo.h", "bar.h"});
+  TestAST Processed = build();
+  auto &FM = Processed.fileManager();
+
+  EXPECT_THAT(PI.getExporters(FM.getFile("private1.h").get(), FM),
+              testing::UnorderedElementsAre(FileNamed("export1.h"),
+                                            FileNamed("normal.h")));
+  EXPECT_THAT(PI.getExporters(FM.getFile("private2.h").get(), FM),
+              testing::UnorderedElementsAre(FileNamed("export1.h")));
+  EXPECT_THAT(PI.getExporters(FM.getFile("private3.h").get(), FM),
+              testing::UnorderedElementsAre(FileNamed("export1.h")));
+
+  EXPECT_TRUE(PI.getExporters(FM.getFile("foo.h").get(), FM).empty());
+  EXPECT_TRUE(PI.getExporters(FM.getFile("bar.h").get(), FM).empty());
+}
+
 } // namespace
 } // namespace clang::include_cleaner