Port getLocStart -> getBeginLoc

[steveire]

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

clang-tools-extra/trunk/change-namespace/ChangeNamespace.cpp

SourceLocation startLocationForType(TypeLoc TLoc) {
   // `struct` but including the namespace qualifier, `a::`.
   if (TLoc.getTypeLocClass() == TypeLoc::Elaborated) {
     NestedNameSpecifierLoc NestedNameSpecifier =
         TLoc.castAs<ElaboratedTypeLoc>().getQualifierLoc();
     if (NestedNameSpecifier.getNestedNameSpecifier())
       return NestedNameSpecifier.getBeginLoc();
     TLoc = TLoc.getNextTypeLoc();
   }
-  return TLoc.getLocStart();
+  return TLoc.getBeginLoc();
 }
 
 SourceLocation endLocationForType(TypeLoc TLoc) {
   // Dig past any namespace or keyword qualifications.
   while (TLoc.getTypeLocClass() == TypeLoc::Elaborated ||
          TLoc.getTypeLocClass() == TypeLoc::Qualified)
     TLoc = TLoc.getNextTypeLoc();
 
while (D) {
     D = D->getParent();
   }
   return false;
 }
 
 // Returns true if \p D is visible at \p Loc with DeclContext \p DeclCtx.
 bool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D,
                              const DeclContext *DeclCtx, SourceLocation Loc) {
-  SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocStart());
+  SourceLocation DeclLoc = SM.getSpellingLoc(D->getBeginLoc());
   Loc = SM.getSpellingLoc(Loc);
   return SM.isBeforeInTranslationUnit(DeclLoc, Loc) &&
          (SM.getFileID(DeclLoc) == SM.getFileID(Loc) &&
           isNestedDeclContext(DeclCtx, D->getDeclContext()));
 }
 
 // Given a qualified symbol name, returns true if the symbol will be
 // incorrectly qualified without leading "::".
replaceQualifiedSymbolInDeclContext(
         CalleeRange.getEnd(), llvm::cast<NamedDecl>(Func));
   }
 }
 
 static SourceLocation getLocAfterNamespaceLBrace(const NamespaceDecl *NsDecl,
                                                  const SourceManager &SM,
                                                  const LangOptions &LangOpts) {
   std::unique_ptr<Lexer> Lex =
-      getLexerStartingFromLoc(NsDecl->getLocStart(), SM, LangOpts);
+      getLexerStartingFromLoc(NsDecl->getBeginLoc(), SM, LangOpts);
   assert(Lex.get() &&
          "Failed to create lexer from the beginning of namespace.");
   if (!Lex.get())
     return SourceLocation();
   Token Tok;
   while (!Lex->LexFromRawLexer(Tok) && Tok.isNot(tok::TokenKind::l_brace)) {
   }
   return Tok.isNot(tok::TokenKind::l_brace)

 //   class FWD;
 //   }  // a
 //   namespace x {
 //   class A { a::FWD *fwd; }
 //   }  // x
 void ChangeNamespaceTool::moveClassForwardDeclaration(
     const ast_matchers::MatchFinder::MatchResult &Result,
     const NamedDecl *FwdDecl) {
-  SourceLocation Start = FwdDecl->getLocStart();
+  SourceLocation Start = FwdDecl->getBeginLoc();
   SourceLocation End = FwdDecl->getLocEnd();
   const SourceManager &SM = *Result.SourceManager;
   SourceLocation AfterSemi = Lexer::findLocationAfterToken(
       End, tok::semi, SM, Result.Context->getLangOpts(),
       /*SkipTrailingWhitespaceAndNewLine=*/true);
   if (AfterSemi.isValid())
     End = AfterSemi.getLocWithOffset(-1);
   // Delete the forward declaration from the code to be moved.
void ChangeNamespaceTool::fixTypeLoc(
   // The declaration which this TypeLoc refers to.
   const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>("from_decl");
   // `hasDeclaration` gives underlying declaration, but if the type is
   // a typedef type, we need to use the typedef type instead.
   auto IsInMovedNs = [&](const NamedDecl *D) {
     if (!llvm::StringRef(D->getQualifiedNameAsString())
              .startswith(OldNamespace + "::"))
       return false;
-    auto ExpansionLoc = Result.SourceManager->getExpansionLoc(D->getLocStart());
+    auto ExpansionLoc = Result.SourceManager->getExpansionLoc(D->getBeginLoc());
     if (ExpansionLoc.isInvalid())
       return false;
     llvm::StringRef Filename = Result.SourceManager->getFilename(ExpansionLoc);
     return FilePatternRE.match(Filename);
   };
   // Make `FromDecl` the immediate declaration that `Type` refers to, i.e. if
   // `Type` is an alias type, we make `FromDecl` the type alias declaration.
   // Also, don't fix the \p Type if it refers to a type alias decl in the moved
void ChangeNamespaceTool::fixTypeLoc(
   assert(DeclCtx && "Empty decl context.");
   replaceQualifiedSymbolInDeclContext(Result, DeclCtx->getDeclContext(), Start,
                                       End, FromDecl);
 }
 
 void ChangeNamespaceTool::fixUsingShadowDecl(
     const ast_matchers::MatchFinder::MatchResult &Result,
     const UsingDecl *UsingDeclaration) {
-  SourceLocation Start = UsingDeclaration->getLocStart();
+  SourceLocation Start = UsingDeclaration->getBeginLoc();
   SourceLocation End = UsingDeclaration->getLocEnd();
   if (Start.isInvalid() || End.isInvalid())
     return;
 
   assert(UsingDeclaration->shadow_size() > 0);
   // FIXME: it might not be always accurate to use the first using-decl.
   const NamedDecl *TargetDecl =
       UsingDeclaration->shadow_begin()->getTargetDecl();

clang-tools-extra/trunk/clang-doc/Mapper.cpp

if (Comment) {
     Comment->setAttached();
     return Comment->parse(Context, nullptr, D);
   }
   return nullptr;
 }
 
 int MapASTVisitor::getLine(const NamedDecl *D,
                            const ASTContext &Context) const {
-  return Context.getSourceManager().getPresumedLoc(D->getLocStart()).getLine();
+  return Context.getSourceManager().getPresumedLoc(D->getBeginLoc()).getLine();
 }
 
 llvm::StringRef MapASTVisitor::getFile(const NamedDecl *D,
                                        const ASTContext &Context) const {
   return Context.getSourceManager()
-      .getPresumedLoc(D->getLocStart())
+      .getPresumedLoc(D->getBeginLoc())
       .getFilename();
 }
 
 } // namespace doc
 } // namespace clang

clang-tools-extra/trunk/clang-move/ClangMove.cpp

std::string MakeAbsolutePath(const SourceManager &SM, StringRef Path) {
   return CleanPath(AbsolutePath);
 }
 
 // Matches AST nodes that are expanded within the given AbsoluteFilePath.
 AST_POLYMORPHIC_MATCHER_P(isExpansionInFile,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc),
                           std::string, AbsoluteFilePath) {
   auto &SourceManager = Finder->getASTContext().getSourceManager();
-  auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getLocStart());
+  auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc());
   if (ExpansionLoc.isInvalid())
     return false;
   auto FileEntry =
       SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc));
   if (!FileEntry)
     return false;
   return MakeAbsolutePath(SourceManager, FileEntry->getName()) ==
          AbsoluteFilePath;
return SM.getLocForEndOfFile(LocInfo.first) == EndLoc
              : EndLoc.getLocWithOffset(1);
 }
 
 // Get full range of a Decl including the comments associated with it.
 clang::CharSourceRange
 getFullRange(const clang::Decl *D,
              const clang::LangOptions &options = clang::LangOptions()) {
   const auto &SM = D->getASTContext().getSourceManager();
-  clang::SourceRange Full(SM.getExpansionLoc(D->getLocStart()),
+  clang::SourceRange Full(SM.getExpansionLoc(D->getBeginLoc()),
                           getLocForEndOfDecl(D));
   // Expand to comments that are associated with the Decl.
   if (const auto *Comment = D->getASTContext().getRawCommentForDeclNoCache(D)) {
     if (SM.isBeforeInTranslationUnit(Full.getEnd(), Comment->getLocEnd()))
       Full.setEnd(Comment->getLocEnd());
     // FIXME: Don't delete a preceding comment, if there are no other entities
     // it could refer to.
-    if (SM.isBeforeInTranslationUnit(Comment->getLocStart(), Full.getBegin()))
-      Full.setBegin(Comment->getLocStart());
+    if (SM.isBeforeInTranslationUnit(Comment->getBeginLoc(), Full.getBegin()))
+      Full.setBegin(Comment->getBeginLoc());
   }
 
   return clang::CharSourceRange::getCharRange(Full);
 }
 
 std::string getDeclarationSourceText(const clang::Decl *D) {
   const auto &SM = D->getASTContext().getSourceManager();
   llvm::StringRef SourceText =
       clang::Lexer::getSourceText(getFullRange(D), SM, clang::LangOptions());
   return SourceText.str();
 }
 
 bool isInHeaderFile(const clang::Decl *D,
                     llvm::StringRef OriginalRunningDirectory,
                     llvm::StringRef OldHeader) {
   const auto &SM = D->getASTContext().getSourceManager();
   if (OldHeader.empty())
     return false;
-  auto ExpansionLoc = SM.getExpansionLoc(D->getLocStart());
+  auto ExpansionLoc = SM.getExpansionLoc(D->getBeginLoc());
   if (ExpansionLoc.isInvalid())
     return false;
 
   if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc))) {
     return MakeAbsolutePath(SM, FE->getName()) ==
            MakeAbsolutePath(OriginalRunningDirectory, OldHeader);
   }
 

clang-tools-extra/trunk/clang-tidy/abseil/StringFindStartswithCheck.cpp

void StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ComparisonExpr = Result.Nodes.getNodeAs<BinaryOperator>("expr");
   assert(ComparisonExpr != nullptr);
   const auto *Needle = Result.Nodes.getNodeAs<Expr>("needle");
   assert(Needle != nullptr);
   const Expr *Haystack = Result.Nodes.getNodeAs<CXXMemberCallExpr>("findexpr")
                              ->getImplicitObjectArgument();
   assert(Haystack != nullptr);
 
-  if (ComparisonExpr->getLocStart().isMacroID())
+  if (ComparisonExpr->getBeginLoc().isMacroID())
     return;
 
   // Get the source code blocks (as characters) for both the string object
   // and the search expression
   const StringRef NeedleExprCode = Lexer::getSourceText(
       CharSourceRange::getTokenRange(Needle->getSourceRange()), Source,
       Context.getLangOpts());
   const StringRef HaystackExprCode = Lexer::getSourceText(
       CharSourceRange::getTokenRange(Haystack->getSourceRange()), Source,
       Context.getLangOpts());
 
   // Create the StartsWith string, negating if comparison was "!=".
   bool Neg = ComparisonExpr->getOpcodeStr() == "!=";
   StringRef StartswithStr;
   if (Neg) {
     StartswithStr = "!absl::StartsWith";
   } else {
     StartswithStr = "absl::StartsWith";
   }
 
   // Create the warning message and a FixIt hint replacing the original expr.
   auto Diagnostic =
-      diag(ComparisonExpr->getLocStart(),
+      diag(ComparisonExpr->getBeginLoc(),
            (StringRef("use ") + StartswithStr + " instead of find() " +
             ComparisonExpr->getOpcodeStr() + " 0")
                .str());
 
   Diagnostic << FixItHint::CreateReplacement(
       ComparisonExpr->getSourceRange(),
       (StartswithStr + "(" + HaystackExprCode + ", " + NeedleExprCode + ")")
           .str());
 
   // Create a preprocessor #include FixIt hint (CreateIncludeInsertion checks
   // whether this already exists).
   auto IncludeHint = IncludeInserter->CreateIncludeInsertion(
-      Source.getFileID(ComparisonExpr->getLocStart()), AbseilStringsMatchHeader,
+      Source.getFileID(ComparisonExpr->getBeginLoc()), AbseilStringsMatchHeader,
       false);
   if (IncludeHint) {
     Diagnostic << *IncludeHint;
   }
 }
 
 void StringFindStartswithCheck::registerPPCallbacks(
     CompilerInstance &Compiler) {

clang-tools-extra/trunk/clang-tidy/android/CloexecCheck.cpp

 namespace android {
 
 namespace {
 // Helper function to form the correct string mode for Type3.
 // Build the replace text. If it's string constant, add <Mode> directly in the
 // end of the string. Else, add <Mode>.
 std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM,
                                      const LangOptions &LangOpts, char Mode) {
-  if (Arg->getLocStart().isMacroID())
+  if (Arg->getBeginLoc().isMacroID())
     return (Lexer::getSourceText(
                 CharSourceRange::getTokenRange(Arg->getSourceRange()), SM,
                 LangOpts) +
             " \"" + Twine(Mode) + "\"")
         .str();
 
   StringRef SR = cast<StringLiteral>(Arg->IgnoreParenCasts())->getString();
   return ("\"" + SR + Twine(Mode) + "\"").str();
void CloexecCheck::insertMacroFlag(const MatchFinder::MatchResult &Result,
   diag(EndLoc, "%0 should use %1 where possible")
       << FD << MacroFlag
       << FixItHint::CreateInsertion(EndLoc, (Twine(" | ") + MacroFlag).str());
 }
 
 void CloexecCheck::replaceFunc(const MatchFinder::MatchResult &Result,
                                StringRef WarningMsg, StringRef FixMsg) {
   const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
-  diag(MatchedCall->getLocStart(), WarningMsg)
+  diag(MatchedCall->getBeginLoc(), WarningMsg)
       << FixItHint::CreateReplacement(MatchedCall->getSourceRange(), FixMsg);
 }
 
 void CloexecCheck::insertStringFlag(
     const ast_matchers::MatchFinder::MatchResult &Result, const char Mode,
     const int ArgPos) {
   const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
   const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr);
   const auto *ModeArg = MatchedCall->getArg(ArgPos);
 
   // Check if the <Mode> may be in the mode string.
   const auto *ModeStr = dyn_cast<StringLiteral>(ModeArg->IgnoreParenCasts());
   if (!ModeStr || (ModeStr->getString().find(Mode) != StringRef::npos))
     return;
 
   const std::string &ReplacementText = buildFixMsgForStringFlag(
       ModeArg, *Result.SourceManager, Result.Context->getLangOpts(), Mode);
 
-  diag(ModeArg->getLocStart(), "use %0 mode '%1' to set O_CLOEXEC")
+  diag(ModeArg->getBeginLoc(), "use %0 mode '%1' to set O_CLOEXEC")
       << FD << std::string(1, Mode)
       << FixItHint::CreateReplacement(ModeArg->getSourceRange(),
                                       ReplacementText);
 }
 
 StringRef CloexecCheck::getSpellingArg(const MatchFinder::MatchResult &Result,
                                        int N) const {
   const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);

clang-tools-extra/trunk/clang-tidy/android/ComparisonInTempFailureRetryCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace android {
 
 namespace {
 AST_MATCHER(BinaryOperator, isRHSATempFailureRetryArg) {
-  if (!Node.getLocStart().isMacroID())
+  if (!Node.getBeginLoc().isMacroID())
     return false;
 
   const SourceManager &SM = Finder->getASTContext().getSourceManager();
-  if (!SM.isMacroArgExpansion(Node.getRHS()->IgnoreParenCasts()->getLocStart()))
+  if (!SM.isMacroArgExpansion(Node.getRHS()->IgnoreParenCasts()->getBeginLoc()))
     return false;
 
   const LangOptions &Opts = Finder->getASTContext().getLangOpts();
-  SourceLocation LocStart = Node.getLocStart();
+  SourceLocation LocStart = Node.getBeginLoc();
   while (LocStart.isMacroID()) {
     SourceLocation Invocation = SM.getImmediateMacroCallerLoc(LocStart);
     Token Tok;
     if (!Lexer::getRawToken(SM.getSpellingLoc(Invocation), Tok, SM, Opts,
                             /*IgnoreWhiteSpace=*/true)) {
       if (Tok.getKind() == tok::raw_identifier &&
           Tok.getRawIdentifier() == "TEMP_FAILURE_RETRY")
         return true;

clang-tools-extra/trunk/clang-tidy/boost/UseToStringCheck.cpp

if (CharType->isSpecificBuiltinType(BuiltinType::Char_S) ||
       CharType->isSpecificBuiltinType(BuiltinType::Char_U))
     StringType = "string";
   else if (CharType->isSpecificBuiltinType(BuiltinType::WChar_S) ||
            CharType->isSpecificBuiltinType(BuiltinType::WChar_U))
     StringType = "wstring";
   else
     return;
 
-  auto Loc = Call->getLocStart();
+  auto Loc = Call->getBeginLoc();
   auto Diag =
       diag(Loc, "use std::to_%0 instead of boost::lexical_cast<std::%0>")
       << StringType;
 
   if (Loc.isMacroID())
     return;
 
   Diag << FixItHint::CreateReplacement(
-      CharSourceRange::getCharRange(Call->getLocStart(),
-                                    Call->getArg(0)->getLocStart()),
+      CharSourceRange::getCharRange(Call->getBeginLoc(),
+                                    Call->getArg(0)->getBeginLoc()),
       (llvm::Twine("std::to_") + StringType + "(").str());
 }
 
 } // namespace boost
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/ArgumentCommentCheck.cpp

if (auto Template = Callee->getTemplateInstantiationPattern()) {
       // pack.
       if (Template->getNumParams() <= I ||
           Template->getParamDecl(I)->isParameterPack()) {
         continue;
       }
     }
 
     CharSourceRange BeforeArgument =
-        makeFileCharRange(ArgBeginLoc, Args[I]->getLocStart());
+        makeFileCharRange(ArgBeginLoc, Args[I]->getBeginLoc());
     ArgBeginLoc = Args[I]->getLocEnd();
 
     std::vector<std::pair<SourceLocation, StringRef>> Comments;
     if (BeforeArgument.isValid()) {
       Comments = getCommentsInRange(Ctx, BeforeArgument);
     } else {
       // Fall back to parsing back from the start of the argument.
       CharSourceRange ArgsRange = makeFileCharRange(
-          Args[I]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
+          Args[I]->getBeginLoc(), Args[NumArgs - 1]->getLocEnd());
       Comments = getCommentsBeforeLoc(Ctx, ArgsRange.getBegin());
     }
 
     for (auto Comment : Comments) {
       llvm::SmallVector<StringRef, 2> Matches;
       if (IdentRE.match(Comment.second, &Matches) &&
           !sameName(Matches[2], II->getName(), StrictMode)) {
         {

clang-tools-extra/trunk/clang-tidy/bugprone/AssertSideEffectCheck.cpp

Finder->addMatcher(
                                   hasUnaryOperand(DescendantWithSideEffect))))))
           .bind("condStmt"),
       this);
 }
 
 void AssertSideEffectCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
   const LangOptions LangOpts = getLangOpts();
-  SourceLocation Loc = Result.Nodes.getNodeAs<Stmt>("condStmt")->getLocStart();
+  SourceLocation Loc = Result.Nodes.getNodeAs<Stmt>("condStmt")->getBeginLoc();
 
   StringRef AssertMacroName;
   while (Loc.isValid() && Loc.isMacroID()) {
     StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LangOpts);
 
     // Check if this macro is an assert.
     if (std::find(AssertMacros.begin(), AssertMacros.end(), MacroName) !=
         AssertMacros.end()) {

clang-tools-extra/trunk/clang-tidy/bugprone/BoolPointerImplicitConversionCheck.cpp

 }
 
 void BoolPointerImplicitConversionCheck::check(
     const MatchFinder::MatchResult &Result) {
   auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
   auto *Var = Result.Nodes.getNodeAs<DeclRefExpr>("expr");
 
   // Ignore macros.
-  if (Var->getLocStart().isMacroID())
+  if (Var->getBeginLoc().isMacroID())
     return;
 
   // Only allow variable accesses for now, no function calls or member exprs.
   // Check that we don't dereference the variable anywhere within the if. This
   // avoids false positives for checks of the pointer for nullptr before it is
   // dereferenced. If there is a dereferencing operator on this variable don't
   // emit a diagnostic. Also ignore array subscripts.
   const Decl *D = Var->getDecl();
if (!match(findAll(
       !match(findAll(callExpr(hasAnyArgument(ignoringParenImpCasts(DeclRef)))),
              *If, *Result.Context)
            .empty() ||
       !match(findAll(cxxDeleteExpr(has(ignoringParenImpCasts(expr(DeclRef))))),
              *If, *Result.Context)
            .empty())
     return;
 
-  diag(Var->getLocStart(), "dubious check of 'bool *' against 'nullptr', did "
+  diag(Var->getBeginLoc(), "dubious check of 'bool *' against 'nullptr', did "
                            "you mean to dereference it?")
-      << FixItHint::CreateInsertion(Var->getLocStart(), "*");
+      << FixItHint::CreateInsertion(Var->getBeginLoc(), "*");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/CopyConstructorInitCheck.cpp

void CopyConstructorInitCheck::check(const MatchFinder::MatchResult &Result) {
 
   if (FixItInitList.empty() || ParamName.empty() || ShouldNotDoFixit)
     return;
 
   std::string FixItMsg{FixItInitList.substr(0, FixItInitList.size() - 2)};
   SourceLocation FixItLoc;
   // There is no initialization list in this constructor.
   if (!HasWrittenInitializer) {
-    FixItLoc = Ctor->getBody()->getLocStart();
+    FixItLoc = Ctor->getBody()->getBeginLoc();
     FixItMsg = " : " + FixItMsg;
   } else {
     // We apply the missing ctors at the beginning of the initialization list.
     FixItLoc = (*Ctor->init_begin())->getSourceLocation();
     FixItMsg += ',';
   }
   FixItMsg += ' ';
 
   Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg);
 } // namespace misc
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/DanglingHandleCheck.cpp

 
 void DanglingHandleCheck::registerMatchers(MatchFinder *Finder) {
   registerMatchersForVariables(Finder);
   registerMatchersForReturn(Finder);
 }
 
 void DanglingHandleCheck::check(const MatchFinder::MatchResult &Result) {
   auto *Handle = Result.Nodes.getNodeAs<CXXRecordDecl>("handle");
-  diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getLocStart(),
+  diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getBeginLoc(),
        "%0 outlives its value")
       << Handle->getQualifiedNameAsString();
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/InaccurateEraseCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase");
   const auto *EndExpr =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("end");
-  const SourceLocation Loc = MemberCall->getLocStart();
+  const SourceLocation Loc = MemberCall->getBeginLoc();
 
   FixItHint Hint;
 
   if (!Loc.isMacroID() && EndExpr) {
     const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("alg");
     std::string ReplacementText = Lexer::getSourceText(
         CharSourceRange::getTokenRange(EndExpr->getSourceRange()),
         *Result.SourceManager, getLangOpts());

clang-tools-extra/trunk/clang-tidy/bugprone/IncorrectRoundingsCheck.cpp

MatchFinder->addMatcher(
           hasImplicitDestinationType(isInteger()),
           ignoringParenCasts(binaryOperator(hasOperatorName("+"), OneSideHalf)))
           .bind("CastExpr"),
       this);
 }
 
 void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr");
-  diag(CastExpr->getLocStart(),
+  diag(CastExpr->getBeginLoc(),
        "casting (double + 0.5) to integer leads to incorrect rounding; "
        "consider using lround (#include <cmath>) instead");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/IntegerDivisionCheck.cpp

Finder->addMatcher(
               expr(Exceptions,
                    hasAncestor(castExpr(equalsBoundNode("FloatCast")))))))
           .bind("IntDiv"),
       this);
 }
 
 void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv");
-  diag(IntDiv->getLocStart(), "result of integer division used in a floating "
+  diag(IntDiv->getBeginLoc(), "result of integer division used in a floating "
                               "point context; possible loss of precision");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp

void MisplacedOperatorInStrlenInAllocCheck::check(
   const StringRef RHSText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(BinOp->getRHS()->getSourceRange()),
       *Result.SourceManager, getLangOpts());
 
   auto Hint = FixItHint::CreateReplacement(
       StrLen->getSourceRange(),
       (StrLenBegin + LHSText + StrLenEnd + " + " + RHSText).str());
 
-  diag(Alloc->getLocStart(),
+  diag(Alloc->getBeginLoc(),
        "addition operator is applied to the argument of %0 instead of its "
-       "result") << StrLen->getDirectCallee()->getName() << Hint;
+       "result")
+      << StrLen->getDirectCallee()->getName() << Hint;
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/MisplacedWideningCastCheck.cpp

if ((FirstSize = relativeCharSizesW(First)) != 0 &&
     return FirstSize > SecondSize;
   return false;
 }
 
 void MisplacedWideningCastCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Cast = Result.Nodes.getNodeAs<CastExpr>("Cast");
   if (!CheckImplicitCasts && isa<ImplicitCastExpr>(Cast))
     return;
-  if (Cast->getLocStart().isMacroID())
+  if (Cast->getBeginLoc().isMacroID())
     return;
 
   const auto *Calc = Result.Nodes.getNodeAs<Expr>("Calc");
-  if (Calc->getLocStart().isMacroID())
+  if (Calc->getBeginLoc().isMacroID())
     return;
 
   if (Cast->isTypeDependent() || Cast->isValueDependent() ||
       Calc->isTypeDependent() || Calc->isValueDependent())
     return;
 
   ASTContext &Context = *Result.Context;
 
if (CastBuiltinType && CalcBuiltinType &&
       return;
   }
 
   // Don't write a warning if we can easily see that the result is not
   // truncated.
   if (Context.getIntWidth(CalcType) >= getMaxCalculationWidth(Context, Calc))
     return;
 
-  diag(Cast->getLocStart(), "either cast from %0 to %1 is ineffective, or "
+  diag(Cast->getBeginLoc(), "either cast from %0 to %1 is ineffective, or "
                             "there is loss of precision before the conversion")
       << CalcType << CastType;
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/MoveForwardingReferenceCheck.cpp

static void replaceMoveWithForward(const UnresolvedLookupExpr *Callee,
                                    const TemplateTypeParmDecl *TypeParmDecl,
                                    DiagnosticBuilder &Diag,
                                    const ASTContext &Context) {
   const SourceManager &SM = Context.getSourceManager();
   const LangOptions &LangOpts = Context.getLangOpts();
 
   CharSourceRange CallRange =
       Lexer::makeFileCharRange(CharSourceRange::getTokenRange(
-                                   Callee->getLocStart(), Callee->getLocEnd()),
+                                   Callee->getBeginLoc(), Callee->getLocEnd()),
                                SM, LangOpts);
 
   if (CallRange.isValid()) {
     const std::string TypeName =
         TypeParmDecl->getIdentifier()
             ? TypeParmDecl->getName().str()
             : (llvm::Twine("decltype(") + ParmVar->getName() + ")").str();
 

clang-tools-extra/trunk/clang-tidy/bugprone/MultipleStatementMacroCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 namespace {
 
-AST_MATCHER(Expr, isInMacro) { return Node.getLocStart().isMacroID(); }
+AST_MATCHER(Expr, isInMacro) { return Node.getBeginLoc().isMacroID(); }
 
 /// \brief Find the next statement after `S`.
 const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
   auto Parents = Result.Context->getParents(*S);
   if (Parents.empty())
     return nullptr;
   const auto *Parent = Parents[0].get<Stmt>();
   if (!Parent)

 void MultipleStatementMacroCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *Inner = Result.Nodes.getNodeAs<Expr>("inner");
   const auto *Outer = Result.Nodes.getNodeAs<Stmt>("outer");
   const auto *Next = nextStmt(Result, Outer);
   if (!Next)
     return;
 
-  SourceLocation OuterLoc = Outer->getLocStart();
+  SourceLocation OuterLoc = Outer->getBeginLoc();
   if (Result.Nodes.getNodeAs<Stmt>("else"))
     OuterLoc = cast<IfStmt>(Outer)->getElseLoc();
 
-  auto InnerRanges = getExpansionRanges(Inner->getLocStart(), Result);
+  auto InnerRanges = getExpansionRanges(Inner->getBeginLoc(), Result);
   auto OuterRanges = getExpansionRanges(OuterLoc, Result);
-  auto NextRanges = getExpansionRanges(Next->getLocStart(), Result);
+  auto NextRanges = getExpansionRanges(Next->getBeginLoc(), Result);
 
   // Remove all the common ranges, starting from the top (the last ones in the
   // list).
   while (!InnerRanges.empty() && !OuterRanges.empty() && !NextRanges.empty() &&
          InnerRanges.back() == OuterRanges.back() &&
          InnerRanges.back() == NextRanges.back()) {
     InnerRanges.pop_back();
     OuterRanges.pop_back();

clang-tools-extra/trunk/clang-tidy/bugprone/SizeofContainerCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *SizeOf =
       Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof");
 
   auto Diag =
-      diag(SizeOf->getLocStart(), "sizeof() doesn't return the size of the "
+      diag(SizeOf->getBeginLoc(), "sizeof() doesn't return the size of the "
                                   "container; did you mean .size()?");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/SizeofExpressionCheck.cpp

Finder->addMatcher(
           .bind("sizeof-sizeof-expr"),
       this);
 }
 
 void SizeofExpressionCheck::check(const MatchFinder::MatchResult &Result) {
   const ASTContext &Ctx = *Result.Context;
 
   if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
-    diag(E->getLocStart(),
+    diag(E->getBeginLoc(),
          "suspicious usage of 'sizeof(K)'; did you mean 'K'?");
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-integer-call")) {
-    diag(E->getLocStart(), "suspicious usage of 'sizeof()' on an expression "
+    diag(E->getBeginLoc(), "suspicious usage of 'sizeof()' on an expression "
                            "that results in an integer");
   } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-this")) {
-    diag(E->getLocStart(),
+    diag(E->getBeginLoc(),
          "suspicious usage of 'sizeof(this)'; did you mean 'sizeof(*this)'");
   } else if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-charp")) {
-    diag(E->getLocStart(),
+    diag(E->getBeginLoc(),
          "suspicious usage of 'sizeof(char*)'; do you mean 'strlen'?");
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-pointer-to-aggregate")) {
-    diag(E->getLocStart(),
+    diag(E->getBeginLoc(),
          "suspicious usage of 'sizeof(A*)'; pointer to aggregate");
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-compare-constant")) {
-    diag(E->getLocStart(),
+    diag(E->getBeginLoc(),
          "suspicious comparison of 'sizeof(expr)' to a constant");
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-comma-expr")) {
-    diag(E->getLocStart(), "suspicious usage of 'sizeof(..., ...)'");
+    diag(E->getBeginLoc(), "suspicious usage of 'sizeof(..., ...)'");
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-divide-expr")) {
     const auto *NumTy = Result.Nodes.getNodeAs<Type>("num-type");
     const auto *DenomTy = Result.Nodes.getNodeAs<Type>("denom-type");
     const auto *ElementTy = Result.Nodes.getNodeAs<Type>("elem-type");
     const auto *PointedTy = Result.Nodes.getNodeAs<Type>("elem-ptr-type");
 
     CharUnits NumeratorSize = getSizeOfType(Ctx, NumTy);
     CharUnits DenominatorSize = getSizeOfType(Ctx, DenomTy);
     CharUnits ElementSize = getSizeOfType(Ctx, ElementTy);
 
     if (DenominatorSize > CharUnits::Zero() &&
         !NumeratorSize.isMultipleOf(DenominatorSize)) {
-      diag(E->getLocStart(), "suspicious usage of 'sizeof(...)/sizeof(...)';"
+      diag(E->getBeginLoc(), "suspicious usage of 'sizeof(...)/sizeof(...)';"
                              " numerator is not a multiple of denominator");
     } else if (ElementSize > CharUnits::Zero() &&
                DenominatorSize > CharUnits::Zero() &&
                ElementSize != DenominatorSize) {
-      diag(E->getLocStart(), "suspicious usage of 'sizeof(...)/sizeof(...)';"
+      diag(E->getBeginLoc(), "suspicious usage of 'sizeof(...)/sizeof(...)';"
                              " numerator is not a multiple of denominator");
     } else if (NumTy && DenomTy && NumTy == DenomTy) {
-      diag(E->getLocStart(),
+      diag(E->getBeginLoc(),
            "suspicious usage of sizeof pointer 'sizeof(T)/sizeof(T)'");
     } else if (PointedTy && DenomTy && PointedTy == DenomTy) {
-      diag(E->getLocStart(),
+      diag(E->getBeginLoc(),
            "suspicious usage of sizeof pointer 'sizeof(T*)/sizeof(T)'");
     } else if (NumTy && DenomTy && NumTy->isPointerType() &&
                DenomTy->isPointerType()) {
-      diag(E->getLocStart(),
+      diag(E->getBeginLoc(),
            "suspicious usage of sizeof pointer 'sizeof(P*)/sizeof(Q*)'");
     }
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-sizeof-expr")) {
-    diag(E->getLocStart(), "suspicious usage of 'sizeof(sizeof(...))'");
+    diag(E->getBeginLoc(), "suspicious usage of 'sizeof(sizeof(...))'");
   } else if (const auto *E =
                  Result.Nodes.getNodeAs<Expr>("sizeof-multiply-sizeof")) {
-    diag(E->getLocStart(), "suspicious 'sizeof' by 'sizeof' multiplication");
+    diag(E->getBeginLoc(), "suspicious 'sizeof' by 'sizeof' multiplication");
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.cpp

Finder->addMatcher(
           .bind("constructor"),
       this);
 }
 
 void StringConstructorCheck::check(const MatchFinder::MatchResult &Result) {
   const ASTContext &Ctx = *Result.Context;
   const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("constructor");
   assert(E && "missing constructor expression");
-  SourceLocation Loc = E->getLocStart();
+  SourceLocation Loc = E->getBeginLoc();
 
   if (Result.Nodes.getNodeAs<Expr>("swapped-parameter")) {
     const Expr *P0 = E->getArg(0);
     const Expr *P1 = E->getArg(1);
     diag(Loc, "string constructor parameters are probably swapped;"
               " expecting string(count, character)")
         << tooling::fixit::createReplacement(*P0, *P1, Ctx)
         << tooling::fixit::createReplacement(*P1, *P0, Ctx);

clang-tools-extra/trunk/clang-tidy/bugprone/StringIntegerAssignmentCheck.cpp

Finder->addMatcher(
                                            .bind("expr"))),
           unless(isInTemplateInstantiation())),
       this);
 }
 
 void StringIntegerAssignmentCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *Argument = Result.Nodes.getNodeAs<Expr>("expr");
-  SourceLocation Loc = Argument->getLocStart();
+  SourceLocation Loc = Argument->getBeginLoc();
 
   auto Diag =
       diag(Loc, "an integer is interpreted as a character code when assigning "
                 "it to a string; if this is intended, cast the integer to the "
                 "appropriate character type; if you want a string "
                 "representation, use the appropriate conversion facility");
 
   if (Loc.isMacroID())

clang-tools-extra/trunk/clang-tidy/bugprone/StringLiteralWithEmbeddedNulCheck.cpp

void StringLiteralWithEmbeddedNulCheck::check(
   if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("strlit")) {
     for (size_t Offset = 0, Length = SL->getLength(); Offset < Length;
          ++Offset) {
       // Find a sequence of character like "\0x12".
       if (Offset + 3 < Length && SL->getCodeUnit(Offset) == '\0' &&
           SL->getCodeUnit(Offset + 1) == 'x' &&
           isDigit(SL->getCodeUnit(Offset + 2)) &&
           isDigit(SL->getCodeUnit(Offset + 3))) {
-        diag(SL->getLocStart(), "suspicious embedded NUL character");
+        diag(SL->getBeginLoc(), "suspicious embedded NUL character");
         return;
       }
     }
   }
 
   if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("truncated")) {
-    diag(SL->getLocStart(),
+    diag(SL->getBeginLoc(),
          "truncated string literal with embedded NUL character");
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.cpp

 void SuspiciousMemsetUsageCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *CharZeroFill =
           Result.Nodes.getNodeAs<CharacterLiteral>("char-zero-fill")) {
     // Case 1: fill_char of memset() is a character '0'. Probably an
     // integer zero was intended.
 
     SourceRange CharRange = CharZeroFill->getSourceRange();
     auto Diag =
-        diag(CharZeroFill->getLocStart(), "memset fill value is char '0', "
+        diag(CharZeroFill->getBeginLoc(), "memset fill value is char '0', "
                                           "potentially mistaken for int 0");
 
     // Only suggest a fix if no macros are involved.
     if (CharRange.getBegin().isMacroID())
       return;
     Diag << FixItHint::CreateReplacement(
         CharSourceRange::getTokenRange(CharRange), "0");
   }
 
   else if (const auto *NumFill =
                Result.Nodes.getNodeAs<IntegerLiteral>("num-fill")) {
     // Case 2: fill_char of memset() is larger in size than an unsigned char
     // so it gets truncated during conversion.
 
     llvm::APSInt NumValue;
     const auto UCharMax = (1 << Result.Context->getCharWidth()) - 1;
     if (!NumFill->EvaluateAsInt(NumValue, *Result.Context) ||
         (NumValue >= 0 && NumValue <= UCharMax))
       return;
 
-    diag(NumFill->getLocStart(), "memset fill value is out of unsigned "
+    diag(NumFill->getBeginLoc(), "memset fill value is out of unsigned "
                                  "character range, gets truncated");
   }
 
   else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
     // Case 3: byte_count of memset() is zero. This is most likely an
     // argument swap.
 
     const Expr *FillChar = Call->getArg(1);
else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
     if (!FillChar->isValueDependent() &&
         FillChar->EvaluateAsInt(Value1, *Result.Context) &&
         (Value1 == 0 || Value1.isNegative()))
       return;
 
     // `byte_count` is known to be zero at compile time, and `fill_char` is
     // either not known or known to be a positive integer. Emit a warning
     // and fix-its to swap the arguments.
-    auto D = diag(Call->getLocStart(),
+    auto D = diag(Call->getBeginLoc(),
                   "memset of size zero, potentially swapped arguments");
     StringRef RHSString = tooling::fixit::getText(*ByteCount, *Result.Context);
     StringRef LHSString = tooling::fixit::getText(*FillChar, *Result.Context);
     if (LHSString.empty() || RHSString.empty())
       return;
 
     D << tooling::fixit::createReplacement(*FillChar, RHSString)
       << tooling::fixit::createReplacement(*ByteCount, LHSString);
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

for (unsigned int i = 0; i < Size; ++i) {
     }
   }
 
   // Warn only when concatenation is not common in this initializer list.
   // The current threshold is set to less than 1/5 of the string literals.
   if (double(Count) / Size > RatioThreshold)
     return;
 
-  diag(ConcatenatedLiteral->getLocStart(),
+  diag(ConcatenatedLiteral->getBeginLoc(),
        "suspicious string literal, probably missing a comma");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

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

Finder->addMatcher(
       this);
 }
 
 void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
   if (Result.Context->getDiagnostics().hasUncompilableErrorOccurred())
     return;
 
   const auto *Semicolon = Result.Nodes.getNodeAs<NullStmt>("semi");
-  SourceLocation LocStart = Semicolon->getLocStart();
+  SourceLocation LocStart = Semicolon->getBeginLoc();
 
   if (LocStart.isMacroID())
     return;
 
   ASTContext &Ctxt = *Result.Context;
   auto Token = utils::lexer::getPreviousToken(Ctxt, LocStart);
   auto &SM = *Result.SourceManager;
   unsigned SemicolonLine = SM.getSpellingLineNumber(LocStart);
void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
   FileID FID = SM.getFileID(LocEnd);
   llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, LocEnd);
   Lexer Lexer(SM.getLocForStartOfFile(FID), Ctxt.getLangOpts(),
               Buffer->getBufferStart(), SM.getCharacterData(LocEnd) + 1,
               Buffer->getBufferEnd());
   if (Lexer.LexFromRawLexer(Token))
     return;
 
-  unsigned BaseIndent = SM.getSpellingColumnNumber(Statement->getLocStart());
+  unsigned BaseIndent = SM.getSpellingColumnNumber(Statement->getBeginLoc());
   unsigned NewTokenIndent = SM.getSpellingColumnNumber(Token.getLocation());
   unsigned NewTokenLine = SM.getSpellingLineNumber(Token.getLocation());
 
   if (!IsIfStmt && NewTokenIndent <= BaseIndent &&
       Token.getKind() != tok::l_brace && NewTokenLine != SemicolonLine)
     return;
 
   diag(LocStart, "potentially unintended semicolon")
       << FixItHint::CreateRemoval(SourceRange(LocStart, LocEnd));
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

void SuspiciousStringCompareCheck::check(
   const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
   assert(Decl != nullptr && Call != nullptr);
 
   if (Result.Nodes.getNodeAs<Stmt>("missing-comparison")) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         Call->getRParenLoc(), 0, Result.Context->getSourceManager(),
         getLangOpts());
 
-    diag(Call->getLocStart(),
+    diag(Call->getBeginLoc(),
          "function %0 is called without explicitly comparing result")
         << Decl << FixItHint::CreateInsertion(EndLoc, " != 0");
   }
 
   if (const auto *E = Result.Nodes.getNodeAs<Expr>("logical-not-comparison")) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         Call->getRParenLoc(), 0, Result.Context->getSourceManager(),
         getLangOpts());
-    SourceLocation NotLoc = E->getLocStart();
+    SourceLocation NotLoc = E->getBeginLoc();
 
-    diag(Call->getLocStart(),
+    diag(Call->getBeginLoc(),
          "function %0 is compared using logical not operator")
-        << Decl << FixItHint::CreateRemoval(
-                       CharSourceRange::getTokenRange(NotLoc, NotLoc))
+        << Decl
+        << FixItHint::CreateRemoval(
         << FixItHint::CreateInsertion(EndLoc, " == 0");
   }
 
   if (Result.Nodes.getNodeAs<Stmt>("invalid-comparison")) {
-    diag(Call->getLocStart(),
+    diag(Call->getBeginLoc(),
          "function %0 is compared to a suspicious constant")
         << Decl;
   }
 
   if (const auto *BinOp =
           Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) {
-    diag(Call->getLocStart(), "results of function %0 used by operator '%1'")
+    diag(Call->getBeginLoc(), "results of function %0 used by operator '%1'")
         << Decl << BinOp->getOpcodeStr();
   }
 
   if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) {
-    diag(Call->getLocStart(), "function %0 has suspicious implicit cast")
+    diag(Call->getBeginLoc(), "function %0 has suspicious implicit cast")
         << Decl;
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/SwappedArgumentsCheck.cpp

for (unsigned I = 1, E = Call->getNumArgs(); I < E; ++I) {
     const Expr *LHSFrom = ignoreNoOpCasts(LHSCast->getSubExpr());
     const Expr *RHSFrom = ignoreNoOpCasts(RHSCast->getSubExpr());
     if (LHS->getType() == RHS->getType() ||
         LHS->getType() != RHSFrom->getType() ||
         RHS->getType() != LHSFrom->getType())
       continue;
 
     // Emit a warning and fix-its that swap the arguments.
-    diag(Call->getLocStart(), "argument with implicit conversion from %0 "
+    diag(Call->getBeginLoc(), "argument with implicit conversion from %0 "
                               "to %1 followed by argument converted from "
                               "%2 to %3, potentially swapped arguments.")
         << LHS->getType() << LHSFrom->getType() << RHS->getType()
         << RHSFrom->getType()
         << tooling::fixit::createReplacement(*LHS, *RHS, Ctx)
         << tooling::fixit::createReplacement(*RHS, *LHS, Ctx);
 
     // Remember that we emitted a warning for this argument.
     UsedArgs.insert(RHSCast);
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/TerminatingContinueCheck.cpp

Finder->addMatcher(
           .bind("continue"),
       this);
 }
 
 void TerminatingContinueCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue");
 
   auto Diag =
-      diag(ContStmt->getLocStart(),
+      diag(ContStmt->getBeginLoc(),
            "'continue' in loop with false condition is equivalent to 'break'")
       << tooling::fixit::createReplacement(*ContStmt, "break");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/ThrowKeywordMissingCheck.cpp

Finder->addMatcher(
           .bind("temporary-exception-not-thrown"),
       this); 
 }
 
 void ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *TemporaryExpr =
       Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown");
 
-  diag(TemporaryExpr->getLocStart(), "suspicious exception object created but "
+  diag(TemporaryExpr->getBeginLoc(), "suspicious exception object created but "
                                      "not thrown; did you mean 'throw %0'?")
       << TemporaryExpr->getType().getBaseTypeIdentifier()->getName();
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.cpp

 }
 
 void UndefinedMemoryManipulationCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) {
     QualType DestType = Call->getArg(0)->IgnoreImplicit()->getType();
     if (!DestType->getPointeeType().isNull())
       DestType = DestType->getPointeeType();
-    diag(Call->getLocStart(), "undefined behavior, destination object type %0 "
+    diag(Call->getBeginLoc(), "undefined behavior, destination object type %0 "
                               "is not TriviallyCopyable")
         << DestType;
   }
   if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) {
     QualType SourceType = Call->getArg(1)->IgnoreImplicit()->getType();
     if (!SourceType->getPointeeType().isNull())
       SourceType = SourceType->getPointeeType();
-    diag(Call->getLocStart(),
+    diag(Call->getBeginLoc(),
          "undefined behavior, source object type %0 is not TriviallyCopyable")
         << SourceType;
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/UndelegatedConstructorCheck.cpp

Finder->addMatcher(
                   .bind("construct"))),
           unless(isInTemplateInstantiation())),
       this);
 }
 
 void UndelegatedConstructorCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
-  diag(E->getLocStart(), "did you intend to call a delegated constructor? "
+  diag(E->getBeginLoc(), "did you intend to call a delegated constructor? "
                          "A temporary object is created here instead");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/UnusedRaiiCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
 
   // We ignore code expanded from macros to reduce the number of false
   // positives.
-  if (E->getLocStart().isMacroID())
+  if (E->getBeginLoc().isMacroID())
     return;
 
   // Don't emit a warning for the last statement in the surrounding compund
   // statement.
   const auto *CS = Result.Nodes.getNodeAs<CompoundStmt>("compound");
   if (E == CS->body_back())
     return;
 
   // Emit a warning.
-  auto D = diag(E->getLocStart(), "object destroyed immediately after "
+  auto D = diag(E->getBeginLoc(), "object destroyed immediately after "
                                   "creation; did you mean to name the object?");
   const char *Replacement = " give_me_a_name";
 
   // If this is a default ctor we have to remove the parens or we'll introduce a
   // most vexing parse.
   const auto *BTE = Result.Nodes.getNodeAs<CXXBindTemporaryExpr>("temp");
   if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(BTE->getSubExpr()))
     if (TOE->getNumArgs() == 0) {

clang-tools-extra/trunk/clang-tidy/bugprone/UnusedReturnValueCheck.cpp

Finder->addMatcher(
       stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt,
                  UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt,
                  UnusedInCaseStmt)),
       this);
 }
 
 void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
-    diag(Matched->getLocStart(),
+    diag(Matched->getBeginLoc(),
          "the value returned by this function should be used")
         << Matched->getSourceRange();
-    diag(Matched->getLocStart(),
+    diag(Matched->getBeginLoc(),
          "cast the expression to void to silence this warning",
          DiagnosticIDs::Note);
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/bugprone/VirtualNearMissCheck.cpp

if (const auto *BaseRD = BaseSpec.getType()->getAsCXXRecordDecl()) {
           if (checkOverrideWithoutName(Context, BaseMD, DerivedMD)) {
             // A "virtual near miss" is found.
             auto Range = CharSourceRange::getTokenRange(
                 SourceRange(DerivedMD->getLocation()));
 
             bool ApplyFix = !BaseMD->isTemplateInstantiation() &&
                             !DerivedMD->isTemplateInstantiation();
             auto Diag =
-                diag(DerivedMD->getLocStart(),
+                diag(DerivedMD->getBeginLoc(),
                      "method '%0' has a similar name and the same signature as "
                      "virtual method '%1'; did you mean to override it?")
                 << DerivedMD->getQualifiedNameAsString()
                 << BaseMD->getQualifiedNameAsString();
             if (ApplyFix)
               Diag << FixItHint::CreateReplacement(Range, BaseMD->getName());
           }
         }
       }
     }
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cert/LimitedRandomnessCheck.cpp

 }
 
 void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) {
   std::string msg = "";
   if (getLangOpts().CPlusPlus)
     msg = "; use C++11 random library instead";
 
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
-  diag(MatchedDecl->getLocStart(), "rand() has limited randomness" + msg);
+  diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + msg);
 }
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/AvoidGotoCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 namespace {
 AST_MATCHER(GotoStmt, isForwardJumping) {
-  return Node.getLocStart() < Node.getLabel()->getLocStart();
+  return Node.getBeginLoc() < Node.getLabel()->getBeginLoc();
 }
 } // namespace
 
 void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // TODO: This check does not recognize `IndirectGotoStmt` which is a
Finder->addMatcher(gotoStmt(anyOf(unless(hasAncestor(NestedLoop)),
                      this);
 }
 
 void AvoidGotoCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Goto = Result.Nodes.getNodeAs<GotoStmt>("goto");
 
   diag(Goto->getGotoLoc(), "avoid using 'goto' for flow control")
       << Goto->getSourceRange();
-  diag(Goto->getLabel()->getLocStart(), "label defined here",
+  diag(Goto->getLabel()->getBeginLoc(), "label defined here",
        DiagnosticIDs::Note);
 }
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

Finder->addMatcher(
                      hasLHS(hasType(isInteger())), hasRHS(IsFloatExpr),
                      unless(isInTemplateInstantiation()))
           .bind("op"),
       this);
 }
 
 void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("op")) {
-    if (Op->getLocStart().isMacroID())
+    if (Op->getBeginLoc().isMacroID())
       return;
     diag(Op->getOperatorLoc(), "narrowing conversion from %0 to %1")
         << Op->getRHS()->getType() << Op->getLHS()->getType();
     return;
   }
   const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast");
-  if (Cast->getLocStart().isMacroID())
+  if (Cast->getBeginLoc().isMacroID())
     return;
   diag(Cast->getExprLoc(), "narrowing conversion from %0 to %1")
       << Cast->getSubExpr()->getType() << Cast->getType();
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/NoMallocCheck.cpp

if ((Call = Result.Nodes.getNodeAs<CallExpr>("allocation")))
     Recommendation = "consider a container or a smart pointer";
   else if ((Call = Result.Nodes.getNodeAs<CallExpr>("realloc")))
     Recommendation = "consider std::vector or std::string";
   else if ((Call = Result.Nodes.getNodeAs<CallExpr>("free")))
     Recommendation = "use RAII";
 
   assert(Call && "Unhandled binding in the Matcher");
 
-  diag(Call->getLocStart(), "do not manage memory manually; %0")
-      << Recommendation << SourceRange(Call->getLocStart(), Call->getLocEnd());
+  diag(Call->getBeginLoc(), "do not manage memory manually; %0")
+      << Recommendation << SourceRange(Call->getBeginLoc(), Call->getLocEnd());
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

 bool OwningMemoryCheck::handleDeletion(const BoundNodes &Nodes) {
   // Result of delete matchers.
   const auto *DeleteStmt = Nodes.getNodeAs<CXXDeleteExpr>("delete_expr");
   const auto *DeletedVariable =
       Nodes.getNodeAs<DeclRefExpr>("deleted_variable");
 
   // Deletion of non-owners, with `delete variable;`
   if (DeleteStmt) {
-    diag(DeleteStmt->getLocStart(),
+    diag(DeleteStmt->getBeginLoc(),
          "deleting a pointer through a type that is "
          "not marked 'gsl::owner<>'; consider using a "
          "smart pointer instead")
         << DeletedVariable->getSourceRange();
 
     // FIXME: The declaration of the variable that was deleted can be
     // rewritten.
     const ValueDecl *Decl = DeletedVariable->getDecl();
-    diag(Decl->getLocStart(), "variable declared here", DiagnosticIDs::Note)
+    diag(Decl->getBeginLoc(), "variable declared here", DiagnosticIDs::Note)
         << Decl->getSourceRange();
 
     return true;
   }
   return false;
 }
 
 bool OwningMemoryCheck::handleLegacyConsumers(const BoundNodes &Nodes) {
   // Result of matching for legacy consumer-functions like `::free()`.
   const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
 
   // FIXME: `freopen` should be handled seperately because it takes the filename
   // as a pointer, which should not be an owner. The argument that is an owner
   // is known and the false positive coming from the filename can be avoided.
   if (LegacyConsumer) {
-    diag(LegacyConsumer->getLocStart(),
+    diag(LegacyConsumer->getBeginLoc(),
          "calling legacy resource function without passing a 'gsl::owner<>'")
         << LegacyConsumer->getSourceRange();
     return true;
   }
   return false;
 }
 
 bool OwningMemoryCheck::handleExpectedOwner(const BoundNodes &Nodes) {
   // Result of function call matchers.
   const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");
 
   // Expected function argument to be owner.
   if (ExpectedOwner) {
-    diag(ExpectedOwner->getLocStart(),
+    diag(ExpectedOwner->getBeginLoc(),
          "expected argument of type 'gsl::owner<>'; got %0")
         << ExpectedOwner->getType() << ExpectedOwner->getSourceRange();
     return true;
   }
   return false;
 }
 
 /// Assignment and initialization of owner variables.
 bool OwningMemoryCheck::handleAssignmentAndInit(const BoundNodes &Nodes) {
   const auto *OwnerAssignment =
       Nodes.getNodeAs<BinaryOperator>("owner_assignment");
   const auto *OwnerInitialization =
       Nodes.getNodeAs<VarDecl>("owner_initialization");
   const auto *OwnerInitializer =
       Nodes.getNodeAs<CXXCtorInitializer>("owner_member_initializer");
 
   // Assignments to owners.
   if (OwnerAssignment) {
-    diag(OwnerAssignment->getLocStart(),
+    diag(OwnerAssignment->getBeginLoc(),
          "expected assignment source to be of type 'gsl::owner<>'; got %0")
         << OwnerAssignment->getRHS()->getType()
         << OwnerAssignment->getSourceRange();
     return true;
   }
 
   // Initialization of owners.
   if (OwnerInitialization) {
-    diag(OwnerInitialization->getLocStart(),
+    diag(OwnerInitialization->getBeginLoc(),
          "expected initialization with value of type 'gsl::owner<>'; got %0")
         << OwnerInitialization->getAnyInitializer()->getType()
         << OwnerInitialization->getSourceRange();
     return true;
   }
 
   // Initializer of class constructors that initialize owners.
   if (OwnerInitializer) {
bool OwningMemoryCheck::handleAssignmentFromNewOwner(const BoundNodes &Nodes) {
 
   const auto *BadOwnerArgument =
       Nodes.getNodeAs<Expr>("bad_owner_creation_argument");
   const auto *BadOwnerParameter =
       Nodes.getNodeAs<ParmVarDecl>("bad_owner_creation_parameter");
 
   // Bad assignments to non-owners, where the RHS is a newly created owner.
   if (BadOwnerAssignment) {
-    diag(BadOwnerAssignment->getLocStart(),
+    diag(BadOwnerAssignment->getBeginLoc(),
          "assigning newly created 'gsl::owner<>' to non-owner %0")
         << BadOwnerAssignment->getLHS()->getType()
         << BadOwnerAssignment->getSourceRange();
     return true;
   }
 
   // Bad initialization of non-owners, where the RHS is a newly created owner.
   if (BadOwnerInitialization) {
-    diag(BadOwnerInitialization->getLocStart(),
+    diag(BadOwnerInitialization->getBeginLoc(),
          "initializing non-owner %0 with a newly created 'gsl::owner<>'")
         << BadOwnerInitialization->getType()
         << BadOwnerInitialization->getSourceRange();
 
     // FIXME: FixitHint to rewrite the type of the initialized variable
     // as 'gsl::owner<OriginalType>'
 
     // If the type of the variable was deduced, the wrapping owner typedef is
     // eliminated, therefore the check emits a special note for that case.
     if (Nodes.getNodeAs<AutoType>("deduced_type")) {
-      diag(BadOwnerInitialization->getLocStart(),
+      diag(BadOwnerInitialization->getBeginLoc(),
            "type deduction did not result in an owner", DiagnosticIDs::Note);
     }
     return true;
   }
 
   // Function call, where one arguments is a newly created owner, but the
   // parameter type is not.
   if (BadOwnerArgument) {
     assert(BadOwnerParameter &&
            "parameter for the problematic argument not found");
-    diag(BadOwnerArgument->getLocStart(), "initializing non-owner argument of "
+    diag(BadOwnerArgument->getBeginLoc(), "initializing non-owner argument of "
                                           "type %0 with a newly created "
                                           "'gsl::owner<>'")
         << BadOwnerParameter->getType() << BadOwnerArgument->getSourceRange();
     return true;
   }
   return false;
 }
 
 bool OwningMemoryCheck::handleReturnValues(const BoundNodes &Nodes) {
   // Function return statements, that are owners/resources, but the function
   // declaration does not declare its return value as owner.
   const auto *BadReturnType = Nodes.getNodeAs<ReturnStmt>("bad_owner_return");
   const auto *Function = Nodes.getNodeAs<FunctionDecl>("function_decl");
 
   // Function return values, that should be owners but aren't.
   if (BadReturnType) {
     // The returned value is a resource or variable that was not annotated with
     // owner<> and the function return type is not owner<>.
-    diag(BadReturnType->getLocStart(),
+    diag(BadReturnType->getBeginLoc(),
          "returning a newly created resource of "
          "type %0 or 'gsl::owner<>' from a "
          "function whose return type is not 'gsl::owner<>'")
         << Function->getReturnType() << BadReturnType->getSourceRange();
 
     // FIXME: Rewrite the return type as 'gsl::owner<OriginalType>'
     return true;
   }
   return false;
 }
 
 bool OwningMemoryCheck::handleOwnerMembers(const BoundNodes &Nodes) {
   // Classes, that have owners as member, but do not declare destructors
   // accordingly.
   const auto *BadClass = Nodes.getNodeAs<CXXRecordDecl>("non_destructor_class");
 
   // Classes, that contains owners, but do not declare destructors.
   if (BadClass) {
     const auto *DeclaredOwnerMember =
         Nodes.getNodeAs<FieldDecl>("undestructed_owner_member");
     assert(DeclaredOwnerMember &&
            "match on class with bad destructor but without a declared owner");
 
-    diag(DeclaredOwnerMember->getLocStart(),
+    diag(DeclaredOwnerMember->getBeginLoc(),
          "member variable of type 'gsl::owner<>' requires the class %0 to "
          "implement a destructor to release the owned resource")
         << BadClass;
     return true;
   }
   return false;
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.cpp

 void ProTypeCstyleCastCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedCast = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
 
   if (MatchedCast->getCastKind() == CK_BitCast ||
       MatchedCast->getCastKind() == CK_LValueBitCast ||
       MatchedCast->getCastKind() == CK_IntegralToPointer ||
       MatchedCast->getCastKind() == CK_PointerToIntegral ||
       MatchedCast->getCastKind() == CK_ReinterpretMemberPointer) {
-    diag(MatchedCast->getLocStart(),
+    diag(MatchedCast->getBeginLoc(),
          "do not use C-style cast to convert between unrelated types");
     return;
   }
 
   QualType SourceType = MatchedCast->getSubExpr()->getType();
 
   if (MatchedCast->getCastKind() == CK_BaseToDerived) {
     const auto *SourceDecl = SourceType->getPointeeCXXRecordDecl();
     if (!SourceDecl) // The cast is from object to reference.
       SourceDecl = SourceType->getAsCXXRecordDecl();
     if (!SourceDecl)
       return;
 
     if (SourceDecl->isPolymorphic()) {
       // Leave type spelling exactly as it was (unlike
       // getTypeAsWritten().getAsString() which would spell enum types 'enum
       // X').
       StringRef DestTypeString = Lexer::getSourceText(
           CharSourceRange::getTokenRange(
               MatchedCast->getLParenLoc().getLocWithOffset(1),
               MatchedCast->getRParenLoc().getLocWithOffset(-1)),
           *Result.SourceManager, getLangOpts());
 
       auto diag_builder = diag(
-          MatchedCast->getLocStart(),
+          MatchedCast->getBeginLoc(),
           "do not use C-style cast to downcast from a base to a derived class; "
           "use dynamic_cast instead");
 
       const Expr *SubExpr =
           MatchedCast->getSubExprAsWritten()->IgnoreImpCasts();
       std::string CastText = ("dynamic_cast<" + DestTypeString + ">").str();
       if (!isa<ParenExpr>(SubExpr)) {
         CastText.push_back('(');
         diag_builder << FixItHint::CreateInsertion(
             Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0,
                                        *Result.SourceManager, getLangOpts()),
             ")");
       }
       auto ParenRange = CharSourceRange::getTokenRange(
           MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc());
       diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
     } else {
       diag(
-          MatchedCast->getLocStart(),
+          MatchedCast->getBeginLoc(),
           "do not use C-style cast to downcast from a base to a derived class");
     }
     return;
   }
 
   if (MatchedCast->getCastKind() == CK_NoOp &&
       needsConstCast(SourceType, MatchedCast->getType())) {
-    diag(MatchedCast->getLocStart(),
+    diag(MatchedCast->getBeginLoc(),
          "do not use C-style cast to cast away constness");
   }
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

SourceLocation getLocation(const ASTContext &Context,
                              const CXXConstructorDecl &Constructor) const {
     assert((Where != nullptr || Placement == InitializerPlacement::New) &&
            "Location should be relative to an existing initializer or this "
            "insertion represents a new initializer list.");
     SourceLocation Location;
     switch (Placement) {
     case InitializerPlacement::New:
       Location = utils::lexer::getPreviousToken(
-                     Context, Constructor.getBody()->getLocStart())
+                     Context, Constructor.getBody()->getBeginLoc())
                      .getLocation();
       break;
     case InitializerPlacement::Before:
       Location = utils::lexer::getPreviousToken(
                      Context, Where->getSourceRange().getBegin())
                      .getLocation();
       break;
     case InitializerPlacement::After:
forEachField(ClassDecl, ClassDecl.fields(),
                [&](const FieldDecl *F) { Decls.push_back(F); });
 }
 
 template <typename T>
 void fixInitializerList(const ASTContext &Context, DiagnosticBuilder &Diag,
                         const CXXConstructorDecl *Ctor,
                         const SmallPtrSetImpl<const T *> &DeclsToInit) {
   // Do not propose fixes in macros since we cannot place them correctly.
-  if (Ctor->getLocStart().isMacroID())
+  if (Ctor->getBeginLoc().isMacroID())
     return;
 
   SmallVector<const NamedDecl *, 16> OrderedDecls;
   getInitializationsInOrder(*Ctor->getParent(), OrderedDecls);
 
   for (const auto &Insertion :
        computeInsertions(Ctor->inits(), OrderedDecls, DeclsToInit)) {
     if (!Insertion.Initializers.empty())
void ProTypeMemberInitCheck::checkMissingMemberInitializer(
   // Collect all the fields we need to initialize, including indirect fields.
   SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit;
   forEachField(ClassDecl, FieldsToInit,
                [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });
   if (AllFieldsToInit.empty())
     return;
 
   DiagnosticBuilder Diag =
-      diag(Ctor ? Ctor->getLocStart() : ClassDecl.getLocation(),
+      diag(Ctor ? Ctor->getBeginLoc() : ClassDecl.getLocation(),
            IsUnion
                ? "union constructor should initialize one of these fields: %0"
                : "constructor does not initialize these fields: %0")
       << toCommaSeparatedString(OrderedFields, AllFieldsToInit);
 
   // Do not propose fixes for constructors in macros since we cannot place them
   // correctly.
-  if (Ctor && Ctor->getLocStart().isMacroID())
+  if (Ctor && Ctor->getBeginLoc().isMacroID())
     return;
 
   // Collect all fields but only suggest a fix for the first member of unions,
   // as initializing more than one union member is an error.
   SmallPtrSet<const FieldDecl *, 16> FieldsToFix;
   SmallPtrSet<const RecordDecl *, 4> UnionsSeen;
   forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) {
     if (!FieldsToInit.count(F))
for (const CXXCtorInitializer *Init : Ctor->inits()) {
         BasesToInit.erase(Init->getBaseClass()->getAsCXXRecordDecl());
     }
   }
 
   if (BasesToInit.empty())
     return;
 
   DiagnosticBuilder Diag =
-      diag(Ctor ? Ctor->getLocStart() : ClassDecl.getLocation(),
+      diag(Ctor ? Ctor->getBeginLoc() : ClassDecl.getLocation(),
            "constructor does not initialize these bases: %0")
       << toCommaSeparatedString(AllBases, BasesToInit);
 
   if (Ctor)
     fixInitializerList(Context, Diag, Ctor, BasesToInit);
 }
 
 void ProTypeMemberInitCheck::checkUninitializedTrivialType(
     const ASTContext &Context, const VarDecl *Var) {
   DiagnosticBuilder Diag =
-      diag(Var->getLocStart(), "uninitialized record type: %0") << Var;
+      diag(Var->getBeginLoc(), "uninitialized record type: %0") << Var;
 
   Diag << FixItHint::CreateInsertion(
       getLocationForEndOfToken(Context, Var->getSourceRange().getEnd()),
       Context.getLangOpts().CPlusPlus11 ? "{}" : " = {}");
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

void DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this);
 }
 
 void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *S =
           Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt")) {
     diag(S->getUsedLocation(),
          "calling a function that uses a default argument is disallowed");
-    diag(S->getParam()->getLocStart(),
-        "default parameter was declared here",
+    diag(S->getParam()->getBeginLoc(), "default parameter was declared here",
          DiagnosticIDs::Note);
   } else if (const ParmVarDecl *D =
           Result.Nodes.getNodeAs<ParmVarDecl>("decl")) {
     SourceRange DefaultArgRange = D->getDefaultArgRange();
 
     if (DefaultArgRange.getEnd() != D->getLocEnd()) {
       return;
     } else if (DefaultArgRange.getBegin().isMacroID()) {
-      diag(D->getLocStart(),
+      diag(D->getBeginLoc(),
            "declaring a parameter with a default argument is disallowed");
     } else {
-      SourceLocation StartLocation = D->getName().empty() ?
-              D->getLocStart() : D->getLocation();
+      SourceLocation StartLocation =
+          D->getName().empty() ? D->getBeginLoc() : D->getLocation();
 
       SourceRange RemovalRange(Lexer::getLocForEndOfToken(
              StartLocation, 0,
              *Result.SourceManager,
              Result.Context->getLangOpts()
            ),
            DefaultArgRange.getEnd()
          );
 
-      diag(D->getLocStart(),
+      diag(D->getBeginLoc(),
            "declaring a parameter with a default argument is disallowed")
-          << D
-          << FixItHint::CreateRemoval(RemovalRange);
+          << D << FixItHint::CreateRemoval(RemovalRange);
     }
   }
 }
 
 } // namespace fuchsia
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) {
     for (const auto &V : D->vbases()) {
       const auto *Ty = V.getType()->getAs<RecordType>();
       if (!Ty) continue;
       const auto *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition());
       if (!isInterface(Base)) NumConcrete++;
     }
 
     if (NumConcrete > 1) {
-      diag(D->getLocStart(),
-           "inheriting mulitple classes that aren't "
+      diag(D->getBeginLoc(), "inheriting mulitple classes that aren't "
                              "pure virtual is discouraged");
     }
   }
 }
 
 }  // namespace fuchsia
 }  // namespace tidy
 }  // namespace clang

clang-tools-extra/trunk/clang-tidy/fuchsia/OverloadedOperatorCheck.cpp

 void OverloadedOperatorCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(functionDecl(isFuchsiaOverloadedOperator()).bind("decl"),
                      this);
 }
 
 void OverloadedOperatorCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl");
   assert(D && "No FunctionDecl captured!");
-  
-  SourceLocation Loc = D->getLocStart();
+  SourceLocation Loc = D->getBeginLoc();
   if (Loc.isValid())
     diag(Loc, "overloading %0 is disallowed") << D;
 }
 
 } // namespace fuchsia
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.cpp

Finder->addMatcher(
                       isConstantInitializer()))))))
           .bind("decl"),
       this);
 }
 
 void StaticallyConstructedObjectsCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl"))
-    diag(D->getLocStart(), "static objects are disallowed; if possible, use a "
+    diag(D->getBeginLoc(), "static objects are disallowed; if possible, use a "
                            "constexpr constructor instead");
 }
 
 } // namespace fuchsia
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/fuchsia/TrailingReturnCheck.cpp

Finder->addMatcher(
                          unless(anyOf(returns(decltypeType()),
                                       hasParent(cxxRecordDecl(isLambda()))))))
           .bind("decl"),
       this);
 }
 
 void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *D = Result.Nodes.getNodeAs<Decl>("decl"))
-    diag(D->getLocStart(),
+    diag(D->getBeginLoc(),
          "a trailing return type is disallowed for this type of declaration");
 }
 
 } // namespace fuchsia
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/fuchsia/VirtualInheritanceCheck.cpp

 void VirtualInheritanceCheck::registerMatchers(MatchFinder *Finder) {
   // Defining classes using direct virtual inheritance is disallowed.
   Finder->addMatcher(cxxRecordDecl(hasDirectVirtualBaseClass()).bind("decl"),
                      this);
 }
 
 void VirtualInheritanceCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl"))
-    diag(D->getLocStart(), "direct virtual inheritance is disallowed");
+    diag(D->getBeginLoc(), "direct virtual inheritance is disallowed");
 }
 
 }  // namespace fuchsia
 }  // namespace tidy
 }  // namespace clang

clang-tools-extra/trunk/clang-tidy/google/AvoidCStyleCastsCheck.cpp

void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   const QualType DestTypeAsWritten =
       CastExpr->getTypeAsWritten().getUnqualifiedType();
   const QualType SourceTypeAsWritten =
       CastExpr->getSubExprAsWritten()->getType().getUnqualifiedType();
   const QualType SourceType = SourceTypeAsWritten.getCanonicalType();
   const QualType DestType = DestTypeAsWritten.getCanonicalType();
 
   auto ReplaceRange = CharSourceRange::getCharRange(
-      CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getLocStart());
+      CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getBeginLoc());
 
   bool FnToFnCast =
       isFunction(SourceTypeAsWritten) && isFunction(DestTypeAsWritten);
 
   if (CastExpr->getCastKind() == CK_NoOp && !FnToFnCast) {
     // Function pointer/reference casts may be needed to resolve ambiguities in
     // case of overloaded functions, so detection of redundant casts is trickier
     // in this case. Don't emit "redundant cast" warnings for function
     // pointer/reference types.
     if (SourceTypeAsWritten == DestTypeAsWritten) {
-      diag(CastExpr->getLocStart(), "redundant cast to the same type")
+      diag(CastExpr->getBeginLoc(), "redundant cast to the same type")
           << FixItHint::CreateRemoval(ReplaceRange);
       return;
     }
   }
 
   // The rest of this check is only relevant to C++.
   // We also disable it for Objective-C++.
   if (!getLangOpts().CPlusPlus || getLangOpts().ObjC1 || getLangOpts().ObjC2)
     return;
   // Ignore code inside extern "C" {} blocks.
   if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context)
            .empty())
     return;
   // Ignore code in .c files and headers included from them, even if they are
   // compiled as C++.
   if (getCurrentMainFile().endswith(".c"))
     return;
 
   SourceManager &SM = *Result.SourceManager;
 
   // Ignore code in .c files #included in other files (which shouldn't be done,
   // but people still do this for test and other purposes).
-  if (SM.getFilename(SM.getSpellingLoc(CastExpr->getLocStart())).endswith(".c"))
+  if (SM.getFilename(SM.getSpellingLoc(CastExpr->getBeginLoc())).endswith(".c"))
     return;
 
   // Leave type spelling exactly as it was (unlike
   // getTypeAsWritten().getAsString() which would spell enum types 'enum X').
   StringRef DestTypeString =
       Lexer::getSourceText(CharSourceRange::getTokenRange(
                                CastExpr->getLParenLoc().getLocWithOffset(1),
                                CastExpr->getRParenLoc().getLocWithOffset(-1)),
                            SM, getLangOpts());
 
   auto Diag =
-      diag(CastExpr->getLocStart(), "C-style casts are discouraged; use %0");
+      diag(CastExpr->getBeginLoc(), "C-style casts are discouraged; use %0");
 
   auto ReplaceWithCast = [&](std::string CastText) {
     const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
     if (!isa<ParenExpr>(SubExpr)) {
       CastText.push_back('(');
       Diag << FixItHint::CreateInsertion(
           Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, SM,
                                      getLangOpts()),

clang-tools-extra/trunk/clang-tidy/google/ExplicitMakePairCheck.cpp

void ExplicitMakePairCheck::check(const MatchFinder::MatchResult &Result) {
   const Expr *Arg0 = Call->getArg(0)->IgnoreParenImpCasts();
   const Expr *Arg1 = Call->getArg(1)->IgnoreParenImpCasts();
 
   // If types don't match, we suggest replacing with std::pair and explicit
   // template arguments. Otherwise just remove the template arguments from
   // make_pair.
   if (Arg0->getType() != Call->getArg(0)->getType() ||
       Arg1->getType() != Call->getArg(1)->getType()) {
-    diag(Call->getLocStart(), "for C++11-compatibility, use pair directly")
+    diag(Call->getBeginLoc(), "for C++11-compatibility, use pair directly")
         << FixItHint::CreateReplacement(
-               SourceRange(DeclRef->getLocStart(), DeclRef->getLAngleLoc()),
+               SourceRange(DeclRef->getBeginLoc(), DeclRef->getLAngleLoc()),
                "std::pair<");
   } else {
-    diag(Call->getLocStart(),
+    diag(Call->getBeginLoc(),
          "for C++11-compatibility, omit template arguments from make_pair")
         << FixItHint::CreateRemoval(
                SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc()));
   }
 }
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/GlobalNamesInHeadersCheck.cpp

Finder->addMatcher(decl(anyOf(usingDecl(), usingDirectiveDecl()),
                           hasDeclContext(translationUnitDecl()))
                          .bind("using_decl"),
                      this);
 }
 
 void GlobalNamesInHeadersCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *D = Result.Nodes.getNodeAs<Decl>("using_decl");
   // If it comes from a macro, we'll assume it is fine.
-  if (D->getLocStart().isMacroID())
+  if (D->getBeginLoc().isMacroID())
     return;
 
   // Ignore if it comes from the "main" file ...
   if (Result.SourceManager->isInMainFile(
-          Result.SourceManager->getExpansionLoc(D->getLocStart()))) {
+          Result.SourceManager->getExpansionLoc(D->getBeginLoc()))) {
     // unless that file is a header.
     if (!utils::isSpellingLocInHeaderFile(
-            D->getLocStart(), *Result.SourceManager, HeaderFileExtensions))
+            D->getBeginLoc(), *Result.SourceManager, HeaderFileExtensions))
       return;
   }
 
   if (const auto *UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) {
     if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) {
       // Anynoumous namespaces inject a using directive into the AST to import
       // the names into the containing namespace.
       // We should not have them in headers, but there is another warning for
       // that.
       return;
     }
   }
 
-  diag(D->getLocStart(),
+  diag(D->getBeginLoc(),
        "using declarations in the global namespace in headers are prohibited");
 }
 
 } // namespace readability
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/IntegerTypesCheck.cpp

Finder->addMatcher(typeLoc(loc(isInteger()),
                                  callee(functionDecl(hasAttr(attr::Format)))))))
                          .bind("tl"),
                      this);
   IdentTable = llvm::make_unique<IdentifierTable>(getLangOpts());
 }
 
 void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
   auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl");
-  SourceLocation Loc = TL.getLocStart();
+  SourceLocation Loc = TL.getBeginLoc();
 
   if (Loc.isInvalid() || Loc.isMacroID())
     return;
 
   // Look through qualification.
   if (auto QualLoc = TL.getAs<QualifiedTypeLoc>())
     TL = QualLoc.getUnqualifiedLoc();
 

clang-tools-extra/trunk/clang-tidy/google/OverloadedUnaryAndCheck.cpp

Finder->addMatcher(
           unless(cxxMethodDecl()),
           functionDecl(parameterCountIs(1), hasOverloadedOperatorName("&"))
               .bind("overload"))),
       this);
 }
 
 void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload");
-  diag(Decl->getLocStart(),
+  diag(Decl->getBeginLoc(),
        "do not overload unary operator&, it is dangerous.");
 }
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp

void UnnamedNamespaceInHeaderCheck::registerMatchers(
   if (getLangOpts().CPlusPlus)
     Finder->addMatcher(namespaceDecl(isAnonymous()).bind("anonymousNamespace"),
                        this);
 }
 
 void UnnamedNamespaceInHeaderCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *N = Result.Nodes.getNodeAs<NamespaceDecl>("anonymousNamespace");
-  SourceLocation Loc = N->getLocStart();
+  SourceLocation Loc = N->getBeginLoc();
   if (!Loc.isValid())
     return;
 
   if (utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager,
                                        HeaderFileExtensions))
     diag(Loc, "do not use unnamed namespaces in header files");
 }
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

void UsingNamespaceDirectiveCheck::registerMatchers(
   // provide any benefit to other languages, despite being benign.
   if (getLangOpts().CPlusPlus)
     Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
 }
 
 void UsingNamespaceDirectiveCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace");
-  SourceLocation Loc = U->getLocStart();
+  SourceLocation Loc = U->getBeginLoc();
   if (U->isImplicit() || !Loc.isValid())
     return;
 
   // Do not warn if namespace is a std namespace with user-defined literals. The
   // user-defined literals can only be used with a using directive.
   if (isStdLiteralsNamespace(U->getNominatedNamespace()))
     return;
 

clang-tools-extra/trunk/clang-tidy/hicpp/ExceptionBaseclassCheck.cpp

Finder->addMatcher(
                                 anything())))
           .bind("bad_throw"),
       this);
 }
 
 void ExceptionBaseclassCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *BadThrow = Result.Nodes.getNodeAs<CXXThrowExpr>("bad_throw");
 
-  diag(BadThrow->getSubExpr()->getLocStart(), "throwing an exception whose "
+  diag(BadThrow->getSubExpr()->getBeginLoc(), "throwing an exception whose "
                                               "type %0 is not derived from "
                                               "'std::exception'")
       << BadThrow->getSubExpr()->getType() << BadThrow->getSourceRange();
 
   const auto *TypeDecl = Result.Nodes.getNodeAs<NamedDecl>("decl");
   if (TypeDecl != nullptr)
-    diag(TypeDecl->getLocStart(), "type defined here", DiagnosticIDs::Note);
+    diag(TypeDecl->getBeginLoc(), "type defined here", DiagnosticIDs::Note);
 }
 
 } // namespace hicpp
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

else if (T->isIntegralType(Context))
     return twoPow(Context.getTypeSize(T));
   else
     return 1;
 }
 
 void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *ElseIfWithoutElse =
           Result.Nodes.getNodeAs<IfStmt>("else-if")) {
-    diag(ElseIfWithoutElse->getLocStart(),
+    diag(ElseIfWithoutElse->getBeginLoc(),
          "potentially uncovered codepath; add an ending else statement");
     return;
   }
   const auto *Switch = Result.Nodes.getNodeAs<SwitchStmt>("switch");
   std::size_t SwitchCaseCount;
   bool SwitchHasDefault;
   std::tie(SwitchCaseCount, SwitchHasDefault) = countCaseLabels(Switch);
 
if (!SwitchHasDefault && SwitchCaseCount > 0) {
     handleSwitchWithoutDefault(Switch, SwitchCaseCount, Result);
     return;
   }
   // Warns for degenerated 'switch' statements that neither define a case nor
   // a default label.
   // FIXME: Evaluate, if emitting a fix-it to simplify that statement is 
   // reasonable.
   if (!SwitchHasDefault && SwitchCaseCount == 0) {
-    diag(Switch->getLocStart(),
+    diag(Switch->getBeginLoc(),
          "switch statement without labels has no effect");
     return;
   }
   llvm_unreachable("matched a case, that was not explicitly handled");
 }
 
 void MultiwayPathsCoveredCheck::handleSwitchWithDefault(
     const SwitchStmt *Switch, std::size_t CaseCount) {
   assert(CaseCount > 0 && "Switch statement with supposedly one default "
                           "branch did not contain any case labels");
   if (CaseCount == 1 || CaseCount == 2)
-    diag(Switch->getLocStart(),
+    diag(Switch->getBeginLoc(),
          CaseCount == 1
              ? "degenerated switch with default label only"
              : "switch could be better written as an if/else statement");
 }
 
 void MultiwayPathsCoveredCheck::handleSwitchWithoutDefault(
     const SwitchStmt *Switch, std::size_t CaseCount,
     const MatchFinder::MatchResult &Result) {
if (const auto *BitfieldDecl =
       return twoPow(BitfieldDecl->getBitWidthValue(*Result.Context));
     }
 
     return static_cast<std::size_t>(0);
   }();
 
   // FIXME: Transform the 'switch' into an 'if' for CaseCount == 1.
   if (CaseCount < MaxPathsPossible)
-    diag(Switch->getLocStart(),
+    diag(Switch->getBeginLoc(),
          CaseCount == 1 ? "switch with only one case; use an if statement"
                         : "potential uncovered code path; add a default label");
 }
 } // namespace hicpp
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/hicpp/SignedBitwiseCheck.cpp

void SignedBitwiseCheck::check(const MatchFinder::MatchResult &Result) {
   assert(SignedOperand &&
          "No signed operand found in problematic bitwise operations");
 
   bool IsUnary = false;
   SourceLocation Location;
 
   if (const auto *UnaryOp = N.getNodeAs<UnaryOperator>("unary-signed")) {
     IsUnary = true;
-    Location = UnaryOp->getLocStart();
+    Location = UnaryOp->getBeginLoc();
   } else {
     if (const auto *BinaryOp =
             N.getNodeAs<BinaryOperator>("binary-no-sign-interference"))
-      Location = BinaryOp->getLocStart();
+      Location = BinaryOp->getBeginLoc();
     else if (const auto *BinaryOp =
                  N.getNodeAs<BinaryOperator>("binary-sign-interference"))
-      Location = BinaryOp->getLocStart();
+      Location = BinaryOp->getBeginLoc();
     else
       llvm_unreachable("unexpected matcher result");
   }
   diag(Location, "use of a signed integer operand with a "
                  "%select{binary|unary}0 bitwise operator")
       << IsUnary << SignedOperand->getSourceRange();
 }
 
 } // namespace hicpp
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/llvm/TwineLocalCheck.cpp

SourceRange TypeRange =
         VD->getTypeSourceInfo()->getTypeLoc().getSourceRange();
 
     // A real Twine, turn it into a std::string.
     if (VD->getType()->getCanonicalTypeUnqualified() ==
         C->getType()->getCanonicalTypeUnqualified()) {
       SourceLocation EndLoc = Lexer::getLocForEndOfToken(
           VD->getInit()->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
       Diag << FixItHint::CreateReplacement(TypeRange, "std::string")
-           << FixItHint::CreateInsertion(VD->getInit()->getLocStart(), "(")
+           << FixItHint::CreateInsertion(VD->getInit()->getBeginLoc(), "(")
            << FixItHint::CreateInsertion(EndLoc, ").str()");
     } else {
       // Just an implicit conversion. Insert the real type.
       Diag << FixItHint::CreateReplacement(
           TypeRange,
           C->getType().getAsString(Result.Context->getPrintingPolicy()));
     }
   }
 }
 
 } // namespace llvm
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/DefinitionsInHeadersCheck.cpp

 namespace tidy {
 namespace misc {
 
 namespace {
 
 AST_MATCHER_P(NamedDecl, usesHeaderFileExtension,
               utils::HeaderFileExtensionsSet, HeaderFileExtensions) {
   return utils::isExpansionLocInHeaderFile(
-      Node.getLocStart(), Finder->getASTContext().getSourceManager(),
+      Node.getBeginLoc(), Finder->getASTContext().getSourceManager(),
       HeaderFileExtensions);
 }
 
 } // namespace
 
 DefinitionsInHeadersCheck::DefinitionsInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),

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

if((Value != 0 && ~Value != 0) || Sym->getExprLoc().isMacroID())
         return;
 
     SourceLocation Loc = IneffectiveOperator->getOperatorLoc();
 
     BinaryOperatorKind Opcode = IneffectiveOperator->getOpcode();
     if (exprEvaluatesToZero(Opcode, Value)) {
       diag(Loc, "expression always evaluates to 0");
     } else if (exprEvaluatesToBitwiseNegatedZero(Opcode, Value)) {
-      SourceRange ConstExprRange(ConstExpr->getLocStart(),
+      SourceRange ConstExprRange(ConstExpr->getBeginLoc(),
                                  ConstExpr->getLocEnd());
       StringRef ConstExprText = Lexer::getSourceText(
           CharSourceRange::getTokenRange(ConstExprRange), *Result.SourceManager,
           Result.Context->getLangOpts());
 
       diag(Loc, "expression always evaluates to '%0'") << ConstExprText;
 
     } else if (exprEvaluatesToSymbolic(Opcode, Value)) {
-      SourceRange SymExprRange(Sym->getLocStart(), Sym->getLocEnd());
+      SourceRange SymExprRange(Sym->getBeginLoc(), Sym->getLocEnd());
 
       StringRef ExprText = Lexer::getSourceText(
           CharSourceRange::getTokenRange(SymExprRange), *Result.SourceManager,
           Result.Context->getLangOpts());
 
       diag(Loc, "expression always evaluates to '%0'") << ExprText;
     }
   }

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

void StaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = ASTCtx->getSourceManager();
   const auto *CondStmt = Result.Nodes.getNodeAs<Stmt>("condStmt");
   const auto *Condition = Result.Nodes.getNodeAs<Expr>("condition");
   const auto *IsAlwaysFalse = Result.Nodes.getNodeAs<Expr>("isAlwaysFalse");
   const auto *AssertMSG = Result.Nodes.getNodeAs<StringLiteral>("assertMSG");
   const auto *AssertExprRoot =
       Result.Nodes.getNodeAs<BinaryOperator>("assertExprRoot");
   const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("castExpr");
-  SourceLocation AssertExpansionLoc = CondStmt->getLocStart();
+  SourceLocation AssertExpansionLoc = CondStmt->getBeginLoc();
 
   if (!AssertExpansionLoc.isValid() || !AssertExpansionLoc.isMacroID())
     return;
 
   StringRef MacroName =
       Lexer::getImmediateMacroName(AssertExpansionLoc, SM, Opts);
 
   if (MacroName != "assert" || Condition->isValueDependent() ||
if (AssertLoc.isValid() && !AssertLoc.isMacroID() &&
     FixItHints.push_back(
         FixItHint::CreateReplacement(SourceRange(AssertLoc), "static_assert"));
 
     std::string StaticAssertMSG = ", \"\"";
     if (AssertExprRoot) {
       FixItHints.push_back(FixItHint::CreateRemoval(
           SourceRange(AssertExprRoot->getOperatorLoc())));
       FixItHints.push_back(FixItHint::CreateRemoval(
-          SourceRange(AssertMSG->getLocStart(), AssertMSG->getLocEnd())));
+          SourceRange(AssertMSG->getBeginLoc(), AssertMSG->getLocEnd())));
       StaticAssertMSG = (Twine(", \"") + AssertMSG->getString() + "\"").str();
     }
 
     FixItHints.push_back(
         FixItHint::CreateInsertion(LastParenLoc, StaticAssertMSG));
   }
 
   diag(AssertLoc, "found assert() that could be replaced by static_assert()")

clang-tools-extra/trunk/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

if (qualType->isPointerType()) {
     auto *inner = subExpr->IgnoreParenImpCasts();
     if (isa<StringLiteral>(inner))
       return;
     // If it's a variable from a catch statement, we return as well.
     auto *declRef = dyn_cast<DeclRefExpr>(inner);
     if (declRef && isCatchVariable(declRef)) {
       return;
     }
-    diag(subExpr->getLocStart(), "throw expression throws a pointer; it should "
+    diag(subExpr->getBeginLoc(), "throw expression throws a pointer; it should "
                                  "throw a non-pointer value instead");
   }
   // If the throw statement does not throw by pointer then it throws by value
   // which is ok.
   // There are addition checks that emit diagnosis messages if the thrown value
   // is not an RValue. See:
   // https://www.securecoding.cert.org/confluence/display/cplusplus/ERR09-CPP.+Throw+anonymous+temporaries
   // This behavior can be influenced by an option.
else if (constructorCall &&
       if (currentSubExpr->isLValue()) {
         if (auto *tmp = dyn_cast<DeclRefExpr>(currentSubExpr))
           emit = !isFunctionOrCatchVar(tmp);
         else if (isa<CallExpr>(currentSubExpr))
           emit = true;
       }
     }
     if (emit)
-      diag(subExpr->getLocStart(),
+      diag(subExpr->getBeginLoc(),
            "throw expression should throw anonymous temporary values instead");
   }
 }
 
 void ThrowByValueCatchByReferenceCheck::diagnoseCatchLocations(
     const CXXCatchStmt *catchStmt, ASTContext &context) {
   if (!catchStmt)
     return;
   auto caughtType = catchStmt->getCaughtType();
   if (caughtType.isNull())
     return;
   auto *varDecl = catchStmt->getExceptionDecl();
   if (const auto *PT = caughtType.getCanonicalType()->getAs<PointerType>()) {
     const char *diagMsgCatchReference = "catch handler catches a pointer value; "
                                         "should throw a non-pointer value and "
                                         "catch by reference instead";
     // We do not diagnose when catching pointer to strings since we also allow
     // throwing string literals.
     if (!PT->getPointeeType()->isAnyCharacterType())
-      diag(varDecl->getLocStart(), diagMsgCatchReference);
+      diag(varDecl->getBeginLoc(), diagMsgCatchReference);
   } else if (!caughtType->isReferenceType()) {
     const char *diagMsgCatchReference = "catch handler catches by value; "
                                         "should catch by reference instead";
     // If it's not a pointer and not a reference then it must be caught "by
     // value". In this case we should emit a diagnosis message unless the type
     // is trivial.
     if (!caughtType.isTrivialType(context))
-      diag(varDecl->getLocStart(), diagMsgCatchReference);
+      diag(varDecl->getBeginLoc(), diagMsgCatchReference);
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

void UnconventionalAssignOperatorCheck::registerMatchers(
   Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
                          .bind("returnStmt"),
                      this);
 }
 
 void UnconventionalAssignOperatorCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) {
-    diag(RetStmt->getLocStart(), "operator=() should always return '*this'");
+    diag(RetStmt->getBeginLoc(), "operator=() should always return '*this'");
   } else {
     static const char *const Messages[][2] = {
         {"ReturnType", "operator=() should return '%0&'"},
         {"ArgumentType", "operator=() should take '%0 const&', '%0&&' or '%0'"},
         {"cv", "operator=() should not be marked '%1'"}};
 
     const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
     for (const auto &Message : Messages) {
       if (Result.Nodes.getNodeAs<Decl>(Message[0]))
-        diag(Method->getLocStart(), Message[1])
+        diag(Method->getBeginLoc(), Message[1])
             << Method->getParent()->getName()
             << (Method->isConst() ? "const" : "virtual");
     }
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/UnusedAliasDeclsCheck.cpp

void UnusedAliasDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(namespaceAliasDecl(isExpansionInMainFile()).bind("alias"),
                      this);
   Finder->addMatcher(nestedNameSpecifier().bind("nns"), this);
 }
 
 void UnusedAliasDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *AliasDecl = Result.Nodes.getNodeAs<NamedDecl>("alias")) {
     FoundDecls[AliasDecl] = CharSourceRange::getCharRange(
-        AliasDecl->getLocStart(),
+        AliasDecl->getBeginLoc(),
         Lexer::findLocationAfterToken(
             AliasDecl->getLocEnd(), tok::semi, *Result.SourceManager,
             getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     return;
   }
 
   if (const auto *NestedName =

clang-tools-extra/trunk/clang-tidy/misc/UnusedParametersCheck.cpp

Finder->addMatcher(
       this);
 }
 
 template <typename T>
 static CharSourceRange removeNode(const MatchFinder::MatchResult &Result,
                                   const T *PrevNode, const T *Node,
                                   const T *NextNode) {
   if (NextNode)
-    return CharSourceRange::getCharRange(Node->getLocStart(),
-                                         NextNode->getLocStart());
+    return CharSourceRange::getCharRange(Node->getBeginLoc(),
+                                         NextNode->getBeginLoc());
 
   if (PrevNode)
     return CharSourceRange::getTokenRange(
         Lexer::getLocForEndOfToken(PrevNode->getLocEnd(), 0,
                                    *Result.SourceManager,
                                    Result.Context->getLangOpts()),
         Node->getLocEnd());
 

clang-tools-extra/trunk/clang-tidy/misc/UnusedUsingDeclsCheck.cpp

if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     // FIXME: We ignore using-decls defined in function definitions at the
     // moment because of false positives caused by ADL and different function
     // scopes.
     if (isa<FunctionDecl>(Using->getDeclContext()))
       return;
 
     UsingDeclContext Context(Using);
     Context.UsingDeclRange = CharSourceRange::getCharRange(
-        Using->getLocStart(),
+        Using->getBeginLoc(),
         Lexer::findLocationAfterToken(
             Using->getLocEnd(), tok::semi, *Result.SourceManager, getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     for (const auto *UsingShadow : Using->shadows()) {
       const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl();
       if (ShouldCheckDecl(TargetDecl))
         Context.UsingTargetDecls.insert(TargetDecl);
     }

clang-tools-extra/trunk/clang-tidy/modernize/AvoidBindCheck.cpp

for (size_t I = 1, ArgCount = C->getNumArgs(); I < ArgCount; ++I) {
     const Expr *E = C->getArg(I);
     BindArgument B;
     if (const auto *M = dyn_cast<MaterializeTemporaryExpr>(E)) {
       const auto *TE = M->GetTemporaryExpr();
       B.Kind = isa<CallExpr>(TE) ? BK_CallExpr : BK_Temporary;
     }
 
     B.Tokens = Lexer::getSourceText(
-        CharSourceRange::getTokenRange(E->getLocStart(), E->getLocEnd()),
+        CharSourceRange::getTokenRange(E->getBeginLoc(), E->getLocEnd()),
         *Result.SourceManager, Result.Context->getLangOpts());
 
     SmallVector<StringRef, 2> Matches;
     if (B.Kind == BK_Other && MatchPlaceholder.match(B.Tokens, &Matches)) {
       B.Kind = BK_Placeholder;
       B.PlaceHolderIndex = std::stoi(Matches[1]);
     }
     BindArguments.push_back(B);
Finder->addMatcher(
           callee(namedDecl(hasName("::std::bind"))),
           hasArgument(0, declRefExpr(to(functionDecl().bind("f"))).bind("ref")))
           .bind("bind"),
       this);
 }
 
 void AvoidBindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("bind");
-  auto Diag = diag(MatchedDecl->getLocStart(), "prefer a lambda to std::bind");
+  auto Diag = diag(MatchedDecl->getBeginLoc(), "prefer a lambda to std::bind");
 
   const auto Args = buildBindArguments(Result, MatchedDecl);
 
   // Do not attempt to create fixits for nested call expressions.
   // FIXME: Create lambda capture variables to capture output of calls.
   // NOTE: Supporting nested std::bind will be more difficult due to placeholder
   // sharing between outer and inner std:bind invocations.
   if (llvm::any_of(Args,

clang-tools-extra/trunk/clang-tidy/modernize/MakeSmartPtrCheck.cpp

 }
 
 void MakeSmartPtrCheck::checkReset(SourceManager &SM,
                                    const CXXMemberCallExpr *Reset,
                                    const CXXNewExpr *New) {
   const auto *Expr = cast<MemberExpr>(Reset->getCallee());
   SourceLocation OperatorLoc = Expr->getOperatorLoc();
   SourceLocation ResetCallStart = Reset->getExprLoc();
-  SourceLocation ExprStart = Expr->getLocStart();
+  SourceLocation ExprStart = Expr->getBeginLoc();
   SourceLocation ExprEnd =
       Lexer::getLocForEndOfToken(Expr->getLocEnd(), 0, SM, getLangOpts());
 
   bool InMacro = ExprStart.isMacroID();
 
   if (InMacro && IgnoreMacros) {
     return;
   }
if (const auto *NewConstruct = New->getConstructExpr()) {
             NewConstruct->getParenOrBraceRange().getEnd().getLocWithOffset(-1));
       }
     } else {
       // Aggregate initialization.
       //   smart_ptr<Pair>(new Pair{first, second});
       // Has to be replaced with:
       //   smart_ptr<Pair>(Pair{first, second});
       InitRange = SourceRange(
-          New->getAllocatedTypeSourceInfo()->getTypeLoc().getLocStart(),
+          New->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
           New->getInitializer()->getSourceRange().getEnd());
     }
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getCharRange(NewStart, InitRange.getBegin()));
     Diag << FixItHint::CreateRemoval(
         SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd));
     break;
   }

clang-tools-extra/trunk/clang-tidy/modernize/PassByValueCheck.cpp

if (!paramReferredExactlyOnce(Ctor, ParamDecl))
     return;
 
   // If the parameter is trivial to copy, don't move it. Moving a trivivally
   // copyable type will cause a problem with performance-move-const-arg
   if (ParamDecl->getType().getNonReferenceType().isTriviallyCopyableType(
           *Result.Context))
     return;
 
-  auto Diag = diag(ParamDecl->getLocStart(), "pass by value and use std::move");
+  auto Diag = diag(ParamDecl->getBeginLoc(), "pass by value and use std::move");
 
   // Iterate over all declarations of the constructor.
   for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) {
     auto ParamTL = ParmDecl->getTypeSourceInfo()->getTypeLoc();
     auto RefTL = ParamTL.getAs<ReferenceTypeLoc>();
 
     // Do not replace if it is already a value, skip.
     if (RefTL.isNull())
       continue;
 
     TypeLoc ValueTL = RefTL.getPointeeLoc();
-    auto TypeRange = CharSourceRange::getTokenRange(ParmDecl->getLocStart(),
+    auto TypeRange = CharSourceRange::getTokenRange(ParmDecl->getBeginLoc(),
                                                     ParamTL.getLocEnd());
     std::string ValueStr = Lexer::getSourceText(CharSourceRange::getTokenRange(
                                                     ValueTL.getSourceRange()),
                                                 SM, getLangOpts())
                                .str();
     ValueStr += ' ';
     Diag << FixItHint::CreateReplacement(TypeRange, ValueStr);
   }

clang-tools-extra/trunk/clang-tidy/modernize/RawStringLiteralCheck.cpp

if (!getLangOpts().CPlusPlus11)
     return;
 
   Finder->addMatcher(
       stringLiteral(unless(hasParent(predefinedExpr()))).bind("lit"), this);
 }
 
 void RawStringLiteralCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("lit");
-  if (Literal->getLocStart().isMacroID())
+  if (Literal->getBeginLoc().isMacroID())
     return;
 
   if (containsEscapedCharacters(Result, Literal, DisallowedChars)) {
     std::string Replacement = asRawStringLiteral(Literal, DelimiterStem);
     if (ReplaceShorterLiterals ||
         Replacement.length() <=
-            Lexer::MeasureTokenLength(Literal->getLocStart(),
+            Lexer::MeasureTokenLength(Literal->getBeginLoc(),
                                       *Result.SourceManager, getLangOpts()))
       replaceWithRawStringLiteral(Result, Literal, Replacement);
   }
 }
 
 void RawStringLiteralCheck::replaceWithRawStringLiteral(
     const MatchFinder::MatchResult &Result, const StringLiteral *Literal,
     StringRef Replacement) {
   CharSourceRange CharRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Literal->getSourceRange()),
       *Result.SourceManager, getLangOpts());
-  diag(Literal->getLocStart(),
+  diag(Literal->getBeginLoc(),
        "escaped string literal can be written as a raw string literal")
       << FixItHint::CreateReplacement(CharRange, Replacement);
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/RedundantVoidArgCheck.cpp

if (const auto *Function = Nodes.getNodeAs<FunctionDecl>(FunctionId)) {
     processLambdaExpr(Result, Lambda);
   }
 }
 
 void RedundantVoidArgCheck::processFunctionDecl(
     const MatchFinder::MatchResult &Result, const FunctionDecl *Function) {
   if (Function->isThisDeclarationADefinition()) {
     const Stmt *Body = Function->getBody();
-    SourceLocation Start = Function->getLocStart();
+    SourceLocation Start = Function->getBeginLoc();
     SourceLocation End =
-        Body ? Body->getLocStart().getLocWithOffset(-1) : Function->getLocEnd();
+        Body ? Body->getBeginLoc().getLocWithOffset(-1) : Function->getLocEnd();
     removeVoidArgumentTokens(Result, SourceRange(Start, End),
                              "function definition");
   } else {
     removeVoidArgumentTokens(Result, Function->getSourceRange(),
                              "function declaration");
   }
 }
 
if (protoTypeHasNoParms(Member->getType())) {
     removeVoidArgumentTokens(Result, Member->getSourceRange(),
                              "field declaration");
   }
 }
 
 void RedundantVoidArgCheck::processVarDecl(
     const MatchFinder::MatchResult &Result, const VarDecl *Var) {
   if (protoTypeHasNoParms(Var->getType())) {
-    SourceLocation Begin = Var->getLocStart();
+    SourceLocation Begin = Var->getBeginLoc();
     if (Var->hasInit()) {
       SourceLocation InitStart =
-          Result.SourceManager->getExpansionLoc(Var->getInit()->getLocStart())
+          Result.SourceManager->getExpansionLoc(Var->getInit()->getBeginLoc())
               .getLocWithOffset(-1);
       removeVoidArgumentTokens(Result, SourceRange(Begin, InitStart),
                                "variable declaration with initializer");
     } else {
       removeVoidArgumentTokens(Result, Var->getSourceRange(),
                                "variable declaration");
     }
   }

 }
 
 void RedundantVoidArgCheck::processLambdaExpr(
     const MatchFinder::MatchResult &Result, const LambdaExpr *Lambda) {
   if (Lambda->getLambdaClass()->getLambdaCallOperator()->getNumParams() == 0 &&
       Lambda->hasExplicitParameters()) {
     SourceLocation Begin =
         Lambda->getIntroducerRange().getEnd().getLocWithOffset(1);
-    SourceLocation End = Lambda->getBody()->getLocStart().getLocWithOffset(-1);
+    SourceLocation End = Lambda->getBody()->getBeginLoc().getLocWithOffset(-1);
     removeVoidArgumentTokens(Result, SourceRange(Begin, End),
                              "lambda expression");
   }
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp

Options.store(Opts, "IncludeStyle",
                 utils::IncludeSorter::toString(IncludeStyle));
 }
 
 void ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<DeclRefExpr>("name");
   const auto *MatchedArgumentThree = Result.Nodes.getNodeAs<Expr>("randomFunc");
   const auto *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("match");
 
-  if (MatchedCallExpr->getLocStart().isMacroID())
+  if (MatchedCallExpr->getBeginLoc().isMacroID())
     return;
 
   auto Diag = [&] {
     if (MatchedCallExpr->getNumArgs() == 3) {
       auto DiagL =
-          diag(MatchedCallExpr->getLocStart(),
+          diag(MatchedCallExpr->getBeginLoc(),
                "'std::random_shuffle' has been removed in C++17; use "
                "'std::shuffle' and an alternative random mechanism instead");
       DiagL << FixItHint::CreateReplacement(
           MatchedArgumentThree->getSourceRange(),
           "std::mt19937(std::random_device()())");
       return DiagL;
     } else {
-      auto DiagL = diag(MatchedCallExpr->getLocStart(),
+      auto DiagL = diag(MatchedCallExpr->getBeginLoc(),
                         "'std::random_shuffle' has been removed in C++17; use "
                         "'std::shuffle' instead");
       DiagL << FixItHint::CreateInsertion(
           MatchedCallExpr->getRParenLoc(),
           ", std::mt19937(std::random_device()())");
       return DiagL;
     }
   }();
 
   std::string NewName = "shuffle";
   StringRef ContainerText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(MatchedDecl->getSourceRange()),
       *Result.SourceManager, getLangOpts());
   if (ContainerText.startswith("std::"))
     NewName = "std::" + NewName;
 
   Diag << FixItHint::CreateRemoval(MatchedDecl->getSourceRange());
-  Diag << FixItHint::CreateInsertion(MatchedDecl->getLocStart(), NewName);
+  Diag << FixItHint::CreateInsertion(MatchedDecl->getBeginLoc(), NewName);
 
   if (Optional<FixItHint> IncludeFixit =
           IncludeInserter->CreateIncludeInsertion(
               Result.Context->getSourceManager().getFileID(
-                  MatchedCallExpr->getLocStart()),
+                  MatchedCallExpr->getBeginLoc()),
               "random", /*IsAngled=*/true))
     Diag << IncludeFixit.getValue();
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/ShrinkToFitCheck.cpp

 }
 
 void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("CopyAndSwapTrick");
   const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink");
   FixItHint Hint;
 
-  if (!MemberCall->getLocStart().isMacroID()) {
+  if (!MemberCall->getBeginLoc().isMacroID()) {
     const LangOptions &Opts = getLangOpts();
     std::string ReplacementText;
     if (const auto *UnaryOp = llvm::dyn_cast<UnaryOperator>(Container)) {
       ReplacementText =
           Lexer::getSourceText(CharSourceRange::getTokenRange(
                                    UnaryOp->getSubExpr()->getSourceRange()),
                                *Result.SourceManager, Opts);
       ReplacementText += "->shrink_to_fit()";
     } else {
       ReplacementText = Lexer::getSourceText(
           CharSourceRange::getTokenRange(Container->getSourceRange()),
           *Result.SourceManager, Opts);
       ReplacementText += ".shrink_to_fit()";
     }
 
     Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(),
                                         ReplacementText);
   }
 
-  diag(MemberCall->getLocStart(), "the shrink_to_fit method should be used "
+  diag(MemberCall->getBeginLoc(), "the shrink_to_fit method should be used "
                                   "to reduce the capacity of a shrinkable "
                                   "container")
       << Hint;
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/UnaryStaticAssertCheck.cpp

 void UnaryStaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl =
       Result.Nodes.getNodeAs<StaticAssertDecl>("static_assert");
   const StringLiteral *AssertMessage = MatchedDecl->getMessage();
 
   SourceLocation Loc = MatchedDecl->getLocation();
 
   if (!AssertMessage || AssertMessage->getLength() ||
-      AssertMessage->getLocStart().isMacroID() || Loc.isMacroID())
+      AssertMessage->getBeginLoc().isMacroID() || Loc.isMacroID())
     return;
 
   diag(Loc,
        "use unary 'static_assert' when the string literal is an empty string")
       << FixItHint::CreateRemoval(AssertMessage->getSourceRange());
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/UseBoolLiteralsCheck.cpp

void UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast");
   bool LiteralBooleanValue = Literal->getValue().getBoolValue();
 
   if (Literal->isInstantiationDependent())
     return;
 
   const Expr *Expression = Cast ? Cast : Literal;
 
-  bool InMacro = Expression->getLocStart().isMacroID();
+  bool InMacro = Expression->getBeginLoc().isMacroID();
 
   if (InMacro && IgnoreMacros)
     return;
 
   auto Diag =
       diag(Expression->getExprLoc(),
            "converting integer literal to bool, use bool literal instead");
 
   if (!InMacro)
     Diag << FixItHint::CreateReplacement(
         Expression->getSourceRange(), LiteralBooleanValue ? "true" : "false");
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

void UseDefaultMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
   else
     llvm_unreachable("Bad Callback. No node provided.");
 }
 
 void UseDefaultMemberInitCheck::checkDefaultInit(
     const MatchFinder::MatchResult &Result, const CXXCtorInitializer *Init) {
   const FieldDecl *Field = Init->getAnyMember();
 
-  SourceLocation StartLoc = Field->getLocStart();
+  SourceLocation StartLoc = Field->getBeginLoc();
   if (StartLoc.isMacroID() && IgnoreMacros)
     return;
 
   SourceLocation FieldEnd =
       Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
                                  *Result.SourceManager, getLangOpts());
   SourceLocation LParenEnd = Lexer::getLocForEndOfToken(
       Init->getLParenLoc(), 0, *Result.SourceManager, getLangOpts());

clang-tools-extra/trunk/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, SpecialFunctionDecl))
       return;
     SpecialFunctionName = "copy-assignment operator";
   }
 
   // The location of the body is more useful inside a macro as spelling and
   // expansion locations are reported.
   SourceLocation Location = SpecialFunctionDecl->getLocation();
   if (Location.isMacroID())
-    Location = Body->getLocStart();
+    Location = Body->getBeginLoc();
 
   auto Diag = diag(Location, "use '= default' to define a trivial " +
                                  SpecialFunctionName);
 
   if (ApplyFix)
     Diag << FixItHint::CreateReplacement(Body->getSourceRange(), "= default;")
          << RemoveInitializers;
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp

if (!VisitedPreviously) {
       // Reset state as we unwind back up the tree.
       CastFound = false;
       Visited = false;
     }
     return true;
   }
 
   bool VisitStmt(Stmt *S) {
-    if (SM.getFileLoc(S->getLocStart()) != CastLoc)
+    if (SM.getFileLoc(S->getBeginLoc()) != CastLoc)
       return true;
     Visited = true;
 
     const ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(S);
     if (Cast && (Cast->getCastKind() == CK_NullToPointer ||
                  Cast->getCastKind() == CK_NullToMemberPointer))
       CastFound = true;
 
bool VisitStmt(Stmt *S) {
     if (!FirstSubExpr)
       FirstSubExpr = CastSubExpr;
 
     if (C->getCastKind() != CK_NullToPointer &&
         C->getCastKind() != CK_NullToMemberPointer) {
       return true;
     }
 
-    SourceLocation StartLoc = FirstSubExpr->getLocStart();
+    SourceLocation StartLoc = FirstSubExpr->getBeginLoc();
     SourceLocation EndLoc = FirstSubExpr->getLocEnd();
 
     // If the location comes from a macro arg expansion, *all* uses of that
     // arg must be checked to result in NullTo(Member)Pointer casts.
     //
     // If the location comes from a macro body expansion, check to see if its
     // coming from one of the allowed 'NULL' macros.
     if (SM.isMacroArgExpansion(StartLoc) && SM.isMacroArgExpansion(EndLoc)) {
private:
   bool skipSubTree() {
     PruneSubtree = true;
     return true;
   }
 
   /// \brief Tests that all expansions of a macro arg, one of which expands to
   /// result in \p CE, yield NullTo(Member)Pointer casts.
   bool allArgUsesValid(const CastExpr *CE) {
-    SourceLocation CastLoc = CE->getLocStart();
+    SourceLocation CastLoc = CE->getBeginLoc();
 
     // Step 1: Get location of macro arg and location of the macro the arg was
     // provided to.
     SourceLocation ArgLoc, MacroLoc;
     if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc))
       return false;
 
     // Step 2: Find the first ancestor that doesn't expand from this macro.
while (true) {
             return false;
         }
       }
 
       const ast_type_traits::DynTypedNode &Parent = Parents[0];
 
       SourceLocation Loc;
       if (const auto *D = Parent.get<Decl>())
-        Loc = D->getLocStart();
+        Loc = D->getBeginLoc();
       else if (const auto *S = Parent.get<Stmt>())
-        Loc = S->getLocStart();
+        Loc = S->getBeginLoc();
 
       // TypeLoc and NestedNameSpecifierLoc are members of the parent map. Skip
       // them and keep going up.
       if (Loc.isValid()) {
         if (!expandsFrom(Loc, MacroLoc)) {
           Result = Parent;
           return true;
         }

clang-tools-extra/trunk/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

 }
 
 void UseTransparentFunctorsCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *FuncClass =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("FunctorClass");
   if (const auto *FuncInst =
           Result.Nodes.getNodeAs<CXXConstructExpr>("FuncInst")) {
-    diag(FuncInst->getLocStart(), Message)
-          << (FuncClass->getName() + "<>").str();
+    diag(FuncInst->getBeginLoc(), Message)
     return;
   }
 
   const auto *Functor = Result.Nodes.getNodeAs<TemplateArgument>("Functor");
   const auto FunctorParentLoc =
       Result.Nodes.getNodeAs<TypeLoc>("FunctorParentLoc")
           ->getAs<TemplateSpecializationTypeLoc>();
 

clang-tools-extra/trunk/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

 
 void UseUncaughtExceptionsCheck::check(const MatchFinder::MatchResult &Result) {
   SourceLocation BeginLoc;
   SourceLocation EndLoc;
   const CallExpr *C = Result.Nodes.getNodeAs<CallExpr>("init_call_expr");
   bool WarnOnly = false;
 
   if (C) {
-    BeginLoc = C->getLocStart();
+    BeginLoc = C->getBeginLoc();
     EndLoc = C->getLocEnd();
   } else if (const auto *E = Result.Nodes.getNodeAs<CallExpr>("call_expr")) {
-    BeginLoc = E->getLocStart();
+    BeginLoc = E->getBeginLoc();
     EndLoc = E->getLocEnd();
   } else if (const auto *D =
                  Result.Nodes.getNodeAs<DeclRefExpr>("decl_ref_expr")) {
-    BeginLoc = D->getLocStart();
+    BeginLoc = D->getBeginLoc();
     EndLoc = D->getLocEnd();
     WarnOnly = true;
   } else {
     const auto *U = Result.Nodes.getNodeAs<UsingDecl>("using_decl");
     assert(U && "Null pointer, no node provided");
     BeginLoc = U->getNameInfo().getBeginLoc();
     EndLoc = U->getNameInfo().getEndLoc();
   }

clang-tools-extra/trunk/clang-tidy/modernize/UseUsingCheck.cpp

 void UseUsingCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<TypedefDecl>("typedef");
   if (MatchedDecl->getLocation().isInvalid())
     return;
 
   auto &Context = *Result.Context;
   auto &SM = *Result.SourceManager;
 
-  SourceLocation StartLoc = MatchedDecl->getLocStart();
+  SourceLocation StartLoc = MatchedDecl->getBeginLoc();
 
   if (StartLoc.isMacroID() && IgnoreMacros)
     return;
 
   auto Diag =
       diag(StartLoc, "use 'using' instead of 'typedef'");
 
   // do not fix if there is macro or array

clang-tools-extra/trunk/clang-tidy/objc/AvoidNSErrorInitCheck.cpp

Finder->addMatcher(objcMessageExpr(hasSelector("init"),
                                      hasReceiverType(asString("NSError *")))
                          .bind("nserrorInit"),
                      this);
 }
 
 void AvoidNSErrorInitCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedExpr =
       Result.Nodes.getNodeAs<ObjCMessageExpr>("nserrorInit");
-  diag(MatchedExpr->getLocStart(),
+  diag(MatchedExpr->getBeginLoc(),
        "use errorWithDomain:code:userInfo: or initWithDomain:code:userInfo: to "
        "create a new NSError");
 }
 
 }  // namespace objc
 }  // namespace tidy
 }  // namespace clang

clang-tools-extra/trunk/clang-tidy/objc/AvoidSpinlockCheck.cpp

Finder->addMatcher(
       callExpr(callee((functionDecl(hasAnyName(
                    "OSSpinlockLock", "OSSpinlockUnlock", "OSSpinlockTry")))))
           .bind("spinlock"),
       this);
 }
 
 void AvoidSpinlockCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock");
-  diag(MatchedExpr->getLocStart(),
+  diag(MatchedExpr->getBeginLoc(),
        "use os_unfair_lock_lock() or dispatch queue APIs instead of the "
        "deprecated OSSpinLock");
 }
 
 }  // namespace objc
 }  // namespace tidy
 }  // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/FasterStringFindCheck.cpp

 void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
   const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   auto Replacement = MakeCharacterLiteral(Literal);
   if (!Replacement)
     return;
 
-  diag(Literal->getLocStart(), "%0 called with a string literal consisting of "
+  diag(Literal->getBeginLoc(), "%0 called with a string literal consisting of "
                                "a single character; consider using the more "
                                "effective overload accepting a character")
-      << FindFunc << FixItHint::CreateReplacement(
-                         CharSourceRange::getTokenRange(Literal->getLocStart(),
-                                                        Literal->getLocEnd()),
-                         *Replacement);
+      << FindFunc
+      << FixItHint::CreateReplacement(
+             CharSourceRange::getTokenRange(Literal->getBeginLoc(),
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/ForRangeCopyCheck.cpp

void ForRangeCopyCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar")))
                          .bind("forRange"),
                      this);
 }
 
 void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar");
   // Ignore code in macros since we can't place the fixes correctly.
-  if (Var->getLocStart().isMacroID())
+  if (Var->getBeginLoc().isMacroID())
     return;
   if (handleConstValueCopy(*Var, *Result.Context))
     return;
   const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange");
   handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context);
 }
 
 bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar,

clang-tools-extra/trunk/clang-tidy/performance/ImplicitConversionInLoopCheck.cpp

void ImplicitConversionInLoopCheck::ReportAndFix(
   QualType ConstType = OperatorCall->getType().withConst();
   QualType ConstRefType = Context->getLValueReferenceType(ConstType);
   const char Message[] =
       "the type of the loop variable %0 is different from the one returned "
       "by the iterator and generates an implicit conversion; you can either "
       "change the type to the matching one (%1 but 'const auto&' is always a "
       "valid option) or remove the reference to make it explicit that you are "
       "creating a new value";
-  diag(VD->getLocStart(), Message) << VD << ConstRefType;
+  diag(VD->getBeginLoc(), Message) << VD << ConstRefType;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/InefficientAlgorithmCheck.cpp

const QualType AlgCmp =
         Arg->getType().getUnqualifiedType().getCanonicalType();
     const unsigned CmpPosition =
         (IneffContName.find("map") == llvm::StringRef::npos) ? 1 : 2;
     const QualType ContainerCmp = IneffCont->getTemplateArgs()[CmpPosition]
                                       .getAsType()
                                       .getUnqualifiedType()
                                       .getCanonicalType();
     if (AlgCmp != ContainerCmp) {
-      diag(Arg->getLocStart(),
+      diag(Arg->getBeginLoc(),
            "different comparers used in the algorithm and the container");
       return;
     }
   }
 
   const auto *AlgDecl = AlgCall->getDirectCallee();
   if (!AlgDecl)
     return;
StringRef ParamText = Lexer::getSourceText(
         LangOpts);
     std::string ReplacementText =
         (llvm::Twine(ContainerText) + (PtrToContainer ? "->" : ".") +
          AlgDecl->getName() + "(" + ParamText + ")")
             .str();
     Hint = FixItHint::CreateReplacement(CallRange, ReplacementText);
   }
 
-  diag(AlgCall->getLocStart(),
+  diag(AlgCall->getBeginLoc(),
        "this STL algorithm call should be replaced with a container method")
       << Hint;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/InefficientVectorOperationCheck.cpp

for (const auto *Ref : AllVectorVarRefs) {
     // Skip cases where there are usages (defined as DeclRefExpr that refers to
     // "v") of vector variable `v` before the for loop. We consider these usages
     // are operations causing memory preallocation (e.g. "v.resize(n)",
     // "v.reserve(n)").
     //
     // FIXME: make it more intelligent to identify the pre-allocating operations
     // before the for loop.
     if (SM.isBeforeInTranslationUnit(Ref->getLocation(),
-                                     LoopStmt->getLocStart())) {
+                                     LoopStmt->getBeginLoc())) {
       return;
     }
   }
 
   llvm::StringRef VectorVarName = Lexer::getSourceText(
       CharSourceRange::getTokenRange(
           VectorAppendCall->getImplicitObjectArgument()->getSourceRange()),
       SM, Context->getLangOpts());
if (RangeLoop) {
     // Handle counter-based loop cases.
     StringRef LoopEndSource = Lexer::getSourceText(
         CharSourceRange::getTokenRange(LoopEndExpr->getSourceRange()), SM,
         Context->getLangOpts());
     ReserveStmt = (VectorVarName + ".reserve(" + LoopEndSource + ");\n").str();
   }
 
   auto Diag =
-      diag(VectorAppendCall->getLocStart(),
+      diag(VectorAppendCall->getBeginLoc(),
            "%0 is called inside a loop; "
            "consider pre-allocating the vector capacity before the loop")
       << VectorAppendCall->getMethodDecl()->getDeclName();
 
   if (!ReserveStmt.empty())
-    Diag << FixItHint::CreateInsertion(LoopStmt->getLocStart(), ReserveStmt);
+    Diag << FixItHint::CreateInsertion(LoopStmt->getBeginLoc(), ReserveStmt);
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/MoveConstArgCheck.cpp

 namespace performance {
 
 static void ReplaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
                                const SourceManager &SM,
                                const LangOptions &LangOpts) {
   const Expr *Arg = Call->getArg(0);
 
   CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange(
-      CharSourceRange::getCharRange(Call->getLocStart(), Arg->getLocStart()),
+      CharSourceRange::getCharRange(Call->getBeginLoc(), Arg->getBeginLoc()),
       SM, LangOpts);
   CharSourceRange AfterArgumentsRange = Lexer::makeFileCharRange(
       CharSourceRange::getCharRange(Call->getLocEnd(),
                                     Call->getLocEnd().getLocWithOffset(1)),
       SM, LangOpts);
 
   if (BeforeArgumentsRange.isValid() && AfterArgumentsRange.isValid()) {
     Diag << FixItHint::CreateRemoval(BeforeArgumentsRange)

clang-tools-extra/trunk/clang-tidy/performance/TypePromotionInMathFnCheck.cpp

auto Diag = diag(Call->getExprLoc(), "call to '%0' promotes float to double")
                      Call->getCallee()->getSourceRange(), NewFnName);
 
   // Suggest including <cmath> if the function we're suggesting is declared in
   // <cmath> and it's not already included.  We never have to suggest including
   // <math.h>, because the functions we're suggesting moving away from are all
   // declared in <math.h>.
   if (FnInCmath)
     if (auto IncludeFixit = IncludeInserter->CreateIncludeInsertion(
-            Result.Context->getSourceManager().getFileID(Call->getLocStart()),
+            Result.Context->getSourceManager().getFileID(Call->getBeginLoc()),
             "cmath", /*IsAngled=*/true))
       Diag << *IncludeFixit;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

auto Diag =
       << paramNameOrIndex(Param->getName(), Index);
   // Do not propose fixes when:
   // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
   // 2. the function is virtual as it might break overrides
   // 3. the function is referenced outside of a call expression within the
   //    compilation unit as the signature change could introduce build errors.
   // 4. the function is an explicit template specialization.
   const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
-  if (Param->getLocStart().isMacroID() || (Method && Method->isVirtual()) ||
+  if (Param->getBeginLoc().isMacroID() || (Method && Method->isVirtual()) ||
       isReferencedOutsideOfCallExpr(*Function, *Result.Context) ||
       isExplicitTemplateSpecialization(*Function))
     return;
   for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
        FunctionDecl = FunctionDecl->getPreviousDecl()) {
     const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
     Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
                                                    *Result.Context);
void UnnecessaryValueParamCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IncludeStyle",
                 utils::IncludeSorter::toString(IncludeStyle));
 }
 
 void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
                                                const DeclRefExpr &CopyArgument,
                                                const ASTContext &Context) {
-  auto Diag = diag(CopyArgument.getLocStart(),
+  auto Diag = diag(CopyArgument.getBeginLoc(),
                    "parameter %0 is passed by value and only copied once; "
                    "consider moving it to avoid unnecessary copies")
               << &Var;
   // Do not propose fixes in macros since we cannot place them correctly.
-  if (CopyArgument.getLocStart().isMacroID())
+  if (CopyArgument.getBeginLoc().isMacroID())
     return;
   const auto &SM = Context.getSourceManager();
   auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
                                            Context.getLangOpts());
-  Diag << FixItHint::CreateInsertion(CopyArgument.getLocStart(), "std::move(")
+  Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(")
        << FixItHint::CreateInsertion(EndLoc, ")");
   if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
-          SM.getFileID(CopyArgument.getLocStart()), "utility",
+          SM.getFileID(CopyArgument.getBeginLoc()), "utility",
           /*IsAngled=*/true))
     Diag << *IncludeFixit;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/AvoidConstParamsInDecls.cpp

 
 namespace clang {
 namespace tidy {
 namespace readability {
 namespace {
 
 SourceRange getTypeRange(const ParmVarDecl &Param) {
   if (Param.getIdentifier() != nullptr)
-    return SourceRange(Param.getLocStart(),
+    return SourceRange(Param.getBeginLoc(),
                        Param.getLocEnd().getLocWithOffset(-1));
   return Param.getSourceRange();
 }
 
 } // namespace
 
 void AvoidConstParamsInDecls::registerMatchers(MatchFinder *Finder) {
   const auto ConstParamDecl =

 
 void AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) {
   const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
   const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
 
   if (!Param->getType().isLocalConstQualified())
     return;
 
-  auto Diag = diag(Param->getLocStart(),
+  auto Diag = diag(Param->getBeginLoc(),
                    "parameter %0 is const-qualified in the function "
                    "declaration; const-qualification of parameters only has an "
                    "effect in function definitions");
   if (Param->getName().empty()) {
     for (unsigned int i = 0; i < Func->getNumParams(); ++i) {
       if (Param == Func->getParamDecl(i)) {
         Diag << (i + 1);
         break;
       }
     }
   } else {
     Diag << Param;
   }
 
-  if (Param->getLocStart().isMacroID() != Param->getLocEnd().isMacroID()) {
+  if (Param->getBeginLoc().isMacroID() != Param->getLocEnd().isMacroID()) {
     // Do not offer a suggestion if the part of the variable declaration comes
     // from a macro.
     return;
   }
 
   CharSourceRange FileRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(getTypeRange(*Param)),
       *Result.SourceManager, getLangOpts());

clang-tools-extra/trunk/clang-tidy/readability/BracesAroundStatementsCheck.cpp

 
 /// Find location of right parenthesis closing condition.
 template <typename IfOrWhileStmt>
 SourceLocation
 BracesAroundStatementsCheck::findRParenLoc(const IfOrWhileStmt *S,
                                            const SourceManager &SM,
                                            const ASTContext *Context) {
   // Skip macros.
-  if (S->getLocStart().isMacroID())
+  if (S->getBeginLoc().isMacroID())
     return SourceLocation();
 
   SourceLocation CondEndLoc = S->getCond()->getLocEnd();
   if (const DeclStmt *CondVar = S->getConditionVariableDeclStmt())
     CondEndLoc = CondVar->getLocEnd();
 
   if (!CondEndLoc.isValid()) {
     return SourceLocation();
CharSourceRange FileRange = Lexer::makeFileCharRange(
       Context->getLangOpts());
   if (FileRange.isInvalid())
     return false;
 
   // Convert InitialLoc to file location, if it's on the same macro expansion
   // level as the start of the statement. We also need file locations for
   // Lexer::getLocForEndOfToken working properly.
   InitialLoc = Lexer::makeFileCharRange(
-                   CharSourceRange::getCharRange(InitialLoc, S->getLocStart()),
+                   CharSourceRange::getCharRange(InitialLoc, S->getBeginLoc()),
                    SM, Context->getLangOpts())
                    .getBegin();
   if (InitialLoc.isInvalid())
     return false;
   SourceLocation StartLoc =
       Lexer::getLocForEndOfToken(InitialLoc, 0, SM, Context->getLangOpts());
 
   // StartLoc points at the location of the opening brace to be inserted.

clang-tools-extra/trunk/clang-tidy/readability/ContainerSizeEmptyCheck.cpp

if (const auto *UnaryOp =
       Hint = FixItHint::CreateReplacement(UnaryOp->getSourceRange(),
                                           ReplacementText);
     else
       Hint = FixItHint::CreateReplacement(MemberCall->getSourceRange(),
                                           "!" + ReplacementText);
   }
 
   if (MemberCall) {
-    diag(MemberCall->getLocStart(),
+    diag(MemberCall->getBeginLoc(),
          "the 'empty' method should be used to check "
          "for emptiness instead of 'size'")
         << Hint;
   } else {
-    diag(BinCmp->getLocStart(),
+    diag(BinCmp->getBeginLoc(),
          "the 'empty' method should be used to check "
          "for emptiness instead of comparing to an empty object")
         << Hint;
   }
 
   const auto *Container = Result.Nodes.getNodeAs<NamedDecl>("container");
   const auto *Empty = Result.Nodes.getNodeAs<FunctionDecl>("empty");
 
   diag(Empty->getLocation(), "method %0::empty() defined here",
        DiagnosticIDs::Note)
       << Container;
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/DeleteNullPointerCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void DeleteNullPointerCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete");
   const auto *Compound = Result.Nodes.getNodeAs<CompoundStmt>("compound");
 
   auto Diag = diag(
-      IfWithDelete->getLocStart(),
+      IfWithDelete->getBeginLoc(),
       "'if' statement is unnecessary; deleting null pointer has no effect");
   if (IfWithDelete->getElse())
     return;
   // FIXME: generate fixit for this case.
 
   Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
-      IfWithDelete->getLocStart(),
+      IfWithDelete->getBeginLoc(),
       Lexer::getLocForEndOfToken(IfWithDelete->getCond()->getLocEnd(), 0,
                                  *Result.SourceManager,
                                  Result.Context->getLangOpts())));
   if (Compound) {
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getTokenRange(Compound->getLBracLoc()));
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getTokenRange(Compound->getRBracLoc()));
   }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/DeletedDefaultCheck.cpp

 }
 
 void DeletedDefaultCheck::check(const MatchFinder::MatchResult &Result) {
   const StringRef Message = "%0 is explicitly defaulted but implicitly "
                             "deleted, probably because %1; definition can "
                             "either be removed or explicitly deleted";
   if (const auto *Constructor =
           Result.Nodes.getNodeAs<CXXConstructorDecl>("constructor")) {
-    auto Diag = diag(Constructor->getLocStart(), Message);
+    auto Diag = diag(Constructor->getBeginLoc(), Message);
     if (Constructor->isDefaultConstructor()) {
       Diag << "default constructor"
            << "a non-static data member or a base class is lacking a default "
               "constructor";
     } else if (Constructor->isCopyConstructor()) {
       Diag << "copy constructor"
            << "a non-static data member or a base class is not copyable";
     } else if (Constructor->isMoveConstructor()) {
       Diag << "move constructor"
            << "a non-static data member or a base class is neither copyable "
               "nor movable";
     }
   } else if (const auto *Assignment =
                  Result.Nodes.getNodeAs<CXXMethodDecl>("method-decl")) {
-    diag(Assignment->getLocStart(), Message)
+    diag(Assignment->getBeginLoc(), Message)
         << (Assignment->isCopyAssignmentOperator() ? "copy assignment operator"
                                                    : "move assignment operator")
         << "a base class or a non-static data member is not assignable, e.g. "
            "because the latter is marked 'const'";
   }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/FunctionSizeCheck.cpp

bool TraverseStmt(Stmt *Node) {
     return true;
   }
 
   bool TraverseCompoundStmt(CompoundStmt *Node) {
     // If this new compound statement is located in a compound statement, which
     // is already nested NestingThreshold levels deep, record the start location
     // of this new compound statement.
     if (CurrentNestingLevel == Info.NestingThreshold)
-      Info.NestingThresholders.push_back(Node->getLocStart());
+      Info.NestingThresholders.push_back(Node->getBeginLoc());
 
     ++CurrentNestingLevel;
     Base::TraverseCompoundStmt(Node);
     --CurrentNestingLevel;
 
     return true;
   }
 
void FunctionSizeCheck::check(const MatchFinder::MatchResult &Result) {
   auto &FI = Visitor.Info;
 
   if (FI.Statements == 0)
     return;
 
   // Count the lines including whitespace and comments. Really simple.
   if (const Stmt *Body = Func->getBody()) {
     SourceManager *SM = Result.SourceManager;
-    if (SM->isWrittenInSameFile(Body->getLocStart(), Body->getLocEnd())) {
+    if (SM->isWrittenInSameFile(Body->getBeginLoc(), Body->getLocEnd())) {
       FI.Lines = SM->getSpellingLineNumber(Body->getLocEnd()) -
-                 SM->getSpellingLineNumber(Body->getLocStart());
+                 SM->getSpellingLineNumber(Body->getBeginLoc());
     }
   }
 
   unsigned ActualNumberParameters = Func->getNumParams();
 
   if (FI.Lines > LineThreshold || FI.Statements > StatementThreshold ||
       FI.Branches > BranchThreshold ||
       ActualNumberParameters > ParameterThreshold ||

clang-tools-extra/trunk/clang-tidy/readability/IdentifierNamingCheck.cpp

if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
 
     std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
     std::replace(KindName.begin(), KindName.end(), '_', ' ');
 
     std::string Fixup = fixupWithStyle(Name, Style);
     if (StringRef(Fixup).equals(Name)) {
       if (!IgnoreFailedSplit) {
         LLVM_DEBUG(llvm::dbgs()
-                   << Decl->getLocStart().printToString(*Result.SourceManager)
+                   << Decl->getBeginLoc().printToString(*Result.SourceManager)
                    << llvm::format(": unable to split words for %s '%s'\n",
                                    KindName.c_str(), Name.str().c_str()));
       }
     } else {
       NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
           Decl->getLocation(), Decl->getNameAsString())];
       SourceRange Range =
           DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())

clang-tools-extra/trunk/clang-tidy/readability/ImplicitBoolConversionCheck.cpp

 namespace clang {
 namespace tidy {
 namespace readability {
 
 namespace {
 
 AST_MATCHER(Stmt, isMacroExpansion) {
   SourceManager &SM = Finder->getASTContext().getSourceManager();
-  SourceLocation Loc = Node.getLocStart();
+  SourceLocation Loc = Node.getBeginLoc();
   return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
 }
 
 bool isNULLMacroExpansion(const Stmt *Statement, ASTContext &Context) {
   SourceManager &SM = Context.getSourceManager();
   const LangOptions &LO = Context.getLangOpts();
-  SourceLocation Loc = Statement->getLocStart();
+  SourceLocation Loc = Statement->getBeginLoc();
   return SM.isMacroBodyExpansion(Loc) &&
          Lexer::getImmediateMacroName(Loc, SM, LO) == "NULL";
 }
 
 AST_MATCHER(Stmt, isNULLMacroExpansion) {
   return isNULLMacroExpansion(&Node, Finder->getASTContext());
 }
 

 void fixGenericExprCastToBool(DiagnosticBuilder &Diag,
                               const ImplicitCastExpr *Cast, const Stmt *Parent,
                               ASTContext &Context) {
   // In case of expressions like (! integer), we should remove the redundant not
   // operator and use inverted comparison (integer == 0).
   bool InvertComparison =
       Parent != nullptr && isUnaryLogicalNotOperator(Parent);
   if (InvertComparison) {
-    SourceLocation ParentStartLoc = Parent->getLocStart();
+    SourceLocation ParentStartLoc = Parent->getBeginLoc();
     SourceLocation ParentEndLoc =
-        cast<UnaryOperator>(Parent)->getSubExpr()->getLocStart();
+        cast<UnaryOperator>(Parent)->getSubExpr()->getBeginLoc();
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getCharRange(ParentStartLoc, ParentEndLoc));
 
     Parent = Context.getParents(*Parent)[0].get<Stmt>();
   }
 
   const Expr *SubExpr = Cast->getSubExpr();
 
   bool NeedInnerParens = areParensNeededForStatement(SubExpr);
   bool NeedOuterParens =
       Parent != nullptr && areParensNeededForStatement(Parent);
 
   std::string StartLocInsertion;
 
   if (NeedOuterParens) {
     StartLocInsertion += "(";
   }
   if (NeedInnerParens) {
     StartLocInsertion += "(";
   }
 
   if (!StartLocInsertion.empty()) {
-    Diag << FixItHint::CreateInsertion(Cast->getLocStart(), StartLocInsertion);
+    Diag << FixItHint::CreateInsertion(Cast->getBeginLoc(), StartLocInsertion);
   }
 
   std::string EndLocInsertion;
 
   if (NeedInnerParens) {
     EndLocInsertion += ")";
   }
 

 
 void fixGenericExprCastFromBool(DiagnosticBuilder &Diag,
                                 const ImplicitCastExpr *Cast,
                                 ASTContext &Context, StringRef OtherType) {
   const Expr *SubExpr = Cast->getSubExpr();
   bool NeedParens = !isa<ParenExpr>(SubExpr);
 
   Diag << FixItHint::CreateInsertion(
-      Cast->getLocStart(),
+      Cast->getBeginLoc(),
       (Twine("static_cast<") + OtherType + ">" + (NeedParens ? "(" : ""))
           .str());
 
   if (NeedParens) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         Cast->getLocEnd(), 0, Context.getSourceManager(),
         Context.getLangOpts());
 
if (AllowPointerConditions &&
     return;
   }
 
   if (AllowIntegerConditions && Cast->getCastKind() == CK_IntegralToBoolean &&
       isCastAllowedInCondition(Cast, Context)) {
     return;
   }
 
-  auto Diag = diag(Cast->getLocStart(), "implicit conversion %0 -> bool")
+  auto Diag = diag(Cast->getBeginLoc(), "implicit conversion %0 -> bool")
               << Cast->getSubExpr()->getType();
 
   StringRef EquivalentLiteral =
       getEquivalentBoolLiteralForExpr(Cast->getSubExpr(), Context);
   if (!EquivalentLiteral.empty()) {
     Diag << tooling::fixit::createReplacement(*Cast, EquivalentLiteral);
   } else {
     fixGenericExprCastToBool(Diag, Cast, Parent, Context);
   }
 }
 
 void ImplicitBoolConversionCheck::handleCastFromBool(
     const ImplicitCastExpr *Cast, const ImplicitCastExpr *NextImplicitCast,
     ASTContext &Context) {
   QualType DestType =
       NextImplicitCast ? NextImplicitCast->getType() : Cast->getType();
-  auto Diag = diag(Cast->getLocStart(), "implicit conversion bool -> %0")
+  auto Diag = diag(Cast->getBeginLoc(), "implicit conversion bool -> %0")
               << DestType;
 
   if (const auto *BoolLiteral =
           dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) {
     Diag << tooling::fixit::createReplacement(
         *Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context));
   } else {
     fixGenericExprCastFromBool(Diag, Cast, Context, DestType.getAsString());
   }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

InconsistentDeclarationsContainer InconsistentDeclarations =
                                    ParameterSourceDeclaration,
                                    *Result.SourceManager, Strict);
   if (InconsistentDeclarations.empty()) {
     // Avoid unnecessary further visits.
     markRedeclarationsAsVisited(OriginalDeclaration);
     return;
   }
 
-  SourceLocation StartLoc = OriginalDeclaration->getLocStart();
+  SourceLocation StartLoc = OriginalDeclaration->getBeginLoc();
   if (StartLoc.isMacroID() && IgnoreMacros) {
     markRedeclarationsAsVisited(OriginalDeclaration);
     return;
   }
 
   if (OriginalDeclaration->getTemplatedKind() ==
       FunctionDecl::TK_FunctionTemplateSpecialization) {
     formatDiagnostics(this, ParameterSourceDeclaration, OriginalDeclaration,

clang-tools-extra/trunk/clang-tidy/readability/MisleadingIndentationCheck.cpp

if (const auto *CurrentIf = dyn_cast<IfStmt>(CurrentStmt)) {
       Inner = CurrentWhile->getBody();
     } else {
       continue;
     }
 
     if (isa<CompoundStmt>(Inner))
       continue;
 
-    SourceLocation InnerLoc = Inner->getLocStart();
-    SourceLocation OuterLoc = CurrentStmt->getLocStart();
+    SourceLocation InnerLoc = Inner->getBeginLoc();
+    SourceLocation OuterLoc = CurrentStmt->getBeginLoc();
 
     if (SM.getExpansionLineNumber(InnerLoc) ==
         SM.getExpansionLineNumber(OuterLoc))
       continue;
 
     const Stmt *NextStmt = CStmt->body_begin()[i + 1];
-    SourceLocation NextLoc = NextStmt->getLocStart();
+    SourceLocation NextLoc = NextStmt->getBeginLoc();
 
     if (InnerLoc.isMacroID() || OuterLoc.isMacroID() || NextLoc.isMacroID())
       continue;
 
     if (SM.getExpansionColumnNumber(InnerLoc) ==
         SM.getExpansionColumnNumber(NextLoc)) {
       diag(NextLoc, "misleading indentation: statement is indented too deeply");
       diag(OuterLoc, "did you mean this line to be inside this '%0'",

clang-tools-extra/trunk/clang-tidy/readability/MisplacedArrayIndexCheck.cpp

Finder->addMatcher(arraySubscriptExpr(hasLHS(hasType(isInteger())),
                          .bind("expr"),
                      this);
 }
 
 void MisplacedArrayIndexCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ArraySubscriptE =
       Result.Nodes.getNodeAs<ArraySubscriptExpr>("expr");
 
-  auto Diag = diag(ArraySubscriptE->getLocStart(), "confusing array subscript "
+  auto Diag = diag(ArraySubscriptE->getBeginLoc(), "confusing array subscript "
                                                    "expression, usually the "
                                                    "index is inside the []");
 
   // Only try to fixit when LHS and RHS can be swapped directly without changing
   // the logic.
   const Expr *RHSE = ArraySubscriptE->getRHS()->IgnoreParenImpCasts();
   if (!isa<StringLiteral>(RHSE) && !isa<DeclRefExpr>(RHSE) &&
       !isa<MemberExpr>(RHSE))

clang-tools-extra/trunk/clang-tidy/readability/NamedParameterCheck.cpp

for (unsigned I = 0, E = Function->getNumParams(); I != E; ++I) {
     // Don't warn on the dummy argument on post-inc and post-dec operators.
     if ((Function->getOverloadedOperator() == OO_PlusPlus ||
          Function->getOverloadedOperator() == OO_MinusMinus) &&
         Parm->getType()->isSpecificBuiltinType(BuiltinType::Int))
       continue;
 
     // Sanity check the source locations.
     if (!Parm->getLocation().isValid() || Parm->getLocation().isMacroID() ||
-        !SM.isWrittenInSameFile(Parm->getLocStart(), Parm->getLocation()))
+        !SM.isWrittenInSameFile(Parm->getBeginLoc(), Parm->getLocation()))
       continue;
 
     // Skip gmock testing::Unused parameters.
     if (auto Typedef = Parm->getType()->getAs<clang::TypedefType>())
       if (Typedef->getDecl()->getQualifiedNameAsString() == "testing::Unused")
         continue;
 
     // Skip std::nullptr_t.
     if (Parm->getType().getCanonicalType()->isNullPtrType())
       continue;
 
     // Look for comments. We explicitly want to allow idioms like
     // void foo(int /*unused*/)
-    const char *Begin = SM.getCharacterData(Parm->getLocStart());
+    const char *Begin = SM.getCharacterData(Parm->getBeginLoc());
     const char *End = SM.getCharacterData(Parm->getLocation());
     StringRef Data(Begin, End - Begin);
     if (Data.find("/*") != StringRef::npos)
       continue;
 
     UnnamedParams.push_back(std::make_pair(Function, I));
   }
 

clang-tools-extra/trunk/clang-tidy/readability/NamespaceCommentCheck.cpp

if (InsertLineBreak)
     Fix.append("\n");
   return Fix;
 }
 
 void NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ND = Result.Nodes.getNodeAs<NamespaceDecl>("namespace");
   const SourceManager &Sources = *Result.SourceManager;
 
-  if (!locationsInSameFile(Sources, ND->getLocStart(), ND->getRBraceLoc()))
+  if (!locationsInSameFile(Sources, ND->getBeginLoc(), ND->getRBraceLoc()))
     return;
 
   // Don't require closing comments for namespaces spanning less than certain
   // number of lines.
-  unsigned StartLine = Sources.getSpellingLineNumber(ND->getLocStart());
+  unsigned StartLine = Sources.getSpellingLineNumber(ND->getBeginLoc());
   unsigned EndLine = Sources.getSpellingLineNumber(ND->getRBraceLoc());
   if (EndLine - StartLine + 1 <= ShortNamespaceLines)
     return;
 
   // Find next token after the namespace closing brace.
   SourceLocation AfterRBrace = ND->getRBraceLoc().getLocWithOffset(1);
   SourceLocation Loc = AfterRBrace;
   Token Tok;

clang-tools-extra/trunk/clang-tidy/readability/NonConstParameterCheck.cpp

for (const auto &It : Parameters) {
     SmallVector<FixItHint, 8> Fixes;
     auto *Function =
         dyn_cast_or_null<const FunctionDecl>(Par->getParentFunctionOrMethod());
     if (!Function)
       continue;
     unsigned Index = Par->getFunctionScopeIndex();
     for (FunctionDecl *FnDecl : Function->redecls())
       Fixes.push_back(FixItHint::CreateInsertion(
-          FnDecl->getParamDecl(Index)->getLocStart(), "const "));
+          FnDecl->getParamDecl(Index)->getBeginLoc(), "const "));
 
     diag(Par->getLocation(), "pointer parameter '%0' can be pointer to const")
         << Par->getName() << Fixes;
   }
 }
 
 void NonConstParameterCheck::markCanNotBeConst(const Expr *E,
                                                bool CanNotBeConst) {

clang-tools-extra/trunk/clang-tidy/readability/RedundantDeclarationCheck.cpp

void RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
   const bool DifferentHeaders =
       !SM.isInMainFile(D->getLocation()) &&
       !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation());
 
   bool MultiVar = false;
   if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // Is this a multivariable declaration?
     for (const auto Other : VD->getDeclContext()->decls()) {
-      if (Other != D && Other->getLocStart() == VD->getLocStart()) {
+      if (Other != D && Other->getBeginLoc() == VD->getBeginLoc()) {
         MultiVar = true;
         break;
       }
     }
   }
 
   SourceLocation EndLoc = Lexer::getLocForEndOfToken(
       D->getSourceRange().getEnd(), 0, SM, Result.Context->getLangOpts());

clang-tools-extra/trunk/clang-tidy/readability/RedundantSmartptrGetCheck.cpp

if (IsPtrToPtr && IsMemberExpr) {
     return;
   }
 
   StringRef SmartptrText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(Smartptr->getSourceRange()),
       *Result.SourceManager, getLangOpts());
   // Replace foo->get() with *foo, and foo.get() with foo.
   std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str();
-  diag(GetCall->getLocStart(), "redundant get() call on smart pointer")
+  diag(GetCall->getBeginLoc(), "redundant get() call on smart pointer")
       << FixItHint::CreateReplacement(GetCall->getSourceRange(), Replacement);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringCStrCheck.cpp

void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
   bool Arrow = Member->isArrow();
   // Replace the "call" node with the "arg" node, prefixed with '*'
   // if the call was using '->' rather than '.'.
   std::string ArgText =
       Arrow ? formatDereference(Result, *Arg) : getText(Result, *Arg).str();
   if (ArgText.empty())
     return;
 
-  diag(Call->getLocStart(), "redundant call to %0")
+  diag(Call->getBeginLoc(), "redundant call to %0")
       << Member->getMemberDecl()
       << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/SimplifyBooleanExprCheck.cpp

 const char SimplifyConditionDiagnostic[] =
     "redundant boolean literal in if statement condition";
 const char SimplifyConditionalReturnDiagnostic[] =
     "redundant boolean literal in conditional return statement";
 
 const CXXBoolLiteralExpr *getBoolLiteral(const MatchFinder::MatchResult &Result,
                                          StringRef Id) {
   const auto *Literal = Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(Id);
-  return (Literal && Literal->getLocStart().isMacroID()) ? nullptr : Literal;
+  return (Literal && Literal->getBeginLoc().isMacroID()) ? nullptr : Literal;
 }
 
 internal::Matcher<Stmt> returnsBool(bool Value, StringRef Id = "ignored") {
   auto SimpleReturnsBool =
       returnStmt(has(cxxBoolLiteral(equals(Value)).bind(Id)))
           .bind("returns-bool");
   return anyOf(SimpleReturnsBool,
                compoundStmt(statementCountIs(1), has(SimpleReturnsBool)));
void SimplifyBooleanExprCheck::reportBinOp(
   const Expr *Other = nullptr;
   if ((Bool = dyn_cast<CXXBoolLiteralExpr>(LHS)))
     Other = RHS;
   else if ((Bool = dyn_cast<CXXBoolLiteralExpr>(RHS)))
     Other = LHS;
   else
     return;
 
-  if (Bool->getLocStart().isMacroID())
+  if (Bool->getBeginLoc().isMacroID())
     return;
 
   // FIXME: why do we need this?
   if (!isa<CXXBoolLiteralExpr>(Other) && containsBoolLiteral(Other))
     return;
 
   bool BoolValue = Bool->getValue();
 
   auto replaceWithExpression = [this, &Result, LHS, RHS, Bool](
                                    const Expr *ReplaceWith, bool Negated) {
     std::string Replacement =
         replacementExpression(Result, Negated, ReplaceWith);
-    SourceRange Range(LHS->getLocStart(), RHS->getLocEnd());
-    issueDiag(Result, Bool->getLocStart(), SimplifyOperatorDiagnostic, Range,
+    SourceRange Range(LHS->getBeginLoc(), RHS->getLocEnd());
+    issueDiag(Result, Bool->getBeginLoc(), SimplifyOperatorDiagnostic, Range,
               Replacement);
   };
 
   switch (Op->getOpcode()) {
     case BO_LAnd:
       if (BoolValue) {
         // expr && true -> expr
         replaceWithExpression(Other, /*Negated=*/false);
void SimplifyBooleanExprCheck::issueDiag(
   if (!containsDiscardedTokens(Result, CharRange))
     Diag << FixItHint::CreateReplacement(CharRange, Replacement);
 }
 
 void SimplifyBooleanExprCheck::replaceWithThenStatement(
     const MatchFinder::MatchResult &Result,
     const CXXBoolLiteralExpr *TrueConditionRemoved) {
   const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
-  issueDiag(Result, TrueConditionRemoved->getLocStart(),
+  issueDiag(Result, TrueConditionRemoved->getBeginLoc(),
             SimplifyConditionDiagnostic, IfStatement->getSourceRange(),
             getText(Result, *IfStatement->getThen()));
 }
 
 void SimplifyBooleanExprCheck::replaceWithElseStatement(
     const MatchFinder::MatchResult &Result,
     const CXXBoolLiteralExpr *FalseConditionRemoved) {
   const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
   const Stmt *ElseStatement = IfStatement->getElse();
-  issueDiag(Result, FalseConditionRemoved->getLocStart(),
+  issueDiag(Result, FalseConditionRemoved->getBeginLoc(),
             SimplifyConditionDiagnostic, IfStatement->getSourceRange(),
             ElseStatement ? getText(Result, *ElseStatement) : "");
 }
 
 void SimplifyBooleanExprCheck::replaceWithCondition(
     const MatchFinder::MatchResult &Result, const ConditionalOperator *Ternary,
     bool Negated) {
   std::string Replacement =
       replacementExpression(Result, Negated, Ternary->getCond());
-  issueDiag(Result, Ternary->getTrueExpr()->getLocStart(),
+  issueDiag(Result, Ternary->getTrueExpr()->getBeginLoc(),
             "redundant boolean literal in ternary expression result",
             Ternary->getSourceRange(), Replacement);
 }
 
 void SimplifyBooleanExprCheck::replaceWithReturnCondition(
     const MatchFinder::MatchResult &Result, const IfStmt *If, bool Negated) {
   StringRef Terminator = isa<CompoundStmt>(If->getElse()) ? ";" : "";
   std::string Condition = replacementExpression(Result, Negated, If->getCond());
   std::string Replacement = ("return " + Condition + Terminator).str();
   SourceLocation Start =
-      Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(ThenLiteralId)->getLocStart();
+      Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(ThenLiteralId)->getBeginLoc();
   issueDiag(Result, Start, SimplifyConditionalReturnDiagnostic,
             If->getSourceRange(), Replacement);
 }
 
 void SimplifyBooleanExprCheck::replaceCompoundReturnWithCondition(
     const MatchFinder::MatchResult &Result, const CompoundStmt *Compound,
     bool Negated) {
   const auto *Ret = Result.Nodes.getNodeAs<ReturnStmt>(CompoundReturnId);
if (const auto *If = dyn_cast<IfStmt>(*Current)) {
         if (*After == Ret) {
           if (!ChainedConditionalReturn && BeforeIf)
             continue;
 
           const Expr *Condition = If->getCond();
           std::string Replacement =
               "return " + replacementExpression(Result, Negated, Condition);
           issueDiag(
-              Result, Lit->getLocStart(), SimplifyConditionalReturnDiagnostic,
-              SourceRange(If->getLocStart(), Ret->getLocEnd()), Replacement);
+              Result, Lit->getBeginLoc(), SimplifyConditionalReturnDiagnostic,
+              SourceRange(If->getBeginLoc(), Ret->getLocEnd()), Replacement);
           return;
         }
 
         BeforeIf = If;
       }
     } else {
       BeforeIf = nullptr;
     }
   }
 }
 
 void SimplifyBooleanExprCheck::replaceWithAssignment(
     const MatchFinder::MatchResult &Result, const IfStmt *IfAssign,
     bool Negated) {
   SourceRange Range = IfAssign->getSourceRange();
   StringRef VariableName =
       getText(Result, *Result.Nodes.getNodeAs<Expr>(IfAssignVariableId));
   StringRef Terminator = isa<CompoundStmt>(IfAssign->getElse()) ? ";" : "";
   std::string Condition =
       replacementExpression(Result, Negated, IfAssign->getCond());
   std::string Replacement =
       (VariableName + " = " + Condition + Terminator).str();
   SourceLocation Location =
-      Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(IfAssignLocId)->getLocStart();
+      Result.Nodes.getNodeAs<CXXBoolLiteralExpr>(IfAssignLocId)->getBeginLoc();
   issueDiag(Result, Location,
             "redundant boolean literal in conditional assignment", Range,
             Replacement);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/SimplifySubscriptExprCheck.cpp

if (Result.Context->getSourceManager().isMacroBodyExpansion(
     return;
 
   const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
   auto DiagBuilder =
       diag(Member->getMemberLoc(),
            "accessing an element of the container does not require a call to "
            "'data()'; did you mean to use 'operator[]'?");
   if (Member->isArrow())
-    DiagBuilder << FixItHint::CreateInsertion(Member->getLocStart(), "(*")
+    DiagBuilder << FixItHint::CreateInsertion(Member->getBeginLoc(), "(*")
                 << FixItHint::CreateInsertion(Member->getOperatorLoc(), ")");
   DiagBuilder << FixItHint::CreateRemoval(
       {Member->getOperatorLoc(), Call->getLocEnd()});
 }
 
 void SimplifySubscriptExprCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "Types", utils::options::serializeStringList(Types));
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/StaticAccessedThroughInstanceCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void StaticAccessedThroughInstanceCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *MemberExpression =
       Result.Nodes.getNodeAs<MemberExpr>("memberExpression");
 
-  if (MemberExpression->getLocStart().isMacroID())
+  if (MemberExpression->getBeginLoc().isMacroID())
     return;
 
   const Expr *BaseExpr = MemberExpression->getBase();
 
   // Do not warn for overlaoded -> operators.
   if (isa<CXXOperatorCallExpr>(BaseExpr))
     return;
 
   QualType BaseType =
       BaseExpr->getType()->isPointerType()
           ? BaseExpr->getType()->getPointeeType().getUnqualifiedType()
           : BaseExpr->getType().getUnqualifiedType();
 
   const ASTContext *AstContext = Result.Context;
   PrintingPolicy PrintingPolicyWithSupressedTag(AstContext->getLangOpts());
   PrintingPolicyWithSupressedTag.SuppressTagKeyword = true;
   std::string BaseTypeName =
       BaseType.getAsString(PrintingPolicyWithSupressedTag);
 
-  SourceLocation MemberExprStartLoc = MemberExpression->getLocStart();
+  SourceLocation MemberExprStartLoc = MemberExpression->getBeginLoc();
   auto Diag =
       diag(MemberExprStartLoc, "static member accessed through instance");
 
   if (BaseExpr->HasSideEffects(*AstContext) ||
       getNameSpecifierNestingLevel(BaseType) > NameSpecifierNestingThreshold)
     return;
 
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(MemberExprStartLoc,
                                     MemberExpression->getMemberLoc()),
       BaseTypeName + "::");
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/StringCompareCheck.cpp

Finder->addMatcher(
                      hasEitherOperand(StrCompare.bind("compare")),
                      hasEitherOperand(integerLiteral(equals(0)).bind("zero")))
           .bind("match2"),
       this);
 }
 
 void StringCompareCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) {
-    diag(Matched->getLocStart(), CompareMessage);
+    diag(Matched->getBeginLoc(), CompareMessage);
     return;
   }
 
   if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match2")) {
     const ASTContext &Ctx = *Result.Context;
 
     if (const auto *Zero = Result.Nodes.getNodeAs<Stmt>("zero")) {
       const auto *Str1 = Result.Nodes.getNodeAs<MemberExpr>("str1");
       const auto *Str2 = Result.Nodes.getNodeAs<Stmt>("str2");
       const auto *Compare = Result.Nodes.getNodeAs<Stmt>("compare");
 
-      auto Diag = diag(Matched->getLocStart(), CompareMessage);
+      auto Diag = diag(Matched->getBeginLoc(), CompareMessage);
 
       if (Str1->isArrow())
-        Diag << FixItHint::CreateInsertion(Str1->getLocStart(), "*");
+        Diag << FixItHint::CreateInsertion(Str1->getBeginLoc(), "*");
 
       Diag << tooling::fixit::createReplacement(*Zero, *Str2, Ctx)
            << tooling::fixit::createReplacement(*Compare, *Str1->getBase(),
                                                 Ctx);
     }
   }
 
   // FIXME: Add fixit to fix the code for case one and two (match1).
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void UniqueptrDeleteReleaseCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");
   const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");
 
-  if (PtrExpr->getLocStart().isMacroID())
+  if (PtrExpr->getBeginLoc().isMacroID())
     return;
 
   // Ignore dependent types.
   // It can give us false positives, so we go with false negatives instead to
   // be safe.
   if (PtrExpr->getType()->isDependentType())
     return;
 
   SourceLocation AfterPtr = Lexer::getLocForEndOfToken(
       PtrExpr->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
 
-  diag(DeleteExpr->getLocStart(),
+  diag(DeleteExpr->getBeginLoc(),
        "prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> "
        "objects")
       << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
-             DeleteExpr->getLocStart(), PtrExpr->getLocStart()))
+             DeleteExpr->getBeginLoc(), PtrExpr->getBeginLoc()))
       << FixItHint::CreateReplacement(
              CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()),
              " = nullptr");
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/utils/ASTUtils.cpp

bool IsBinaryOrTernary(const Expr *E) {
   return false;
 }
 
 bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
                                 const LangOptions &LangOpts,
                                 StringRef FlagName) {
   // If the Flag is an integer constant, check it.
   if (isa<IntegerLiteral>(Flags)) {
-    if (!SM.isMacroBodyExpansion(Flags->getLocStart()) &&
-        !SM.isMacroArgExpansion(Flags->getLocStart()))
+    if (!SM.isMacroBodyExpansion(Flags->getBeginLoc()) &&
+        !SM.isMacroArgExpansion(Flags->getBeginLoc()))
       return false;
 
     // Get the macro name.
     auto MacroName = Lexer::getSourceText(
         CharSourceRange::getTokenRange(Flags->getSourceRange()), SM, LangOpts);
 
     return MacroName == FlagName;
   }

clang-tools-extra/trunk/clang-tidy/utils/NamespaceAliaser.cpp

const auto HasConflictingAncestors =
              .empty();
     if (HasConflictingAncestors || HasConflictingChildren)
       continue;
 
     std::string Declaration =
         (llvm::Twine("\nnamespace ") + Abbreviation + " = " + Namespace + ";")
             .str();
     SourceLocation Loc =
-        Lexer::getLocForEndOfToken(Function->getBody()->getLocStart(), 0,
+        Lexer::getLocForEndOfToken(Function->getBody()->getBeginLoc(), 0,
                                    SourceMgr, Context.getLangOpts());
     AddedAliases[Function][Namespace.str()] = Abbreviation;
     return FixItHint::CreateInsertion(Loc, Declaration);
   }
 
   return None;
 }
 

clang-tools-extra/trunk/clang-tidy/utils/UsingInserter.cpp

Optional<FixItHint> UsingInserter::createUsingDeclaration(
   const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
   if (!Function)
     return None;
 
   if (AddedUsing.count(std::make_pair(Function, QualifiedName.str())) != 0)
     return None;
 
   SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
-      Function->getBody()->getLocStart(), 0, SourceMgr, Context.getLangOpts());
+      Function->getBody()->getBeginLoc(), 0, SourceMgr, Context.getLangOpts());
 
   // Only use using declarations in the main file, not in includes.
   if (SourceMgr.getFileID(InsertLoc) != SourceMgr.getMainFileID())
     return None;
 
   // FIXME: This declaration could be masked. Investigate if
   // there is a way to avoid using Sema.
   bool AlreadyHasUsingDecl =

clang-tools-extra/trunk/clangd/CodeComplete.cpp

llvm::Optional<llvm::StringRef> headerToInsertIfNotPresent() const {
     if (!IndexResult || !IndexResult->Detail ||
         IndexResult->Detail->IncludeHeader.empty())
       return llvm::None;
     if (SemaResult && SemaResult->Declaration) {
       // Avoid inserting new #include if the declaration is found in the current
       // file e.g. the symbol is forward declared.
       auto &SM = SemaResult->Declaration->getASTContext().getSourceManager();
       for (const Decl *RD : SemaResult->Declaration->redecls())
-        if (SM.isInMainFile(SM.getExpansionLoc(RD->getLocStart())))
+        if (SM.isInMainFile(SM.getExpansionLoc(RD->getBeginLoc())))
           return llvm::None;
     }
     return IndexResult->Detail->IncludeHeader;
   }
 
   using Bundle = llvm::SmallVector<CompletionCandidate, 4>;
 };
 using ScoredBundle =

clang-tools-extra/trunk/clangd/CodeCompletionStrings.cpp

if (!Decl || llvm::isa<NamespaceDecl>(Decl)) {
     return "";
   }
   const RawComment *RC = getCompletionComment(Ctx, Decl);
   if (!RC)
     return "";
 
   // Sanity check that the comment does not come from the PCH. We choose to not
   // write them into PCH, because they are racy and slow to load.
-  assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getLocStart()));
+  assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getBeginLoc()));
   std::string Doc = RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics());
   if (!looksLikeDocComment(Doc))
     return "";
   return Doc;
 }
 
 std::string
 getParameterDocComment(const ASTContext &Ctx,
                        const CodeCompleteConsumer::OverloadCandidate &Result,
                        unsigned ArgIndex, bool CommentsFromHeaders) {
   auto *Func = Result.getFunction();
   if (!Func)
     return "";
   const RawComment *RC = getParameterComment(Ctx, Result, ArgIndex);
   if (!RC)
     return "";
   // Sanity check that the comment does not come from the PCH. We choose to not
   // write them into PCH, because they are racy and slow to load.
-  assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getLocStart()));
+  assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getBeginLoc()));
   std::string Doc = RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics());
   if (!looksLikeDocComment(Doc))
     return "";
   return Doc;
 }
 
 void getSignature(const CodeCompletionString &CCS, std::string *Signature,
                   std::string *Snippet, std::string *RequiredQualifiers) {

clang-tools-extra/trunk/clangd/XRefs.cpp

public:
   llvm::Optional<QualType> getDeducedType() { return DeducedType; }
 
   // Handle auto initializers:
   //- auto i = 1;
   //- decltype(auto) i = 1;
   //- auto& i = 1;
   bool VisitDeclaratorDecl(DeclaratorDecl *D) {
     if (!D->getTypeSourceInfo() ||
-        D->getTypeSourceInfo()->getTypeLoc().getLocStart() != SearchedLocation)
+        D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
       return true;
 
     auto DeclT = D->getType();
     // "auto &" is represented as a ReferenceType containing an AutoType
     if (const ReferenceType *RT = dyn_cast<ReferenceType>(DeclT.getTypePtr()))
       DeclT = RT->getPointeeType();
 
     const AutoType *AT = dyn_cast<AutoType>(DeclT.getTypePtr());

clang-tools-extra/trunk/tool-template/ToolTemplate.cpp

public:
   void run(const MatchFinder::MatchResult &Result) override {
     // TODO: This routine will get called for each thing that the matchers
     // find.
     // At this point, you can examine the match, and do whatever you want,
     // including replacing the matched text with other text
     auto *D = Result.Nodes.getNodeAs<NamedDecl>("decl");
     assert(D);
     // Use AtomicChange to get a key.
-    if (D->getLocStart().isValid()) {
-      AtomicChange Change(*Result.SourceManager, D->getLocStart());
+    if (D->getBeginLoc().isValid()) {
+      AtomicChange Change(*Result.SourceManager, D->getBeginLoc());
       Context.reportResult(Change.getKey(), D->getQualifiedNameAsString());
     }
   }
 
   void onStartOfTranslationUnit() override {
     Context.reportResult("START", "Start of TU.");
   }
   void onEndOfTranslationUnit() override {

clang-tools-extra/trunk/unittests/clang-tidy/IncludeInserterTest.cpp

void registerPPCallbacks(CompilerInstance &Compiler) override {
     Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
   }
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     Finder->addMatcher(ast_matchers::declStmt().bind("stmt"), this);
   }
 
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
-    auto Diag = diag(Result.Nodes.getNodeAs<DeclStmt>("stmt")->getLocStart(),
+    auto Diag = diag(Result.Nodes.getNodeAs<DeclStmt>("stmt")->getBeginLoc(),
                      "foo, bar");
     for (StringRef header : HeadersToInclude()) {
       auto Fixit = Inserter->CreateIncludeInsertion(
           Result.SourceManager->getMainFileID(), header, IsAngledInclude());
       if (Fixit) {
         Diag << *Fixit;
       }
     }

clang-tools-extra/trunk/unittests/clang-tidy/NamespaceAliaserTest.cpp

void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     if (!Aliaser)
       Aliaser.reset(new NamespaceAliaser(*Result.SourceManager));
 
     const auto *Call = Result.Nodes.getNodeAs<CallExpr>("foo");
     assert(Call != nullptr && "Did not find node \"foo\"");
     auto Hint = Aliaser->createAlias(*Result.Context, *Call, "::foo::bar",
                                      {"b", "some_alias"});
     if (Hint.hasValue())
-      diag(Call->getLocStart(), "Fix for testing") << Hint.getValue();
+      diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue();
 
-    diag(Call->getLocStart(), "insert call")
-        << FixItHint::CreateInsertion(
-               Call->getLocStart(),
-               Aliaser->getNamespaceName(*Result.Context, *Call, "::foo::bar") +
-                   "::");
+    diag(Call->getBeginLoc(), "insert call") << FixItHint::CreateInsertion(
+        Call->getBeginLoc(),
+        Aliaser->getNamespaceName(*Result.Context, *Call, "::foo::bar") + "::");
   }
 
 private:
   std::unique_ptr<NamespaceAliaser> Aliaser;
 };
 
 template <typename Check>
 std::string runChecker(StringRef Code, unsigned ExpectedWarningCount) {

clang-tools-extra/trunk/unittests/clang-tidy/OverlappingReplacementsTest.cpp

public:
   UseCharCheck(StringRef CheckName, ClangTidyContext *Context)
       : ClangTidyCheck(CheckName, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     using namespace ast_matchers;
     Finder->addMatcher(varDecl(hasType(isInteger())).bind(BoundDecl), this);
   }
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     auto *VD = Result.Nodes.getNodeAs<VarDecl>(BoundDecl);
-    diag(VD->getLocStart(), "use char") << FixItHint::CreateReplacement(
-        CharSourceRange::getTokenRange(VD->getLocStart(), VD->getLocStart()),
+    diag(VD->getBeginLoc(), "use char") << FixItHint::CreateReplacement(
+        CharSourceRange::getTokenRange(VD->getBeginLoc(), VD->getBeginLoc()),
         "char");
   }
 };
 
 class IfFalseCheck : public ClangTidyCheck {
 public:
   IfFalseCheck(StringRef CheckName, ClangTidyContext *Context)
       : ClangTidyCheck(CheckName, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     using namespace ast_matchers;
     Finder->addMatcher(ifStmt().bind(BoundIf), this);
   }
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     auto *If = Result.Nodes.getNodeAs<IfStmt>(BoundIf);
     auto *Cond = If->getCond();
     SourceRange Range = Cond->getSourceRange();
     if (auto *D = If->getConditionVariable()) {
-      Range = SourceRange(D->getLocStart(), D->getLocEnd());
+      Range = SourceRange(D->getBeginLoc(), D->getLocEnd());
     }
     diag(Range.getBegin(), "the cake is a lie") << FixItHint::CreateReplacement(
         CharSourceRange::getTokenRange(Range), "false");
   }
 };
 
 class RefactorCheck : public ClangTidyCheck {
 public:

clang-tools-extra/trunk/unittests/clang-tidy/UsingInserterTest.cpp

if (!Inserter)
       Inserter.reset(new UsingInserter(*Result.SourceManager));
 
     const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo");
     assert(Call != nullptr && "Did not find node \"foo\"");
     auto Hint =
         Inserter->createUsingDeclaration(*Result.Context, *Call, "::foo::func");
 
     if (Hint.hasValue())
-      diag(Call->getLocStart(), "Fix for testing") << Hint.getValue();
+      diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue();
 
-    diag(Call->getLocStart(), "insert call")
+    diag(Call->getBeginLoc(), "insert call")
         << clang::FixItHint::CreateReplacement(
                Call->getCallee()->getSourceRange(),
                Inserter->getShortName(*Result.Context, *Call, "::foo::func"));
   }
 
 private:
   std::unique_ptr<UsingInserter> Inserter;
 };