clang/Basic: Replace SourceManager::getMemoryBufferForFile, NFC

[dexonsmith]

Summary

Replace SourceManager::getMemoryBufferForFile, which returned a
dereferenceable MemoryBuffer* and had a bool*Invalid out parameter,
with getMemoryBufferForFileOrNone (returning
Optional<MemoryBufferRef>) and getMemoryBufferForFileOrFake
(returning MemoryBufferRef).

[JDevlieghere]

clang/lib/Basic/SourceManager.cpp

705

Would it make sense to rename this to the slightly less verbose getMemoryBufferOrNone now that it takes just the File as an argument? Or maybe even getBufferOrNone like the method in ContentCache.

[dexonsmith]

clang/lib/Basic/SourceManager.cpp

121–127

[Highlighting this for the other comment.]

705

There's already a SourceManager::getBufferOrNone (see line 121 of this file, which I am highlighting). I'd rather keep the current weird naming to make it easy to grep for and eventually delete.

This function shouldn't really exist since it's at the wrong layer (FileEntry* -> MemoryBuffer is a FileManager concept). The problem is that the SourceManager owns the memory buffer so this is the only way to get access to it. Once I sink the content cache / MemoryBuffer ownership into the FileManager, we can delete this entirely.

[JDevlieghere]

Thanks for the explanation!

clang/include/clang/Basic/SourceManager.h

public:
   /// Return a new SourceLocation that encodes that the token starting
   /// at \p TokenStart ends prematurely at \p TokenEnd.
   SourceLocation createTokenSplitLoc(SourceLocation SpellingLoc,
                                      SourceLocation TokenStart,
                                      SourceLocation TokenEnd);
 
   /// Retrieve the memory buffer associated with the given file.
   ///
-  /// \param Invalid If non-NULL, will be set \c true if an error
-  /// occurs while retrieving the memory buffer.
-  const llvm::MemoryBuffer *getMemoryBufferForFile(const FileEntry *File,
-                                                   bool *Invalid = nullptr);
+  /// Returns None if the buffer is not valid.
+  llvm::Optional<llvm::MemoryBufferRef>
+  getMemoryBufferForFileOrNone(const FileEntry *File);
+
+  /// Retrieve the memory buffer associated with the given file.
+  ///
+  /// Returns a fake buffer if there isn't a real one.
+  llvm::MemoryBufferRef getMemoryBufferForFileOrFake(const FileEntry *File) {
+    if (auto B = getMemoryBufferForFileOrNone(File))
+      return *B;
+    return getFakeBufferForRecovery()->getMemBufferRef();
+  }
 
   /// Override the contents of the given source file by providing an
   /// already-allocated buffer.
   ///
   /// \param SourceFile the source file whose contents will be overridden.
   ///
   /// \param Buffer the memory buffer whose contents will be used as the
   /// data in the given source file.

clang/include/clang/Frontend/PrecompiledPreamble.h

 #include "llvm/Support/MD5.h"
 #include <cstddef>
 #include <memory>
 #include <system_error>
 #include <type_traits>
 
 namespace llvm {
 class MemoryBuffer;
+class MemoryBufferRef;
 namespace vfs {
 class FileSystem;
 }
 } // namespace llvm
 
 namespace clang {
 class CompilerInstance;
 class CompilerInvocation;
struct PreambleFileHash {
 
     /// Memory buffers have MD5 instead of modification time.  We don't
     /// compute MD5 for on-disk files because we hope that modification time is
     /// enough to tell if the file was changed.
     llvm::MD5::MD5Result MD5 = {};
 
     static PreambleFileHash createForFile(off_t Size, time_t ModTime);
     static PreambleFileHash
-    createForMemoryBuffer(const llvm::MemoryBuffer *Buffer);
+    createForMemoryBuffer(const llvm::MemoryBufferRef &Buffer);
 
     friend bool operator==(const PreambleFileHash &LHS,
                            const PreambleFileHash &RHS) {
       return LHS.Size == RHS.Size && LHS.ModTime == RHS.ModTime &&
              LHS.MD5 == RHS.MD5;
     }
     friend bool operator!=(const PreambleFileHash &LHS,
                            const PreambleFileHash &RHS) {

clang/lib/Basic/SourceManager.cpp

const char *InvalidBOM =
           .StartsWith("\x0E\xFE\xFF", "SCSU")
           .StartsWith("\xFB\xEE\x28", "BOCU-1")
           .StartsWith("\x84\x31\x95\x33", "GB-18030")
           .Default(nullptr);
 
   return InvalidBOM;
 }
 
 llvm::Optional<llvm::MemoryBufferRef>
 ContentCache::getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM,
                               SourceLocation Loc) const {
   if (auto *B = getBufferPointer(Diag, FM, Loc))
     return B->getMemBufferRef();
   return None;
 }
 
 const llvm::MemoryBuffer *
 ContentCache::getBufferPointer(DiagnosticsEngine &Diag, FileManager &FM,
                                SourceLocation Loc) const {
   // Lazily create the Buffer for ContentCaches that wrap files.  If we already
   // computed it, just return what we have.
   if (isBufferInvalid())
     return nullptr;
SourceManager::createExpansionLocImpl(const ExpansionInfo &Info,
   assert(NextLocalOffset + TokLength + 1 > NextLocalOffset &&
          NextLocalOffset + TokLength + 1 <= CurrentLoadedOffset &&
          "Ran out of source locations!");
   // See createFileID for that +1.
   NextLocalOffset += TokLength + 1;
   return SourceLocation::getMacroLoc(NextLocalOffset - (TokLength + 1));
 }
 
-const llvm::MemoryBuffer *
-SourceManager::getMemoryBufferForFile(const FileEntry *File, bool *Invalid) {
+llvm::Optional<llvm::MemoryBufferRef>
+SourceManager::getMemoryBufferForFileOrNone(const FileEntry *File) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
-  auto *B = IR->getBufferPointer(Diag, getFileManager(), SourceLocation());
-  if (Invalid)
-    *Invalid = !B;
-  return B ? B : getFakeBufferForRecovery();
+  return IR->getBufferOrNone(Diag, getFileManager(), SourceLocation());
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          llvm::MemoryBuffer *Buffer,
                                          bool DoNotFree) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
 

clang/lib/Frontend/PrecompiledPreamble.cpp

if (!FileOrErr ||
         *FileOrErr == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))
       continue;
     auto File = *FileOrErr;
     if (time_t ModTime = File->getModificationTime()) {
       FilesInPreamble[File->getName()] =
           PrecompiledPreamble::PreambleFileHash::createForFile(File->getSize(),
                                                                ModTime);
     } else {
-      const llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File);
+      llvm::MemoryBufferRef Buffer =
+          SourceMgr.getMemoryBufferForFileOrFake(File);
       FilesInPreamble[File->getName()] =
           PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(Buffer);
     }
   }
 
   return PrecompiledPreamble(
       std::move(Storage), std::move(PreambleBytes), PreambleEndsAtStartOfLine,
       std::move(FilesInPreamble), std::move(MissingFiles));
for (const auto &R : PreprocessorOpts.RemappedFiles) {
     OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile(
         Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime()));
   }
 
   // OverridenFileBuffers tracks only the files not found in VFS.
   llvm::StringMap<PreambleFileHash> OverridenFileBuffers;
   for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
     const PrecompiledPreamble::PreambleFileHash PreambleHash =
-        PreambleFileHash::createForMemoryBuffer(RB.second);
+        PreambleFileHash::createForMemoryBuffer(RB.second->getMemBufferRef());
     llvm::vfs::Status Status;
     if (moveOnNoError(VFS->status(RB.first), Status))
       OverriddenFiles[Status.getUniqueID()] = PreambleHash;
     else
       OverridenFileBuffers[RB.first] = PreambleHash;
 
     llvm::SmallString<128> MappedPath(RB.first);
     if (!VFS->makeAbsolute(MappedPath))
PrecompiledPreamble::PreambleFileHash::createForFile(off_t Size,
   Result.Size = Size;
   Result.ModTime = ModTime;
   Result.MD5 = {};
   return Result;
 }
 
 PrecompiledPreamble::PreambleFileHash
 PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(
-    const llvm::MemoryBuffer *Buffer) {
+    const llvm::MemoryBufferRef &Buffer) {
   PreambleFileHash Result;
-  Result.Size = Buffer->getBufferSize();
+  Result.Size = Buffer.getBufferSize();
   Result.ModTime = 0;
 
   llvm::MD5 MD5Ctx;
-  MD5Ctx.update(Buffer->getBuffer().data());
+  MD5Ctx.update(Buffer.getBuffer().data());
   MD5Ctx.final(Result.MD5);
 
   return Result;
 }
 
 void PrecompiledPreamble::configurePreamble(
     PreambleBounds Bounds, CompilerInvocation &CI,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,

clang/lib/Lex/Preprocessor.cpp

 
 bool Preprocessor::SetCodeCompletionPoint(const FileEntry *File,
                                           unsigned CompleteLine,
                                           unsigned CompleteColumn) {
   assert(File);
   assert(CompleteLine && CompleteColumn && "Starts from 1:1");
   assert(!CodeCompletionFile && "Already set");
 
-  using llvm::MemoryBuffer;
-
   // Load the actual file's contents.
-  bool Invalid = false;
-  const MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File, &Invalid);
-  if (Invalid)
+  Optional<llvm::MemoryBufferRef> Buffer =
+      SourceMgr.getMemoryBufferForFileOrNone(File);
+  if (!Buffer)
     return true;
 
   // Find the byte position of the truncation point.
   const char *Position = Buffer->getBufferStart();
   for (unsigned Line = 1; Line < CompleteLine; ++Line) {
     for (; *Position; ++Position) {
       if (*Position != '\r' && *Position != '\n')
         continue;