[clang][lex] NFCI: Use FileEntryRef in PPCallbacks::InclusionDirective()

[jansvoboda11]

Summary

This patch changes type of the File parameter in PPCallbacks::InclusionDirective() from const FileEntry * to Optional<FileEntryRef>.

With the API change in place, this patch then removes some uses of the deprecated FileEntry::getName() (e.g. in DependencyGraph.cpp and ModuleDependencyCollector.cpp).

[dexonsmith]

LGTM, with a couple of nitpicks. If you'd rather not improve the tests that's probably fine, since the patch doesn't make them any worse.

clang-tools-extra/clangd/unittests/HeadersTests.cpp

71–72

Test might be cleaner with EXPECT_THAT_ERROR; see comment in ParsedASTTests.cpp.

clang-tools-extra/clangd/unittests/ParsedASTTests.cpp

564–566

It might be nice to see the errors here on failures. You could do that with:

Optional<FileEntryRef> MainFE;
ASSERT_THAT_ERROR(FM.getFileRef(testPath("foo.cpp")).moveInto(MainFE), Succeeded());

The {EXPECT,ASSERT}_THAT_ERROR live in llvm/Testing/Support/Error.h.

clang/lib/Serialization/ASTReader.cpp

6047–6048

I think you can remove the inner if here.

[bnbarham]

Thanks Jan :)!

[jansvoboda11]

Rebase, apply review suggestions

[jansvoboda11]

clang-tools-extra/clangd/unittests/ParsedASTTests.cpp

564–566

That's pretty sweet, thanks for the suggestion!

clang-tools-extra/clang-move/Move.cpp

 class FindAllIncludes : public PPCallbacks {
 public:
   explicit FindAllIncludes(SourceManager *SM, ClangMoveTool *const MoveTool)
       : SM(*SM), MoveTool(MoveTool) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token & /*IncludeTok*/,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
-                          const FileEntry * /*File*/, StringRef SearchPath,
+                          Optional<FileEntryRef> /*File*/, StringRef SearchPath,
                           StringRef /*RelativePath*/,
                           const Module * /*Imported*/,
                           SrcMgr::CharacteristicKind /*FileType*/) override {
     if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
       MoveTool->addIncludes(FileName, IsAngled, SearchPath,
                             FileEntry->getName(), FilenameRange, SM);
   }
 

clang-tools-extra/clang-tidy/ExpandModularHeadersPPCallbacks.h

private:
   // Handle PPCallbacks.
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
 
   void InclusionDirective(SourceLocation DirectiveLoc,
                           const Token &IncludeToken, StringRef IncludedFilename,
                           bool IsAngled, CharSourceRange FilenameRange,
-                          const FileEntry *IncludedFile, StringRef SearchPath,
-                          StringRef RelativePath, const Module *Imported,
+                          Optional<FileEntryRef> IncludedFile,
+                          StringRef SearchPath, StringRef RelativePath,
+                          const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   void EndOfMainFile() override;
 
   // Handle all other callbacks.
   // Just parse to the corresponding location to generate PPCallbacks for the
   // corresponding range
   void Ident(SourceLocation Loc, StringRef) override;

clang-tools-extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp

if (!EnteredMainFile) {
     EnteredMainFile = true;
     PP->EnterMainSourceFile();
   }
 }
 
 void ExpandModularHeadersPPCallbacks::InclusionDirective(
     SourceLocation DirectiveLoc, const Token &IncludeToken,
     StringRef IncludedFilename, bool IsAngled, CharSourceRange FilenameRange,
-    const FileEntry *IncludedFile, StringRef SearchPath, StringRef RelativePath,
-    const Module *Imported, SrcMgr::CharacteristicKind FileType) {
+    Optional<FileEntryRef> IncludedFile, StringRef SearchPath,
+    StringRef RelativePath, const Module *Imported,
+    SrcMgr::CharacteristicKind FileType) {
   if (Imported) {
     serialization::ModuleFile *MF =
         Compiler.getASTReader()->getModuleManager().lookup(
             Imported->getASTFile());
     handleModuleFile(MF);
   }
   parseToLocation(DirectiveLoc);
 }

clang-tools-extra/clang-tidy/altera/KernelNameRestrictionCheck.cpp

 class KernelNameRestrictionPPCallbacks : public PPCallbacks {
 public:
   explicit KernelNameRestrictionPPCallbacks(ClangTidyCheck &Check,
                                             const SourceManager &SM)
       : Check(Check), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FileNameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FileNameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   void EndOfMainFile() override;
 
 private:
   /// Returns true if the name of the file with path FilePath is 'kernel.cl',
   /// 'verilog.cl', or 'vhdl.cl'. The file name check is case insensitive.
   bool fileNameIsRestricted(StringRef FilePath);
void KernelNameRestrictionCheck::registerPPCallbacks(const SourceManager &SM,
                                                      Preprocessor *PP,
                                                      Preprocessor *) {
   PP->addPPCallbacks(
       std::make_unique<KernelNameRestrictionPPCallbacks>(*this, SM));
 }
 
 void KernelNameRestrictionPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &, StringRef FileName, bool,
-    CharSourceRange, const FileEntry *, StringRef, StringRef, const Module *,
-    SrcMgr::CharacteristicKind) {
+    CharSourceRange, Optional<FileEntryRef>, StringRef, StringRef,
+    const Module *, SrcMgr::CharacteristicKind) {
   IncludeDirective ID = {HashLoc, FileName};
   IncludeDirectives.push_back(std::move(ID));
 }
 
 bool KernelNameRestrictionPPCallbacks::fileNameIsRestricted(
     StringRef FileName) {
   return FileName.equals_insensitive("kernel.cl") ||
          FileName.equals_insensitive("verilog.cl") ||

clang-tools-extra/clang-tidy/bugprone/SuspiciousIncludeCheck.cpp

 public:
   explicit SuspiciousIncludePPCallbacks(SuspiciousIncludeCheck &Check,
                                         const SourceManager &SM,
                                         Preprocessor *PP)
       : Check(Check), PP(PP) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
 private:
   SuspiciousIncludeCheck &Check;
   Preprocessor *PP;
 };
 } // namespace
 

 void SuspiciousIncludeCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(
       ::std::make_unique<SuspiciousIncludePPCallbacks>(*this, SM, PP));
 }
 
 void SuspiciousIncludePPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   if (IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import)
     return;
 
   SourceLocation DiagLoc = FilenameRange.getBegin().getLocWithOffset(1);
 
   const Optional<StringRef> IFE =

clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp

 class IncludeOrderPPCallbacks : public PPCallbacks {
 public:
   explicit IncludeOrderPPCallbacks(ClangTidyCheck &Check,
                                    const SourceManager &SM)
       : LookForMainModule(true), Check(Check), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void EndOfMainFile() override;
 
 private:
   struct IncludeDirective {
     SourceLocation Loc;    ///< '#' location in the include directive
     CharSourceRange Range; ///< SourceRange for the file name
     std::string Filename;  ///< Filename as a string
if (IsAngled)
     return 4;
 
   // Other headers are inserted between the main module header and LLVM headers.
   return 1;
 }
 
 void IncludeOrderPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   // We recognize the first include as a special main module header and want
   // to leave it in the top position.
   IncludeDirective ID = {HashLoc, FilenameRange, std::string(FileName),
                          IsAngled, false};
   if (LookForMainModule && !IsAngled) {
     ID.IsMainModule = true;

clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp

public:
   explicit RestrictedIncludesPPCallbacks(
       RestrictSystemLibcHeadersCheck &Check, const SourceManager &SM,
       const SmallString<128> CompilerIncudeDir)
       : portability::RestrictedIncludesPPCallbacks(Check, SM),
         CompilerIncudeDir(CompilerIncudeDir) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
 private:
   const SmallString<128> CompilerIncudeDir;
 };
 
 } // namespace
 
 void RestrictedIncludesPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   // Compiler provided headers are allowed (e.g stddef.h).
   if (SrcMgr::isSystem(FileType) && SearchPath == CompilerIncudeDir)
     return;
   portability::RestrictedIncludesPPCallbacks::InclusionDirective(
       HashLoc, IncludeTok, FileName, IsAngled, FilenameRange, File, SearchPath,
       RelativePath, Imported, FileType);

clang-tools-extra/clang-tidy/modernize/DeprecatedHeadersCheck.cpp

 namespace {
 class IncludeModernizePPCallbacks : public PPCallbacks {
 public:
   explicit IncludeModernizePPCallbacks(ClangTidyCheck &Check,
                                        LangOptions LangOpts);
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
 private:
   ClangTidyCheck &Check;
   LangOptions LangOpts;
   llvm::StringMap<std::string> CStyledHeaderToCxx;
   llvm::StringSet<> DeleteHeaders;
 };
IncludeModernizePPCallbacks::IncludeModernizePPCallbacks(ClangTidyCheck &Check,
   for (const auto &Key :
        std::vector<std::string>({"stdalign.h", "stdbool.h", "iso646.h"})) {
     DeleteHeaders.insert(Key);
   }
 }
 
 void IncludeModernizePPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   // FIXME: Take care of library symbols from the global namespace.
   //
   // Reasonable options for the check:
   //
   // 1. Insert std prefix for every such symbol occurrence.
   // 2. Insert `using namespace std;` to the beginning of TU.

clang-tools-extra/clang-tidy/modernize/MacroToEnumCheck.cpp

MacroToEnumCallbacks(MacroToEnumCheck *Check, const LangOptions &LangOptions,
       : Check(Check), LangOpts(LangOptions), SM(SM) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     clearCurrentEnum(HashLoc);
   }
 
   // Keep track of macro definitions that look like enums.
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 

clang-tools-extra/clang-tidy/portability/RestrictSystemIncludesCheck.h

 class RestrictedIncludesPPCallbacks : public PPCallbacks {
 public:
   explicit RestrictedIncludesPPCallbacks(RestrictSystemIncludesCheck &Check,
                                          const SourceManager &SM)
       : Check(Check), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void EndOfMainFile() override;
 
 private:
   struct IncludeDirective {
     IncludeDirective() = default;
     IncludeDirective(SourceLocation Loc, CharSourceRange Range,
                      StringRef Filename, StringRef FullPath, bool IsInMainFile)

clang-tools-extra/clang-tidy/portability/RestrictSystemIncludesCheck.cpp

 #include <cstring>
 
 namespace clang {
 namespace tidy {
 namespace portability {
 
 void RestrictedIncludesPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   if (!Check.contains(FileName) && SrcMgr::isSystem(FileType)) {
     SmallString<256> FullPath;
     llvm::sys::path::append(FullPath, SearchPath);
     llvm::sys::path::append(FullPath, RelativePath);
     // Bucket the allowed include directives by the id of the file they were
     // declared in.

clang-tools-extra/clang-tidy/readability/DuplicateIncludeCheck.cpp

public:
   }
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
 
void DuplicateIncludeCallbacks::FileChanged(SourceLocation Loc,
   if (Reason == EnterFile)
     Files.emplace_back();
   else if (Reason == ExitFile)
     Files.pop_back();
 }
 
 void DuplicateIncludeCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   if (llvm::find(Files.back(), FileName) != Files.back().end()) {
     // We want to delete the entire line, so make sure that [Start,End] covers
     // everything.
     SourceLocation Start =
         advanceBeyondCurrentLine(SM, HashLoc, -1).getLocWithOffset(-1);
     SourceLocation End =

clang-tools-extra/clang-tidy/utils/IncludeInserter.cpp

 public:
   explicit IncludeInserterCallback(IncludeInserter *Inserter)
       : Inserter(Inserter) {}
   // Implements PPCallbacks::InclusionDirective(). Records the names and source
   // locations of the inclusions in the main source file being processed.
   void InclusionDirective(SourceLocation HashLocation,
                           const Token &IncludeToken, StringRef FileNameRef,
                           bool IsAngled, CharSourceRange FileNameRange,
-                          const FileEntry * /*IncludedFile*/,
+                          Optional<FileEntryRef> /*IncludedFile*/,
                           StringRef /*SearchPath*/, StringRef /*RelativePath*/,
                           const Module * /*ImportedModule*/,
                           SrcMgr::CharacteristicKind /*FileType*/) override {
     Inserter->addInclude(FileNameRef, IsAngled, HashLocation,
                          IncludeToken.getEndLoc());
   }
 
 private:

clang-tools-extra/clangd/Headers.h

public:
   void collect(const CompilerInstance &CI);
 
   // HeaderID identifies file in the include graph. It corresponds to a
   // FileEntry rather than a FileID, but stays stable across preamble & main
   // file builds.
   enum class HeaderID : unsigned {};
 
   llvm::Optional<HeaderID> getID(const FileEntry *Entry) const;
-  HeaderID getOrCreateID(const FileEntry *Entry);
+  HeaderID getOrCreateID(FileEntryRef Entry);
 
   StringRef getRealPath(HeaderID ID) const {
     assert(static_cast<unsigned>(ID) <= RealPathNames.size());
     return RealPathNames[static_cast<unsigned>(ID)];
   }
 
   bool isSelfContained(HeaderID ID) const {
     return !NonSelfContained.contains(ID);

clang-tools-extra/clangd/Headers.cpp

RecordHeaders(const CompilerInstance &CI, IncludeStructure *Out)
       : SM(CI.getSourceManager()),
         HeaderInfo(CI.getPreprocessor().getHeaderSearchInfo()), Out(Out) {}
 
   // Record existing #includes - both written and resolved paths. Only #includes
   // in the main file are collected.
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
                           CharSourceRange /*FilenameRange*/,
-                          const FileEntry *File, llvm::StringRef /*SearchPath*/,
+                          Optional<FileEntryRef> File,
+                          llvm::StringRef /*SearchPath*/,
                           llvm::StringRef /*RelativePath*/,
                           const clang::Module * /*Imported*/,
                           SrcMgr::CharacteristicKind FileKind) override {
     auto MainFID = SM.getMainFileID();
     // If an include is part of the preamble patch, translate #line directives.
     if (InBuiltinFile)
       HashLoc = translatePreamblePatchLocation(HashLoc, SM);
 
     // Record main-file inclusions (including those mapped from the preamble
     // patch).
     if (isInsideMainFile(HashLoc, SM)) {
       Out->MainFileIncludes.emplace_back();
       auto &Inc = Out->MainFileIncludes.back();
       Inc.Written =
           (IsAngled ? "<" + FileName + ">" : "\"" + FileName + "\"").str();
-      Inc.Resolved = std::string(File ? File->tryGetRealPathName() : "");
+      Inc.Resolved =
+          std::string(File ? File->getFileEntry().tryGetRealPathName() : "");
       Inc.HashOffset = SM.getFileOffset(HashLoc);
       Inc.HashLine =
           SM.getLineNumber(SM.getFileID(HashLoc), Inc.HashOffset) - 1;
       Inc.FileKind = FileKind;
       Inc.Directive = IncludeTok.getIdentifierInfo()->getPPKeywordID();
       if (LastPragmaKeepInMainFileLine == Inc.HashLine)
         Inc.BehindPragmaKeep = true;
       if (File) {
-        IncludeStructure::HeaderID HID = Out->getOrCreateID(File);
+        IncludeStructure::HeaderID HID = Out->getOrCreateID(*File);
         Inc.HeaderID = static_cast<unsigned>(HID);
         if (IsAngled)
           if (auto StdlibHeader = tooling::stdlib::Header::named(Inc.Written)) {
             auto &IDs = Out->StdlibHeaders[*StdlibHeader];
             // Few physical files for one stdlib header name, linear scan is ok.
             if (!llvm::is_contained(IDs, HID))
               IDs.push_back(HID);
           }
       }
     }
 
     // Record include graph (not just for main-file includes)
     if (File) {
-      auto *IncludingFileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc));
+      auto IncludingFileEntry = SM.getFileEntryRefForID(SM.getFileID(HashLoc));
       if (!IncludingFileEntry) {
         assert(SM.getBufferName(HashLoc).startswith("<") &&
                "Expected #include location to be a file or <built-in>");
         // Treat as if included from the main file.
-        IncludingFileEntry = SM.getFileEntryForID(MainFID);
+        IncludingFileEntry = SM.getFileEntryRefForID(MainFID);
       }
-      auto IncludingID = Out->getOrCreateID(IncludingFileEntry),
-           IncludedID = Out->getOrCreateID(File);
+      auto IncludingID = Out->getOrCreateID(*IncludingFileEntry),
+           IncludedID = Out->getOrCreateID(*File);
       Out->IncludeChildren[IncludingID].push_back(IncludedID);
     }
   }
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     switch (Reason) {
IncludeStructure::getID(const FileEntry *Entry) const {
   }
   auto It = UIDToIndex.find(Entry->getUniqueID());
   if (It == UIDToIndex.end())
     return llvm::None;
   return It->second;
 }
 
 IncludeStructure::HeaderID
-IncludeStructure::getOrCreateID(const FileEntry *Entry) {
+IncludeStructure::getOrCreateID(FileEntryRef Entry) {
   // Main file's FileEntry was not known at IncludeStructure creation time.
-  if (Entry == MainFileEntry) {
+  if (&Entry.getFileEntry() == MainFileEntry) {
     if (RealPathNames.front().empty())
       RealPathNames.front() = MainFileEntry->tryGetRealPathName().str();
     return MainFileID;
   }
   auto R = UIDToIndex.try_emplace(
-      Entry->getUniqueID(),
+      Entry.getUniqueID(),
       static_cast<IncludeStructure::HeaderID>(RealPathNames.size()));
   if (R.second)
     RealPathNames.emplace_back();
   IncludeStructure::HeaderID Result = R.first->getSecond();
   std::string &RealPathName = RealPathNames[static_cast<unsigned>(Result)];
   if (RealPathName.empty())
-    RealPathName = Entry->tryGetRealPathName().str();
+    RealPathName = Entry.getFileEntry().tryGetRealPathName().str();
   return Result;
 }
 
 llvm::DenseMap<IncludeStructure::HeaderID, unsigned>
 IncludeStructure::includeDepth(HeaderID Root) const {
   // Include depth 0 is the main file only.
   llvm::DenseMap<HeaderID, unsigned> Result;
   assert(static_cast<unsigned>(Root) < RealPathNames.size());

clang-tools-extra/clangd/ParsedAST.cpp

for (const auto &Inc : Includes) {
       // Note that we can't make use of FileTok->length/text in here as in the
       // case of angled includes this will contain tok::less instead of
       // filename. Whereas Inc.Written contains the full header name including
       // quotes/angles.
       SynthesizedFilenameTok.setLength(Inc.Written.length());
       SynthesizedFilenameTok.setKind(tok::header_name);
       SynthesizedFilenameTok.setLiteralData(Inc.Written.data());
 
-      const FileEntry *FE = File ? &File->getFileEntry() : nullptr;
       llvm::StringRef WrittenFilename =
           llvm::StringRef(Inc.Written).drop_front().drop_back();
       Delegate->InclusionDirective(
           HashTok->location(), SynthesizedIncludeTok, WrittenFilename,
           Inc.Written.front() == '<',
           syntax::FileRange(SM, SynthesizedFilenameTok.getLocation(),
                             SynthesizedFilenameTok.getEndLoc())
               .toCharRange(SM),
-          FE, "SearchPath", "RelPath",
+          File, "SearchPath", "RelPath",
           /*Imported=*/nullptr, Inc.FileKind);
       if (File)
         Delegate->FileSkipped(*File, SynthesizedFilenameTok, Inc.FileKind);
     }
   }
 
   const std::vector<Inclusion> Includes;
   PPCallbacks *Delegate;

clang-tools-extra/clangd/index/IndexAction.cpp

 #include <functional>
 #include <memory>
 #include <utility>
 
 namespace clang {
 namespace clangd {
 namespace {
 
-llvm::Optional<std::string> toURI(const FileEntry *File) {
+llvm::Optional<std::string> toURI(Optional<FileEntryRef> File) {
   if (!File)
     return llvm::None;
-  auto AbsolutePath = File->tryGetRealPathName();
+  auto AbsolutePath = File->getFileEntry().tryGetRealPathName();
   if (AbsolutePath.empty())
     return llvm::None;
   return URI::create(AbsolutePath).toString();
 }
 
 // Collects the nodes and edges of include graph during indexing action.
 // Important: The graph generated by those callbacks might contain cycles and
 // self edges.
void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     // We only need to process each file once. So we don't care about anything
     // but entries.
     if (Reason != FileChangeReason::EnterFile)
       return;
 
     const auto FileID = SM.getFileID(Loc);
-    const auto *File = SM.getFileEntryForID(FileID);
+    auto File = SM.getFileEntryRefForID(FileID);
     auto URI = toURI(File);
     if (!URI)
       return;
     auto I = IG.try_emplace(*URI).first;
 
     auto &Node = I->getValue();
     // Node has already been populated.
     if (Node.URI.data() == I->getKeyData()) {
#endif
     if (FileID == SM.getMainFileID())
       Node.Flags |= IncludeGraphNode::SourceFlag::IsTU;
     Node.URI = I->getKey();
   }
 
   // Add edges from including files to includes.
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File,
                           llvm::StringRef SearchPath,
                           llvm::StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     auto IncludeURI = toURI(File);
     if (!IncludeURI)
       return;
 
-    auto IncludingURI = toURI(SM.getFileEntryForID(SM.getFileID(HashLoc)));
+    auto IncludingURI = toURI(SM.getFileEntryRefForID(SM.getFileID(HashLoc)));
     if (!IncludingURI)
       return;
 
     auto NodeForInclude = IG.try_emplace(*IncludeURI).first->getKey();
     auto NodeForIncluding = IG.try_emplace(*IncludingURI);
 
     NodeForIncluding.first->getValue().DirectIncludes.push_back(NodeForInclude);
   }
 
   // Sanity check to ensure we have already populated a skipped file.
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override {
 #ifndef NDEBUG
-    auto URI = toURI(&SkippedFile.getFileEntry());
+    auto URI = toURI(SkippedFile);
     if (!URI)
       return;
     auto I = IG.try_emplace(*URI);
     assert(!I.second && "File inserted for the first time on skip.");
     assert(I.first->getKeyData() == I.first->getValue().URI.data() &&
            "Node have not been populated yet");
 #endif
   }

clang-tools-extra/clangd/unittests/HeadersTests.cpp

 #include "clang/Basic/TokenKinds.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using ::testing::AllOf;
std::unique_ptr<CompilerInstance> setupClang() {
 
     EXPECT_FALSE(Clang->getFrontendOpts().Inputs.empty());
     return Clang;
   }
 
 protected:
   IncludeStructure::HeaderID getID(StringRef Filename,
                                    IncludeStructure &Includes) {
     auto &SM = Clang->getSourceManager();
-    auto Entry = SM.getFileManager().getFile(Filename);
-    EXPECT_TRUE(Entry);
+    auto Entry = SM.getFileManager().getFileRef(Filename);
+    EXPECT_THAT_EXPECTED(Entry, llvm::Succeeded());
     return Includes.getOrCreateID(*Entry);
   }
 
   IncludeStructure collectIncludes() {
     Clang = setupClang();
     PreprocessOnlyAction Action;
     EXPECT_TRUE(
         Action.BeginSourceFile(*Clang, Clang->getFrontendOpts().Inputs[0]));

clang-tools-extra/clangd/unittests/ParsedASTTests.cpp

 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Token.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock-matchers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
TEST(ParsedASTTest, ReplayPreambleForTidyCheckers) {
   static std::vector<Inclusion> Includes;
   static std::vector<syntax::Token> SkippedFiles;
   struct ReplayPreamblePPCallback : public PPCallbacks {
     const SourceManager &SM;
     explicit ReplayPreamblePPCallback(const SourceManager &SM) : SM(SM) {}
 
     void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                             StringRef FileName, bool IsAngled,
-                            CharSourceRange FilenameRange, const FileEntry *,
-                            StringRef, StringRef, const clang::Module *,
+                            CharSourceRange FilenameRange,
+                            Optional<FileEntryRef>, StringRef, StringRef,
+                            const clang::Module *,
                             SrcMgr::CharacteristicKind) override {
       Includes.emplace_back(SM, HashLoc, IncludeTok, FileName, IsAngled,
                             FilenameRange);
     }
 
     void FileSkipped(const FileEntryRef &, const Token &FilenameTok,
                      SrcMgr::CharacteristicKind) override {
       SkippedFiles.emplace_back(FilenameTok);
TEST(ParsedASTTest, PatchesDeletedIncludes) {
   // Ensure source location information is correct.
   EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
               testing::Pointwise(
                   eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
   // Ensure file proximity signals are correct.
   auto &SM = ExpectedAST.getSourceManager();
   auto &FM = SM.getFileManager();
   // Copy so that we can getOrCreateID().
   IncludeStructure Includes = ExpectedAST.getIncludeStructure();
-  auto MainFE = FM.getFile(testPath("foo.cpp"));
-  ASSERT_TRUE(MainFE);
+  auto MainFE = FM.getFileRef(testPath("foo.cpp"));
+  ASSERT_THAT_EXPECTED(MainFE, llvm::Succeeded());
   auto MainID = Includes.getOrCreateID(*MainFE);
   auto &PatchedFM = PatchedAST->getSourceManager().getFileManager();
   IncludeStructure PatchedIncludes = PatchedAST->getIncludeStructure();
-  auto PatchedMainFE = PatchedFM.getFile(testPath("foo.cpp"));
-  ASSERT_TRUE(PatchedMainFE);
+  auto PatchedMainFE = PatchedFM.getFileRef(testPath("foo.cpp"));
+  ASSERT_THAT_EXPECTED(PatchedMainFE, llvm::Succeeded());
   auto PatchedMainID = PatchedIncludes.getOrCreateID(*PatchedMainFE);
   EXPECT_EQ(Includes.includeDepth(MainID)[MainID],
             PatchedIncludes.includeDepth(PatchedMainID)[PatchedMainID]);
 }
 
 // Returns Code guarded by #ifndef guards
 std::string guard(llvm::StringRef Code) {
   static int GuardID = 0;

clang-tools-extra/modularize/CoverageChecker.cpp

 class CoverageCheckerCallbacks : public PPCallbacks {
 public:
   CoverageCheckerCallbacks(CoverageChecker &Checker) : Checker(Checker) {}
   ~CoverageCheckerCallbacks() override {}
 
   // Include directive callback.
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     Checker.collectUmbrellaHeaderHeader(File->getName());
   }
 
 private:
   CoverageChecker &Checker;
 };
 

clang-tools-extra/modularize/PreprocessorTracker.cpp

PreprocessorCallbacks(PreprocessorTrackerImpl &ppTracker,
       : PPTracker(ppTracker), PP(PP), RootHeaderFile(rootHeaderFile) {}
   ~PreprocessorCallbacks() override {}
 
   // Overridden handlers.
   void InclusionDirective(clang::SourceLocation HashLoc,
                           const clang::Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
                           clang::CharSourceRange FilenameRange,
-                          const clang::FileEntry *File,
+                          llvm::Optional<clang::FileEntryRef> File,
                           llvm::StringRef SearchPath,
                           llvm::StringRef RelativePath,
                           const clang::Module *Imported,
                           clang::SrcMgr::CharacteristicKind FileType) override;
   void FileChanged(clang::SourceLocation Loc,
                    clang::PPCallbacks::FileChangeReason Reason,
                    clang::SrcMgr::CharacteristicKind FileType,
                    clang::FileID PrevFID = clang::FileID()) override;

 }
 
 // Preprocessor callbacks for modularize.
 
 // Handle include directive.
 void PreprocessorCallbacks::InclusionDirective(
     clang::SourceLocation HashLoc, const clang::Token &IncludeTok,
     llvm::StringRef FileName, bool IsAngled,
-    clang::CharSourceRange FilenameRange, const clang::FileEntry *File,
-    llvm::StringRef SearchPath, llvm::StringRef RelativePath,
-    const clang::Module *Imported, clang::SrcMgr::CharacteristicKind FileType) {
+    clang::CharSourceRange FilenameRange,
+    llvm::Optional<clang::FileEntryRef> File, llvm::StringRef SearchPath,
+    llvm::StringRef RelativePath, const clang::Module *Imported,
+    clang::SrcMgr::CharacteristicKind FileType) {
   int DirectiveLine, DirectiveColumn;
   std::string HeaderPath = getSourceLocationFile(PP, HashLoc);
   getSourceLocationLineAndColumn(PP, HashLoc, DirectiveLine, DirectiveColumn);
   PPTracker.handleIncludeDirective(HeaderPath, DirectiveLine, DirectiveColumn,
                                    FileName);
 }
 
 // Handle file entry/exit.

clang-tools-extra/pp-trace/PPCallbacksTracker.h

public:
 
   void FileChanged(SourceLocation Loc, PPCallbacks::FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID = FileID()) override;
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           llvm::StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File,
                           llvm::StringRef SearchPath,
                           llvm::StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
                     const Module *Imported) override;
   void EndOfMainFile() override;
   void Ident(SourceLocation Loc, llvm::StringRef str) override;
   void PragmaDirective(SourceLocation Loc,
public:
   void appendArgument(const char *Name, const Token &Value);
 
   /// Append an enum argument to the top trace item.
   void appendArgument(const char *Name, int Value, const char *const Strings[]);
 
   /// Append a FileID argument to the top trace item.
   void appendArgument(const char *Name, FileID Value);
 
-  /// Append a FileEntry argument to the top trace item.
-  void appendArgument(const char *Name, const FileEntry *Value);
+  /// Append a FileEntryRef argument to the top trace item.
+  void appendArgument(const char *Name, Optional<FileEntryRef> Value);
+  void appendArgument(const char *Name, FileEntryRef Value);
 
   /// Append a SourceLocation argument to the top trace item.
   void appendArgument(const char *Name, SourceLocation Value);
 
   /// Append a SourceRange argument to the top trace item.
   void appendArgument(const char *Name, SourceRange Value);
 
   /// Append a CharSourceRange argument to the top trace item.

clang-tools-extra/pp-trace/PPCallbacksTracker.cpp

 }
 
 // Callback invoked whenever a source file is skipped as the result
 // of header guard optimization.
 void PPCallbacksTracker::FileSkipped(const FileEntryRef &SkippedFile,
                                      const Token &FilenameTok,
                                      SrcMgr::CharacteristicKind FileType) {
   beginCallback("FileSkipped");
-  appendArgument("ParentFile", &SkippedFile.getFileEntry());
+  appendArgument("ParentFile", SkippedFile);
   appendArgument("FilenameTok", FilenameTok);
   appendArgument("FileType", FileType, CharacteristicKindStrings);
 }
 
 // Callback invoked whenever an inclusion directive of
 // any kind (#include, #import, etc.) has been processed, regardless
 // of whether the inclusion will actually result in an inclusion.
 void PPCallbacksTracker::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, llvm::StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     llvm::StringRef SearchPath, llvm::StringRef RelativePath,
     const Module *Imported, SrcMgr::CharacteristicKind FileType) {
   beginCallback("InclusionDirective");
   appendArgument("IncludeTok", IncludeTok);
   appendFilePathArgument("FileName", FileName);
   appendArgument("IsAngled", IsAngled);
   appendArgument("FilenameRange", FilenameRange);
   appendArgument("File", File);
if (!FileEntry) {
     appendArgument(Name, "(getFileEntryForID failed)");
     return;
   }
   appendFilePathArgument(Name, FileEntry->getName());
 }
 
 // Append a FileEntry argument to the top trace item.
 void PPCallbacksTracker::appendArgument(const char *Name,
-                                        const FileEntry *Value) {
+                                        Optional<FileEntryRef> Value) {
   if (!Value) {
     appendArgument(Name, "(null)");
     return;
   }
-  appendFilePathArgument(Name, Value->getName());
+  appendArgument(Name, *Value);
+}
+
+void PPCallbacksTracker::appendArgument(const char *Name, FileEntryRef Value) {
+  appendFilePathArgument(Name, Value.getName());
 }
 
 // Append a SourceLocation argument to the top trace item.
 void PPCallbacksTracker::appendArgument(const char *Name,
                                         SourceLocation Value) {
   if (Value.isInvalid()) {
     appendArgument(Name, "(invalid)");
     return;

clang/include/clang/Lex/PPCallbacks.h

public:
   /// directory holds normal user code, system code, or system code which is
   /// implicitly 'extern "C"' in C++ mode.
   ///
   virtual void InclusionDirective(SourceLocation HashLoc,
                                   const Token &IncludeTok,
                                   StringRef FileName,
                                   bool IsAngled,
                                   CharSourceRange FilenameRange,
-                                  const FileEntry *File,
+                                  Optional<FileEntryRef> File,
                                   StringRef SearchPath,
                                   StringRef RelativePath,
                                   const Module *Imported,
                                   SrcMgr::CharacteristicKind FileType) {
   }
 
   /// Callback invoked whenever a submodule was entered.
   ///
public:
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override {
     First->FileSkipped(SkippedFile, FilenameTok, FileType);
     Second->FileSkipped(SkippedFile, FilenameTok, FileType);
   }
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     First->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
                               FilenameRange, File, SearchPath, RelativePath,
                               Imported, FileType);
     Second->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
                                FilenameRange, File, SearchPath, RelativePath,
                                Imported, FileType);
   }

clang/include/clang/Lex/PreprocessingRecord.h

private:
     /// This is a value of type InclusionKind.
     unsigned Kind : 2;
 
     /// Whether the inclusion directive was automatically turned into
     /// a module import.
     unsigned ImportedModule : 1;
 
     /// The file that was included.
-    const FileEntry *File;
+    Optional<FileEntryRef> File;
 
   public:
-    InclusionDirective(PreprocessingRecord &PPRec,
-                       InclusionKind Kind, StringRef FileName,
-                       bool InQuotes, bool ImportedModule,
-                       const FileEntry *File, SourceRange Range);
+    InclusionDirective(PreprocessingRecord &PPRec, InclusionKind Kind,
+                       StringRef FileName, bool InQuotes, bool ImportedModule,
+                       Optional<FileEntryRef> File, SourceRange Range);
 
     /// Determine what kind of inclusion directive this is.
     InclusionKind getKind() const { return static_cast<InclusionKind>(Kind); }
 
     /// Retrieve the included file name as it was written in the source.
     StringRef getFileName() const { return FileName; }
 
     /// Determine whether the included file name was written in quotes;
     /// otherwise, it was written in angle brackets.
     bool wasInQuotes() const { return InQuotes; }
 
     /// Determine whether the inclusion directive was automatically
     /// turned into a module import.
     bool importedModule() const { return ImportedModule; }
 
     /// Retrieve the file entry for the actual file that was included
     /// by this directive.
-    const FileEntry *getFile() const { return File; }
+    Optional<FileEntryRef> getFile() const { return File; }
 
     // Implement isa/cast/dyncast/etc.
     static bool classof(const PreprocessedEntity *PE) {
       return PE->getKind() == InclusionDirectiveKind;
     }
   };
 
   /// An abstract class that should be subclassed by any external source
private:
     void MacroExpands(const Token &Id, const MacroDefinition &MD,
                       SourceRange Range, const MacroArgs *Args) override;
     void MacroDefined(const Token &Id, const MacroDirective *MD) override;
     void MacroUndefined(const Token &Id, const MacroDefinition &MD,
                         const MacroDirective *Undef) override;
     void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                             StringRef FileName, bool IsAngled,
                             CharSourceRange FilenameRange,
-                            const FileEntry *File, StringRef SearchPath,
+                            Optional<FileEntryRef> File, StringRef SearchPath,
                             StringRef RelativePath, const Module *Imported,
                             SrcMgr::CharacteristicKind FileType) override;
     void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
                const MacroDefinition &MD) override;
     void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
                 const MacroDefinition &MD) override;
 
     using PPCallbacks::Elifdef;

clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h

 public:
   ModuleDepCollectorPP(ModuleDepCollector &MDC) : MDC(MDC) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
                     const Module *Imported) override;
 
   void EndOfMainFile() override;
 
 private:
   /// The parent dependency collector.

clang/lib/CodeGen/MacroPPCallbacks.h

public:
   /// \param PrevFID the file that was exited if \p Reason is ExitFile.
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID = FileID()) override;
 
   /// Callback invoked whenever a directive (#xxx) is processed.
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   /// Hook called whenever a macro definition is seen.
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   /// Hook called whenever a macro \#undef is seen.
   ///
   /// MD is released immediately following this callback.
   void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
                       const MacroDirective *Undef) override;
 };
 
 } // end namespace clang
 
 #endif

clang/lib/CodeGen/MacroPPCallbacks.cpp

void MacroPPCallbacks::FileChanged(SourceLocation Loc, FileChangeReason Reason,
   if (Reason == EnterFile)
     FileEntered(Loc);
   else if (Reason == ExitFile)
     FileExited(Loc);
 }
 
 void MacroPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
 
   // Record the line location of the current included file.
   LastHashLoc = HashLoc;
 }
 
 void MacroPPCallbacks::MacroDefined(const Token &MacroNameTok,

clang/lib/Frontend/DependencyFile.cpp

void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
     DepCollector.maybeAddDependency(Filename, /*FromModule=*/false,
                                     /*IsSystem=*/isSystem(FileType),
                                     /*IsModuleFile=*/false,
                                     /*IsMissing=*/false);
   }
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     if (!File)
       DepCollector.maybeAddDependency(FileName, /*FromModule*/false,
                                      /*IsSystem*/false, /*IsModuleFile*/false,
                                      /*IsMissing*/true);
     // Files that actually exist are handled by FileChanged.
   }
 

clang/lib/Frontend/DependencyGraph.cpp

 using namespace clang;
 namespace DOT = llvm::DOT;
 
 namespace {
 class DependencyGraphCallback : public PPCallbacks {
   const Preprocessor *PP;
   std::string OutputFile;
   std::string SysRoot;
-  llvm::SetVector<const FileEntry *> AllFiles;
-  typedef llvm::DenseMap<const FileEntry *,
-                         SmallVector<const FileEntry *, 2> > DependencyMap;
+  llvm::SetVector<FileEntryRef> AllFiles;
+  using DependencyMap =
+      llvm::DenseMap<FileEntryRef, SmallVector<FileEntryRef, 2>>;
 
   DependencyMap Dependencies;
 
 private:
   raw_ostream &writeNodeReference(raw_ostream &OS,
                                   const FileEntry *Node);
   void OutputGraphFile();
 
 public:
   DependencyGraphCallback(const Preprocessor *_PP, StringRef OutputFile,
                           StringRef SysRoot)
     : PP(_PP), OutputFile(OutputFile.str()), SysRoot(SysRoot.str()) { }
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   void EndOfMainFile() override {
     OutputGraphFile();
   }
 
 };
 }
 
 void clang::AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile,
                                      StringRef SysRoot) {
   PP.addPPCallbacks(std::make_unique<DependencyGraphCallback>(&PP, OutputFile,
                                                                SysRoot));
 }
 
 void DependencyGraphCallback::InclusionDirective(
     SourceLocation HashLoc,
     const Token &IncludeTok,
     StringRef FileName,
     bool IsAngled,
     CharSourceRange FilenameRange,
-    const FileEntry *File,
+    Optional<FileEntryRef> File,
     StringRef SearchPath,
     StringRef RelativePath,
     const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   if (!File)
     return;
 
   SourceManager &SM = PP->getSourceManager();
-  const FileEntry *FromFile
-    = SM.getFileEntryForID(SM.getFileID(SM.getExpansionLoc(HashLoc)));
+  Optional<FileEntryRef> FromFile =
+      SM.getFileEntryRefForID(SM.getFileID(SM.getExpansionLoc(HashLoc)));
   if (!FromFile)
     return;
 
-  Dependencies[FromFile].push_back(File);
+  Dependencies[*FromFile].push_back(*File);
 
-  AllFiles.insert(File);
-  AllFiles.insert(FromFile);
+  AllFiles.insert(*File);
+  AllFiles.insert(*FromFile);
 }
 
 raw_ostream &
 DependencyGraphCallback::writeNodeReference(raw_ostream &OS,
                                             const FileEntry *Node) {
   OS << "header_" << Node->getUID();
   return OS;
 }
void DependencyGraphCallback::OutputGraphFile() {
   OS << "digraph \"dependencies\" {\n";
 
   // Write the nodes
   for (unsigned I = 0, N = AllFiles.size(); I != N; ++I) {
     // Write the node itself.
     OS.indent(2);
     writeNodeReference(OS, AllFiles[I]);
     OS << " [ shape=\"box\", label=\"";
-    StringRef FileName = AllFiles[I]->getName();
+    StringRef FileName = AllFiles[I].getName();
     if (FileName.startswith(SysRoot))
       FileName = FileName.substr(SysRoot.size());
 
     OS << DOT::EscapeString(std::string(FileName)) << "\"];\n";
   }
 
   // Write the edges
   for (DependencyMap::iterator F = Dependencies.begin(),

clang/lib/Frontend/ModuleDependencyCollector.cpp

struct ModuleDependencyPPCallbacks : public PPCallbacks {
   ModuleDependencyCollector &Collector;
   SourceManager &SM;
   ModuleDependencyPPCallbacks(ModuleDependencyCollector &Collector,
                               SourceManager &SM)
       : Collector(Collector), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     if (!File)
       return;
     Collector.addFile(File->getName());
   }
 };
 
 struct ModuleDependencyMMCallbacks : public ModuleMapCallbacks {

clang/lib/Frontend/PrecompiledPreamble.cpp

 
 public:
   MissingFileCollector(llvm::StringSet<> &Out, const HeaderSearch &Search,
                        const SourceManager &SM)
       : Out(Out), Search(Search), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
-    // File is null if it wasn't found.
+    // File is None if it wasn't found.
     // (We have some false negatives if PP recovered e.g. <foo> -> "foo")
-    if (File != nullptr)
+    if (File)
       return;
 
     // If it's a rare absolute include, we know the full path already.
     if (llvm::sys::path::is_absolute(FileName)) {
       Out.insert(FileName);
       return;
     }
 

clang/lib/Frontend/PrintPreprocessedOutput.cpp

public:
   /// MoveToLine(/*...*/, /*RequireStartOfLine=*/true).
   void startNewLineIfNeeded();
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void Ident(SourceLocation Loc, StringRef str) override;
   void PragmaMessage(SourceLocation Loc, StringRef Namespace,
                      PragmaMessageKind Kind, StringRef Str) override;
   void PragmaDebug(SourceLocation Loc, StringRef DebugType) override;
   void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override;
   void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override;
   void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,

 }
 
 void PrintPPOutputPPCallbacks::InclusionDirective(
     SourceLocation HashLoc,
     const Token &IncludeTok,
     StringRef FileName,
     bool IsAngled,
     CharSourceRange FilenameRange,
-    const FileEntry *File,
+    Optional<FileEntryRef> File,
     StringRef SearchPath,
     StringRef RelativePath,
     const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   // In -dI mode, dump #include directives prior to dumping their content or
   // interpretation.
   if (DumpIncludeDirectives) {
     MoveToLine(HashLoc, /*RequireStartOfLine=*/true);

clang/lib/Frontend/Rewrite/InclusionRewriter.cpp

 private:
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void If(SourceLocation Loc, SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override;
   void Elif(SourceLocation Loc, SourceRange ConditionRange,
             ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
   void WriteLineInfo(StringRef Filename, int Line,
                      SrcMgr::CharacteristicKind FileType,
                      StringRef Extra = StringRef());

 /// FileChanged() or FileSkipped() is called after this (or neither is
 /// called if this #include results in an error or does not textually include
 /// anything).
 void InclusionRewriter::InclusionDirective(SourceLocation HashLoc,
                                            const Token &/*IncludeTok*/,
                                            StringRef /*FileName*/,
                                            bool /*IsAngled*/,
                                            CharSourceRange /*FilenameRange*/,
-                                           const FileEntry * /*File*/,
+                                           Optional<FileEntryRef> /*File*/,
                                            StringRef /*SearchPath*/,
                                            StringRef /*RelativePath*/,
                                            const Module *Imported,
                                            SrcMgr::CharacteristicKind FileType){
   if (Imported) {
     auto P = ModuleIncludes.insert(std::make_pair(HashLoc, Imported));
     (void)P;
     assert(P.second && "Unexpected revisitation of the same include directive");

clang/lib/Lex/PPDirectives.cpp

if (Action == Enter && File && PreambleConditionalStack.isRecording() &&
     Diag(FilenameTok.getLocation(),
          diag::err_pp_including_mainfile_in_preamble);
     return {ImportAction::None};
   }
 
   if (Callbacks && !IsImportDecl) {
     // Notify the callback object that we've seen an inclusion directive.
     // FIXME: Use a different callback for a pp-import?
-    Callbacks->InclusionDirective(
-        HashLoc, IncludeTok, LookupFilename, isAngled, FilenameRange,
-        File ? &File->getFileEntry() : nullptr, SearchPath, RelativePath,
-        Action == Import ? SuggestedModule.getModule() : nullptr,
+    Callbacks->InclusionDirective(HashLoc, IncludeTok, LookupFilename, isAngled,
+                                  FilenameRange, File, SearchPath, RelativePath,
+                                  Action == Import ? SuggestedModule.getModule()
+                                                   : nullptr,
                                   FileCharacter);
     if (Action == Skip && File)
       Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
   }
 
   if (!File)
     return {ImportAction::None};
 
   // If this is a C++20 pp-import declaration, diagnose if we didn't find any

clang/lib/Lex/PreprocessingRecord.cpp

 using namespace clang;
 
 ExternalPreprocessingRecordSource::~ExternalPreprocessingRecordSource() =
     default;
 
 InclusionDirective::InclusionDirective(PreprocessingRecord &PPRec,
                                        InclusionKind Kind, StringRef FileName,
                                        bool InQuotes, bool ImportedModule,
-                                       const FileEntry *File, SourceRange Range)
+                                       Optional<FileEntryRef> File,
+                                       SourceRange Range)
     : PreprocessingDirective(InclusionDirectiveKind, Range), InQuotes(InQuotes),
       Kind(Kind), ImportedModule(ImportedModule), File(File) {
   char *Memory = (char *)PPRec.Allocate(FileName.size() + 1, alignof(char));
   memcpy(Memory, FileName.data(), FileName.size());
   Memory[FileName.size()] = 0;
   this->FileName = StringRef(Memory, FileName.size());
 }
 

 }
 
 void PreprocessingRecord::InclusionDirective(
     SourceLocation HashLoc,
     const Token &IncludeTok,
     StringRef FileName,
     bool IsAngled,
     CharSourceRange FilenameRange,
-    const FileEntry *File,
+    Optional<FileEntryRef> File,
     StringRef SearchPath,
     StringRef RelativePath,
     const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   InclusionDirective::InclusionKind Kind = InclusionDirective::Include;
 
   switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
   case tok::pp_include:

clang/lib/Serialization/ASTReader.cpp

if (DeserializationListener)
       DeserializationListener->MacroDefinitionRead(PPID, MD);
 
     return MD;
   }
 
   case PPD_INCLUSION_DIRECTIVE: {
     const char *FullFileNameStart = Blob.data() + Record[0];
     StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
-    const FileEntry *File = nullptr;
+    Optional<FileEntryRef> File;
     if (!FullFileName.empty())
-      if (auto FE = PP.getFileManager().getFile(FullFileName))
-        File = *FE;
+      File = PP.getFileManager().getOptionalFileRef(FullFileName);
 
     // FIXME: Stable encoding
     InclusionDirective::InclusionKind Kind
       = static_cast<InclusionDirective::InclusionKind>(Record[2]);
     InclusionDirective *ID
       = new (PPRec) InclusionDirective(PPRec, Kind,
                                        StringRef(Blob.data(), Record[0]),
                                        Record[1], Record[3],

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

void ModuleDepCollectorPP::FileChanged(SourceLocation Loc,
   if (Optional<StringRef> Filename =
           SM.getNonBuiltinFilenameForID(SM.getFileID(SM.getExpansionLoc(Loc))))
     MDC.FileDeps.push_back(
         std::string(llvm::sys::path::remove_leading_dotslash(*Filename)));
 }
 
 void ModuleDepCollectorPP::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
-    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    bool IsAngled, CharSourceRange FilenameRange, Optional<FileEntryRef> File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   if (!File && !Imported) {
     // This is a non-modular include that HeaderSearch failed to find. Add it
     // here as `FileChanged` will never see it.
     MDC.FileDeps.push_back(std::string(FileName));
   }
   handleImport(Imported);

clang/tools/libclang/CIndex.cpp

CXCursor clang_getCursorLexicalParent(CXCursor cursor) {
   return clang_getNullCursor();
 }
 
 CXFile clang_getIncludedFile(CXCursor cursor) {
   if (cursor.kind != CXCursor_InclusionDirective)
     return nullptr;
 
   const InclusionDirective *ID = getCursorInclusionDirective(cursor);
-  return const_cast<FileEntry *>(ID->getFile());
+  Optional<FileEntryRef> File = ID->getFile();
+  return const_cast<FileEntry *>(File ? &File->getFileEntry() : nullptr);
 }
 
 unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) {
   if (C.kind != CXCursor_ObjCPropertyDecl)
     return CXObjCPropertyAttr_noattr;
 
   unsigned Result = CXObjCPropertyAttr_noattr;
   const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C));

clang/tools/libclang/CXIndexDataConsumer.h

public:
   static bool isFunctionLocalDecl(const Decl *D);
 
   bool shouldAbort();
 
   bool hasDiagnosticCallback() const { return CB.diagnostic; }
 
   void enteredMainFile(const FileEntry *File);
 
-  void ppIncludedFile(SourceLocation hashLoc,
-                      StringRef filename, const FileEntry *File,
-                      bool isImport, bool isAngled, bool isModuleImport);
+  void ppIncludedFile(SourceLocation hashLoc, StringRef filename,
+                      Optional<FileEntryRef> File, bool isImport, bool isAngled,
+                      bool isModuleImport);
 
   void importedModule(const ImportDecl *ImportD);
   void importedPCH(const FileEntry *File);
 
   void startedTranslationUnit();
 
   void indexDiagnostics();
 

clang/tools/libclang/CXIndexDataConsumer.cpp

CXIdxClientFile idxFile =
                          static_cast<CXFile>(const_cast<FileEntry *>(File)),
                          nullptr);
     FileMap[File] = idxFile;
   }
 }
 
 void CXIndexDataConsumer::ppIncludedFile(SourceLocation hashLoc,
                                      StringRef filename,
-                                     const FileEntry *File,
+                                     Optional<FileEntryRef> File,
                                      bool isImport, bool isAngled,
                                      bool isModuleImport) {
   if (!CB.ppIncludedFile)
     return;
 
+  const FileEntry *FE = File ? &File->getFileEntry() : nullptr;
+
   ScratchAlloc SA(*this);
   CXIdxIncludedFileInfo Info = { getIndexLoc(hashLoc),
                                  SA.toCStr(filename),
                                  static_cast<CXFile>(
-                                   const_cast<FileEntry *>(File)),
+                                   const_cast<FileEntry *>(FE)),
                                  isImport, isAngled, isModuleImport };
   CXIdxClientFile idxFile = CB.ppIncludedFile(ClientData, &Info);
-  FileMap[File] = idxFile;
+  FileMap[FE] = idxFile;
 }
 
 void CXIndexDataConsumer::importedModule(const ImportDecl *ImportD) {
   if (!CB.importedASTFile)
     return;
 
   Module *Mod = ImportD->getImportedModule();
   if (!Mod)

clang/tools/libclang/Indexing.cpp

void FileChanged(SourceLocation Loc, FileChangeReason Reason,
     if (Loc == MainFileLoc && Reason == PPCallbacks::EnterFile) {
       IsMainFileEntered = true;
       DataConsumer.enteredMainFile(SM.getFileEntryForID(SM.getMainFileID()));
     }
   }
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     bool isImport = (IncludeTok.is(tok::identifier) &&
             IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import);
     DataConsumer.ppIncludedFile(HashLoc, FileName, File, isImport, IsAngled,
                             Imported);
   }
 
   /// MacroDefined - This hook is called whenever a macro definition is seen.

clang/unittests/Lex/PPCallbacksTest.cpp

 
 namespace {
 
 // Stub to collect data from InclusionDirective callbacks.
 class InclusionDirectiveCallbacks : public PPCallbacks {
 public:
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
-                          CharSourceRange FilenameRange, const FileEntry *File,
-                          StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported,
+                          CharSourceRange FilenameRange,
+                          Optional<FileEntryRef> File, StringRef SearchPath,
+                          StringRef RelativePath, const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override {
     this->HashLoc = HashLoc;
     this->IncludeTok = IncludeTok;
     this->FileName = FileName.str();
     this->IsAngled = IsAngled;
     this->FilenameRange = FilenameRange;
     this->File = File;
     this->SearchPath = SearchPath.str();
     this->RelativePath = RelativePath.str();
     this->Imported = Imported;
     this->FileType = FileType;
   }
 
   SourceLocation HashLoc;
   Token IncludeTok;
   SmallString<16> FileName;
   bool IsAngled;
   CharSourceRange FilenameRange;
-  const FileEntry* File;
+  Optional<FileEntryRef> File;
   SmallString<16> SearchPath;
   SmallString<16> RelativePath;
   const Module* Imported;
   SrcMgr::CharacteristicKind FileType;
 };
 
 class CondDirectiveCallbacks : public PPCallbacks {
 public: