clang/StaticAnalyzer: Stop using SourceManager::getBuffer

[dexonsmith]

Summary

Update clang/lib/StaticAnalyzer to stop relying on a MemoryBuffer*, using the MemoryBufferRef from getBufferOrNone or the Optional<MemoryBufferRef> from getBufferOrFake, depending on whether there's logic for checking validity of the buffer. The change to clang/lib/StaticAnalyzer/Core/IssueHash.cpp is potentially a functionality change, since the logic was wrong (it checked for nullptr, which was never returned by the old API), but if that was reachable the new behaviour should be better.

[dexonsmith]

Fix a warning about an unused Invalid flag.

[Szelethus]

Sounds good! Thanks!

clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

void EmptyLocalizationContextChecker::MethodCrawler::VisitObjCMessageExpr(
   // If NSLocalizedString macro is wrapped in another macro, we need to
   // unwrap the expansion until we get to the NSLocalizedStringMacro.
   while (SE.isExpansion()) {
     SL = SE.getExpansion().getSpellingLoc();
     SLInfo = Mgr.getSourceManager().getDecomposedLoc(SL);
     SE = Mgr.getSourceManager().getSLocEntry(SLInfo.first);
   }
 
-  bool Invalid = false;
-  const llvm::MemoryBuffer *BF =
-      Mgr.getSourceManager().getBuffer(SLInfo.first, SL, &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> BF =
+      Mgr.getSourceManager().getBufferOrNone(SLInfo.first, SL);
+  if (!BF)
     return;
 
   Lexer TheLexer(SL, LangOptions(), BF->getBufferStart(),
                  BF->getBufferStart() + SLInfo.second, BF->getBufferEnd());
 
   Token I;
   Token Result;    // This will hold the token just before the last ')'
   int p_count = 0; // This is for parenthesis matching

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
                                               SourceRange Range) {
   SourceRange ExpansionRange(SM.getExpansionLoc(Range.getBegin()),
                              SM.getExpansionRange(Range.getEnd()).getEnd());
 
   FileID FID = SM.getFileID(ExpansionRange.getBegin());
   if (FID != SM.getFileID(ExpansionRange.getEnd()))
     return None;
 
-  bool Invalid;
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, &Invalid);
-  if (Invalid)
+  Optional<MemoryBufferRef> Buffer = SM.getBufferOrNone(FID);
+  if (!Buffer)
     return None;
 
   unsigned BeginOffset = SM.getFileOffset(ExpansionRange.getBegin());
   unsigned EndOffset = SM.getFileOffset(ExpansionRange.getEnd());
   StringRef Snippet = Buffer->getBuffer().slice(BeginOffset, EndOffset);
 
   // We're searching the raw bytes of the buffer here, which might include
   // escaped newlines and such. That's okay; we're trying to decide whether the

clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
 
   SourceManager &SM = R.getSourceMgr();
   assert(&Pos.getManager() == &SM && "SourceManagers are different!");
   std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedExpansionLoc(Pos);
 
   if (LPosInfo.first != BugFileID)
     return;
 
-  const llvm::MemoryBuffer *Buf = SM.getBuffer(LPosInfo.first);
-  const char* FileStart = Buf->getBufferStart();
+  llvm::MemoryBufferRef Buf = SM.getBufferOrFake(LPosInfo.first);
+  const char *FileStart = Buf.getBufferStart();
 
   // Compute the column number.  Rewind from the current position to the start
   // of the line.
   unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);
   const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();
   const char *LineStart = TokInstantiationPtr-ColNo;
 
   // Compute LineEnd.
   const char *LineEnd = TokInstantiationPtr;
-  const char* FileEnd = Buf->getBufferEnd();
+  const char *FileEnd = Buf.getBufferEnd();
   while (*LineEnd != '\n' && LineEnd != FileEnd)
     ++LineEnd;
 
   // Compute the margin offset by counting tabs and non-tabs.
   unsigned PosNo = 0;
   for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
     PosNo += *c == '\t' ? 8 : 1;
 

clang/lib/StaticAnalyzer/Core/IssueHash.cpp

if (const auto *ND = dyn_cast<NamedDecl>(D)) {
     }
 
     return DeclName;
   }
 
   return "";
 }
 
-static StringRef GetNthLineOfFile(const llvm::MemoryBuffer *Buffer, int Line) {
+static StringRef GetNthLineOfFile(llvm::Optional<llvm::MemoryBufferRef> Buffer,
+                                  int Line) {
   if (!Buffer)
     return "";
 
   llvm::line_iterator LI(*Buffer, false);
   for (; !LI.is_at_eof() && LI.line_number() != Line; ++LI)
     ;
 
   return *LI;
 }
 
 static std::string NormalizeLine(const SourceManager &SM, FullSourceLoc &L,
                                  const LangOptions &LangOpts) {
   static StringRef Whitespaces = " \t\n";
 
-  StringRef Str = GetNthLineOfFile(SM.getBuffer(L.getFileID(), L),
+  StringRef Str = GetNthLineOfFile(SM.getBufferOrNone(L.getFileID(), L),
                                    L.getExpansionLineNumber());
   StringRef::size_type col = Str.find_first_not_of(Whitespaces);
   if (col == StringRef::npos)
     col = 1; // The line only contains whitespace.
   else
     col++;
   SourceLocation StartOfLine =
       SM.translateLineCol(SM.getFileID(L), L.getExpansionLineNumber(), col);
-  const llvm::MemoryBuffer *Buffer =
-      SM.getBuffer(SM.getFileID(StartOfLine), StartOfLine);
+  Optional<llvm::MemoryBufferRef> Buffer =
+      SM.getBufferOrNone(SM.getFileID(StartOfLine), StartOfLine);
   if (!Buffer)
     return {};
 
   const char *BufferPos = SM.getCharacterData(StartOfLine);
 
   Token Token;
   Lexer Lexer(SM.getLocForStartOfFile(SM.getFileID(StartOfLine)), LangOpts,
               Buffer->getBufferStart(), BufferPos, Buffer->getBufferEnd());

clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

 class TokenStream {
 public:
   TokenStream(SourceLocation ExpanLoc, const SourceManager &SM,
               const LangOptions &LangOpts)
       : ExpanLoc(ExpanLoc) {
     FileID File;
     unsigned Offset;
     std::tie(File, Offset) = SM.getDecomposedLoc(ExpanLoc);
-    const llvm::MemoryBuffer *MB = SM.getBuffer(File);
-    const char *MacroNameTokenPos = MB->getBufferStart() + Offset;
+    llvm::MemoryBufferRef MB = SM.getBufferOrFake(File);
+    const char *MacroNameTokenPos = MB.getBufferStart() + Offset;
 
     RawLexer = std::make_unique<Lexer>(SM.getLocForStartOfFile(File), LangOpts,
-                                       MB->getBufferStart(), MacroNameTokenPos,
-                                       MB->getBufferEnd());
+                                       MB.getBufferStart(), MacroNameTokenPos,
+                                       MB.getBufferEnd());
   }
 
   void next(Token &Result) {
     if (CurrTokenIt == TokenRange.end()) {
       RawLexer->LexFromRawLexer(Result);
       return;
     }
     Result = *CurrTokenIt;

clang/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp

 static unsigned int adjustColumnPos(const SourceManager &SM, SourceLocation Loc,
                                     unsigned int TokenLen = 0) {
   assert(!Loc.isInvalid() && "invalid Loc when adjusting column position");
 
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedExpansionLoc(Loc);
   assert(LocInfo.second > SM.getExpansionColumnNumber(Loc) &&
          "position in file is before column number?");
 
-  bool InvalidBuffer = false;
-  const MemoryBuffer *Buf = SM.getBuffer(LocInfo.first, &InvalidBuffer);
-  assert(!InvalidBuffer && "got an invalid buffer for the location's file");
+  Optional<MemoryBufferRef> Buf = SM.getBufferOrNone(LocInfo.first);
+  assert(Buf && "got an invalid buffer for the location's file");
   assert(Buf->getBufferSize() >= (LocInfo.second + TokenLen) &&
          "token extends past end of buffer?");
 
   // Adjust the offset to be the start of the line, since we'll be counting
   // Unicode characters from there until our column offset.
   unsigned int Off = LocInfo.second - (SM.getExpansionColumnNumber(Loc) - 1);
   unsigned int Ret = 1;
   while (Off < (LocInfo.second + TokenLen)) {

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

for (const Decl *Callee : VisitedCallees)
                                                  : Callee->getCanonicalDecl());
     VisitedAsTopLevel.insert(D);
   }
 }
 
 static bool isBisonFile(ASTContext &C) {
   const SourceManager &SM = C.getSourceManager();
   FileID FID = SM.getMainFileID();
-  StringRef Buffer = SM.getBuffer(FID)->getBuffer();
+  StringRef Buffer = SM.getBufferOrFake(FID).getBuffer();
   if (Buffer.startswith("/* A Bison parser, made by"))
     return true;
   return false;
 }
 
 void AnalysisConsumer::runAnalysisOnTranslationUnit(ASTContext &C) {
   BugReporter BR(*Mgr);
   TranslationUnitDecl *TU = C.getTranslationUnitDecl();