[NFC] Extract method to SourceManager for traversing the macro "stack"

[george.karpenkov]

Summary

The code for going up the macro arg expansion is duplicated in many places (and we need it for the analyzer as well, so I did not want to duplicate it two more times).

This patch is an NFC, so the semantics should remain the same.
I am still slightly confused as to why in half of the places getImmediateSpellingLoc is used, and getImmediateExpansionRange is used in the other half.

[NoQ]

The change looks obviously correct, but it might need attention of someone who knows more than me about the SourceManager :)

[vsk]

lib/Sema/SemaChecking.cpp

9351

Does getImmediateMacroCallerLoc differ at all from getImmediateSpellingLoc?

[george.karpenkov]

lib/Sema/SemaChecking.cpp

9351

@vsk the former is called in a loop, if that is your question?..

[vsk]

lib/Sema/SemaChecking.cpp

9351

No, you're replacing a loop which does:

while (...) L = getImmediateMacroCallerLoc(L);

with a loop that does:

while (...) L = getImmediateSpellingLoc(L);

Given that the precondition is that L is a macro arg expansion, I think the two loops are semantically equivalent, but I haven't dug into it much. I was just asking if you thought the same.

[vsk]

Thanks!

lib/Sema/SemaChecking.cpp

9351

Yeah I just double-checked, they are equivalent.

[george.karpenkov]

lib/Sema/SemaChecking.cpp

9351

@vsk right, then it probably makes more sense to call getImmediateMacroCallerLoc

include/clang/Basic/SourceManager.h

SourceLocation getImmediateMacroCallerLoc(SourceLocation Loc) const {
     if (isMacroArgExpansion(Loc))
       return getImmediateSpellingLoc(Loc);
 
     // Otherwise, the caller of the macro is located where this macro is
     // expanded (while the spelling is part of the macro definition).
     return getImmediateExpansionRange(Loc).first;
   }
 
+  /// \return Location of the top-level macro caller.
+  SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const;
+
 private:
   friend class ASTReader;
   friend class ASTWriter;
 
   llvm::MemoryBuffer *getFakeBufferForRecovery() const;
   const SrcMgr::ContentCache *getFakeContentCacheForRecovery() const;
 
   const SrcMgr::SLocEntry &loadSLocEntry(unsigned Index, bool *Invalid) const;

lib/Basic/SourceManager.cpp

 /// Return the start/end of the expansion information.
 std::pair<SourceLocation,SourceLocation>
 SourceManager::getImmediateExpansionRange(SourceLocation Loc) const {
   assert(Loc.isMacroID() && "Not a macro expansion loc!");
   const ExpansionInfo &Expansion = getSLocEntry(getFileID(Loc)).getExpansion();
   return Expansion.getExpansionLocRange();
 }
 
+SourceLocation SourceManager::getTopMacroCallerLoc(SourceLocation Loc) const {
+  while (isMacroArgExpansion(Loc))
+    Loc = getImmediateSpellingLoc(Loc);
+  return Loc;
+}
+
 /// getExpansionRange - Given a SourceLocation object, return the range of
 /// tokens covered by the expansion in the ultimate file.
 std::pair<SourceLocation,SourceLocation>
 SourceManager::getExpansionRange(SourceLocation Loc) const {
   if (Loc.isFileID()) return std::make_pair(Loc, Loc);
 
   std::pair<SourceLocation,SourceLocation> Res =
     getImmediateExpansionRange(Loc);

lib/Edit/Commit.cpp

 bool Commit::canInsert(SourceLocation loc, FileOffset &offs) {
   if (loc.isInvalid())
     return false;
 
   if (loc.isMacroID())
     isAtStartOfMacroExpansion(loc, &loc);
 
   const SourceManager &SM = SourceMgr;
-  while (SM.isMacroArgExpansion(loc))
-    loc = SM.getImmediateSpellingLoc(loc);
+  loc = SM.getTopMacroCallerLoc(loc);
 
   if (loc.isMacroID())
     if (!isAtStartOfMacroExpansion(loc, &loc))
       return false;
 
   if (SM.isInSystemHeader(loc))
     return false;
 
bool Commit::canInsertAfterToken(SourceLocation loc, FileOffset &offs,
   SourceLocation spellLoc = SourceMgr.getSpellingLoc(loc);
   unsigned tokLen = Lexer::MeasureTokenLength(spellLoc, SourceMgr, LangOpts);
   AfterLoc = loc.getLocWithOffset(tokLen);
 
   if (loc.isMacroID())
     isAtEndOfMacroExpansion(loc, &loc);
 
   const SourceManager &SM = SourceMgr;
-  while (SM.isMacroArgExpansion(loc))
-    loc = SM.getImmediateSpellingLoc(loc);
+  loc = SM.getTopMacroCallerLoc(loc);
 
   if (loc.isMacroID())
     if (!isAtEndOfMacroExpansion(loc, &loc))
       return false;
 
   if (SM.isInSystemHeader(loc))
     return false;
 

lib/Sema/SemaChecking.cpp

static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T,
 
   // Check for NULL (GNUNull) or nullptr (CXX11_nullptr).
   const Expr::NullPointerConstantKind NullKind =
       E->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull);
   if (NullKind != Expr::NPCK_GNUNull && NullKind != Expr::NPCK_CXX11_nullptr)
     return;
 
   // Return if target type is a safe conversion.
   if (T->isAnyPointerType() || T->isBlockPointerType() ||
       T->isMemberPointerType() || !T->isScalarType() || T->isNullPtrType())
     return;
 
   SourceLocation Loc = E->getSourceRange().getBegin();
 
   // Venture through the macro stacks to get to the source of macro arguments.
   // The new location is a better location than the complete location that was
   // passed in.
-  while (S.SourceMgr.isMacroArgExpansion(Loc))
-    Loc = S.SourceMgr.getImmediateMacroCallerLoc(Loc);
-
-  while (S.SourceMgr.isMacroArgExpansion(CC))
-    CC = S.SourceMgr.getImmediateMacroCallerLoc(CC);
+  Loc = S.SourceMgr.getTopMacroCallerLoc(Loc);
+  CC = S.SourceMgr.getTopMacroCallerLoc(CC);
 
   // __null is usually wrapped in a macro.  Go up a macro if that is the case.
   if (NullKind == Expr::NPCK_GNUNull && Loc.isMacroID()) {
     StringRef MacroName = Lexer::getImmediateMacroNameForDiagnostics(
         Loc, S.SourceMgr, S.getLangOpts());
     if (MacroName == "NULL")
       Loc = S.SourceMgr.getImmediateExpansionRange(Loc).first;
   }