ARCMigrate: Migrate ObjCMT.cpp over to FileEntryRef

[dexonsmith]

Summary

Migrate ObjCMT.cpp from using const FileEntry* to FileEntryRef. This
is one of the blockers for changing SourceManager to use
FileEntryRef.

This adds an initial version of SourceManager::getFileEntryRefForID,
which uses to FileEntry::getLastRef; after SourceManager switches,
SourceManager::getFileEntryForID will need to call this function.

This also adds uses of FileEntryRef as a key in a DenseMap, and a
call to hash_value(Optional) in DenseMapInfo<EditEntry>; support for
these were added in prep commits.

[dexonsmith]

The prep commits are:

• https://reviews.llvm.org/D92627 (add hashing support for FileEntryRef)
• https://reviews.llvm.org/D92630 (use hash_combine in DenseMapInfo EditEntry)
• https://reviews.llvm.org/D92676 (hash_value for Optional)

[jansvoboda11]

LGTM.

clang/include/clang/Basic/SourceManager.h

public:
 
   /// Returns the FileEntry record for the provided FileID.
   const FileEntry *getFileEntryForID(FileID FID) const {
     if (auto *Entry = getSLocEntryForFile(FID))
       return Entry->getFile().getContentCache().OrigEntry;
     return nullptr;
   }
 
+  /// Returns the FileEntryRef for the provided FileID.
+  Optional<FileEntryRef> getFileEntryRefForID(FileID FID) const {
+    if (auto *Entry = getFileEntryForID(FID))
+      return Entry->getLastRef();
+    return None;
+  }
+
   /// Returns the filename for the provided FileID, unless it's a built-in
   /// buffer that's not represented by a filename.
   ///
   /// Returns None for non-files and built-in files.
   Optional<StringRef> getNonBuiltinFilenameForID(FileID FID) const;
 
   /// Returns the FileEntry record for the provided SLocEntry.
   const FileEntry *getFileEntryForSLocEntry(const SrcMgr::SLocEntry &sloc) const

clang/lib/ARCMigrate/ObjCMT.cpp

protected:
   void HandleTranslationUnit(ASTContext &Ctx) override;
 
   bool canModifyFile(StringRef Path) {
     if (WhiteListFilenames.empty())
       return true;
     return WhiteListFilenames.find(llvm::sys::path::filename(Path))
         != WhiteListFilenames.end();
   }
-  bool canModifyFile(const FileEntry *FE) {
+  bool canModifyFile(Optional<FileEntryRef> FE) {
     if (!FE)
       return false;
     return canModifyFile(FE->getName());
   }
   bool canModifyFile(FileID FID) {
     if (FID.isInvalid())
       return false;
-    return canModifyFile(PP.getSourceManager().getFileEntryForID(FID));
+    return canModifyFile(PP.getSourceManager().getFileEntryRefForID(FID));
   }
 
   bool canModify(const Decl *D) {
     if (!D)
       return false;
     if (const ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(D))
       return canModify(CatImpl->getCategoryDecl());
     if (const ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D))
if (IsOutputFile) {
   Rewriter rewriter(Ctx.getSourceManager(), Ctx.getLangOpts());
   RewritesReceiver Rec(rewriter);
   Editor->applyRewrites(Rec);
 
   for (Rewriter::buffer_iterator
         I = rewriter.buffer_begin(), E = rewriter.buffer_end(); I != E; ++I) {
     FileID FID = I->first;
     RewriteBuffer &buf = I->second;
-    const FileEntry *file = Ctx.getSourceManager().getFileEntryForID(FID);
+    Optional<FileEntryRef> file = Ctx.getSourceManager().getFileEntryRefForID(FID);
     assert(file);
     SmallString<512> newText;
     llvm::raw_svector_ostream vecOS(newText);
     buf.write(vecOS);
     std::unique_ptr<llvm::MemoryBuffer> memBuf(
         llvm::MemoryBuffer::getMemBufferCopy(
             StringRef(newText.data(), newText.size()), file->getName()));
     SmallString<64> filePath(file->getName());
MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return std::make_unique<ObjCMigrateASTConsumer>(
       CI.getFrontendOpts().OutputFile, ObjCMTAction, Remapper,
       CI.getFileManager(), PPRec, CI.getPreprocessor(),
       /*isOutputFile=*/true, WhiteList);
 }
 
 namespace {
 struct EditEntry {
-  const FileEntry *File = nullptr;
+  Optional<FileEntryRef> File;
   unsigned Offset = 0;
   unsigned RemoveLen = 0;
   std::string Text;
 };
 } // end anonymous namespace
 
 namespace llvm {
 template<> struct DenseMapInfo<EditEntry> {
for (MappingNode::iterator
 
       ScalarNode *ValueString = dyn_cast<ScalarNode>((*KVI).getValue());
       if (!ValueString)
         continue;
       SmallString<64> ValueStorage;
       StringRef Val = ValueString->getValue(ValueStorage);
 
       if (Key == "file") {
-        auto FE = FileMgr.getFile(Val);
-        if (FE)
-          Entry.File = *FE;
+        if (auto File = FileMgr.getOptionalFileRef(Val))
+          Entry.File = File;
         else
           Ignore = true;
       } else if (Key == "offset") {
         if (Val.getAsInteger(10, Entry.Offset))
           Ignore = true;
       } else if (Key == "remove") {
         if (Val.getAsInteger(10, Entry.RemoveLen))
           Ignore = true;

 } // end anonymous namespace
 
 static bool reportDiag(const Twine &Err, DiagnosticsEngine &Diag) {
   Diag.Report(Diag.getCustomDiagID(DiagnosticsEngine::Error, "%0"))
       << Err.str();
   return true;
 }
 
-static std::string applyEditsToTemp(const FileEntry *FE,
+static std::string applyEditsToTemp(FileEntryRef FE,
                                     ArrayRef<EditEntry> Edits,
                                     FileManager &FileMgr,
                                     DiagnosticsEngine &Diag) {
   using namespace llvm::sys;
 
   SourceManager SM(Diag, FileMgr);
   FileID FID = SM.createFileID(FE, SourceLocation(), SrcMgr::C_User);
   LangOptions LangOpts;
static std::string applyEditsToTemp(FileEntryRef FE,
 
   const RewriteBuffer *Buf = rewriter.getRewriteBufferFor(FID);
   SmallString<512> NewText;
   llvm::raw_svector_ostream OS(NewText);
   Buf->write(OS);
 
   SmallString<64> TempPath;
   int FD;
-  if (fs::createTemporaryFile(path::filename(FE->getName()),
-                              path::extension(FE->getName()).drop_front(), FD,
+  if (fs::createTemporaryFile(path::filename(FE.getName()),
+                              path::extension(FE.getName()).drop_front(), FD,
                               TempPath)) {
     reportDiag("Could not create file: " + TempPath.str(), Diag);
     return std::string();
   }
 
   llvm::raw_fd_ostream TmpOut(FD, /*shouldClose=*/true);
   TmpOut.write(NewText.data(), NewText.size());
   TmpOut.close();
bool arcmt::getFileRemappingsFromFileList(
   FileManager FileMgr(FSOpts);
   RemapFileParser Parser(FileMgr);
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
                             DiagClient, /*ShouldOwnClient=*/false));
 
-  typedef llvm::DenseMap<const FileEntry *, std::vector<EditEntry> >
+  typedef llvm::DenseMap<FileEntryRef, std::vector<EditEntry> >
       FileEditEntriesTy;
   FileEditEntriesTy FileEditEntries;
 
   llvm::DenseSet<EditEntry> EntriesSet;
 
   for (ArrayRef<StringRef>::iterator
          I = remapFiles.begin(), E = remapFiles.end(); I != E; ++I) {
     SmallVector<EditEntry, 16> Entries;
     if (Parser.parse(*I, Entries))
       continue;
 
     for (SmallVectorImpl<EditEntry>::iterator
            EI = Entries.begin(), EE = Entries.end(); EI != EE; ++EI) {
       EditEntry &Entry = *EI;
       if (!Entry.File)
         continue;
       std::pair<llvm::DenseSet<EditEntry>::iterator, bool>
         Insert = EntriesSet.insert(Entry);
       if (!Insert.second)
         continue;
 
-      FileEditEntries[Entry.File].push_back(Entry);
+      FileEditEntries[*Entry.File].push_back(Entry);
     }
   }
 
   for (FileEditEntriesTy::iterator
          I = FileEditEntries.begin(), E = FileEditEntries.end(); I != E; ++I) {
     std::string TempFile = applyEditsToTemp(I->first, I->second,
                                             FileMgr, *Diags);
     if (TempFile.empty()) {
       hasErrorOccurred = true;
       continue;
     }
 
-    remap.emplace_back(std::string(I->first->getName()), TempFile);
+    remap.emplace_back(std::string(I->first.getName()), TempFile);
   }
 
   return hasErrorOccurred;
 }