clang-{tools,unittests}: Stop using SourceManager::getBuffer, NFC

[dexonsmith]

Summary

Update clang-tools-extra, clang/tools, clang/unittests to migrate from
SourceManager::getBuffer, which returns an always dereferenceable
MemoryBuffer*, to getBufferOrNone or getBufferOrFake, both of
which return a MemoryBufferRef, depending on whether the call site was
checking for validity of the buffer. No functionality change intended.

[dexonsmith]

Removed the now-unused Invalid local variable from the libclang change; not sure how I missed the warning before.

clang-tools-extra/clang-tidy/bugprone/SuspiciousSemicolonCheck.cpp

void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
   const bool IsIfStmt = isa<IfStmt>(Statement);
 
   if (!IsIfStmt &&
       SM.getSpellingLineNumber(Token.getLocation()) != SemicolonLine)
     return;
 
   SourceLocation LocEnd = Semicolon->getEndLoc();
   FileID FID = SM.getFileID(LocEnd);
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, LocEnd);
+  llvm::MemoryBufferRef Buffer = SM.getBufferOrFake(FID, LocEnd);
   Lexer Lexer(SM.getLocForStartOfFile(FID), Ctxt.getLangOpts(),
-              Buffer->getBufferStart(), SM.getCharacterData(LocEnd) + 1,
-              Buffer->getBufferEnd());
+              Buffer.getBufferStart(), SM.getCharacterData(LocEnd) + 1,
+              Buffer.getBufferEnd());
   if (Lexer.LexFromRawLexer(Token))
     return;
 
   unsigned BaseIndent = SM.getSpellingColumnNumber(Statement->getBeginLoc());
   unsigned NewTokenIndent = SM.getSpellingColumnNumber(Token.getLocation());
   unsigned NewTokenLine = SM.getSpellingLineNumber(Token.getLocation());
 
   if (!IsIfStmt && NewTokenIndent <= BaseIndent &&

clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp

static bool areExprsFromDifferentMacros(const Expr *LhsExpr,
 
   const SourceManager &SM = AstCtx->getSourceManager();
   const LangOptions &LO = AstCtx->getLangOpts();
 
   std::pair<FileID, unsigned> LsrLocInfo =
       SM.getDecomposedLoc(SM.getExpansionLoc(Lsr.getBegin()));
   std::pair<FileID, unsigned> RsrLocInfo =
       SM.getDecomposedLoc(SM.getExpansionLoc(Rsr.getBegin()));
-  const llvm::MemoryBuffer *MB = SM.getBuffer(LsrLocInfo.first);
+  llvm::MemoryBufferRef MB = SM.getBufferOrFake(LsrLocInfo.first);
 
-  const char *LTokenPos = MB->getBufferStart() + LsrLocInfo.second;
-  const char *RTokenPos = MB->getBufferStart() + RsrLocInfo.second;
+  const char *LTokenPos = MB.getBufferStart() + LsrLocInfo.second;
+  const char *RTokenPos = MB.getBufferStart() + RsrLocInfo.second;
   Lexer LRawLex(SM.getLocForStartOfFile(LsrLocInfo.first), LO,
-                MB->getBufferStart(), LTokenPos, MB->getBufferEnd());
+                MB.getBufferStart(), LTokenPos, MB.getBufferEnd());
   Lexer RRawLex(SM.getLocForStartOfFile(RsrLocInfo.first), LO,
-                MB->getBufferStart(), RTokenPos, MB->getBufferEnd());
+                MB.getBufferStart(), RTokenPos, MB.getBufferEnd());
 
   Token LTok, RTok;
   do { // Compare the expressions token-by-token.
     LRawLex.LexFromRawLexer(LTok);
     RRawLex.LexFromRawLexer(RTok);
   } while (!LTok.is(tok::eof) && !RTok.is(tok::eof) &&
            isSameRawIdentifierToken(LTok, RTok, SM) &&
            !isTokAtEndOfExpr(Lsr, LTok, SM) &&

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

diag(AssertLoc, "found assert() that could be replaced by static_assert()")
       << FixItHints;
 }
 
 SourceLocation StaticAssertCheck::getLastParenLoc(const ASTContext *ASTCtx,
                                                   SourceLocation AssertLoc) {
   const LangOptions &Opts = ASTCtx->getLangOpts();
   const SourceManager &SM = ASTCtx->getSourceManager();
 
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getFileID(AssertLoc));
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      SM.getBufferOrNone(SM.getFileID(AssertLoc));
   if (!Buffer)
     return SourceLocation();
 
   const char *BufferPos = SM.getCharacterData(AssertLoc);
 
   Token Token;
   Lexer Lexer(SM.getLocForStartOfFile(SM.getFileID(AssertLoc)), Opts,
               Buffer->getBufferStart(), BufferPos, Buffer->getBufferEnd());

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.cpp

 bool MagicNumbersCheck::isSyntheticValue(const SourceManager *SourceManager,
                                          const IntegerLiteral *Literal) const {
   const std::pair<FileID, unsigned> FileOffset =
       SourceManager->getDecomposedLoc(Literal->getLocation());
   if (FileOffset.first.isInvalid())
     return false;
 
   const StringRef BufferIdentifier =
-      SourceManager->getBuffer(FileOffset.first)->getBufferIdentifier();
+      SourceManager->getBufferOrFake(FileOffset.first).getBufferIdentifier();
 
   return BufferIdentifier.empty();
 }
 
 bool MagicNumbersCheck::isBitFieldWidth(
     const clang::ast_matchers::MatchFinder::MatchResult &Result,
     const IntegerLiteral &Literal) const {
   return IgnoreBitFieldsWidths &&

clang-tools-extra/clangd/ParsedAST.cpp

private:
   //   ... main file contents ...
   //
   // When using a preamble, the "header1" and "header2" subtrees get skipped.
   // We insert them right after the built-in header, which still appears.
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind Kind, FileID PrevFID) override {
     // It'd be nice if there was a better way to identify built-in headers...
     if (Reason == FileChangeReason::ExitFile &&
-        SM.getBuffer(PrevFID)->getBufferIdentifier() == "<built-in>")
+        SM.getBufferOrFake(PrevFID).getBufferIdentifier() == "<built-in>")
       replay();
   }
 
   void replay() {
     for (const auto &Inc : Includes) {
       const FileEntry *File = nullptr;
       if (Inc.Resolved != "")
         if (auto FE = SM.getFileManager().getFile(Inc.Resolved))

clang-tools-extra/clangd/SemanticHighlighting.cpp

for (ArrayRef<HighlightingToken> TokRef = Tokens; !TokRef.empty();) {
           });
       if (auto Resolved = resolveConflict(Conflicting))
         NonConflicting.push_back(*Resolved);
       // TokRef[Conflicting.size()] is the next token with a different range (or
       // the end of the Tokens).
       TokRef = TokRef.drop_front(Conflicting.size());
     }
     const auto &SM = AST.getSourceManager();
-    StringRef MainCode = SM.getBuffer(SM.getMainFileID())->getBuffer();
+    StringRef MainCode = SM.getBufferOrFake(SM.getMainFileID()).getBuffer();
 
     // Merge token stream with "inactive line" markers.
     std::vector<HighlightingToken> WithInactiveLines;
     auto SortedSkippedRanges = AST.getMacros().SkippedRanges;
     llvm::sort(SortedSkippedRanges);
     auto It = NonConflicting.begin();
     for (const Range &R : SortedSkippedRanges) {
       // Create one token for each line in the skipped range, so it works

clang-tools-extra/clangd/SourceCode.cpp

llvm::Optional<SourceRange> toHalfOpenFileRange(const SourceManager &SM,
   if (!isValidFileRange(SM, Result))
     return llvm::None;
 
   return Result;
 }
 
 llvm::StringRef toSourceCode(const SourceManager &SM, SourceRange R) {
   assert(isValidFileRange(SM, R));
-  bool Invalid = false;
-  auto *Buf = SM.getBuffer(SM.getFileID(R.getBegin()), &Invalid);
-  assert(!Invalid);
+  auto Buf = SM.getBufferOrNone(SM.getFileID(R.getBegin()));
+  assert(Buf);
 
   size_t BeginOffset = SM.getFileOffset(R.getBegin());
   size_t EndOffset = SM.getFileOffset(R.getEnd());
   return Buf->getBuffer().substr(BeginOffset, EndOffset - BeginOffset);
 }
 
 llvm::Expected<SourceLocation> sourceLocationInMainFile(const SourceManager &SM,
                                                         Position P) {
-  llvm::StringRef Code = SM.getBuffer(SM.getMainFileID())->getBuffer();
+  llvm::StringRef Code = SM.getBufferOrFake(SM.getMainFileID()).getBuffer();
   auto Offset =
       positionToOffset(Code, P, /*AllowColumnBeyondLineLength=*/false);
   if (!Offset)
     return Offset.takeError();
   return SM.getLocForStartOfFile(SM.getMainFileID()).getLocWithOffset(*Offset);
 }
 
 Range halfOpenToRange(const SourceManager &SM, CharSourceRange R) {

clang-tools-extra/modularize/PreprocessorTracker.cpp

static std::string getSourceString(clang::Preprocessor &PP,
   const char *EndPtr = PP.getSourceManager().getCharacterData(EndLoc);
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).trim().str();
 }
 
 // Retrieve source line from file image given a location.
 static std::string getSourceLine(clang::Preprocessor &PP,
                                  clang::SourceLocation Loc) {
-  const llvm::MemoryBuffer *MemBuffer =
-      PP.getSourceManager().getBuffer(PP.getSourceManager().getFileID(Loc));
-  const char *Buffer = MemBuffer->getBufferStart();
-  const char *BufferEnd = MemBuffer->getBufferEnd();
+  llvm::MemoryBufferRef MemBuffer = PP.getSourceManager().getBufferOrFake(
+      PP.getSourceManager().getFileID(Loc));
+  const char *Buffer = MemBuffer.getBufferStart();
+  const char *BufferEnd = MemBuffer.getBufferEnd();
   const char *BeginPtr = PP.getSourceManager().getCharacterData(Loc);
   const char *EndPtr = BeginPtr;
   while (BeginPtr > Buffer) {
     if (*BeginPtr == '\n') {
       BeginPtr++;
       break;
     }
     BeginPtr--;
   }
   while (EndPtr < BufferEnd) {
     if (*EndPtr == '\n') {
       break;
     }
     EndPtr++;
   }
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).str();
 }
 
 // Retrieve source line from file image given a file ID and line number.
 static std::string getSourceLine(clang::Preprocessor &PP, clang::FileID FileID,
                                  int Line) {
-  const llvm::MemoryBuffer *MemBuffer = PP.getSourceManager().getBuffer(FileID);
-  const char *Buffer = MemBuffer->getBufferStart();
-  const char *BufferEnd = MemBuffer->getBufferEnd();
+  llvm::MemoryBufferRef MemBuffer =
+      PP.getSourceManager().getBufferOrFake(FileID);
+  const char *Buffer = MemBuffer.getBufferStart();
+  const char *BufferEnd = MemBuffer.getBufferEnd();
   const char *BeginPtr = Buffer;
   const char *EndPtr = BufferEnd;
   int LineCounter = 1;
   if (Line == 1)
     BeginPtr = Buffer;
   else {
     while (Buffer < BufferEnd) {
       if (*Buffer == '\n') {

clang/tools/clang-diff/ClangDiff.cpp

if (IsLeft) {
     MyTag = 'R';
     OtherTag = 'L';
     LeftId = TargetId;
     RightId = Id;
   }
   unsigned Begin, End;
   std::tie(Begin, End) = Tree.getSourceRangeOffsets(Node);
   const SourceManager &SrcMgr = Tree.getASTContext().getSourceManager();
-  auto Code = SrcMgr.getBuffer(SrcMgr.getMainFileID())->getBuffer();
+  auto Code = SrcMgr.getBufferOrFake(SrcMgr.getMainFileID()).getBuffer();
   for (; Offset < Begin; ++Offset)
     printHtml(OS, Code[Offset]);
   OS << "<span id='" << MyTag << Id << "' "
      << "tid='" << OtherTag << TargetId << "' ";
   OS << "title='";
   printHtml(OS, Node.getTypeLabel());
   OS << "\n" << LeftId << " -> " << RightId;
   std::string Value = Tree.getNodeValue(Node);

clang/tools/clang-import-test/clang-import-test.cpp

 
 private:
   static void PrintSourceForLocation(const SourceLocation &Loc,
                                      SourceManager &SM) {
     const char *LocData = SM.getCharacterData(Loc, /*Invalid=*/nullptr);
     unsigned LocColumn =
         SM.getSpellingColumnNumber(Loc, /*Invalid=*/nullptr) - 1;
     FileID FID = SM.getFileID(Loc);
-    const llvm::MemoryBuffer *Buffer =
-        SM.getBuffer(FID, Loc, /*Invalid=*/nullptr);
+    llvm::MemoryBufferRef Buffer = SM.getBufferOrFake(FID, Loc);
 
-    assert(LocData >= Buffer->getBufferStart() &&
-           LocData < Buffer->getBufferEnd());
+    assert(LocData >= Buffer.getBufferStart() &&
+           LocData < Buffer.getBufferEnd());
 
     const char *LineBegin = LocData - LocColumn;
 
-    assert(LineBegin >= Buffer->getBufferStart());
+    assert(LineBegin >= Buffer.getBufferStart());
 
     const char *LineEnd = nullptr;
 
     for (LineEnd = LineBegin; *LineEnd != '\n' && *LineEnd != '\r' &&
-                              LineEnd < Buffer->getBufferEnd();
+                              LineEnd < Buffer.getBufferEnd();
          ++LineEnd)
       ;
 
     llvm::StringRef LineString(LineBegin, LineEnd - LineBegin);
 
     llvm::errs() << LineString << '\n';
     llvm::errs().indent(LocColumn);
     llvm::errs() << '^';

clang/tools/libclang/CIndex.cpp

const char *clang_getFileContents(CXTranslationUnit TU, CXFile file,
                                   size_t *size) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
 
   const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager();
   FileID fid = SM.translateFile(static_cast<FileEntry *>(file));
-  bool Invalid = true;
-  const llvm::MemoryBuffer *buf = SM.getBuffer(fid, &Invalid);
-  if (Invalid) {
+  llvm::Optional<llvm::MemoryBufferRef> buf = SM.getBufferOrNone(fid);
+  if (!buf) {
     if (size)
       *size = 0;
     return nullptr;
   }
   if (size)
     *size = buf->getBufferSize();
   return buf->getBufferStart();
 }

clang/unittests/AST/ASTImporterTest.cpp

SourceLocation ImportedLoc;
     auto Pattern = varDecl(hasName("X"));
     VarDecl *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
     ImportedLoc = Import(FromD, Lang_C99)->getLocation();
   }
 
   // Make sure the imported buffer has the original contents.
   SourceManager &ToSM = ToAST->getSourceManager();
   FileID ImportedID = ToSM.getFileID(ImportedLoc);
-  EXPECT_EQ(Source, ToSM.getBuffer(ImportedID, SourceLocation())->getBuffer());
+  EXPECT_EQ(Source,
+            ToSM.getBufferOrFake(ImportedID, SourceLocation()).getBuffer());
 }
 
 TEST_P(ImportSourceLocations, OverwrittenFileBuffer) {
   // Test importing overwritten file buffers.
 
   std::string Path = "input0.c";
   TranslationUnitDecl *FromTU = getTuDecl("int X;", Lang_C99, Path);
 
SourceLocation ImportedLoc;
     VarDecl *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
     ImportedLoc = Import(FromD, Lang_C99)->getLocation();
   }
 
   // Make sure the imported buffer has the overwritten contents.
   SourceManager &ToSM = ToAST->getSourceManager();
   FileID ImportedID = ToSM.getFileID(ImportedLoc);
   EXPECT_EQ(Contents,
-            ToSM.getBuffer(ImportedID, SourceLocation())->getBuffer());
+            ToSM.getBufferOrFake(ImportedID, SourceLocation()).getBuffer());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportExprOfAlignmentAttr) {
   // Test if import of these packed and aligned attributes does not trigger an
   // error situation where source location from 'From' context is referenced in
   // 'To' context through evaluation of the alignof attribute.
   // This happens if the 'alignof(A)' expression is not imported correctly.
   Decl *FromTU = getTuDecl(