[clang][index] NFCI: Make `CXFile` a `FileEntryRef`

[jansvoboda11]

Summary

This patch swaps out the void * behind CXFile from FileEntry * to FileEntryRef::MapEntry *. This allows us to remove some deprecated uses of FileEntry::getName().

Depends on D151854.

[benlangmuir]

clang/test/Modules/crash-vfs-umbrella-frameworks.m

13 ↗

(On Diff #527613)

This looks suspicious; what's going on here?

clang/tools/libclang/CXFile.h

2

Missing filename and C++ language tag from header comment.

clang/tools/libclang/CXLoadedDiagnostic.cpp

278–279

Does this preserve behaviour in call cases? operator[] will construct nullptr if the key is missing, but the new code will crash dereferencing an invalid iterator.

[jansvoboda11]

Remove accidental diff with --crash in test, add file header, continue being defensive in CXLoadedDiagnostic.cpp.

clang/test/Modules/crash-vfs-umbrella-frameworks.m

13 ↗

(On Diff #527613)

Bad cherry-pick, removed.

clang/tools/libclang/CXLoadedDiagnostic.cpp

278–279

You're right, let's continue being defensive here.

[Jake-Egan]

Hi, there's a test failure on AIX, could you take a look please?

https://lab.llvm.org/buildbot/#/builders/214/builds/8005/steps/6/logs/FAIL__Clang__index-with-module_m

[jansvoboda11]

In D151938#4426106, @Jake-Egan wrote:

Hi, there's a test failure on AIX, could you take a look please?

https://lab.llvm.org/buildbot/#/builders/214/builds/8005/steps/6/logs/FAIL__Clang__index-with-module_m

Thanks for notifying me. Interestingly, I didn't receive any notification from that bot. Is it possible for me to reproduce this locally on my Mac? If not, could you please provide me with the stack trace for the failing call to cantFail()?

[uabelho]

clang/tools/libclang/CXFile.h

18

Gcc warns here:

../../clang/tools/libclang/CXFile.h:18:50: warning: cast from type 'const MapEntry*' {aka 'const llvm::StringMapEntry<llvm::ErrorOr<clang::FileEntryRef::MapValue> >*'} to type 'CXFile' {aka 'void*'} casts away qualifiers [-Wcast-qual]

Anything that should be fixed?

[jansvoboda11]

clang/tools/libclang/CXFile.h

18

Thanks, should be fixed in 1c64c414.

[Jake-Egan]

Sorry for the late response @jansvoboda11, when lookupModuleFile is called, the file build/tools/clang/test/Index/Core/Output/index-with-module.m.tmp.mcp/A03A61VI43WA/ModA-21USRMHJNU3PG.pcm doesn't exist. So it seems there's some issue with the creation of the file.

The backtrace is:

#0  0x09000000005cefe4 in pthread_kill () from /usr/lib/libpthreads.a(shr_xpg5_64.o)
#1  0x09000000005ce808 in _p_raise () from /usr/lib/libpthreads.a(shr_xpg5_64.o)
#2  0x090000000004130c in raise () from /usr/lib/libc.a(shr_64.o)
#3  0x090000000005f49c in abort () from /usr/lib/libc.a(shr_64.o)
#4  0x0900000006cb4e30 in llvm::llvm_unreachable_internal (msg=<optimized out>, 
    file=0x8001000a0014bee <L.._MergedGlobals.658+12910> "/llvm-project/llvm/include/llvm/Support/Error.h", line=755) at /llvm-project/llvm/lib/Support/ErrorHandling.cpp:212
#5  0x0900000006ccc5ec in llvm::cantFail (Err=..., Msg=
    0x0 <clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind)>)
    at /llvm-project/llvm/include/llvm/Support/Error.h:755
#6  llvm::handleAllErrors<llvm::consumeError(llvm::Error)::{lambda(llvm::ErrorInfoBase const&)#1}>(llvm::Error, llvm::consumeError(llvm::Error)::{lambda(llvm::ErrorInfoBase const&)#1}&&) (E=..., Handlers=...)
    at /llvm-project/llvm/include/llvm/Support/Error.h:967
#7  0x0900000006d0ef30 in llvm::consumeError (Err=...)
    at /llvm-project/llvm/include/llvm/Support/Error.h:1044
#8  llvm::expectedToOptional<clang::FileEntryRef> (E=...)
    at /llvm-project/llvm/include/llvm/Support/Error.h:1057
#9  0x0000000102dc03a0 in clang::serialization::ModuleManager::lookupModuleFile (this=<optimized out>, FileName=..., 
    ExpectedSize=576478347173894528, ExpectedModTime=0, File=...)
    at /llvm-project/clang/lib/Serialization/ModuleManager.cpp:451
#10 0x0000000102dbf380 in clang::serialization::ModuleManager::addModule (this=0x110950d40, FileName=..., 
    Type=clang::serialization::MK_ExplicitModule, ImportLoc=..., 
    ImportedBy=0x0 <clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind)>, 
    Generation=67, ExpectedSize=-1, ExpectedModTime=-1, ExpectedSignature=..., 
    ReadSignature=@0x11071e1a8: 0x102dbd514 <readASTFileSignature(llvm::StringRef)>, 
    Module=@0xfffffffffffd678: 0x0 <clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind)>, ErrorStr=...) at /llvm-project/clang/lib/Serialization/ModuleManager.cpp:121
#11 0x0000000102dbc2a8 in clang::ASTReader::ReadASTCore (this=0x110950cb0, FileName=..., 
    Type=clang::serialization::MK_ImplicitModule, ImportLoc=..., 
    ImportedBy=0x0 <clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind)>, 
    Loaded=..., ExpectedSize=-1, ExpectedModTime=0, ExpectedSignature=..., ClientLoadCapabilities=19)
    at /llvm-project/clang/lib/Serialization/ASTReader.cpp:4584
#12 0x0000000102dbad14 in clang::ASTReader::ReadAST(llvm::StringRef, clang::serialization::ModuleKind, clang::SourceLocation, unsigned int, llvm::SmallVectorImpl<clang::ASTReader::ImportedSubmodule>*) ()
#13 0x0000000102c826a8 in clang::CompilerInstance::findOrCompileModuleAndReadAST(llvm::StringRef, clang::SourceLocation, clang::SourceLocation, bool) ()
#14 0x0000000102c7e75c in clang::CompilerInstance::loadModule (this=0x110950cc8, ImportLoc=..., Path=..., 
    Visibility=(clang::Module::AllVisible | unknown: 0x12), IsInclusionDirective=<optimized out>)
    at /llvm-project/clang/lib/Frontend/CompilerInstance.cpp:1995
#15 0x00000001001143ac in clang::Preprocessor::LexAfterModuleImport (this=0x1108ee6c8, Result=...)
    at /llvm-project/clang/lib/Lex/Preprocessor.cpp:1323
#16 0x00000001001132e4 in clang::Preprocessor::Lex (
this=0x110981100, Result=...) at /llvm-project/clang/lib/Lex/Preprocessor.cpp:899
#17 0x000000010271eb1c in clang::Parser::ConsumeToken (this=0x1109810f0)
    at /llvm-project/clang/include/clang/Parse/Parser.h:504
#18 clang::Parser::ParseModuleName (this=0x1109810f0, UseLoc=..., Path=..., IsImport=<optimized out>)
    at /llvm-project/clang/lib/Parse/Parser.cpp:2638
#19 0x000000010271de04 in clang::Parser::ParseModuleImport (this=0x1109810f0, AtLoc=..., 
    ImportState=@0x1: clang::Sema::FirstDecl) at /llvm-project/clang/lib/Parse/Parser.cpp:2526
#20 0x000000010296637c in clang::Parser::ParseObjCAtDirectives (this=0x1109810f0, DeclAttrs=..., DeclSpecAttrs=...)
    at /llvm-project/clang/lib/Parse/ParseObjc.cpp:99
#21 0x0000000102842e58 in clang::Parser::ParseExternalDeclaration (this=0x1109810f0, Attrs=..., DeclSpecAttrs=..., 
    DS=0x0 <clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind)>)
    at /llvm-project/clang/lib/Parse/Parser.cpp:908
#22 0x000000010271a934 in clang::Parser::ParseTopLevelDecl (this=0x1109810f0, Result=..., 
    ImportState=@0xfffffffffffeef8: clang::Sema::FirstDecl)
    at /llvm-project/clang/lib/Parse/Parser.cpp:742
#23 0x0000000102719524 in clang::Parser::ParseFirstTopLevelDecl (this=0xfffffffffffef90, Result=..., 
    ImportState=@0xffffffffffff1e8: clang::Sema::FirstDecl)
    at /llvm-project/clang/lib/Parse/Parser.cpp:594
#24 0x0000000101693200 in clang::ParseAST (S=..., PrintStats=<optimized out>, SkipFunctionBodies=<optimized out>)
    at /llvm-project/clang/lib/Parse/ParseAST.cpp:162
#25 0x00000001015f4d80 in clang::ASTFrontendAction::ExecuteAction() ()
#26 0x0000000102f96d18 in clang::FrontendAction::Execute() ()
    at /opt/IBM/openxlC/17.1.1/bin/../include/c++/v1/optional:957
#27 0x0000000102c77838 in clang::ASTUnit::LoadFromCompilerInvocationAction (CI=..., PCHContainerOps=..., Diags=..., 
    Action=<optimized out>, Unit=<optimized out>, Persistent=<optimized out>, ResourceFilesPath=..., 
    OnlyLocalDecls=<optimized out>, CaptureDiagnostics=<optimized out>, PrecompilePreambleAfterNParses=<optimized out>, 
    CacheCodeCompletionResults=<optimized out>, UserFilesAreVolatile=<optimized out>, ErrAST=<optimized out>)
    at /llvm-project/clang/lib/Frontend/ASTUnit.cpp:1651
#28 0x000000010002c1c4 in printSourceSymbols (Executable=<optimized out>, Args=..., indexLocals=<optimized out>, 
    dumpModuleImports=<optimized out>, ignoreMacros=<optimized out>)
    at /llvm-project/clang/tools/c-index-test/core_main.cpp:241
#29 indextest_core_main (argc=<optimized out>, argv=<optimized out>)
    at /llvm-project/clang/tools/c-index-test/core_main.cpp:370
#30 0x0000000100000a1c in main (argc=276155128, argv=0xffffffffffff8c0)
    at /llvm-project/clang/tools/c-index-test/c-index-test.c:5142

[jansvoboda11]

In D151938#4626992, @Jake-Egan wrote:

Sorry for the late response @jansvoboda11, when lookupModuleFile is called, the file build/tools/clang/test/Index/Core/Output/index-with-module.m.tmp.mcp/A03A61VI43WA/ModA-21USRMHJNU3PG.pcm doesn't exist. So it seems there's some issue with the creation of the file.

The backtrace is:

...

@Jake-Egan Thank you for the stack trace and XFAILing the test! Other tests started failing after converting more FileEntry usages to FileEntryRef: https://lab.llvm.org/buildbot/#/builders/214/builds/9416

There are definitely some behavioral changes these patches introduce, but I don't see anything obviously wrong. What's more concerning, though, is that llvm::expectedToOptional()/llvm::cantFail() end up in llvm_unreachable(). Are you able to investigate? If not, could you provide me a way to reproduce this? These failures only occur on the AIX bots AFAIK.

[Jake-Egan]

@jansvoboda11 Thanks for taking care of the other tests. I'm not sure how this could be reproduced not on AIX. I'll have to investigate.

[Jake-Egan]

@jansvoboda11 Actually, we could give you access to an AIX machine to debug this. Would that work for you?

[jansvoboda11]

In D151938#4645381, @Jake-Egan wrote:

@jansvoboda11 Actually, we could give you access to an AIX machine to debug this. Would that work for you?

Hi, I'd be happy to try that!

clang/include/clang/Basic/Module.h

private:
   /// \c SubModules vector at which that submodule resides.
   llvm::StringMap<unsigned> SubModuleIndex;
 
   /// The AST file if this is a top-level module which has a
   /// corresponding serialized AST file, or null otherwise.
   OptionalFileEntryRef ASTFile;
 
   /// The top-level headers associated with this module.
-  llvm::SmallSetVector<const FileEntry *, 2> TopHeaders;
+  llvm::SmallSetVector<FileEntryRef, 2> TopHeaders;
 
   /// top-level header filenames that aren't resolved to FileEntries yet.
   std::vector<std::string> TopHeaderNames;
 
   /// Cache of modules visible to lookup in this module.
   mutable llvm::DenseSet<const Module*> VisibleModulesCache;
 
   /// The ID used when referencing this module within a VisibleModuleSet.
public:
   }
 
   /// Get the effective umbrella directory for this module: either the one
   /// explicitly written in the module map file, or the parent of the umbrella
   /// header.
   OptionalDirectoryEntryRef getEffectiveUmbrellaDir() const;
 
   /// Add a top-level header associated with this module.
-  void addTopHeader(const FileEntry *File);
+  void addTopHeader(FileEntryRef File);
 
   /// Add a top-level header filename associated with this module.
   void addTopHeaderFilename(StringRef Filename) {
     TopHeaderNames.push_back(std::string(Filename));
   }
 
   /// The top-level headers associated with this module.
-  ArrayRef<const FileEntry *> getTopHeaders(FileManager &FileMgr);
+  ArrayRef<FileEntryRef> getTopHeaders(FileManager &FileMgr);
 
   /// Determine whether this module has declared its intention to
   /// directly use another module.
   bool directlyUses(const Module *Requested);
 
   /// Add the given feature requirement to the list of features
   /// required by this module.
   ///

clang/include/clang/Frontend/ASTUnit.h

public:
 
   /// Iterate over local declarations (locally parsed if this is a parsed
   /// source file or the loaded declarations of the primary module if this is an
   /// AST file).
   /// \returns true if the iteration was complete or false if it was aborted.
   bool visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn);
 
   /// Get the PCH file if one was included.
-  const FileEntry *getPCHFile();
+  OptionalFileEntryRef getPCHFile();
 
   /// Returns true if the ASTUnit was constructed from a serialized
   /// module file.
   bool isModuleFile() const;
 
   std::unique_ptr<llvm::MemoryBuffer>
   getBufferForFile(StringRef Filename, std::string *ErrorStr = nullptr);
 

clang/lib/Basic/Module.cpp

 OptionalDirectoryEntryRef Module::getEffectiveUmbrellaDir() const {
   if (const auto *ME = Umbrella.dyn_cast<const FileEntryRef::MapEntry *>())
     return FileEntryRef(*ME).getDir();
   if (const auto *ME = Umbrella.dyn_cast<const DirectoryEntryRef::MapEntry *>())
     return DirectoryEntryRef(*ME);
   return std::nullopt;
 }
 
-void Module::addTopHeader(const FileEntry *File) {
+void Module::addTopHeader(FileEntryRef File) {
   assert(File);
   TopHeaders.insert(File);
 }
 
-ArrayRef<const FileEntry *> Module::getTopHeaders(FileManager &FileMgr) {
+ArrayRef<FileEntryRef> Module::getTopHeaders(FileManager &FileMgr) {
   if (!TopHeaderNames.empty()) {
-    for (std::vector<std::string>::iterator
-           I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
-      if (auto FE = FileMgr.getFile(*I))
+    for (StringRef TopHeaderName : TopHeaderNames)
+      if (auto FE = FileMgr.getOptionalFileRef(TopHeaderName))
         TopHeaders.insert(*FE);
-    }
     TopHeaderNames.clear();
   }
 
   return llvm::ArrayRef(TopHeaders.begin(), TopHeaders.end());
 }
 
 bool Module::directlyUses(const Module *Requested) {
   auto *Top = getTopLevelModule();

clang/lib/Frontend/ASTUnit.cpp

for (ASTUnit::top_level_iterator TL = top_level_begin(),
          TL != TLEnd; ++TL) {
     if (!Fn(context, *TL))
       return false;
   }
 
   return true;
 }
 
-const FileEntry *ASTUnit::getPCHFile() {
+OptionalFileEntryRef ASTUnit::getPCHFile() {
   if (!Reader)
-    return nullptr;
+    return std::nullopt;
 
   serialization::ModuleFile *Mod = nullptr;
   Reader->getModuleManager().visit([&Mod](serialization::ModuleFile &M) {
     switch (M.Kind) {
     case serialization::MK_ImplicitModule:
     case serialization::MK_ExplicitModule:
     case serialization::MK_PrebuiltModule:
       return true; // skip dependencies.
     case serialization::MK_PCH:
       Mod = &M;
       return true; // found it.
     case serialization::MK_Preamble:
       return false; // look in dependencies.
     case serialization::MK_MainFile:
       return false; // look in dependencies.
     }
 
     return true;
   });
   if (Mod)
     return Mod->File;
 
-  return nullptr;
+  return std::nullopt;
 }
 
 bool ASTUnit::isModuleFile() const {
   return isMainFileAST() && getLangOpts().isCompilingModule();
 }
 
 InputKind ASTUnit::getInputKind() const {
   auto &LangOpts = getLangOpts();

clang/lib/Frontend/FrontendAction.cpp

static std::error_code collectModuleHeaderIncludes(
   } else if (std::optional<Module::DirectoryName> UmbrellaDir =
                  Module->getUmbrellaDirAsWritten()) {
     // Add all of the headers we find in this subdirectory.
     std::error_code EC;
     SmallString<128> DirNative;
     llvm::sys::path::native(UmbrellaDir->Entry.getName(), DirNative);
 
     llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
-    SmallVector<
-        std::pair<std::string, OptionalFileEntryRefDegradesToFileEntryPtr>, 8>
-        Headers;
+    SmallVector<std::pair<std::string, FileEntryRef>, 8> Headers;
     for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
          Dir != End && !EC; Dir.increment(EC)) {
       // Check whether this entry has an extension typically associated with
       // headers.
       if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
                .Cases(".h", ".H", ".hh", ".hpp", true)
                .Default(false))
         continue;

clang/lib/Serialization/ASTWriter.cpp

while (!Q.empty()) {
     for (auto &HL : HeaderLists) {
       RecordData::value_type Record[] = {HL.RecordKind};
       for (auto &H : Mod->Headers[HL.HeaderKind])
         Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten);
     }
 
     // Emit the top headers.
     {
-      auto TopHeaders = Mod->getTopHeaders(PP->getFileManager());
       RecordData::value_type Record[] = {SUBMODULE_TOPHEADER};
-      for (auto *H : TopHeaders) {
-        SmallString<128> HeaderName(H->getName());
+      for (FileEntryRef H : Mod->getTopHeaders(PP->getFileManager())) {
+        SmallString<128> HeaderName(H.getName());
         PreparePathForOutput(HeaderName);
         Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, HeaderName);
       }
     }
 
     // Emit the imports.
     if (!Mod->Imports.empty()) {
       RecordData Record;

clang/tools/libclang/CIndex.cpp

 // library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CIndexDiagnostic.h"
 #include "CIndexer.h"
 #include "CLog.h"
 #include "CXCursor.h"
+#include "CXFile.h"
 #include "CXSourceLocation.h"
 #include "CXString.h"
 #include "CXTranslationUnit.h"
 #include "CXType.h"
 #include "CursorVisitor.h"
 #include "clang-c/FatalErrorHandler.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjCCommon.h"

 //===----------------------------------------------------------------------===//
 // CXFile Operations.
 //===----------------------------------------------------------------------===//
 
 CXString clang_getFileName(CXFile SFile) {
   if (!SFile)
     return cxstring::createNull();
 
-  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
-  return cxstring::createRef(FEnt->getName());
+  FileEntryRef FEnt = *cxfile::getFileEntryRef(SFile);
+  return cxstring::createRef(FEnt.getName());
 }
 
 time_t clang_getFileTime(CXFile SFile) {
   if (!SFile)
     return 0;
 
-  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
-  return FEnt->getModificationTime();
+  FileEntryRef FEnt = *cxfile::getFileEntryRef(SFile);
+  return FEnt.getModificationTime();
 }
 
 CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 
   FileManager &FMgr = CXXUnit->getFileManager();
-  auto File = FMgr.getFile(file_name);
-  if (!File)
-    return nullptr;
-  return const_cast<FileEntry *>(*File);
+  return cxfile::makeCXFile(FMgr.getOptionalFileRef(file_name));
 }
 
 const char *clang_getFileContents(CXTranslationUnit TU, CXFile file,
                                   size_t *size) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
 
   const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager();
-  FileID fid = SM.translateFile(static_cast<FileEntry *>(file));
+  FileID fid = SM.translateFile(*cxfile::getFileEntryRef(file));
   std::optional<llvm::MemoryBufferRef> buf = SM.getBufferOrNone(fid);
   if (!buf) {
     if (size)
       *size = 0;
     return nullptr;
   }
   if (size)
     *size = buf->getBufferSize();
   return buf->getBufferStart();
 }
 
 unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, CXFile file) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return 0;
   }
 
   if (!file)
     return 0;
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
-  FileEntry *FEnt = static_cast<FileEntry *>(file);
+  FileEntryRef FEnt = *cxfile::getFileEntryRef(file);
   return CXXUnit->getPreprocessor()
       .getHeaderSearchInfo()
       .isFileMultipleIncludeGuarded(FEnt);
 }
 
 int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) {
   if (!file || !outID)
     return 1;
 
-  FileEntry *FEnt = static_cast<FileEntry *>(file);
-  const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID();
+  FileEntryRef FEnt = *cxfile::getFileEntryRef(file);
+  const llvm::sys::fs::UniqueID &ID = FEnt.getUniqueID();
   outID->data[0] = ID.getDevice();
   outID->data[1] = ID.getFile();
-  outID->data[2] = FEnt->getModificationTime();
+  outID->data[2] = FEnt.getModificationTime();
   return 0;
 }
 
 int clang_File_isEqual(CXFile file1, CXFile file2) {
   if (file1 == file2)
     return true;
 
   if (!file1 || !file2)
     return false;
 
-  FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
-  FileEntry *FEnt2 = static_cast<FileEntry *>(file2);
-  return FEnt1->getUniqueID() == FEnt2->getUniqueID();
+  FileEntryRef FEnt1 = *cxfile::getFileEntryRef(file1);
+  FileEntryRef FEnt2 = *cxfile::getFileEntryRef(file2);
+  return FEnt1.getUniqueID() == FEnt2.getUniqueID();
 }
 
 CXString clang_File_tryGetRealPathName(CXFile SFile) {
   if (!SFile)
     return cxstring::createNull();
 
-  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
-  return cxstring::createRef(FEnt->tryGetRealPathName());
+  FileEntryRef FEnt = *cxfile::getFileEntryRef(SFile);
+  return cxstring::createRef(FEnt.getFileEntry().tryGetRealPathName());
 }
 
 //===----------------------------------------------------------------------===//
 // CXCursor Operations.
 //===----------------------------------------------------------------------===//
 
 static const Decl *getDeclFromExpr(const Stmt *E) {
   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
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);
-  OptionalFileEntryRef File = ID->getFile();
-  return const_cast<FileEntry *>(File ? &File->getFileEntry() : nullptr);
+  return cxfile::makeCXFile(ID->getFile());
 }
 
 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));

 
 CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
   if (!File)
     return nullptr;
-  FileEntry *FE = static_cast<FileEntry *>(File);
+  FileEntryRef FE = *cxfile::getFileEntryRef(File);
 
   ASTUnit &Unit = *cxtu::getASTUnit(TU);
   HeaderSearch &HS = Unit.getPreprocessor().getHeaderSearchInfo();
-  // TODO: Make CXFile a FileEntryRef.
-  ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE->getLastRef());
+  ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE);
 
   return Header.getModule();
 }
 
 CXFile clang_Module_getASTFile(CXModule CXMod) {
   if (!CXMod)
     return nullptr;
   Module *Mod = static_cast<Module *>(CXMod);
-  if (auto File = Mod->getASTFile())
-    return const_cast<FileEntry *>(&File->getFileEntry());
-  return nullptr;
+  return cxfile::makeCXFile(Mod->getASTFile());
 }
 
 CXModule clang_Module_getParent(CXModule CXMod) {
   if (!CXMod)
     return nullptr;
   Module *Mod = static_cast<Module *>(CXMod);
   return Mod->Parent;
 }
unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU,
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return 0;
   }
   if (!CXMod)
     return 0;
   Module *Mod = static_cast<Module *>(CXMod);
   FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
-  ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
+  ArrayRef<FileEntryRef> TopHeaders = Mod->getTopHeaders(FileMgr);
   return TopHeaders.size();
 }
 
 CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU, CXModule CXMod,
                                       unsigned Index) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
   if (!CXMod)
     return nullptr;
   Module *Mod = static_cast<Module *>(CXMod);
   FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
 
-  ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
+  ArrayRef<FileEntryRef> TopHeaders = Mod->getTopHeaders(FileMgr);
   if (Index < TopHeaders.size())
-    return const_cast<FileEntry *>(TopHeaders[Index]);
+    return cxfile::makeCXFile(TopHeaders[Index]);
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // C++ AST instrospection.
 //===----------------------------------------------------------------------===//
 
CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit TU, CXFile file) {
   ASTUnit *astUnit = cxtu::getASTUnit(TU);
   PreprocessingRecord *ppRec =
       astUnit->getPreprocessor().getPreprocessingRecord();
   if (!ppRec)
     return skipped;
 
   ASTContext &Ctx = astUnit->getASTContext();
   SourceManager &sm = Ctx.getSourceManager();
-  FileEntry *fileEntry = static_cast<FileEntry *>(file);
+  FileEntryRef fileEntry = *cxfile::getFileEntryRef(file);
   FileID wantedFileID = sm.translateFile(fileEntry);
   bool isMainFile = wantedFileID == sm.getMainFileID();
 
   const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges();
   std::vector<SourceRange> wantedRanges;
   for (std::vector<SourceRange>::const_iterator i = SkippedRanges.begin(),
                                                 ei = SkippedRanges.end();
        i != ei; ++i) {
if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
       return *this;
     }
   } else {
     LogOS << "<NULL TU>";
   }
   return *this;
 }
 
-Logger &cxindex::Logger::operator<<(const FileEntry *FE) {
-  *this << FE->getName();
+Logger &cxindex::Logger::operator<<(FileEntryRef FE) {
+  *this << FE.getName();
   return *this;
 }
 
 Logger &cxindex::Logger::operator<<(CXCursor cursor) {
   CXString cursorName = clang_getCursorDisplayName(cursor);
   *this << cursorName << "@" << clang_getCursorLocation(cursor);
   clang_disposeString(cursorName);
   return *this;

clang/tools/libclang/CIndexHigh.cpp

 //===- CIndexHigh.cpp - Higher level API functions ------------------------===//
 //
 // 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 "CursorVisitor.h"
 #include "CLog.h"
 #include "CXCursor.h"
+#include "CXFile.h"
 #include "CXSourceLocation.h"
 #include "CXTranslationUnit.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "llvm/Support/Compiler.h"
 
 using namespace clang;
 using namespace cxcursor;
CXResult clang_findReferencesInFile(CXCursor cursor, CXFile file,
   }
   if (!visitor.visit) {
     if (Log)
       *Log << "Null visitor";
     return CXResult_Invalid;
   }
 
   if (Log)
-    *Log << cursor << " @" << static_cast<const FileEntry *>(file);
+    *Log << cursor << " @" << *cxfile::getFileEntryRef(file);
 
   ASTUnit *CXXUnit = cxcursor::getCursorASTUnit(cursor);
   if (!CXXUnit)
     return CXResult_Invalid;
 
   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 
   if (cursor.kind == CXCursor_MacroDefinition ||
       cursor.kind == CXCursor_MacroExpansion) {
     if (findMacroRefsInFile(cxcursor::getCursorTU(cursor),
                             cursor,
-                            static_cast<const FileEntry *>(file),
+                            *cxfile::getFileEntryRef(file),
                             visitor))
       return CXResult_VisitBreak;
     return CXResult_Success;
   }
 
   // We are interested in semantics of identifiers so for C++ constructor exprs
   // prefer type references, e.g.:
   //
   //  return MyStruct();
   //
   // for 'MyStruct' we'll have a cursor pointing at the constructor decl but
   // we are actually interested in the type declaration.
   cursor = cxcursor::getTypeRefCursor(cursor);
 
   CXCursor refCursor = clang_getCursorReferenced(cursor);
 
   if (!clang_isDeclaration(refCursor.kind)) {
     if (Log)
       *Log << "cursor is not referencing a declaration";
     return CXResult_Invalid;
   }
 
   if (findIdRefsInFile(cxcursor::getCursorTU(cursor),
                        refCursor,
-                       static_cast<const FileEntry *>(file),
+                       *cxfile::getFileEntryRef(file),
                        visitor))
     return CXResult_VisitBreak;
   return CXResult_Success;
 }
 
 CXResult clang_findIncludesInFile(CXTranslationUnit TU, CXFile file,
                              CXCursorAndRangeVisitor visitor) {
   if (cxtu::isNotUsableTU(TU)) {
CXResult clang_findIncludesInFile(CXTranslationUnit TU, CXFile file,
   }
   if (!visitor.visit) {
     if (Log)
       *Log << "Null visitor";
     return CXResult_Invalid;
   }
 
   if (Log)
-    *Log << TU << " @" << static_cast<const FileEntry *>(file);
+    *Log << TU << " @" << *cxfile::getFileEntryRef(file);
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
   if (!CXXUnit)
     return CXResult_Invalid;
 
   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 
-  if (findIncludesInFile(TU, static_cast<const FileEntry *>(file), visitor))
+  if (findIncludesInFile(TU, *cxfile::getFileEntryRef(file), visitor))
     return CXResult_VisitBreak;
   return CXResult_Success;
 }
 
 static enum CXVisitorResult _visitCursorAndRange(void *context,
                                                  CXCursor cursor,
                                                  CXSourceRange range) {
   CXCursorAndRangeVisitorBlock block = (CXCursorAndRangeVisitorBlock)context;

clang/tools/libclang/CIndexInclusionStack.cpp

 //===- CIndexInclusionStack.cpp - Clang-C Source Indexing Library ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a callback mechanism for clients to get the inclusion
 // stack from a translation unit.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CIndexer.h"
+#include "CXFile.h"
 #include "CXSourceLocation.h"
 #include "CXTranslationUnit.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/Frontend/ASTUnit.h"
 using namespace clang;
 
 namespace {
 void getInclusions(bool IsLocal, unsigned n, CXTranslationUnit TU,
for (unsigned i = 0 ; i < n ; ++i) {
     }
 
     // If there is a preamble, the last entry is the "inclusion" of that
     // preamble into the main file, which has the bogus entry of main.c:1:1
     if (HasPreamble && !InclusionStack.empty())
       InclusionStack.pop_back();
 
     // Callback to the client.
-    // FIXME: We should have a function to construct CXFiles.
-    CB(static_cast<CXFile>(const_cast<FileEntry *>(
-           static_cast<const FileEntry *>(FI.getContentCache().OrigEntry))),
+    CB(cxfile::makeCXFile(*FI.getContentCache().OrigEntry),
        InclusionStack.data(), InclusionStack.size(), clientData);
   }
 }
 } // namespace
 
 void clang_getInclusions(CXTranslationUnit TU, CXInclusionVisitor CB,
                          CXClientData clientData) {
   if (cxtu::isNotUsableTU(TU)) {

clang/tools/libclang/CLog.h

 //===- CLog.h - Logging Interface -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_LIBCLANG_CLOG_H
 #define LLVM_CLANG_TOOLS_LIBCLANG_CLOG_H
 
 #include "clang-c/Index.h"
+#include "clang/Basic/FileEntry.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 
 namespace llvm {
 class format_object_base;
 }
 
 namespace clang {
-  class FileEntry;
-
 namespace cxindex {
 
 class Logger;
 typedef IntrusiveRefCntPtr<Logger> LogRef;
 
 /// Collects logging output and writes it to stderr when it's destructed.
 /// Common use case:
 /// \code
static LogRef make(llvm::StringRef name,
     return nullptr;
   }
 
   explicit Logger(llvm::StringRef name, bool trace)
       : Name(std::string(name)), Trace(trace), LogOS(Msg) {}
   ~Logger();
 
   Logger &operator<<(CXTranslationUnit);
-  Logger &operator<<(const FileEntry *FE);
+  Logger &operator<<(FileEntryRef FE);
   Logger &operator<<(CXCursor cursor);
   Logger &operator<<(CXSourceLocation);
   Logger &operator<<(CXSourceRange);
   Logger &operator<<(CXString);
   Logger &operator<<(llvm::StringRef Str) { LogOS << Str; return *this; }
   Logger &operator<<(const char *Str) {
     if (Str)
       LogOS << Str;

clang/tools/libclang/CXFile.h

+//===- CXFile.h - Routines for manipulating CXFile --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_LIBCLANG_CXFILE_H
+#define LLVM_CLANG_TOOLS_LIBCLANG_CXFILE_H
+
+#include "clang-c/CXFile.h"
+#include "clang/Basic/FileEntry.h"
+
+namespace clang {
+namespace cxfile {
+inline CXFile makeCXFile(OptionalFileEntryRef FE) {
+  return CXFile(FE ? &FE->getMapEntry() : nullptr);
+}
+
+inline OptionalFileEntryRef getFileEntryRef(CXFile File) {
+  if (!File)
+    return std::nullopt;
+  return FileEntryRef(*reinterpret_cast<const FileEntryRef::MapEntry *>(File));
+}
+} // namespace cxfile
+} // namespace clang
+
+#endif

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 enteredMainFile(OptionalFileEntryRef File);
 
   void ppIncludedFile(SourceLocation hashLoc, StringRef filename,
                       OptionalFileEntryRef File, bool isImport, bool isAngled,
                       bool isModuleImport);
 
   void importedModule(const ImportDecl *ImportD);
-  void importedPCH(const FileEntry *File);
+  void importedPCH(FileEntryRef File);
 
   void startedTranslationUnit();
 
   void indexDiagnostics();
 
   void handleDiagnosticSet(CXDiagnosticSet CXDiagSet);
 
   bool handleFunction(const FunctionDecl *FD);

clang/tools/libclang/CXIndexDataConsumer.cpp

 //===- CXIndexDataConsumer.cpp - Index data consumer for libclang----------===//
 //
 // 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 "CXIndexDataConsumer.h"
 #include "CIndexDiagnostic.h"
+#include "CXFile.h"
 #include "CXTranslationUnit.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/Frontend/ASTUnit.h"
 
 using namespace clang;

 }
 
 bool CXIndexDataConsumer::shouldAbort() {
   if (!CB.abortQuery)
     return false;
   return CB.abortQuery(ClientData, nullptr);
 }
 
-void CXIndexDataConsumer::enteredMainFile(const FileEntry *File) {
+void CXIndexDataConsumer::enteredMainFile(OptionalFileEntryRef File) {
   if (File && CB.enteredMainFile) {
     CXIdxClientFile idxFile =
-      CB.enteredMainFile(ClientData,
-                         static_cast<CXFile>(const_cast<FileEntry *>(File)),
-                         nullptr);
-    FileMap[File] = idxFile;
+        CB.enteredMainFile(ClientData, cxfile::makeCXFile(*File), nullptr);
+    FileMap[*File] = idxFile;
   }
 }
 
 void CXIndexDataConsumer::ppIncludedFile(SourceLocation hashLoc,
                                          StringRef filename,
                                          OptionalFileEntryRef 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 *>(FE)),
+                                 cxfile::makeCXFile(File),
                                  isImport, isAngled, isModuleImport };
   CXIdxClientFile idxFile = CB.ppIncludedFile(ClientData, &Info);
   FileMap[FE] = idxFile;
 }
 
 void CXIndexDataConsumer::importedModule(const ImportDecl *ImportD) {
   if (!CB.importedASTFile)
     return;
 
   Module *Mod = ImportD->getImportedModule();
   if (!Mod)
     return;
 
   // If the imported module is part of the top-level module that we're
   // indexing, it doesn't correspond to an imported AST file.
   // FIXME: This assumes that AST files and top-level modules directly
   // correspond, which is unlikely to remain true forever.
   if (Module *SrcMod = ImportD->getImportedOwningModule())
     if (SrcMod->getTopLevelModule() == Mod->getTopLevelModule())
       return;
 
-  FileEntry *FE = nullptr;
-  if (auto File = Mod->getASTFile())
-    FE = const_cast<FileEntry *>(&File->getFileEntry());
-  CXIdxImportedASTFileInfo Info = {static_cast<CXFile>(FE), Mod,
+  OptionalFileEntryRef FE = Mod->getASTFile();
+  CXIdxImportedASTFileInfo Info = {cxfile::makeCXFile(FE), Mod,
                                    getIndexLoc(ImportD->getLocation()),
                                    ImportD->isImplicit()};
   CXIdxClientASTFile astFile = CB.importedASTFile(ClientData, &Info);
   (void)astFile;
 }
 
-void CXIndexDataConsumer::importedPCH(const FileEntry *File) {
+void CXIndexDataConsumer::importedPCH(FileEntryRef File) {
   if (!CB.importedASTFile)
     return;
 
   CXIdxImportedASTFileInfo Info = {
-                                    static_cast<CXFile>(
-                                      const_cast<FileEntry *>(File)),
+                                    cxfile::makeCXFile(File),
                                     /*module=*/nullptr,
                                     getIndexLoc(SourceLocation()),
                                     /*isImplicit=*/false
                                   };
   CXIdxClientASTFile astFile = CB.importedASTFile(ClientData, &Info);
   (void)astFile;
 }
 
void CXIndexDataConsumer::translateLoc(SourceLocation Loc,
 
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
   FileID FID = LocInfo.first;
   unsigned FileOffset = LocInfo.second;
 
   if (FID.isInvalid())
     return;
   
-  const FileEntry *FE = SM.getFileEntryForID(FID);
+  OptionalFileEntryRefDegradesToFileEntryPtr FE = SM.getFileEntryRefForID(FID);
   if (indexFile)
     *indexFile = getIndexFile(FE);
   if (file)
-    *file = const_cast<FileEntry *>(FE);
+    *file = cxfile::makeCXFile(FE);
   if (line)
     *line = SM.getLineNumber(FID, FileOffset);
   if (column)
     *column = SM.getColumnNumber(FID, FileOffset);
   if (offset)
     *offset = FileOffset;
 }
 

clang/tools/libclang/CXLoadedDiagnostic.cpp

 //===-- CXLoadedDiagnostic.cpp - Handling of persisent diags ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements handling of persisent diagnostics.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CXLoadedDiagnostic.h"
+#include "CXFile.h"
 #include "CXString.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Frontend/SerializedDiagnosticReader.h"
 #include "clang/Frontend/SerializedDiagnostics.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
public:
 
   llvm::BumpPtrAllocator Alloc;
   Strings Categories;
   Strings WarningFlags;
   Strings FileNames;
   
   FileSystemOptions FO;
   FileManager FakeFiles;
-  llvm::DenseMap<unsigned, const FileEntry *> Files;
+  llvm::DenseMap<unsigned, FileEntryRef> Files;
 
   /// Copy the string into our own allocator.
   const char *copyString(StringRef Blob) {
     char *mem = Alloc.Allocate<char>(Blob.size() + 1);
     memcpy(mem, Blob.data(), Blob.size());
     mem[Blob.size()] = '\0';
     return mem;
   }

 }
 
 std::error_code
 DiagLoader::readLocation(const serialized_diags::Location &SDLoc,
                          CXLoadedDiagnostic::Location &LoadedLoc) {
   unsigned FileID = SDLoc.FileID;
   if (FileID == 0)
     LoadedLoc.file = nullptr;
   else {
-    LoadedLoc.file = const_cast<FileEntry *>(TopDiags->Files[FileID]);
-    if (!LoadedLoc.file)
+    auto It = TopDiags->Files.find(FileID);
+    if (It == TopDiags->Files.end())
       return reportInvalidFile("Corrupted file entry in source location");
+    LoadedLoc.file = cxfile::makeCXFile(It->second);
   }
   LoadedLoc.line = SDLoc.Line;
   LoadedLoc.column = SDLoc.Col;
   LoadedLoc.offset = SDLoc.Offset;
   return std::error_code();
 }
 
 std::error_code

 
 std::error_code DiagLoader::visitFilenameRecord(unsigned ID, unsigned Size,
                                                 unsigned Timestamp,
                                                 StringRef Name) {
   // FIXME: Why do we care about long strings?
   if (Name.size() > 65536)
     return reportInvalidFile("Out-of-bounds string in filename");
   TopDiags->FileNames[ID] = TopDiags->copyString(Name);
-  TopDiags->Files[ID] =
-      TopDiags->FakeFiles.getVirtualFile(Name, Size, Timestamp);
+  TopDiags->Files.insert(
+      {ID, TopDiags->FakeFiles.getVirtualFileRef(Name, Size, Timestamp)});
   return std::error_code();
 }
 
 std::error_code
 DiagLoader::visitSourceRangeRecord(const serialized_diags::Location &Start,
                                    const serialized_diags::Location &End) {
   CXSourceRange SR;
   if (std::error_code EC = readRange(Start, End, SR))

clang/tools/libclang/CXSourceLocation.cpp

 //===- CXSourceLocation.cpp - CXSourceLocations APIs ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines routines for manipulating CXSourceLocations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CXSourceLocation.h"
 #include "CIndexer.h"
 #include "CLog.h"
+#include "CXFile.h"
 #include "CXLoadedDiagnostic.h"
 #include "CXString.h"
 #include "CXTranslationUnit.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 
CXSourceLocation clang_getLocation(CXTranslationUnit TU,
   if (!file)
     return clang_getNullLocation();
   if (line == 0 || column == 0)
     return clang_getNullLocation();
   
   LogRef Log = Logger::make(__func__);
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
-  const FileEntry *File = static_cast<const FileEntry *>(file);
+  FileEntryRef File = *cxfile::getFileEntryRef(file);
   SourceLocation SLoc = CXXUnit->getLocation(File, line, column);
   if (SLoc.isInvalid()) {
     if (Log)
       *Log << llvm::format("(\"%s\", %d, %d) = invalid",
-                           File->getName().str().c_str(), line, column);
+                           File.getName().str().c_str(), line, column);
     return clang_getNullLocation();
   }
   
   CXSourceLocation CXLoc =
       cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc);
   if (Log)
-    *Log << llvm::format("(\"%s\", %d, %d) = ", File->getName().str().c_str(),
+    *Log << llvm::format("(\"%s\", %d, %d) = ", File.getName().str().c_str(),
                          line, column)
          << CXLoc;
 
   return CXLoc;
 }
   
 CXSourceLocation clang_getLocationForOffset(CXTranslationUnit TU,
                                             CXFile file,
                                             unsigned offset) {
   if (cxtu::isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return clang_getNullLocation();
   }
   if (!file)
     return clang_getNullLocation();
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 
   SourceLocation SLoc 
-    = CXXUnit->getLocation(static_cast<const FileEntry *>(file), offset);
+    = CXXUnit->getLocation(*cxfile::getFileEntryRef(file), offset);
 
   if (SLoc.isInvalid())
     return clang_getNullLocation();
   
   return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc);
 }
 
 //===----------------------------------------------------------------------===//
void clang_getExpansionLocation(CXSourceLocation location,
   bool Invalid = false;
   const SrcMgr::SLocEntry &sloc = SM.getSLocEntry(fileID, &Invalid);
   if (Invalid || !sloc.isFile()) {
     createNullLocation(file, line, column, offset);
     return;
   }
   
   if (file)
-    *file = const_cast<FileEntry *>(SM.getFileEntryForSLocEntry(sloc));
+    *file = cxfile::makeCXFile(SM.getFileEntryRefForID(fileID));
   if (line)
     *line = SM.getExpansionLineNumber(ExpansionLoc);
   if (column)
     *column = SM.getExpansionColumnNumber(ExpansionLoc);
   if (offset)
     *offset = SM.getDecomposedLoc(ExpansionLoc).second;
 }
 
void clang_getSpellingLocation(CXSourceLocation location,
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(SpellLoc);
   FileID FID = LocInfo.first;
   unsigned FileOffset = LocInfo.second;
   
   if (FID.isInvalid())
     return createNullLocation(file, line, column, offset);
   
   if (file)
-    *file = const_cast<FileEntry *>(SM.getFileEntryForID(FID));
+    *file = cxfile::makeCXFile(SM.getFileEntryRefForID(FID));
   if (line)
     *line = SM.getLineNumber(FID, FileOffset);
   if (column)
     *column = SM.getColumnNumber(FID, FileOffset);
   if (offset)
     *offset = FileOffset;
 }
 
void clang_getFileLocation(CXSourceLocation location,
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(FileLoc);
   FileID FID = LocInfo.first;
   unsigned FileOffset = LocInfo.second;
 
   if (FID.isInvalid())
     return createNullLocation(file, line, column, offset);
 
   if (file)
-    *file = const_cast<FileEntry *>(SM.getFileEntryForID(FID));
+    *file = cxfile::makeCXFile(SM.getFileEntryRefForID(FID));
   if (line)
     *line = SM.getLineNumber(FID, FileOffset);
   if (column)
     *column = SM.getColumnNumber(FID, FileOffset);
   if (offset)
     *offset = FileOffset;
 }

clang/tools/libclang/Indexing.cpp

void FileChanged(SourceLocation Loc, FileChangeReason Reason,
     if (IsMainFileEntered)
       return;
 
     SourceManager &SM = PP.getSourceManager();
     SourceLocation MainFileLoc = SM.getLocForStartOfFile(SM.getMainFileID());
 
     if (Loc == MainFileLoc && Reason == PPCallbacks::EnterFile) {
       IsMainFileEntered = true;
-      DataConsumer.enteredMainFile(SM.getFileEntryForID(SM.getMainFileID()));
+      DataConsumer.enteredMainFile(
+          *SM.getFileEntryRefForID(SM.getMainFileID()));
     }
   }
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange,
                           OptionalFileEntryRef File, StringRef SearchPath,
                           StringRef RelativePath, const Module *Imported,
IndexingFrontendAction(std::shared_ptr<CXIndexDataConsumer> dataConsumer,
                          ThreadSafeParsedRegions *skData)
       : DataConsumer(std::move(dataConsumer)), Opts(Opts), SKData(skData) {}
 
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override {
     PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
 
     if (!PPOpts.ImplicitPCHInclude.empty()) {
-      auto File = CI.getFileManager().getFile(PPOpts.ImplicitPCHInclude);
-      if (File)
+      if (auto File =
+              CI.getFileManager().getOptionalFileRef(PPOpts.ImplicitPCHInclude))
         DataConsumer->importedPCH(*File);
     }
 
     DataConsumer->setASTContext(CI.getASTContext());
     Preprocessor &PP = CI.getPreprocessor();
     PP.addPPCallbacks(std::make_unique<IndexPPCallbacks>(PP, *DataConsumer));
     DataConsumer->setPreprocessor(CI.getPreprocessorPtr());
 
static CXErrorCode clang_indexTranslationUnit_Impl(
   CXIndexDataConsumer DataConsumer(client_data, CB, index_options, TU);
 
   ASTUnit *Unit = cxtu::getASTUnit(TU);
   if (!Unit)
     return CXError_Failure;
 
   ASTUnit::ConcurrencyCheck Check(*Unit);
 
-  if (const FileEntry *PCHFile = Unit->getPCHFile())
-    DataConsumer.importedPCH(PCHFile);
+  if (OptionalFileEntryRef PCHFile = Unit->getPCHFile())
+    DataConsumer.importedPCH(*PCHFile);
 
   FileManager &FileMgr = Unit->getFileManager();
 
   if (Unit->getOriginalSourceFileName().empty())
-    DataConsumer.enteredMainFile(nullptr);
-  else if (auto MainFile = FileMgr.getFile(Unit->getOriginalSourceFileName()))
+    DataConsumer.enteredMainFile(std::nullopt);
+  else if (auto MainFile =
+               FileMgr.getFileRef(Unit->getOriginalSourceFileName()))
     DataConsumer.enteredMainFile(*MainFile);
   else
-    DataConsumer.enteredMainFile(nullptr);
+    DataConsumer.enteredMainFile(std::nullopt);
 
   DataConsumer.setASTContext(Unit->getASTContext());
   DataConsumer.startedTranslationUnit();
 
   indexPreprocessingRecord(*Unit, DataConsumer);
   indexASTUnit(*Unit, DataConsumer, getIndexingOptionsFromCXOptions(index_options));
   DataConsumer.indexDiagnostics();