clang/Basic: Remove ContentCache::getRawBuffer, NFC

[dexonsmith]

Summary

Replace ContentCache::getRawBuffer with getBufferDataIfLoaded and
getBufferIfLoaded, excising another accessor for the underlying
MemoryBuffer* in favour of StringRef and MemoryBufferRef.

[dexonsmith]

Fix a compile error (I forgot to run check-clang-tools before).

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

public:
   void recordFileContent(const FileEntry *File,
                          const SrcMgr::ContentCache &ContentCache,
                          llvm::vfs::InMemoryFileSystem &InMemoryFs) {
     // Return if we are not interested in the contents of this file.
     if (!FilesToRecord.count(File))
       return;
 
     // FIXME: Why is this happening? We might be losing contents here.
-    if (!ContentCache.getRawBuffer())
+    llvm::Optional<StringRef> Data = ContentCache.getBufferDataIfLoaded();
+    if (!Data)
       return;
 
     InMemoryFs.addFile(File->getName(), /*ModificationTime=*/0,
-                       llvm::MemoryBuffer::getMemBufferCopy(
-                           ContentCache.getRawBuffer()->getBuffer()));
+                       llvm::MemoryBuffer::getMemBufferCopy(*Data));
     // Remove the file from the set of necessary files.
     FilesToRecord.erase(File);
   }
 
   /// Makes sure we have contents for all the files we were interested in. Ideally
   /// `FilesToRecord` should be empty.
   void checkAllFilesRecorded() {
     for (auto FileEntry : FilesToRecord)

clang/include/clang/Basic/SourceManager.h

public:
     ///
     /// This can be 0 if the MemBuffer was not actually expanded.
     unsigned getSizeBytesMapped() const;
 
     /// Returns the kind of memory used to back the memory buffer for
     /// this content cache.  This is used for performance analysis.
     llvm::MemoryBuffer::BufferKind getMemoryBufferKind() const;
 
-    /// Get the underlying buffer, returning NULL if the buffer is not
-    /// yet available.
-    const llvm::MemoryBuffer *getRawBuffer() const { return Buffer.get(); }
+    /// Return the buffer, only if it has been loaded.
+    /// specified FileID, returning None if it's not yet loaded.
+    ///
+    /// \param FID The file ID whose contents will be returned.
+    llvm::Optional<llvm::MemoryBufferRef> getBufferIfLoaded() const {
+      if (Buffer)
+        return Buffer->getMemBufferRef();
+      return None;
+    }
+
+    /// Return a StringRef to the source buffer data, only if it has already
+    /// been loaded.
+    llvm::Optional<StringRef> getBufferDataIfLoaded() const {
+      if (Buffer)
+        return Buffer->getBuffer();
+      return None;
+    }
 
     /// Set the buffer.
     void setBuffer(std::unique_ptr<llvm::MemoryBuffer> B) {
       IsBufferInvalid = false;
       Buffer = std::move(B);
     }
 
     /// Set the buffer to one that's not owned (or to nullptr).
     ///
     /// \pre Buffer cannot already be set.
-    void setUnownedBuffer(const llvm::MemoryBuffer *B) {
+    void setUnownedBuffer(llvm::Optional<llvm::MemoryBufferRef> B) {
       assert(!Buffer && "Expected to be called right after construction");
       if (B)
-        setBuffer(llvm::MemoryBuffer::getMemBuffer(B->getMemBufferRef()));
+        setBuffer(llvm::MemoryBuffer::getMemBuffer(*B));
     }
 
     // If BufStr has an invalid BOM, returns the BOM name; otherwise, returns
     // nullptr
     static const char *getInvalidBOM(StringRef BufStr);
   };
 
   // Assert that the \c ContentCache objects will always be 8-byte aligned so

clang/lib/Basic/SourceManager.cpp

if (!BufferOrError) {
 
     return None;
   }
 
   Buffer = std::move(*BufferOrError);
 
   // Check that the file's size is the same as in the file entry (which may
   // have come from a stat cache).
-  if (getRawBuffer()->getBufferSize() != (size_t)ContentsEntry->getSize()) {
+  if (Buffer->getBufferSize() != (size_t)ContentsEntry->getSize()) {
     if (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_file_modified,
                                 ContentsEntry->getName());
     else
       Diag.Report(Loc, diag::err_file_modified)
         << ContentsEntry->getName();
 
     return None;
void SourceManager::initializeForReplay(const SourceManager &Old) {
 
   auto CloneContentCache = [&](const ContentCache *Cache) -> ContentCache * {
     auto *Clone = new (ContentCacheAlloc.Allocate<ContentCache>()) ContentCache;
     Clone->OrigEntry = Cache->OrigEntry;
     Clone->ContentsEntry = Cache->ContentsEntry;
     Clone->BufferOverridden = Cache->BufferOverridden;
     Clone->IsFileVolatile = Cache->IsFileVolatile;
     Clone->IsTransient = Cache->IsTransient;
-    Clone->setUnownedBuffer(Cache->getRawBuffer());
+    Clone->setUnownedBuffer(Cache->getBufferIfLoaded());
     return Clone;
   };
 
   // Ensure all SLocEntries are loaded from the external source.
   for (unsigned I = 0, N = Old.LoadedSLocEntryTable.size(); I != N; ++I)
     if (!Old.SLocEntryLoaded[I])
       Old.loadSLocEntry(I, nullptr);
 

 }
 
 /// As part of recovering from missing or changed content, produce a
 /// fake content cache.
 const SrcMgr::ContentCache *
 SourceManager::getFakeContentCacheForRecovery() const {
   if (!FakeContentCacheForRecovery) {
     FakeContentCacheForRecovery = std::make_unique<SrcMgr::ContentCache>();
-    FakeContentCacheForRecovery->setUnownedBuffer(getFakeBufferForRecovery());
+    FakeContentCacheForRecovery->setUnownedBuffer(
+        getFakeBufferForRecovery()->getMemBufferRef());
   }
   return FakeContentCacheForRecovery.get();
 }
 
 /// Returns the previous in-order FileID or an invalid FileID if there
 /// is no previous one.
 FileID SourceManager::getPreviousFileID(FileID FID) const {
   if (FID.isInvalid())

 
 llvm::Optional<StringRef>
 SourceManager::getBufferDataIfLoaded(FileID FID) const {
   bool MyInvalid = false;
   const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
   if (!SLoc.isFile() || MyInvalid)
     return None;
 
-  if (const llvm::MemoryBuffer *Buf =
-          SLoc.getFile().getContentCache()->getRawBuffer())
-    return Buf->getBuffer();
-  return None;
+  return SLoc.getFile().getContentCache()->getBufferDataIfLoaded();
 }
 
 llvm::Optional<StringRef> SourceManager::getBufferDataOrNone(FileID FID) const {
   bool MyInvalid = false;
   const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
   if (!SLoc.isFile() || MyInvalid)
     return None;
 

clang/lib/Serialization/ASTReader.cpp

if (NumFileDecls && ContextObj) {
       FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
                                                              NumFileDecls));
     }
 
     const SrcMgr::ContentCache *ContentCache
       = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
     if (OverriddenBuffer && !ContentCache->BufferOverridden &&
         ContentCache->ContentsEntry == ContentCache->OrigEntry &&
-        !ContentCache->getRawBuffer()) {
+        !ContentCache->getBufferIfLoaded()) {
       auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
       if (!Buffer)
         return true;
       SourceMgr.overrideFileContents(File, std::move(Buffer));
     }
 
     break;
   }

clang/lib/Serialization/ASTWriter.cpp

for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
     Entry.BufferOverridden = Cache->BufferOverridden;
     Entry.IsTopLevelModuleMap = isModuleMap(File.getFileCharacteristic()) &&
                                 File.getIncludeLoc().isInvalid();
 
     auto ContentHash = hash_code(-1);
     if (PP->getHeaderSearchInfo()
             .getHeaderSearchOpts()
             .ValidateASTInputFilesContent) {
-      auto *MemBuff = Cache->getRawBuffer();
+      auto MemBuff = Cache->getBufferIfLoaded();
       if (MemBuff)
         ContentHash = hash_value(MemBuff->getBuffer());
       else
         // FIXME: The path should be taken from the FileEntryRef.
         PP->Diag(SourceLocation(), diag::err_module_unable_to_hash_content)
             << Entry.File->getName();
     }
     auto CH = llvm::APInt(64, ContentHash);