[clang][lex] NFCI: Use DirectoryEntryRef in ModuleMap::parseModuleMapFile()

[jansvoboda11]

Summary

This patch changes the argument type of ModuleMap::parseModuleMapFile() from const DirectoryEntry * to DirectoryEntryRef in order to remove the deprecated uses of DirectoryEntry::getName().

Depends on D127648.

[bnbarham]

clang-tools-extra/modularize/ModularizeUtilities.cpp

275

It seems like this is optional purely because of the assignment below and that has an assert that seems to be invalid anyway - couldn't we just check the optional down there and return an error, assign otherwise, and remove the assert?

clang-tools-extra/modularize/ModularizeUtilities.cpp

std::error_code ModularizeUtilities::loadProblemHeaderList(
   }
   return std::error_code();
 }
 
 // Load single module map and extract header file list.
 std::error_code ModularizeUtilities::loadModuleMap(
     llvm::StringRef InputPath) {
   // Get file entry for module.modulemap file.
-  auto ModuleMapEntryOrErr =
-    SourceMgr->getFileManager().getFile(InputPath);
+  auto ModuleMapEntryOrErr = SourceMgr->getFileManager().getFileRef(InputPath);
 
   // return error if not found.
   if (!ModuleMapEntryOrErr) {
     llvm::errs() << "error: File \"" << InputPath << "\" not found.\n";
-    return ModuleMapEntryOrErr.getError();
+    return errorToErrorCode(ModuleMapEntryOrErr.takeError());
   }
-  const FileEntry *ModuleMapEntry = *ModuleMapEntryOrErr;
+  FileEntryRef ModuleMapEntry = *ModuleMapEntryOrErr;
 
   // Because the module map parser uses a ForwardingDiagnosticConsumer,
   // which doesn't forward the BeginSourceFile call, we do it explicitly here.
   DC.BeginSourceFile(*LangOpts, nullptr);
 
   // Figure out the home directory for the module map file.
-  const DirectoryEntry *Dir = ModuleMapEntry->getDir();
+  Optional<DirectoryEntryRef> Dir = ModuleMapEntry.getDir();
   StringRef DirName(Dir->getName());
   if (llvm::sys::path::filename(DirName) == "Modules") {
     DirName = llvm::sys::path::parent_path(DirName);
-    if (DirName.endswith(".framework")) {
-      if (auto DirEntry = FileMgr->getDirectory(DirName))
-        Dir = *DirEntry;
-      else
-        Dir = nullptr;
-    }
+    if (DirName.endswith(".framework"))
+      Dir = FileMgr->getOptionalDirectoryRef(DirName);
     // FIXME: This assert can fail if there's a race between the above check
     // and the removal of the directory.
     assert(Dir && "parent must exist");
   }
 
   std::unique_ptr<ModuleMap> ModMap;
   ModMap.reset(new ModuleMap(*SourceMgr, *Diagnostics, *LangOpts,
     Target.get(), *HeaderInfo));
 
   // Parse module.modulemap file into module map.
-  if (ModMap->parseModuleMapFile(ModuleMapEntry, false, Dir)) {
+  if (ModMap->parseModuleMapFile(ModuleMapEntry, false, *Dir)) {
     return std::error_code(1, std::generic_category());
   }
 
   // Do matching end call.
   DC.EndSourceFile();
 
   // Reset missing header count.
   MissingHeaderCount = 0;

clang/include/clang/Lex/ModuleMap.h

public:
   /// \param Offset [inout] On input the offset at which to start parsing. On
   ///        output, the offset at which the module map terminated.
   ///
   /// \param ExternModuleLoc The location of the "extern module" declaration
   ///        that caused us to load this module map file, if any.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool parseModuleMapFile(const FileEntry *File, bool IsSystem,
-                          const DirectoryEntry *HomeDir,
-                          FileID ID = FileID(), unsigned *Offset = nullptr,
+                          DirectoryEntryRef HomeDir, FileID ID = FileID(),
+                          unsigned *Offset = nullptr,
                           SourceLocation ExternModuleLoc = SourceLocation());
 
   /// Dump the contents of the module map, for debugging purposes.
   void dump();
 
   using module_iterator = llvm::StringMap<Module *>::const_iterator;
 
   module_iterator module_begin() const { return Modules.begin(); }

clang/lib/Lex/ModuleMap.cpp

class ModuleMapParser {
     /// The current module map file.
     const FileEntry *ModuleMapFile;
 
     /// Source location of most recent parsed module declaration
     SourceLocation CurrModuleDeclLoc;
 
     /// The directory that file names in this module map file should
     /// be resolved relative to.
-    const DirectoryEntry *Directory;
+    DirectoryEntryRef Directory;
 
     /// Whether this module map is in a system header directory.
     bool IsSystem;
 
     /// Whether an error occurred.
     bool HadError = false;
 
     /// Stores string data for the various string literals referenced
class ModuleMapParser {
     using Attributes = ModuleMap::Attributes;
 
     bool parseOptionalAttributes(Attributes &Attrs);
 
   public:
     explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
                              const TargetInfo *Target, DiagnosticsEngine &Diags,
                              ModuleMap &Map, const FileEntry *ModuleMapFile,
-                             const DirectoryEntry *Directory, bool IsSystem)
+                             DirectoryEntryRef Directory, bool IsSystem)
         : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map),
           ModuleMapFile(ModuleMapFile), Directory(Directory),
           IsSystem(IsSystem) {
       Tok.clear();
       consumeToken();
     }
 
     bool parseModuleMapFile();
if (!Tok.is(MMToken::StringLiteral)) {
     return;
   }
   std::string FileName = std::string(Tok.getString());
   consumeToken(); // filename
 
   StringRef FileNameRef = FileName;
   SmallString<128> ModuleMapFileName;
   if (llvm::sys::path::is_relative(FileNameRef)) {
-    ModuleMapFileName += Directory->getName();
+    ModuleMapFileName += Directory.getName();
     llvm::sys::path::append(ModuleMapFileName, FileName);
     FileNameRef = ModuleMapFileName;
   }
-  if (auto File = SourceMgr.getFileManager().getFile(FileNameRef))
+  if (auto File = SourceMgr.getFileManager().getOptionalFileRef(FileNameRef))
     Map.parseModuleMapFile(
         *File, IsSystem,
         Map.HeaderInfo.getHeaderSearchOpts().ModuleMapFileHomeIsCwd
             ? Directory
-            : (*File)->getDir(),
+            : File->getDir(),
         FileID(), nullptr, ExternLoc);
 }
 
 /// Whether to add the requirement \p Feature to the module \p M.
 ///
 /// This preserves backwards compatibility for two hacks in the Darwin system
 /// module map files:
 ///
void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) {
 
   // Look for this file.
   const DirectoryEntry *Dir = nullptr;
   if (llvm::sys::path::is_absolute(DirName)) {
     if (auto D = SourceMgr.getFileManager().getDirectory(DirName))
       Dir = *D;
   } else {
     SmallString<128> PathName;
-    PathName = Directory->getName();
+    PathName = Directory.getName();
     llvm::sys::path::append(PathName, DirName);
     if (auto D = SourceMgr.getFileManager().getDirectory(PathName))
       Dir = *D;
   }
 
   if (!Dir) {
     Diags.Report(DirNameLoc, diag::warn_mmap_umbrella_dir_not_found)
       << DirName;
case MMToken::UseKeyword:
       HadError = true;
       consumeToken();
       break;
     }
   } while (true);
 }
 
 bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
-                                   const DirectoryEntry *Dir, FileID ID,
+                                   DirectoryEntryRef Dir, FileID ID,
                                    unsigned *Offset,
                                    SourceLocation ExternModuleLoc) {
   assert(Target && "Missing target information");
   llvm::DenseMap<const FileEntry *, bool>::iterator Known
     = ParsedModuleMap.find(File);
   if (Known != ParsedModuleMap.end())
     return Known->second;