Port getStartLoc -> getBeginLoc

[rsmith]

+Hans (release manager for LLVM 7)

Hans, this patch series will affect the API of common Clang classes, resulting in patches to Clang SVN needing some (mechanical) modifications to be applied to the Clang 7 release branch if we land it now. What do you think about that? Would you prefer that we wait until after the 7.0.0 release to make cherry-picks easier?

[hans]

In D50349#1190029, @rsmith wrote:

+Hans (release manager for LLVM 7)

Hans, this patch series will affect the API of common Clang classes, resulting in patches to Clang SVN needing some (mechanical) modifications to be applied to the Clang 7 release branch if we land it now. What do you think about that? Would you prefer that we wait until after the 7.0.0 release to make cherry-picks easier?

Thanks for the heads up. It looks mechanical enough that if it does cause merge conflicts, they will be easy enough to resolve. No need to wait.

[steveire]

Thanks Hans. Yes, I made these patches with some simple sed oneliners.

Once these are approved in principle, I'll re-generate them before pushing.

I have also run clang-format on them, but didn't update Phab with the results to reduce noise.

[steveire]

Accepted as part of a whole-branch review here: http://clang-developers.42468.n3.nabble.com/getLocStart-versus-getStartLoc-td4061010.html

include/clang/AST/Decl.h

 class UnresolvedSetImpl;
 class VarTemplateDecl;
 
 /// A container of type source information.
 ///
 /// A client can read the relevant info using TypeLoc wrappers, e.g:
 /// @code
 /// TypeLoc TL = TypeSourceInfo->getTypeLoc();
-/// TL.getStartLoc().print(OS, SrcMgr);
+/// TL.getBeginLoc().print(OS, SrcMgr);
 /// @endcode
 class alignas(8) TypeSourceInfo {
   // Contains a memory block after the class, used for type source information,
   // allocated by ASTContext.
   friend class ASTContext;
 
   QualType Ty;
 

lib/AST/ASTImporter.cpp

 }
 
 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
   DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
   for (auto *ToD : ToDG) {
     if (!ToD)
       return nullptr;
   }
-  SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
+  SourceLocation ToStartLoc = Importer.Import(S->getBeginLoc());
   SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
   return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
 }
 
 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
   SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
   return new (Importer.getToContext()) NullStmt(ToSemiLoc,
                                                 S->hasLeadingEmptyMacro());

lib/Analysis/CloneDetection.cpp

bool StmtSequence::contains(const StmtSequence &Other) const {
   if (D != Other.D)
     return false;
 
   const SourceManager &SM = getASTContext().getSourceManager();
 
   // Otherwise check if the start and end locations of the current sequence
   // surround the other sequence.
   bool StartIsInBounds =
-      SM.isBeforeInTranslationUnit(getStartLoc(), Other.getStartLoc()) ||
-      getStartLoc() == Other.getStartLoc();
+      SM.isBeforeInTranslationUnit(getBeginLoc(), Other.getBeginLoc()) ||
+      getBeginLoc() == Other.getBeginLoc();
   if (!StartIsInBounds)
     return false;
 
   bool EndIsInBounds =
       SM.isBeforeInTranslationUnit(Other.getEndLoc(), getEndLoc()) ||
       Other.getEndLoc() == getEndLoc();
   return EndIsInBounds;
 }
StmtSequence::iterator StmtSequence::end() const {
   return CS->body_begin() + EndIndex;
 }
 
 ASTContext &StmtSequence::getASTContext() const {
   assert(D);
   return D->getASTContext();
 }
 
-SourceLocation StmtSequence::getStartLoc() const {
+SourceLocation StmtSequence::getBeginLoc() const {
   return front()->getLocStart();
 }
 
 SourceLocation StmtSequence::getEndLoc() const { return back()->getLocEnd(); }
 
 SourceRange StmtSequence::getSourceRange() const {
-  return SourceRange(getStartLoc(), getEndLoc());
+  return SourceRange(getBeginLoc(), getEndLoc());
 }
 
 void CloneDetector::analyzeCodeBody(const Decl *D) {
   assert(D);
   assert(D->hasBody());
 
   Sequences.push_back(StmtSequence(D->getBody(), D));
 }
if (Seq.empty())
     return 0;
 
   size_t Complexity = 1;
 
   ASTContext &Context = Seq.getASTContext();
 
   // Look up what macros expanded into the current statement.
   std::string MacroStack =
-      data_collection::getMacroStack(Seq.getStartLoc(), Context);
+      data_collection::getMacroStack(Seq.getBeginLoc(), Context);
 
   // First, check if ParentMacroStack is not empty which means we are currently
   // dealing with a parent statement which was expanded from a macro.
   // If this parent statement was expanded from the same macros as this
   // statement, we reduce the initial complexity of this statement to zero.
   // This causes that a group of statements that were generated by a single
   // macro expansion will only increase the total complexity by one.
   // Note: This is not the final complexity of this statement as we still

lib/CodeGen/CoverageMappingGen.cpp

SpellingRegion(SourceManager &SM, SourceLocation LocStart,
                  SourceLocation LocEnd) {
     LineStart = SM.getSpellingLineNumber(LocStart);
     ColumnStart = SM.getSpellingColumnNumber(LocStart);
     LineEnd = SM.getSpellingLineNumber(LocEnd);
     ColumnEnd = SM.getSpellingColumnNumber(LocEnd);
   }
 
   SpellingRegion(SourceManager &SM, SourceMappingRegion &R)
-      : SpellingRegion(SM, R.getStartLoc(), R.getEndLoc()) {}
+      : SpellingRegion(SM, R.getBeginLoc(), R.getEndLoc()) {}
 
   /// Check if the start and end locations appear in source order, i.e
   /// top->bottom, left->right.
   bool isInSourceOrder() const {
     return (LineStart < LineEnd) ||
            (LineStart == LineEnd && ColumnStart <= ColumnEnd);
   }
 };
public:
   /// coverage and collects the necessary file information to emit source and
   /// expansion regions.
   void gatherFileIDs(SmallVectorImpl<unsigned> &Mapping) {
     FileIDMapping.clear();
 
     llvm::SmallSet<FileID, 8> Visited;
     SmallVector<std::pair<SourceLocation, unsigned>, 8> FileLocs;
     for (const auto &Region : SourceRegions) {
-      SourceLocation Loc = Region.getStartLoc();
+      SourceLocation Loc = Region.getBeginLoc();
       FileID File = SM.getFileID(Loc);
       if (!Visited.insert(File).second)
         continue;
 
       // Do not map FileID's associated with system headers.
       if (SM.isInSystemHeader(SM.getSpellingLoc(Loc)))
         continue;
 
public:
   }
 
   /// Generate the coverage counter mapping regions from collected
   /// source regions.
   void emitSourceRegions(const SourceRegionFilter &Filter) {
     for (const auto &Region : SourceRegions) {
       assert(Region.hasEndLoc() && "incomplete region");
 
-      SourceLocation LocStart = Region.getStartLoc();
+      SourceLocation LocStart = Region.getBeginLoc();
       assert(SM.getFileID(LocStart).isValid() && "region in invalid file");
 
       // Ignore regions from system headers.
       if (SM.isInSystemHeader(SM.getSpellingLoc(LocStart)))
         continue;
 
       auto CovFileID = getCoverageFileID(LocStart);
       // Ignore regions that don't have a file, such as builtin macros.
size_t completeDeferred(Counter Count, SourceLocation DeferredEndLoc) {
     if (!DeferredRegion)
       return Index;
 
     // Consume the pending region.
     SourceMappingRegion DR = DeferredRegion.getValue();
     DeferredRegion = None;
 
     // If the region ends in an expansion, find the expansion site.
-    FileID StartFile = SM.getFileID(DR.getStartLoc());
+    FileID StartFile = SM.getFileID(DR.getBeginLoc());
     if (SM.getFileID(DeferredEndLoc) != StartFile) {
       if (isNestedIn(DeferredEndLoc, StartFile)) {
         do {
           DeferredEndLoc = getIncludeOrExpansionLoc(DeferredEndLoc);
         } while (StartFile != SM.getFileID(DeferredEndLoc));
       } else {
         return Index;
       }
     }
 
     // The parent of this deferred region ends where the containing decl ends,
     // so the region isn't useful.
-    if (DR.getStartLoc() == DeferredEndLoc)
+    if (DR.getBeginLoc() == DeferredEndLoc)
       return Index;
 
     // If we're visiting statements in non-source order (e.g switch cases or
     // a loop condition) we can't construct a sensible deferred region.
-    if (!SpellingRegion(SM, DR.getStartLoc(), DeferredEndLoc).isInSourceOrder())
+    if (!SpellingRegion(SM, DR.getBeginLoc(), DeferredEndLoc).isInSourceOrder())
       return Index;
 
     DR.setGap(true);
     DR.setCounter(Count);
     DR.setEndLoc(DeferredEndLoc);
     handleFileExit(DeferredEndLoc);
     RegionStack.push_back(DR);
     return Index;
struct CounterCoverageMappingBuilder
   /// Adds all regions from \c ParentIndex to the top of the stack to the
   /// function's \c SourceRegions.
   void popRegions(size_t ParentIndex) {
     assert(RegionStack.size() >= ParentIndex && "parent not in stack");
     bool ParentOfDeferredRegion = false;
     while (RegionStack.size() > ParentIndex) {
       SourceMappingRegion &Region = RegionStack.back();
       if (Region.hasStartLoc()) {
-        SourceLocation StartLoc = Region.getStartLoc();
+        SourceLocation StartLoc = Region.getBeginLoc();
         SourceLocation EndLoc = Region.hasEndLoc()
                                     ? Region.getEndLoc()
                                     : RegionStack[ParentIndex].getEndLoc();
         while (!SM.isWrittenInSameFile(StartLoc, EndLoc)) {
           // The region ends in a nested file or macro expansion. Create a
           // separate region for each expansion.
           SourceLocation NestedLoc = getStartOfFileOrMacro(EndLoc);
           assert(SM.isWrittenInSameFile(NestedLoc, EndLoc));
while (RegionStack.size() > ParentIndex) {
 
         MostRecentLocation = EndLoc;
         // If this region happens to span an entire expansion, we need to make
         // sure we don't overlap the parent region with it.
         if (StartLoc == getStartOfFileOrMacro(StartLoc) &&
             EndLoc == getEndOfFileOrMacro(EndLoc))
           MostRecentLocation = getIncludeOrExpansionLoc(EndLoc);
 
-        assert(SM.isWrittenInSameFile(Region.getStartLoc(), EndLoc));
+        assert(SM.isWrittenInSameFile(Region.getBeginLoc(), EndLoc));
         assert(SpellingRegion(SM, Region).isInSourceOrder());
         SourceRegions.push_back(Region);
 
         if (ParentOfDeferredRegion) {
           ParentOfDeferredRegion = false;
 
           // If there's an existing deferred region, keep the old one, because
           // it means there are two consecutive returns (or a similar pattern).
struct CounterCoverageMappingBuilder
   }
 
   /// Check whether a region with bounds \c StartLoc and \c EndLoc
   /// is already added to \c SourceRegions.
   bool isRegionAlreadyAdded(SourceLocation StartLoc, SourceLocation EndLoc) {
     return SourceRegions.rend() !=
            std::find_if(SourceRegions.rbegin(), SourceRegions.rend(),
                         [&](const SourceMappingRegion &Region) {
-                          return Region.getStartLoc() == StartLoc &&
+                          return Region.getBeginLoc() == StartLoc &&
                                  Region.getEndLoc() == EndLoc;
                         });
   }
 
   /// Adjust the most recently visited location to \c EndLoc.
   ///
   /// This should be used after visiting any statements in non-source order.
   void adjustForOutOfOrderTraversal(SourceLocation EndLoc) {
while (!isNestedIn(MostRecentLocation, ParentFile)) {
       ParentFile = SM.getFileID(LCA);
     }
 
     llvm::SmallSet<SourceLocation, 8> StartLocs;
     Optional<Counter> ParentCounter;
     for (SourceMappingRegion &I : llvm::reverse(RegionStack)) {
       if (!I.hasStartLoc())
         continue;
-      SourceLocation Loc = I.getStartLoc();
+      SourceLocation Loc = I.getBeginLoc();
       if (!isNestedIn(Loc, ParentFile)) {
         ParentCounter = I.getCounter();
         break;
       }
 
       while (!SM.isInFileID(Loc, ParentFile)) {
         // The most nested region for each start location is the one with the
         // correct count. We avoid creating redundant regions by stopping once
struct CounterCoverageMappingBuilder
   void VisitSwitchCase(const SwitchCase *S) {
     extendRegion(S);
 
     SourceMappingRegion &Parent = getRegion();
 
     Counter Count = addCounters(Parent.getCounter(), getRegionCounter(S));
     // Reuse the existing region if it starts at our label. This is typical of
     // the first case in a switch.
-    if (Parent.hasStartLoc() && Parent.getStartLoc() == getStart(S))
+    if (Parent.hasStartLoc() && Parent.getBeginLoc() == getStart(S))
       Parent.setCounter(Count);
     else
       pushRegion(Count, getStart(S));
 
     if (const auto *CS = dyn_cast<CaseStmt>(S)) {
       Visit(CS->getLHS());
       if (const Expr *RHS = CS->getRHS())
         Visit(RHS);

lib/Sema/SemaStmt.cpp

StmtResult Sema::ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
 
   if (Range && ObjCEnumerationCollection(Range))
     return ActOnObjCForCollectionStmt(ForLoc, First, Range, RParenLoc);
 
   DeclStmt *DS = dyn_cast<DeclStmt>(First);
   assert(DS && "first part of for range not a decl stmt");
 
   if (!DS->isSingleDecl()) {
-    Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
+    Diag(DS->getBeginLoc(), diag::err_type_defined_in_for_range);
     return StmtError();
   }
 
   Decl *LoopVar = DS->getSingleDecl();
   if (LoopVar->isInvalidDecl() || !Range ||
       DiagnoseUnexpandedParameterPack(Range, UPPC_Expression)) {
     LoopVar->setInvalidDecl();
     return StmtError();

lib/Sema/TreeTransform.h

if (Transformed != D)
       DeclChanged = true;
 
     Decls.push_back(Transformed);
   }
 
   if (!getDerived().AlwaysRebuild() && !DeclChanged)
     return S;
 
-  return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc());
+  return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
 
   SmallVector<Expr*, 8> Constraints;
   SmallVector<Expr*, 8> Exprs;

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
   Record.AddStmt(S->getRetValue());
   Record.AddSourceLocation(S->getReturnLoc());
   Record.AddDeclRef(S->getNRVOCandidate());
   Code = serialization::STMT_RETURN;
 }
 
 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
   VisitStmt(S);
-  Record.AddSourceLocation(S->getStartLoc());
+  Record.AddSourceLocation(S->getBeginLoc());
   Record.AddSourceLocation(S->getEndLoc());
   DeclGroupRef DG = S->getDeclGroup();
   for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
     Record.AddDeclRef(*D);
   Code = serialization::STMT_DECL;
 }
 
 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {

lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

 }
 
 void ExprEngine::VisitCXXNewAllocatorCall(const CXXNewExpr *CNE,
                                           ExplodedNode *Pred,
                                           ExplodedNodeSet &Dst) {
   ProgramStateRef State = Pred->getState();
   const LocationContext *LCtx = Pred->getLocationContext();
   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
-                                CNE->getStartLoc(),
+                                CNE->getBeginLoc(),
                                 "Error evaluating New Allocator Call");
   CallEventManager &CEMgr = getStateManager().getCallEventManager();
   CallEventRef<CXXAllocatorCall> Call =
     CEMgr.getCXXAllocatorCall(CNE, State, LCtx);
 
   ExplodedNodeSet DstPreCall;
   getCheckerManager().runCheckersForPreCall(DstPreCall, Pred,
                                             *Call, *this);