[clang] use FileEntryRef for SUBMODULE_TOPHEADER

[rmaz]

Summary

Refactor a Module's TopHeaders to use FileEntryRef. This will keep
the paths serialized in a module the same as the ones used to look
up the header initially.

[jansvoboda11]

clang/lib/Basic/Module.cpp

271–272

If we assert that File is not empty right away, why take OptionalFileEntryRef instead of FileEntryRef?

clang/lib/Lex/ModuleMap.cpp

663

How much work would be to refactor File to be FileEntryRef? Would be good if we didn't need to resort to getLastRef().

[rmaz]

Use FileEntryRef for AddTopHeader()

[rmaz]

clang/lib/Lex/ModuleMap.cpp

663

It is unfortunately a fair bit. I spent some time on it but hit a roadblock with the FileManagers VirtualFileEntries:

https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/FileManager.h#L70-L71

We would require this to be refactored to FileEntry too, as it is used here to provide a UID mapping to FileEntry pointers which needs to be changed to refs:

https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/FileManager.cpp#L614-L633

I can put up a follow on diff once this one is shipped if preferred?

[jansvoboda11]

clang/lib/Lex/ModuleMap.cpp

663

I was able to refactor the UID mapping to use FileEntryRef in D142780. Given that, I think it would be preferable to propagate these into findOrCreateModuleForHeaderInUmbrellaDir() and remove getLastRef().

[rmaz]

clang/lib/Lex/ModuleMap.cpp

663

Nice, i'll rebase this and add the remaining changes once its shipped.

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:
 
   /// Determine whether this module has an umbrella directory that is
   /// not based on an umbrella header.
   bool hasUmbrellaDir() const {
     return Umbrella && Umbrella.is<const DirectoryEntry *>();
   }
 
   /// 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/lib/Basic/Module.cpp

 
 Module::DirectoryName Module::getUmbrellaDir() const {
   if (Header U = getUmbrellaHeader())
     return {"", "", U.Entry->getDir()};
 
   return {UmbrellaAsWritten, UmbrellaRelativeToRootModuleDirectory,
           Umbrella.dyn_cast<const DirectoryEntry *>()};
 }
 
-void Module::addTopHeader(const FileEntry *File) {
-  assert(File);
-  TopHeaders.insert(File);
-}
+void Module::addTopHeader(FileEntryRef 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))
+      if (auto FE = FileMgr.getFileRef(*I))
         TopHeaders.insert(*FE);
     }
     TopHeaderNames.clear();
   }
 
   return llvm::ArrayRef(TopHeaders.begin(), TopHeaders.end());
 }
 

clang/lib/Frontend/FrontendAction.cpp

if (!Module->MissingHeaders.empty()) {
     Diag.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
       << MissingHeader.IsUmbrella << MissingHeader.FileName;
     return std::error_code();
   }
 
   // Add includes for each of these headers.
   for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
     for (Module::Header &H : Module->Headers[HK]) {
-      Module->addTopHeader(H.Entry);
+      Module->addTopHeader(*H.Entry);
       // Use the path as specified in the module map file. We'll look for this
       // file relative to the module build directory (the directory containing
       // the module map file) so this will find the same file that we found
       // while parsing the module map.
       addHeaderInclude(H.PathRelativeToRootModuleDirectory, Includes, LangOpts,
                        Module->IsExternC);
     }
   }
   // Note that Module->PrivateHeaders will not be a TopHeader.
 
   if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
-    Module->addTopHeader(UmbrellaHeader.Entry);
+    Module->addTopHeader(*UmbrellaHeader.Entry);
     if (Module->Parent)
       // Include the umbrella header for submodules.
       addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory,
                        Includes, LangOpts, Module->IsExternC);
   } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
     // Add all of the headers we find in this subdirectory.
     std::error_code EC;
     SmallString<128> DirNative;
if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
     if (EC)
       return EC;
 
     // Sort header paths and make the header inclusion order deterministic
     // across different OSs and filesystems.
     llvm::sort(Headers, llvm::less_first());
     for (auto &H : Headers) {
       // Include this header as part of the umbrella directory.
-      Module->addTopHeader(H.second);
+      Module->addTopHeader(*H.second);
       addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC);
     }
   }
 
   // Recurse into submodules.
   for (clang::Module::submodule_iterator Sub = Module->submodule_begin(),
                                       SubEnd = Module->submodule_end();
        Sub != SubEnd; ++Sub)

clang/lib/Lex/ModuleMap.cpp

if (UmbrellaModule->InferSubmodules) {
       // Infer a submodule with the same name as this header file.
       SmallString<32> NameBuf;
       StringRef Name = sanitizeFilenameAsIdentifier(
                          llvm::sys::path::stem(File->getName()), NameBuf);
       Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
                                   Explicit).first;
       InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
       Result->IsInferred = true;
-      Result->addTopHeader(File);
+      Result->addTopHeader(File->getLastRef());
 
       // If inferred submodules export everything they import, add a
       // wildcard to the set of exports.
       if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
         Result->Exports.push_back(Module::ExportDecl(nullptr, true));
     } else {
       // Record each of the directories we stepped through as being part of
       // the module we found, since the umbrella header covers them all.

clang/lib/Serialization/ASTWriter.cpp

for (auto &HL : HeaderLists) {
       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 (auto H : TopHeaders) {
+        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

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);
+  auto 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);
+  auto TopHeaders = Mod->getTopHeaders(FileMgr);
   if (Index < TopHeaders.size())
-    return const_cast<FileEntry *>(TopHeaders[Index]);
+    return const_cast<FileEntry *>(&TopHeaders[Index].getFileEntry());
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // C++ AST instrospection.
 //===----------------------------------------------------------------------===//