clang/Basic: Remove SourceManager::getBufferPointer, NFC

[dexonsmith]

Summary

Inline Source::getBufferPointer into its only remaining caller,
getBufferOrNone. No functionality change.

[JDevlieghere]

LGTM

clang/lib/Basic/SourceManager.cpp

167

Orthogonal to this patch but an idea for a follow-up: this seems lightly error prone and repetitive. We could put it in an llvm::scope_exit and then release it before the final return on line 200.

[dexonsmith]

Thanks for the review!

clang/lib/Basic/SourceManager.cpp

167

Good call; I refactored this a bit in https://reviews.llvm.org/D89431; after that lands I'll do what you suggest, or possibly start with IsBufferInvalid = true and then set it back to false at the end of the function (once we know it's good).

[dexonsmith]

clang/lib/Basic/SourceManager.cpp

167

Posted the follow-up at https://reviews.llvm.org/D89722.

[JDevlieghere]

Thanks!

clang/include/clang/Basic/SourceManager.h

public:
     ///   buffer cannot be retrieved.
     ///
     /// \param Loc If specified, is the location that invalid file diagnostics
     ///   will be emitted at.
     llvm::Optional<llvm::MemoryBufferRef>
     getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM,
                     SourceLocation Loc = SourceLocation()) const;
 
-  private:
-    /// Returns pointer to memory buffer.
-    ///
-    /// TODO: SourceManager needs access to this for now, but once that's done
-    /// we should remove this API.
-    const llvm::MemoryBuffer *getBufferPointer(DiagnosticsEngine &Diag,
-                                               FileManager &FM,
-                                               SourceLocation Loc) const;
-    friend class clang::SourceManager;
-
-  public:
     /// Returns the size of the content encapsulated by this
     /// ContentCache.
     ///
     /// This can be the size of the source file or the size of an
     /// arbitrary scratch buffer.  If the ContentCache encapsulates a source
     /// file this size is retrieved from the file's FileEntry.
     unsigned getSize() const;
 

clang/lib/Basic/SourceManager.cpp

const char *InvalidBOM =
           .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;
+    return None;
   if (auto *B = Buffer.getPointer())
-    return B;
+    return B->getMemBufferRef();
   if (!ContentsEntry)
-    return nullptr;
+    return None;
 
   // Check that the file's size fits in an 'unsigned' (with room for a
   // past-the-end value). This is deeply regrettable, but various parts of
   // Clang (including elsewhere in this file!) use 'unsigned' to represent file
   // offsets, line numbers, string literal lengths, and so on, and fail
   // miserably on large source files.
   if ((uint64_t)ContentsEntry->getSize() >=
       std::numeric_limits<unsigned>::max()) {
     if (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_file_too_large,
                                 ContentsEntry->getName());
     else
       Diag.Report(Loc, diag::err_file_too_large)
         << ContentsEntry->getName();
 
     Buffer.setInt(Buffer.getInt() | InvalidFlag);
-    return nullptr;
+    return None;
   }
 
   auto BufferOrError = FM.getBufferForFile(ContentsEntry, IsFileVolatile);
 
   // If we were unable to open the file, then we are in an inconsistent
   // situation where the content cache referenced a file which no longer
   // exists. Most likely, we were using a stat cache with an invalid entry but
   // the file could also have been removed during processing. Since we can't
   // really deal with this situation, just create an empty buffer.
   if (!BufferOrError) {
     if (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_cannot_open_file,
                                 ContentsEntry->getName(),
                                 BufferOrError.getError().message());
     else
       Diag.Report(Loc, diag::err_cannot_open_file)
           << ContentsEntry->getName() << BufferOrError.getError().message();
 
     Buffer.setInt(Buffer.getInt() | InvalidFlag);
-    return nullptr;
+    return None;
   }
 
   Buffer.setPointer(BufferOrError->release());
 
   // 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 (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_file_modified,
                                 ContentsEntry->getName());
     else
       Diag.Report(Loc, diag::err_file_modified)
         << ContentsEntry->getName();
 
     Buffer.setInt(Buffer.getInt() | InvalidFlag);
-    return nullptr;
+    return None;
   }
 
   // If the buffer is valid, check to see if it has a UTF Byte Order Mark
   // (BOM).  We only support UTF-8 with and without a BOM right now.  See
   // http://en.wikipedia.org/wiki/Byte_order_mark for more information.
   StringRef BufStr = Buffer.getPointer()->getBuffer();
   const char *InvalidBOM = getInvalidBOM(BufStr);
 
   if (InvalidBOM) {
     Diag.Report(Loc, diag::err_unsupported_bom)
       << InvalidBOM << ContentsEntry->getName();
     Buffer.setInt(Buffer.getInt() | InvalidFlag);
-    return nullptr;
+    return None;
   }
 
-  return Buffer.getPointer();
+  return Buffer.getPointer()->getMemBufferRef();
 }
 
 unsigned LineTableInfo::getLineTableFilenameID(StringRef Name) {
   auto IterBool = FilenameIDs.try_emplace(Name, FilenamesByID.size());
   if (IterBool.second)
     FilenamesByID.push_back(&*IterBool.first);
   return IterBool.first->second;
 }