SourceManager: Change getOrCreateFileID API to take FileEntryRef, NFC

[dexonsmith]

Summary

Update SourceManager::getOrCreateFileID to take a FileEntryRef and
migrate all the callers (mostly calling
FileManager::getOptionalFileRef). Also drop the FileEntry* version
of SourceManager::createFileID since this was the last remaining use
of it.

[jansvoboda11]

This LGTM, but it'd be nice to apply the formatting suggestion.

clang-tools-extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

 /// \param[in] TUs Collection of all found and deserialized
 /// TranslationUnitReplacements.
 /// \param[in] TUDs Collection of all found and deserialized
 /// TranslationUnitDiagnostics.
 /// \param[in] SM Used to deduplicate paths.
 ///
 /// \returns A map mapping FileEntry to a set of Replacement targeting that
 /// file.
-static llvm::DenseMap<const FileEntry *, std::vector<tooling::Replacement>>
+static llvm::DenseMap<FileEntryRef, std::vector<tooling::Replacement>>
 groupReplacements(const TUReplacements &TUs, const TUDiagnostics &TUDs,
                   const clang::SourceManager &SM) {
   std::set<StringRef> Warned;
-  llvm::DenseMap<const FileEntry *, std::vector<tooling::Replacement>>
+  llvm::DenseMap<FileEntryRef, std::vector<tooling::Replacement>>
       GroupedReplacements;
 
   // Deduplicate identical replacements in diagnostics unless they are from the
   // same TU.
   // FIXME: Find an efficient way to deduplicate on diagnostics level.
   llvm::DenseMap<const FileEntry *,
                  std::map<tooling::Replacement,
                           const tooling::TranslationUnitDiagnostics *>>
       DiagReplacements;
 
   auto AddToGroup = [&](const tooling::Replacement &R,
                         const tooling::TranslationUnitDiagnostics *SourceTU) {
     // Use the file manager to deduplicate paths. FileEntries are
     // automatically canonicalized.
-    if (auto Entry = SM.getFileManager().getFile(R.getFilePath())) {
+    if (auto Entry = SM.getFileManager().getOptionalFileRef(R.getFilePath())) {
       if (SourceTU) {
         auto &Replaces = DiagReplacements[*Entry];
         auto It = Replaces.find(R);
         if (It == Replaces.end())
           Replaces.emplace(R, SourceTU);
         else if (It->second != SourceTU)
           // This replacement is a duplicate of one suggested by another TU.
           return;
bool mergeAndDeduplicate(const TUReplacements &TUs, const TUDiagnostics &TUDs,
                          FileToChangesMap &FileChanges,
                          clang::SourceManager &SM) {
   auto GroupedReplacements = groupReplacements(TUs, TUDs, SM);
   bool ConflictDetected = false;
 
   // To report conflicting replacements on corresponding file, all replacements
   // are stored into 1 big AtomicChange.
   for (const auto &FileAndReplacements : GroupedReplacements) {
-    const FileEntry *Entry = FileAndReplacements.first;
+    FileEntryRef Entry = FileAndReplacements.first;
     const SourceLocation BeginLoc =
         SM.getLocForStartOfFile(SM.getOrCreateFileID(Entry, SrcMgr::C_User));
-    tooling::AtomicChange FileChange(Entry->getName(), Entry->getName());
+    tooling::AtomicChange FileChange(Entry.getName(), Entry.getName());
     for (const auto &R : FileAndReplacements.second) {
       llvm::Error Err =
           FileChange.replace(SM, BeginLoc.getLocWithOffset(R.getOffset()),
                              R.getLength(), R.getReplacementText());
       if (Err) {
         // FIXME: This will report conflicts by pair using a file+offset format
         // which is not so much human readable.
         // A first improvement could be to translate offset to line+col. For

clang-tools-extra/clang-change-namespace/tool/ClangChangeNamespace.cpp

for (const auto &it : Tool.getReplacements())
     ChangedFiles.insert(it.first);
 
   if (DumpYAML) {
     auto WriteToYAML = [&](llvm::raw_ostream &OS) {
       OS << "[\n";
       for (auto I = ChangedFiles.begin(), E = ChangedFiles.end(); I != E; ++I) {
         OS << "  {\n";
         OS << "    \"FilePath\": \"" << *I << "\",\n";
-        const auto Entry = FileMgr.getFile(*I);
+        const auto Entry = FileMgr.getOptionalFileRef(*I);
         auto ID = Sources.getOrCreateFileID(*Entry, SrcMgr::C_User);
         std::string Content;
         llvm::raw_string_ostream ContentStream(Content);
         Rewrite.getEditBuffer(ID).write(ContentStream);
         OS << "    \"SourceText\": \""
            << llvm::yaml::escape(ContentStream.str()) << "\"\n";
         OS << "  }";
         if (I != std::prev(E))
           OS << ",\n";
       }
       OS << "\n]\n";
     };
     WriteToYAML(llvm::outs());
     return 0;
   }
 
   for (const auto &File : ChangedFiles) {
-    const auto Entry = FileMgr.getFile(File);
+    const auto Entry = FileMgr.getOptionalFileRef(File);
 
     auto ID = Sources.getOrCreateFileID(*Entry, SrcMgr::C_User);
     outs() << "============== " << File << " ==============\n";
     Rewrite.getEditBuffer(ID).write(llvm::outs());
     outs() << "\n============================================\n";
   }
 
   return 0;
 }

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

if (!Context->Spec.NewCC.empty())
     Context->FileToReplacements[Context->Spec.NewCC] =
         createInsertedReplacements(CCIncludes, ActualNewCCDecls,
                                    Context->Spec.NewCC);
 }
 
 // Move all contents from OldFile to NewFile.
 void ClangMoveTool::moveAll(SourceManager &SM, StringRef OldFile,
                             StringRef NewFile) {
-  auto FE = SM.getFileManager().getFile(makeAbsolutePath(OldFile));
+  auto FE = SM.getFileManager().getFileRef(makeAbsolutePath(OldFile));
   if (!FE) {
+    llvm::consumeError(FE.takeError());
     llvm::errs() << "Failed to get file: " << OldFile << "\n";
     return;
   }
   FileID ID = SM.getOrCreateFileID(*FE, SrcMgr::C_User);
   auto Begin = SM.getLocForStartOfFile(ID);
   auto End = SM.getLocForEndOfFile(ID);
   tooling::Replacement RemoveAll(SM, CharSourceRange::getCharRange(Begin, End),
                                  "");

clang-tools-extra/clang-reorder-fields/tool/ClangReorderFields.cpp

DiagnosticsEngine Diagnostics(
       &DiagnosticPrinter, false);
 
   auto &FileMgr = Tool.getFiles();
   SourceManager Sources(Diagnostics, FileMgr);
   Rewriter Rewrite(Sources, DefaultLangOptions);
   Tool.applyAllReplacements(Rewrite);
 
   for (const auto &File : Files) {
-    auto Entry = FileMgr.getFile(File);
+    auto Entry = FileMgr.getOptionalFileRef(File);
     const auto ID = Sources.getOrCreateFileID(*Entry, SrcMgr::C_User);
     Rewrite.getEditBuffer(ID).write(outs());
   }
 
   return ExitCode;
 }

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

public:
 
   unsigned getWarningsAsErrorsCount() const { return WarningsAsErrors; }
 
 private:
   SourceLocation getLocation(StringRef FilePath, unsigned Offset) {
     if (FilePath.empty())
       return SourceLocation();
 
-    auto File = SourceMgr.getFileManager().getFile(FilePath);
+    auto File = SourceMgr.getFileManager().getOptionalFileRef(FilePath);
     if (!File)
       return SourceLocation();
 
     FileID ID = SourceMgr.getOrCreateFileID(*File, SrcMgr::C_User);
     return SourceMgr.getLocForStartOfFile(ID).getLocWithOffset(Offset);
   }
 
   void reportFix(const DiagnosticBuilder &Diag,

clang/include/clang/Basic/SourceManager.h

public:
   void setMainFileID(FileID FID) {
     MainFileID = FID;
   }
 
   /// Returns true when the given FileEntry corresponds to the main file.
   ///
   /// The main file should be set prior to calling this function.
   bool isMainFile(const FileEntry &SourceFile);
+  bool isMainFile(FileEntryRef SourceFile) {
+    return isMainFile(SourceFile.getFileEntry());
+  }
 
   /// Set the file ID for the precompiled preamble.
   void setPreambleFileID(FileID Preamble) {
     assert(PreambleFileID.isInvalid() && "PreambleFileID already set!");
     PreambleFileID = Preamble;
   }
 
   /// Get the file ID for the precompiled preamble if there is one.
   FileID getPreambleFileID() const { return PreambleFileID; }
 
   //===--------------------------------------------------------------------===//
   // Methods to create new FileID's and macro expansions.
   //===--------------------------------------------------------------------===//
 
   /// Create a new FileID that represents the specified file
   /// being \#included from the specified IncludePosition.
   ///
   /// This translates NULL into standard input.
-  FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos,
-                      SrcMgr::CharacteristicKind FileCharacter,
-                      int LoadedID = 0, unsigned LoadedOffset = 0);
-
   FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos,
                       SrcMgr::CharacteristicKind FileCharacter,
                       int LoadedID = 0, unsigned LoadedOffset = 0);
 
   /// Create a new FileID that represents the specified memory buffer.
   ///
   /// This does no caching of the buffer and takes ownership of the
   /// MemoryBuffer, so only pass a MemoryBuffer to this once.
   FileID createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                       SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
                       int LoadedID = 0, unsigned LoadedOffset = 0,
                       SourceLocation IncludeLoc = SourceLocation());
 
   /// Create a new FileID that represents the specified memory buffer.
   ///
   /// This does not take ownership of the MemoryBuffer. The memory buffer must
   /// outlive the SourceManager.
   FileID createFileID(const llvm::MemoryBufferRef &Buffer,
                       SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
                       int LoadedID = 0, unsigned LoadedOffset = 0,
                       SourceLocation IncludeLoc = SourceLocation());
 
   /// Get the FileID for \p SourceFile if it exists. Otherwise, create a
   /// new FileID for the \p SourceFile.
-  FileID getOrCreateFileID(const FileEntry *SourceFile,
+  FileID getOrCreateFileID(FileEntryRef SourceFile,
                            SrcMgr::CharacteristicKind FileCharacter);
 
   /// Return a new SourceLocation that encodes the
   /// fact that a token from SpellingLoc should actually be referenced from
   /// ExpansionLoc, and that it represents the expansion of a macro argument
   /// into the function-like macro body.
   SourceLocation createMacroArgExpansionLoc(SourceLocation Loc,
                                             SourceLocation ExpansionLoc,

clang/lib/Basic/SourceManager.cpp

 //===----------------------------------------------------------------------===//
 // Methods to create new FileID's and macro expansions.
 //===----------------------------------------------------------------------===//
 
 /// Create a new FileID that represents the specified file
 /// being \#included from the specified IncludePosition.
 ///
 /// This translates NULL into standard input.
-FileID SourceManager::createFileID(const FileEntry *SourceFile,
-                                   SourceLocation IncludePos,
-                                   SrcMgr::CharacteristicKind FileCharacter,
-                                   int LoadedID, unsigned LoadedOffset) {
-  assert(SourceFile && "Null source file!");
-  SrcMgr::ContentCache &IR =
-      getOrCreateContentCache(SourceFile, isSystem(FileCharacter));
-  return createFileIDImpl(IR, SourceFile->getName(), IncludePos, FileCharacter,
-                          LoadedID, LoadedOffset);
-}
-
 FileID SourceManager::createFileID(FileEntryRef SourceFile,
                                    SourceLocation IncludePos,
                                    SrcMgr::CharacteristicKind FileCharacter,
                                    int LoadedID, unsigned LoadedOffset) {
   SrcMgr::ContentCache &IR = getOrCreateContentCache(SourceFile,
                                                      isSystem(FileCharacter));
   return createFileIDImpl(IR, SourceFile.getName(), IncludePos, FileCharacter,
                           LoadedID, LoadedOffset);
FileID SourceManager::createFileID(const llvm::MemoryBufferRef &Buffer,
                                    SourceLocation IncludeLoc) {
   return createFileID(llvm::MemoryBuffer::getMemBuffer(Buffer), FileCharacter,
                       LoadedID, LoadedOffset, IncludeLoc);
 }
 
 /// Get the FileID for \p SourceFile if it exists. Otherwise, create a
 /// new FileID for the \p SourceFile.
 FileID
-SourceManager::getOrCreateFileID(const FileEntry *SourceFile,
+SourceManager::getOrCreateFileID(FileEntryRef SourceFile,
                                  SrcMgr::CharacteristicKind FileCharacter) {
   FileID ID = translateFile(SourceFile);
   return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(),
             FileCharacter);
 }
 
 /// createFileID - Create a new FileID for the specified ContentCache and
 /// include position.  This works regardless of whether the ContentCache
SourceManagerForFile::SourceManagerForFile(StringRef FileName,
   FileMgr =
       std::make_unique<FileManager>(FileSystemOptions(), InMemoryFileSystem);
   // This is passed to `SM` as reference, so the pointer has to be referenced
   // by `Environment` due to the same reason above.
   Diagnostics = std::make_unique<DiagnosticsEngine>(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
       new DiagnosticOptions);
   SourceMgr = std::make_unique<SourceManager>(*Diagnostics, *FileMgr);
-  FileID ID = SourceMgr->createFileID(*FileMgr->getFile(FileName),
+  FileID ID = SourceMgr->createFileID(*FileMgr->getOptionalFileRef(FileName),
                                       SourceLocation(), clang::SrcMgr::C_User);
   assert(ID.isValid());
   SourceMgr->setMainFileID(ID);
 }

clang/lib/Tooling/Core/Replacement.cpp

 }
 
 bool Replacement::isApplicable() const {
   return FilePath != InvalidLocation;
 }
 
 bool Replacement::apply(Rewriter &Rewrite) const {
   SourceManager &SM = Rewrite.getSourceMgr();
-  auto Entry = SM.getFileManager().getFile(FilePath);
+  auto Entry = SM.getFileManager().getOptionalFileRef(FilePath);
   if (!Entry)
     return false;
 
   FileID ID = SM.getOrCreateFileID(*Entry, SrcMgr::C_User);
   const SourceLocation Start =
     SM.getLocForStartOfFile(ID).
     getLocWithOffset(ReplacementRange.getOffset());
   // ReplaceText returns false on success.

clang/lib/Tooling/Refactoring.cpp

bool formatAndApplyAllReplacements(
   FileManager &Files = SM.getFileManager();
 
   bool Result = true;
   for (const auto &FileAndReplaces : groupReplacementsByFile(
            Rewrite.getSourceMgr().getFileManager(), FileToReplaces)) {
     const std::string &FilePath = FileAndReplaces.first;
     auto &CurReplaces = FileAndReplaces.second;
 
-    const FileEntry *Entry = nullptr;
-    if (auto File = Files.getFile(FilePath))
-      Entry = *File;
-
-    FileID ID = SM.getOrCreateFileID(Entry, SrcMgr::C_User);
+    Optional<FileEntryRef> Entry = Files.getOptionalFileRef(FilePath);
+    FileID ID = SM.getOrCreateFileID(*Entry, SrcMgr::C_User);
     StringRef Code = SM.getBufferData(ID);
 
     auto CurStyle = format::getStyle(Style, FilePath, "LLVM");
     if (!CurStyle) {
       llvm::errs() << llvm::toString(CurStyle.takeError()) << "\n";
       return false;
     }
 

clang/tools/clang-rename/ClangRename.cpp

DiagnosticsEngine Diagnostics(
         IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
         &DiagnosticPrinter, false);
     auto &FileMgr = Tool.getFiles();
     SourceManager Sources(Diagnostics, FileMgr);
     Rewriter Rewrite(Sources, DefaultLangOptions);
 
     Tool.applyAllReplacements(Rewrite);
     for (const auto &File : Files) {
-      auto Entry = FileMgr.getFile(File);
+      auto Entry = FileMgr.getOptionalFileRef(File);
       const auto ID = Sources.getOrCreateFileID(*Entry, SrcMgr::C_User);
       Rewrite.getEditBuffer(ID).write(outs());
     }
   }
 
   return ExitCode;
 }

clang/unittests/Basic/SourceManagerTest.cpp

const char *Source = "int x;\n"
                        "IDENTITY(int y);\n"
                        "int z;";
 
   std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
       llvm::MemoryBuffer::getMemBuffer(header);
   std::unique_ptr<llvm::MemoryBuffer> Buf =
       llvm::MemoryBuffer::getMemBuffer(Source);
 
-  const FileEntry *SourceFile =
-      FileMgr.getVirtualFile("/mainFile.cpp", Buf->getBufferSize(), 0);
+  FileEntryRef SourceFile =
+      FileMgr.getVirtualFileRef("/mainFile.cpp", Buf->getBufferSize(), 0);
   SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
 
-  const FileEntry *HeaderFile =
-      FileMgr.getVirtualFile("/test-header.h", HeaderBuf->getBufferSize(), 0);
+  FileEntryRef HeaderFile =
+      FileMgr.getVirtualFileRef("/test-header.h", HeaderBuf->getBufferSize(), 0);
   SourceMgr.overrideFileContents(HeaderFile, std::move(HeaderBuf));
 
   FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
   FileID HeaderFileID = SourceMgr.getOrCreateFileID(HeaderFile, SrcMgr::C_User);
   SourceMgr.setMainFileID(MainFileID);
 
   auto BeginLoc = SourceMgr.getLocForStartOfFile(MainFileID);
   auto EndLoc = SourceMgr.getLocForEndOfFile(MainFileID);
TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithMacroInInclude) {
   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[10].Loc, Macros[11].Loc));
 }
 
 TEST_F(SourceManagerTest, isMainFile) {
   const char *Source = "int x;";
 
   std::unique_ptr<llvm::MemoryBuffer> Buf =
       llvm::MemoryBuffer::getMemBuffer(Source);
-  const FileEntry *SourceFile =
-      FileMgr.getVirtualFile("mainFile.cpp", Buf->getBufferSize(), 0);
+  FileEntryRef SourceFile =
+      FileMgr.getVirtualFileRef("mainFile.cpp", Buf->getBufferSize(), 0);
   SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
 
   std::unique_ptr<llvm::MemoryBuffer> Buf2 =
       llvm::MemoryBuffer::getMemBuffer(Source);
   const FileEntry *SecondFile =
       FileMgr.getVirtualFile("file2.cpp", Buf2->getBufferSize(), 0);
   SourceMgr.overrideFileContents(SecondFile, std::move(Buf2));
 
   FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
   SourceMgr.setMainFileID(MainFileID);
 
-  EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
-  EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
+  EXPECT_TRUE(SourceMgr.isMainFile(SourceFile));
+  EXPECT_TRUE(SourceMgr.isMainFile(SourceFile));
   EXPECT_FALSE(SourceMgr.isMainFile(*SecondFile));
 }
 
 #endif
 
 } // anonymous namespace