[include-cleaner] Switch Include from FileEntry* -> FileEntryRef

[sammccall]

Summary

Unlike Header, we really do have a preferred spelling for an include: the one
that we used to open the file.

The fact that Header is still FileEntry* makes it difficult to accidentally
use path equality when we want inode equality.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

void IncludeCleanerCheck::check(const MatchFinder::MatchResult &Result) {
   for (const include_cleaner::Include &I :
        RecordedPreprocessor.Includes.all()) {
     if (Used.contains(&I) || !I.Resolved)
       continue;
     if (RecordedPI.shouldKeep(I.Line))
       continue;
     // Check if main file is the public interface for a private header. If so
     // we shouldn't diagnose it as unused.
-    if (auto PHeader = RecordedPI.getPublic(I.Resolved); !PHeader.empty()) {
+    if (auto PHeader = RecordedPI.getPublic(*I.Resolved); !PHeader.empty()) {
       PHeader = PHeader.trim("<>\"");
       // Since most private -> public mappings happen in a verbatim way, we
       // check textually here. This might go wrong in presence of symlinks or
       // header mappings. But that's not different than rest of the places.
       if (getCurrentMainFile().endswith(PHeader))
         continue;
     }
 
-    if (llvm::none_of(IgnoreHeadersRegex,
-                      [Resolved = I.Resolved->tryGetRealPathName()](
-                          const llvm::Regex &R) { return R.match(Resolved); }))
+    if (llvm::none_of(
+            IgnoreHeadersRegex,
+            [Resolved = (*I.Resolved).getFileEntry().tryGetRealPathName()](
       Unused.push_back(&I);
   }
 
   llvm::StringRef Code = SM->getBufferData(SM->getMainFileID());
   auto FileStyle =
       format::getStyle(format::DefaultFormatStyle, getCurrentMainFile(),
                        format::DefaultFallbackStyle, Code,
                        &SM->getFileManager().getVirtualFileSystem());

clang-tools-extra/clangd/IncludeCleaner.cpp

convertIncludes(const SourceManager &SM,
   for (const Inclusion &Inc : Includes) {
     include_cleaner::Include TransformedInc;
     llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
     TransformedInc.Spelled = WrittenRef.trim("\"<>");
     TransformedInc.HashLocation =
         SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
     TransformedInc.Line = Inc.HashLine + 1;
     TransformedInc.Angled = WrittenRef.starts_with("<");
-    auto FE = SM.getFileManager().getFile(Inc.Resolved);
+    auto FE = SM.getFileManager().getFileRef(Inc.Resolved);
     if (!FE) {
       elog("IncludeCleaner: Failed to get an entry for resolved path {0}: {1}",
-           Inc.Resolved, FE.getError().message());
+           Inc.Resolved, FE.takeError());
       continue;
     }
     TransformedInc.Resolved = *FE;
     ConvertedIncludes.add(std::move(TransformedInc));
   }
   return ConvertedIncludes;
 }
 
include_cleaner::walkUsed(
         for (const auto &H : Providers) {
           if (H.kind() == include_cleaner::Header::Physical &&
               (H.physical() == MainFile || H.physical() == PreamblePatch)) {
             Satisfied = true;
             continue;
           }
           for (auto *Inc : ConvertedIncludes.match(H)) {
             Satisfied = true;
-            auto HeaderID = Includes.getID(Inc->Resolved);
+            auto HeaderID = Includes.getID(&Inc->Resolved->getFileEntry());
             assert(HeaderID.has_value() &&
                    "ConvertedIncludes only contains resolved includes.");
             Used.insert(*HeaderID);
           }
         }
 
         if (Satisfied || Providers.empty() ||
             Ref.RT != include_cleaner::RefType::Explicit)

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

 // keeping the API clean. For example, Symbol may be a Decl AST node, a macro,
 // or a recognized standard library symbol.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_TYPES_H
 #define CLANG_INCLUDE_CLEANER_TYPES_H
 
+#include "clang/Basic/FileEntry.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfoVariant.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 #include <utility>
 #include <variant>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 } // namespace llvm
 namespace clang {
 class Decl;
-class FileEntry;
 class IdentifierInfo;
 namespace include_cleaner {
 
 /// We consider a macro to be a different symbol each time it is defined.
 struct Macro {
   IdentifierInfo *Name;
   /// The location of the Name where the macro is defined.
   SourceLocation Definition;
Header(SentinelTag, decltype(Storage) Sentinel)
       : Storage(std::move(Sentinel)) {}
   friend llvm::DenseMapInfo<Header>;
 };
 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
+  OptionalFileEntryRef Resolved;       // e.g. /path/to/c++/v1/vector
+                                       // nullopt if the header was not found
   SourceLocation HashLocation;         // of hash in #include <vector>
   unsigned Line = 0;                   // 1-based line number for #include
   bool Angled = false;                 // True if spelled with <angle> quotes.
   std::string quote() const;           // e.g. <vector>
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Include &);
 
 /// A container for all includes present in a file.

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

walkUsed(ASTRoots, MacroRefs, PI, SM,
                  Ref.RT == RefType::Explicit &&
                  !HeaderFilter(Providers.front().resolvedPath()))
                Missing.insert(spellHeader({Providers.front(), HS, MainFile}));
            });
 
   AnalysisResults Results;
   for (const Include &I : Inc.all()) {
     if (Used.contains(&I) || !I.Resolved ||
-        HeaderFilter(I.Resolved->tryGetRealPathName()))
+        HeaderFilter(I.Resolved->getFileEntry().tryGetRealPathName()))
       continue;
     if (PI) {
       if (PI->shouldKeep(I.Line))
         continue;
       // Check if main file is the public interface for a private header. If so
       // we shouldn't diagnose it as unused.
-      if (auto PHeader = PI->getPublic(I.Resolved); !PHeader.empty()) {
+      if (auto PHeader = PI->getPublic(*I.Resolved); !PHeader.empty()) {
         PHeader = PHeader.trim("<>\"");
         // Since most private -> public mappings happen in a verbatim way, we
         // check textually here. This might go wrong in presence of symlinks or
         // header mappings. But that's not different than rest of the places.
         if (MainFile->tryGetRealPathName().endswith(PHeader))
           continue;
       }
     }

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

void InclusionDirective(SourceLocation Hash, const Token &IncludeTok,
                           OptionalFileEntryRef File, StringRef SearchPath,
                           StringRef RelativePath, const Module *,
                           SrcMgr::CharacteristicKind) override {
     if (!Active)
       return;
 
     Include I;
     I.HashLocation = Hash;
-    I.Resolved = File ? &File->getFileEntry() : nullptr;
+    I.Resolved = File;
     I.Line = SM.getSpellingLineNumber(Hash);
     I.Spelled = SpelledFilename;
     I.Angled = IsAngled;
     Recorded.Includes.add(I);
   }
 
   void MacroExpands(const Token &MacroName, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {

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

 void Includes::add(const Include &I) {
   unsigned Index = All.size();
   All.push_back(I);
   auto BySpellingIt = BySpelling.try_emplace(I.Spelled).first;
   All.back().Spelled = BySpellingIt->first(); // Now we own the backing string.
 
   BySpellingIt->second.push_back(Index);
   if (I.Resolved)
-    ByFile[I.Resolved].push_back(Index);
+    ByFile[&I.Resolved->getFileEntry()].push_back(Index);
   ByLine[I.Line] = Index;
 }
 
 const Include *Includes::atLine(unsigned OneBasedIndex) const {
   auto It = ByLine.find(OneBasedIndex);
   return (It == ByLine.end()) ? nullptr : &All[It->second];
 }
 

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

ASSERT_THAT(
       Recorded.Includes.all(),
       testing::ElementsAre(spelled("./header.h"), spelled("missing.h")));
 
   auto &H = Recorded.Includes.all().front();
   EXPECT_EQ(H.Line, 2u);
   EXPECT_EQ(H.HashLocation,
             AST.sourceManager().getComposedLoc(
                 AST.sourceManager().getMainFileID(), MainFile.point("H")));
-  EXPECT_EQ(H.Resolved, AST.fileManager().getFile("header.h").get());
+  EXPECT_EQ(H.Resolved, *AST.fileManager().getOptionalFileRef("header.h"));
   EXPECT_FALSE(H.Angled);
 
   auto &M = Recorded.Includes.all().back();
   EXPECT_EQ(M.Line, 3u);
   EXPECT_EQ(M.HashLocation,
             AST.sourceManager().getComposedLoc(
                 AST.sourceManager().getMainFileID(), MainFile.point("M")));
-  EXPECT_EQ(M.Resolved, nullptr);
+  EXPECT_EQ(M.Resolved, std::nullopt);
   EXPECT_TRUE(M.Angled);
 }
 
 TEST_F(RecordPPTest, CapturesMacroRefs) {
   llvm::Annotations Header(R"cpp(
     #define $def^X 1
 
     // Refs, but not in main file.

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

 // Matches an Include* on the specified line;
 MATCHER_P(line, N, "") { return arg->Line == (unsigned)N; }
 
 TEST(RecordedIncludesTest, Match) {
   // We're using synthetic data, but need a FileManager to obtain FileEntry*s.
   // Ensure it doesn't do any actual IO.
   auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
   FileManager FM(FileSystemOptions{});
-  const FileEntry *A = FM.getVirtualFile("/path/a", /*Size=*/0, time_t{});
-  const FileEntry *B = FM.getVirtualFile("/path/b", /*Size=*/0, time_t{});
+  FileEntryRef A = FM.getVirtualFileRef("/path/a", /*Size=*/0, time_t{});
+  FileEntryRef B = FM.getVirtualFileRef("/path/b", /*Size=*/0, time_t{});
 
   Includes Inc;
   Inc.add(Include{"a", A, SourceLocation(), 1});
   Inc.add(Include{"a2", A, SourceLocation(), 2});
   Inc.add(Include{"b", B, SourceLocation(), 3});
   Inc.add(Include{"vector", B, SourceLocation(), 4});
   Inc.add(Include{"vector", B, SourceLocation(), 5});
-  Inc.add(Include{"missing", nullptr, SourceLocation(), 6});
+  Inc.add(Include{"missing", std::nullopt, SourceLocation(), 6});
 
-  EXPECT_THAT(Inc.match(A), ElementsAre(line(1), line(2)));
-  EXPECT_THAT(Inc.match(B), ElementsAre(line(3), line(4), line(5)));
+  EXPECT_THAT(Inc.match(&A.getFileEntry()), ElementsAre(line(1), line(2)));
+  EXPECT_THAT(Inc.match(&B.getFileEntry()),
+              ElementsAre(line(3), line(4), line(5)));
   EXPECT_THAT(Inc.match(*tooling::stdlib::Header::named("<vector>")),
               ElementsAre(line(4), line(5)));
 }
 
 } // namespace
 } // namespace clang::include_cleaner