Change Module::ASTFile and ModuleFile::File => Optional<FileEntryRef>, NFC

[dexonsmith]

Summary

Change Module::ASTFile and ModuleFile::File to use
Optional<FileEntryRef> instead of const FileEntry *. One of many
steps toward removing FileEntry::getName.

[dexonsmith]

Rebase.

[dexonsmith]

Rebased.

[JDevlieghere]

LGTM

[dexonsmith]

Note: the bots revealed I needed another update for some host compilers, which I pushed in 5cb8d93205463f169ad4dd532829147fed2e38d0.

clang/include/clang/Basic/FileEntry.h

const FileEntry &getFileEntry() const {
     return *ME->second->V.get<FileEntry *>();
   }
 
   inline bool isValid() const;
   inline off_t getSize() const;
   inline unsigned getUID() const;
   inline const llvm::sys::fs::UniqueID &getUniqueID() const;
   inline time_t getModificationTime() const;
+  inline void closeFile() const;
 
   /// Check if the underlying FileEntry is the same, intentially ignoring
   /// whether the file was referenced with the same spelling of the filename.
   friend bool operator==(const FileEntryRef &LHS, const FileEntryRef &RHS) {
     return &LHS.getFileEntry() == &RHS.getFileEntry();
   }
   friend bool operator==(const FileEntry *LHS, const FileEntryRef &RHS) {
     return LHS == &RHS.getFileEntry();

 const llvm::sys::fs::UniqueID &FileEntryRef::getUniqueID() const {
   return getFileEntry().getUniqueID();
 }
 
 time_t FileEntryRef::getModificationTime() const {
   return getFileEntry().getModificationTime();
 }
 
+void FileEntryRef::closeFile() const { getFileEntry().closeFile(); }
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_FILEENTRY_H

clang/include/clang/Basic/Module.h

 /// Defines the clang::Module class, which describes a module in the
 /// source code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_MODULE_H
 #define LLVM_CLANG_BASIC_MODULE_H
 
+#include "clang/Basic/FileEntry.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
private:
   std::vector<Module *> SubModules;
 
   /// A mapping from the submodule name to the index into the
   /// \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.
-  const FileEntry *ASTFile = nullptr;
+  Optional<FileEntryRef> ASTFile;
 
   /// The top-level headers associated with this module.
   llvm::SmallSetVector<const FileEntry *, 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.
public:
   const Module *getTopLevelModule() const;
 
   /// Retrieve the name of the top-level module.
   StringRef getTopLevelModuleName() const {
     return getTopLevelModule()->Name;
   }
 
   /// The serialized AST file for this module, if one was created.
-  const FileEntry *getASTFile() const {
+  OptionalFileEntryRefDegradesToFileEntryPtr getASTFile() const {
     return getTopLevelModule()->ASTFile;
   }
 
   /// Set the serialized AST file for the top-level module of this module.
-  void setASTFile(const FileEntry *File) {
-    assert((File == nullptr || getASTFile() == nullptr ||
-            getASTFile() == File) && "file path changed");
+  void setASTFile(Optional<FileEntryRef> File) {
+    assert((!File || !getASTFile() || getASTFile() == File) &&
+           "file path changed");
     getTopLevelModule()->ASTFile = File;
   }
 
   /// Retrieve the directory for which this module serves as the
   /// umbrella.
   DirectoryName getUmbrellaDir() const;
 
   /// Retrieve the header that serves as the umbrella header for this

clang/include/clang/Serialization/ModuleFile.h

public:
 
   /// Whether timestamps are included in this module file.
   bool HasTimestamps = false;
 
   /// Whether the top-level module has been read from the AST file.
   bool DidReadTopLevelSubmodule = false;
 
   /// The file entry for the module file.
-  const FileEntry *File = nullptr;
+  OptionalFileEntryRefDegradesToFileEntryPtr File;
 
   /// The signature of the module file, which may be used instead of the size
   /// and modification time to identify this particular file.
   ASTFileSignature Signature;
 
   /// The signature of the AST block of the module file, this can be used to
   /// unique module files based on AST contents.
   ASTFileSignature ASTBlockHash;

clang/include/clang/Serialization/ModuleManager.h

public:
   /// should return \c true.
   ///
   /// \param File Will be set to the file if there is one, or null
   /// otherwise.
   ///
   /// \returns True if a file exists but does not meet the size/
   /// modification time criteria, false if the file is either available and
   /// suitable, or is missing.
-  bool lookupModuleFile(StringRef FileName,
-                        off_t ExpectedSize,
-                        time_t ExpectedModTime,
-                        const FileEntry *&File);
+  bool lookupModuleFile(StringRef FileName, off_t ExpectedSize,
+                        time_t ExpectedModTime, Optional<FileEntryRef> &File);
 
   /// View the graphviz representation of the module graph.
   void viewGraph();
 
   InMemoryModuleCache &getModuleCache() const { return *ModuleCache; }
 };
 
 } // namespace serialization
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SERIALIZATION_MODULEMANAGER_H

clang/lib/Basic/Module.cpp

void VisibleModuleSet::setVisible(Module *M, SourceLocation Loc,
   };
   VisitModule({M, nullptr});
 }
 
 ASTSourceDescriptor::ASTSourceDescriptor(Module &M)
     : Signature(M.Signature), ClangModule(&M) {
   if (M.Directory)
     Path = M.Directory->getName();
-  if (auto *File = M.getASTFile())
+  if (auto File = M.getASTFile())
     ASTFile = File->getName();
 }
 
 std::string ASTSourceDescriptor::getModuleName() const {
   if (ClangModule)
     return ClangModule->Name;
   else
     return std::string(PCHModuleName);
 }

clang/lib/Sema/SemaModule.cpp

Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
   switch (MDK) {
   case ModuleDeclKind::Interface: {
     // We can't have parsed or imported a definition of this module or parsed a
     // module map defining it already.
     if (auto *M = Map.findModule(ModuleName)) {
       Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;
       if (M->DefinitionLoc.isValid())
         Diag(M->DefinitionLoc, diag::note_prev_module_definition);
-      else if (const auto *FE = M->getASTFile())
+      else if (Optional<FileEntryRef> FE = M->getASTFile())
         Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)
             << FE->getName();
       Mod = M;
       break;
     }
 
     // Create a Module for the module that we're defining.
     Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,

clang/lib/Serialization/ModuleManager.cpp

ModuleManager::addModule(StringRef FileName, ModuleKind Type,
                          ASTFileSignature ExpectedSignature,
                          ASTFileSignatureReader ReadSignature,
                          ModuleFile *&Module,
                          std::string &ErrorStr) {
   Module = nullptr;
 
   // Look for the file entry. This only fails if the expected size or
   // modification time differ.
-  const FileEntry *Entry;
+  OptionalFileEntryRefDegradesToFileEntryPtr Entry;
   if (Type == MK_ExplicitModule || Type == MK_PrebuiltModule) {
     // If we're not expecting to pull this file out of the module cache, it
     // might have a different mtime due to being moved across filesystems in
     // a distributed build. The size must still match, though. (As must the
     // contents, but we can't check that.)
     ExpectedModTime = 0;
   }
   // Note: ExpectedSize and ExpectedModTime will be 0 for MK_ImplicitModule
void ModuleManager::removeModules(ModuleIterator First, ModuleMap *modMap) {
 
   // Delete the modules and erase them from the various structures.
   for (ModuleIterator victim = First; victim != Last; ++victim) {
     Modules.erase(victim->File);
 
     if (modMap) {
       StringRef ModuleName = victim->ModuleName;
       if (Module *mod = modMap->findModule(ModuleName)) {
-        mod->setASTFile(nullptr);
+        mod->setASTFile(None);
       }
     }
   }
 
   // Delete the modules.
   Chain.erase(Chain.begin() + (First - begin()), Chain.end());
 }
 
do {
       // Pop the next module off the stack.
       NextModule = State->Stack.pop_back_val();
     } while (true);
   }
 
   returnVisitState(State);
 }
 
-bool ModuleManager::lookupModuleFile(StringRef FileName,
-                                     off_t ExpectedSize,
+bool ModuleManager::lookupModuleFile(StringRef FileName, off_t ExpectedSize,
                                      time_t ExpectedModTime,
-                                     const FileEntry *&File) {
-  File = nullptr;
+                                     Optional<FileEntryRef> &File) {
+  File = None;
   if (FileName == "-")
     return false;
 
   // Open the file immediately to ensure there is no race between stat'ing and
   // opening the file.
-  auto FileOrErr = FileMgr.getFile(FileName, /*OpenFile=*/true,
-                                   /*CacheFailure=*/false);
+  Optional<FileEntryRef> FileOrErr =
+      expectedToOptional(FileMgr.getFileRef(FileName, /*OpenFile=*/true,
+                                            /*CacheFailure=*/false));
   if (!FileOrErr)
     return false;
 
   File = *FileOrErr;
 
   if ((ExpectedSize && ExpectedSize != File->getSize()) ||
       (ExpectedModTime && ExpectedModTime != File->getModificationTime()))
     // Do not destroy File, as it may be referenced. If we need to rebuild it,

clang/tools/libclang/CIndex.cpp

CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) {
 
   return Header.getModule();
 }
 
 CXFile clang_Module_getASTFile(CXModule CXMod) {
   if (!CXMod)
     return nullptr;
   Module *Mod = static_cast<Module *>(CXMod);
-  return const_cast<FileEntry *>(Mod->getASTFile());
+  if (auto File = Mod->getASTFile())
+    return const_cast<FileEntry *>(&File->getFileEntry());
+  return nullptr;
 }
 
 CXModule clang_Module_getParent(CXModule CXMod) {
   if (!CXMod)
     return nullptr;
   Module *Mod = static_cast<Module *>(CXMod);
   return Mod->Parent;
 }

clang/tools/libclang/CXIndexDataConsumer.cpp

void CXIndexDataConsumer::importedModule(const ImportDecl *ImportD) {
   // 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;
 
-  CXIdxImportedASTFileInfo Info = {
-                                    static_cast<CXFile>(
-                                    const_cast<FileEntry *>(Mod->getASTFile())),
-                                    Mod,
-                                    getIndexLoc(ImportD->getLocation()),
-                                    ImportD->isImplicit()
-                                  };
+  FileEntry *FE = nullptr;
+  if (auto File = Mod->getASTFile())
+    FE = const_cast<FileEntry *>(&File->getFileEntry());
+  CXIdxImportedASTFileInfo Info = {static_cast<CXFile>(FE), Mod,
+                                   ImportD->isImplicit()};
   CXIdxClientASTFile astFile = CB.importedASTFile(ClientData, &Info);
   (void)astFile;
 }
 
 void CXIndexDataConsumer::importedPCH(const FileEntry *File) {
   if (!CB.importedASTFile)
     return;