Port getLocEnd -> getEndLoc

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

 //   }  // a
 //   namespace x {
 //   class A { a::FWD *fwd; }
 //   }  // x
 void ChangeNamespaceTool::moveClassForwardDeclaration(
     const ast_matchers::MatchFinder::MatchResult &Result,
     const NamedDecl *FwdDecl) {
   SourceLocation Start = FwdDecl->getBeginLoc();
-  SourceLocation End = FwdDecl->getLocEnd();
+  SourceLocation End = FwdDecl->getEndLoc();
   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.
   addReplacementOrDie(Start, End, "", SM, &FileToReplacements);
void ChangeNamespaceTool::fixTypeLoc(
   replaceQualifiedSymbolInDeclContext(Result, DeclCtx->getDeclContext(), Start,
                                       End, FromDecl);
 }
 
 void ChangeNamespaceTool::fixUsingShadowDecl(
     const ast_matchers::MatchFinder::MatchResult &Result,
     const UsingDecl *UsingDeclaration) {
   SourceLocation Start = UsingDeclaration->getBeginLoc();
-  SourceLocation End = UsingDeclaration->getLocEnd();
+  SourceLocation End = UsingDeclaration->getEndLoc();
   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();
   std::string TargetDeclName = TargetDecl->getQualifiedNameAsString();

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

 // Decl.
 SourceLocation
 getLocForEndOfDecl(const clang::Decl *D,
                    const LangOptions &LangOpts = clang::LangOptions()) {
   const auto &SM = D->getASTContext().getSourceManager();
   // If the expansion range is a character range, this is the location of
   // the first character past the end. Otherwise it's the location of the
   // first character in the final token in the range.
-  auto EndExpansionLoc = SM.getExpansionRange(D->getLocEnd()).getEnd();
+  auto EndExpansionLoc = SM.getExpansionRange(D->getEndLoc()).getEnd();
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(EndExpansionLoc);
   // Try to load the file buffer.
   bool InvalidTemp = false;
   llvm::StringRef File = SM.getBufferData(LocInfo.first, &InvalidTemp);
   if (InvalidTemp)
     return SourceLocation();
 
   const char *TokBegin = File.data() + LocInfo.second;

 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->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());
+    if (SM.isBeforeInTranslationUnit(Full.getEnd(), Comment->getEndLoc()))
+      Full.setEnd(Comment->getEndLoc());
     // FIXME: Don't delete a preceding comment, if there are no other entities
     // it could refer to.
     if (SM.isBeforeInTranslationUnit(Comment->getBeginLoc(), Full.getBegin()))
       Full.setBegin(Comment->getBeginLoc());
   }
 
   return clang::CharSourceRange::getCharRange(Full);
 }

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

void CloexecCheck::insertMacroFlag(const MatchFinder::MatchResult &Result,
   SourceManager &SM = *Result.SourceManager;
 
   if (utils::exprHasBitFlagWithSpelling(FlagArg->IgnoreParenCasts(), SM,
                                         Result.Context->getLangOpts(),
                                         MacroFlag))
     return;
 
   SourceLocation EndLoc =
-      Lexer::getLocForEndOfToken(SM.getFileLoc(FlagArg->getLocEnd()), 0, SM,
+      Lexer::getLocForEndOfToken(SM.getFileLoc(FlagArg->getEndLoc()), 0, SM,
                                  Result.Context->getLangOpts());
 
   diag(EndLoc, "%0 should use %1 where possible")
       << FD << MacroFlag
       << FixItHint::CreateInsertion(EndLoc, (Twine(" | ") + MacroFlag).str());
 }
 
 void CloexecCheck::replaceFunc(const MatchFinder::MatchResult &Result,

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

if (auto Template = Callee->getTemplateInstantiationPattern()) {
       if (Template->getNumParams() <= I ||
           Template->getParamDecl(I)->isParameterPack()) {
         continue;
       }
     }
 
     CharSourceRange BeforeArgument =
         makeFileCharRange(ArgBeginLoc, Args[I]->getBeginLoc());
-    ArgBeginLoc = Args[I]->getLocEnd();
+    ArgBeginLoc = Args[I]->getEndLoc();
 
     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]->getBeginLoc(), Args[NumArgs - 1]->getLocEnd());
+          Args[I]->getBeginLoc(), Args[NumArgs - 1]->getEndLoc());
       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)) {
         {

 
 void ArgumentCommentCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
   if (const auto *Call = dyn_cast<CallExpr>(E)) {
     const FunctionDecl *Callee = Call->getDirectCallee();
     if (!Callee)
       return;
 
-    checkCallArgs(Result.Context, Callee, Call->getCallee()->getLocEnd(),
+    checkCallArgs(Result.Context, Callee, Call->getCallee()->getEndLoc(),
                   llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs()));
   } else {
     const auto *Construct = cast<CXXConstructExpr>(E);
     if (Construct->getNumArgs() == 1 &&
         Construct->getArg(0)->getSourceRange() == Construct->getSourceRange()) {
       // Ignore implicit construction.
       return;
     }

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

if (NonCopyableBase)
       continue;
     const auto *CExpr = dyn_cast<CXXConstructExpr>(Init->getInit());
     if (!CExpr || !CExpr->getConstructor()->isDefaultConstructor())
       continue;
     HasRelevantBaseInit = true;
     if (CtorInitIsWritten) {
       if (!ParamName.empty())
         SafeFixIts.push_back(
-            FixItHint::CreateInsertion(CExpr->getLocEnd(), ParamName));
+            FixItHint::CreateInsertion(CExpr->getEndLoc(), ParamName));
     } else {
       if (Init->getSourceLocation().isMacroID() ||
           Ctor->getLocation().isMacroID() || ShouldNotDoFixit)
         break;
       FixItInitList += BaseClass->getNameAsString();
       FixItInitList += "(" + ParamName + "), ";
     }
   }

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

void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
   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());
     const SourceLocation EndLoc = Lexer::getLocForEndOfToken(
-        AlgCall->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
+        AlgCall->getEndLoc(), 0, *Result.SourceManager, getLangOpts());
     Hint = FixItHint::CreateInsertion(EndLoc, ", " + ReplacementText);
   }
 
   diag(Loc, "this call will remove at most one item even when multiple items "
             "should be removed")
       << Hint;
 }
 
 } // 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->getBeginLoc(), Callee->getLocEnd()),
+                                   Callee->getBeginLoc(), Callee->getEndLoc()),
                                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/StringIntegerAssignmentCheck.cpp

void StringIntegerAssignmentCheck::check(
   bool IsOneDigit = false;
   bool IsLiteral = false;
   if (const auto *Literal = dyn_cast<IntegerLiteral>(Argument)) {
     IsOneDigit = Literal->getValue().getLimitedValue() < 10;
     IsLiteral = true;
   }
 
   SourceLocation EndLoc = Lexer::getLocForEndOfToken(
-      Argument->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
+      Argument->getEndLoc(), 0, *Result.SourceManager, getLangOpts());
   if (IsOneDigit) {
     Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "L'" : "'")
          << FixItHint::CreateInsertion(EndLoc, "'");
     return;
   }
   if (IsLiteral) {
     Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "L\"" : "\"")
          << FixItHint::CreateInsertion(EndLoc, "\"");

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

void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
 
   const auto *Statement = Result.Nodes.getNodeAs<Stmt>("stmt");
   const bool IsIfStmt = isa<IfStmt>(Statement);
 
   if (!IsIfStmt &&
       SM.getSpellingLineNumber(Token.getLocation()) != SemicolonLine)
     return;
 
-  SourceLocation LocEnd = Semicolon->getLocEnd();
+  SourceLocation LocEnd = Semicolon->getEndLoc();
   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;
 

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

void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
 
   // Otherwise just suggest adding a name. To find the place to insert the name
   // find the first TypeLoc in the children of E, which always points to the
   // written type.
   auto Matches =
       match(expr(hasDescendant(typeLoc().bind("t"))), *E, *Result.Context);
   const auto *TL = selectFirst<TypeLoc>("t", Matches);
   D << FixItHint::CreateInsertion(
-      Lexer::getLocForEndOfToken(TL->getLocEnd(), 0, *Result.SourceManager,
+      Lexer::getLocForEndOfToken(TL->getEndLoc(), 0, *Result.SourceManager,
                                  getLangOpts()),
       Replacement);
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

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

void NoMallocCheck::check(const MatchFinder::MatchResult &Result) {
   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->getBeginLoc(), "do not manage memory manually; %0")
-      << Recommendation << SourceRange(Call->getBeginLoc(), Call->getLocEnd());
+      << Recommendation << SourceRange(Call->getBeginLoc(), Call->getEndLoc());
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

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

auto Diag = diag(Matched->getExprLoc(),
                      "not an integer constant expression; use gsl::at() "
                      "instead");
     if (!GslHeader.empty()) {
       Diag << FixItHint::CreateInsertion(BaseRange.getBegin(), "gsl::at(")
            << FixItHint::CreateReplacement(
                   SourceRange(BaseRange.getEnd().getLocWithOffset(1),
                               IndexRange.getBegin().getLocWithOffset(-1)),
                   ", ")
-           << FixItHint::CreateReplacement(Matched->getLocEnd(), ")");
+           << FixItHint::CreateReplacement(Matched->getEndLoc(), ")");
 
       Optional<FixItHint> Insertion = Inserter->CreateIncludeInsertion(
           Result.SourceManager->getMainFileID(), GslHeader,
           /*IsAngled=*/false);
       if (Insertion)
         Diag << Insertion.getValue();
     }
     return;

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

if (SourceDecl->isPolymorphic()) {
           "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,
+            Lexer::getLocForEndOfToken(SubExpr->getEndLoc(), 0,
                                        *Result.SourceManager, getLangOpts()),
             ")");
       }
       auto ParenRange = CharSourceRange::getTokenRange(
           MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc());
       diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
     } else {
       diag(

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

if (const auto *S =
     diag(S->getUsedLocation(),
          "calling a function that uses a default argument is disallowed");
     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()) {
+    if (DefaultArgRange.getEnd() != D->getEndLoc()) {
       return;
     } else if (DefaultArgRange.getBegin().isMacroID()) {
       diag(D->getBeginLoc(),
            "declaring a parameter with a default argument is disallowed");
     } else {
       SourceLocation StartLocation =
           D->getName().empty() ? D->getBeginLoc() : D->getLocation();
 

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

void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   auto Diag =
       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,
+          Lexer::getLocForEndOfToken(SubExpr->getEndLoc(), 0, SM,
                                      getLangOpts()),
           ")");
     }
     Diag << FixItHint::CreateReplacement(ReplaceRange, CastText);
   };
   auto ReplaceWithNamedCast = [&](StringRef CastType) {
     Diag << CastType;
     ReplaceWithCast((CastType + "<" + DestTypeString + ">").str());

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

void ExplicitConstructorCheck::check(const MatchFinder::MatchResult &Result) {
   if (Ctor->isExplicit() &&
       (Ctor->isCopyOrMoveConstructor() || takesInitializerList)) {
     auto isKWExplicit = [](const Token &Tok) {
       return Tok.is(tok::raw_identifier) &&
              Tok.getRawIdentifier() == "explicit";
     };
     SourceRange ExplicitTokenRange =
         FindToken(*Result.SourceManager, getLangOpts(),
-                  Ctor->getOuterLocStart(), Ctor->getLocEnd(), isKWExplicit);
+                  Ctor->getOuterLocStart(), Ctor->getEndLoc(), isKWExplicit);
     StringRef ConstructorDescription;
     if (Ctor->isMoveConstructor())
       ConstructorDescription = "move";
     else if (Ctor->isCopyConstructor())
       ConstructorDescription = "copy";
     else
       ConstructorDescription = "initializer-list";
 

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

if (VD->hasInit()) {
 
     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());
+          VD->getInit()->getEndLoc(), 0, *Result.SourceManager, getLangOpts());
       Diag << FixItHint::CreateReplacement(TypeRange, "std::string")
            << 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/RedundantExpressionCheck.cpp

if (const auto *ComparisonOperator = Result.Nodes.getNodeAs<BinaryOperator>(
 
     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->getBeginLoc(),
-                                 ConstExpr->getLocEnd());
+                                 ConstExpr->getEndLoc());
       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->getBeginLoc(), Sym->getLocEnd());
+      SourceRange SymExprRange(Sym->getBeginLoc(), Sym->getEndLoc());
 
       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

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->getBeginLoc(), AssertMSG->getLocEnd())));
+          SourceRange(AssertMSG->getBeginLoc(), AssertMSG->getEndLoc())));
       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/UnusedAliasDeclsCheck.cpp

void UnusedAliasDeclsCheck::registerMatchers(MatchFinder *Finder) {
   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->getBeginLoc(),
         Lexer::findLocationAfterToken(
-            AliasDecl->getLocEnd(), tok::semi, *Result.SourceManager,
+            AliasDecl->getEndLoc(), tok::semi, *Result.SourceManager,
             getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     return;
   }
 
   if (const auto *NestedName =
           Result.Nodes.getNodeAs<NestedNameSpecifier>("nns")) {
     if (const auto *AliasDecl = NestedName->getAsNamespaceAlias()) {

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

static CharSourceRange removeNode(const MatchFinder::MatchResult &Result,
                                   const T *PrevNode, const T *Node,
                                   const T *NextNode) {
   if (NextNode)
     return CharSourceRange::getCharRange(Node->getBeginLoc(),
                                          NextNode->getBeginLoc());
 
   if (PrevNode)
     return CharSourceRange::getTokenRange(
-        Lexer::getLocForEndOfToken(PrevNode->getLocEnd(), 0,
+        Lexer::getLocForEndOfToken(PrevNode->getEndLoc(), 0,
                                    *Result.SourceManager,
                                    Result.Context->getLangOpts()),
-        Node->getLocEnd());
+        Node->getEndLoc());
 
   return CharSourceRange::getTokenRange(Node->getSourceRange());
 }
 
 static FixItHint removeParameter(const MatchFinder::MatchResult &Result,
                                  const FunctionDecl *Function, unsigned Index) {
   return FixItHint::CreateRemoval(removeNode(
       Result, Index > 0 ? Function->getParamDecl(Index - 1) : nullptr,

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

if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     // scopes.
     if (isa<FunctionDecl>(Using->getDeclContext()))
       return;
 
     UsingDeclContext Context(Using);
     Context.UsingDeclRange = CharSourceRange::getCharRange(
         Using->getBeginLoc(),
         Lexer::findLocationAfterToken(
-            Using->getLocEnd(), tok::semi, *Result.SourceManager, getLangOpts(),
+            Using->getEndLoc(), 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);
     }
     if (!Context.UsingTargetDecls.empty())
       Contexts.push_back(Context);

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->getBeginLoc(), E->getLocEnd()),
+        CharSourceRange::getTokenRange(E->getBeginLoc(), E->getEndLoc()),
         *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);

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->getBeginLoc();
   SourceLocation ExprEnd =
-      Lexer::getLocForEndOfToken(Expr->getLocEnd(), 0, SM, getLangOpts());
+      Lexer::getLocForEndOfToken(Expr->getEndLoc(), 0, SM, getLangOpts());
 
   bool InMacro = ExprStart.isMacroID();
 
   if (InMacro && IgnoreMacros) {
     return;
   }
 
   // There are some cases where we don't have operator ("." or "->") of the

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

for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) {
     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->getBeginLoc(),
-                                                    ParamTL.getLocEnd());
+                                                    ParamTL.getEndLoc());
     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/RedundantVoidArgCheck.cpp

 }
 
 void RedundantVoidArgCheck::processFunctionDecl(
     const MatchFinder::MatchResult &Result, const FunctionDecl *Function) {
   if (Function->isThisDeclarationADefinition()) {
     const Stmt *Body = Function->getBody();
     SourceLocation Start = Function->getBeginLoc();
     SourceLocation End =
-        Body ? Body->getBeginLoc().getLocWithOffset(-1) : Function->getLocEnd();
+        Body ? Body->getBeginLoc().getLocWithOffset(-1) : Function->getEndLoc();
     removeVoidArgumentTokens(Result, SourceRange(Start, End),
                              "function definition");
   } else {
     removeVoidArgumentTokens(Result, Function->getSourceRange(),
                              "function declaration");
   }
 }
 

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

void UseEmplaceCheck::check(const MatchFinder::MatchResult &Result) {
 
   if (FunctionNameSourceRange.getBegin().isMacroID())
     return;
 
   const auto *EmplacePrefix = MakeCall ? "emplace_back" : "emplace_back(";
   Diag << FixItHint::CreateReplacement(FunctionNameSourceRange, EmplacePrefix);
 
   const SourceRange CallParensRange =
-      MakeCall ? SourceRange(MakeCall->getCallee()->getLocEnd(),
+      MakeCall ? SourceRange(MakeCall->getCallee()->getEndLoc(),
                              MakeCall->getRParenLoc())
                : CtorCall->getParenOrBraceRange();
 
   // Finish if there is no explicit constructor call.
   if (CallParensRange.getBegin().isInvalid())
     return;
 
   const SourceLocation ExprBegin =

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

Finder->addMatcher(
       cxxMethodDecl(isDeleted(), unless(isPublic())).bind(DeletedNotPublic),
       this);
 }
 
 void UseEqualsDeleteCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Func =
           Result.Nodes.getNodeAs<CXXMethodDecl>(SpecialFunction)) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
-        Func->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
+        Func->getEndLoc(), 0, *Result.SourceManager, getLangOpts());
 
     // FIXME: Improve FixItHint to make the method public.
     diag(Func->getLocation(),
          "use '= delete' to prohibit calling of a special member function")
         << FixItHint::CreateInsertion(EndLoc, " = delete");
   } else if (const auto *Func =
                  Result.Nodes.getNodeAs<CXXMethodDecl>(DeletedNotPublic)) {
     // Ignore this warning in macros, since it's extremely noisy in code using

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

if (!FirstSubExpr)
       FirstSubExpr = CastSubExpr;
 
     if (C->getCastKind() != CK_NullToPointer &&
         C->getCastKind() != CK_NullToMemberPointer) {
       return true;
     }
 
     SourceLocation StartLoc = FirstSubExpr->getBeginLoc();
-    SourceLocation EndLoc = FirstSubExpr->getLocEnd();
+    SourceLocation EndLoc = FirstSubExpr->getEndLoc();
 
     // 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)) {
       SourceLocation FileLocStart = SM.getFileLoc(StartLoc),

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->getBeginLoc();
-    EndLoc = C->getLocEnd();
+    EndLoc = C->getEndLoc();
   } else if (const auto *E = Result.Nodes.getNodeAs<CallExpr>("call_expr")) {
     BeginLoc = E->getBeginLoc();
-    EndLoc = E->getLocEnd();
+    EndLoc = E->getEndLoc();
   } else if (const auto *D =
                  Result.Nodes.getNodeAs<DeclRefExpr>("decl_ref_expr")) {
     BeginLoc = D->getBeginLoc();
-    EndLoc = D->getLocEnd();
+    EndLoc = D->getEndLoc();
     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/performance/FasterStringFindCheck.cpp

if (!Replacement)
     return;
 
   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->getBeginLoc(),
-                                            Literal->getLocEnd()),
+                                            Literal->getEndLoc()),
              *Replacement);
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

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

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->getBeginLoc(), Arg->getBeginLoc()),
       SM, LangOpts);
   CharSourceRange AfterArgumentsRange = Lexer::makeFileCharRange(
-      CharSourceRange::getCharRange(Call->getLocEnd(),
-                                    Call->getLocEnd().getLocWithOffset(1)),
+      CharSourceRange::getCharRange(Call->getEndLoc(),
+                                    Call->getEndLoc().getLocWithOffset(1)),
       SM, LangOpts);
 
   if (BeforeArgumentsRange.isValid() && AfterArgumentsRange.isValid()) {
     Diag << FixItHint::CreateRemoval(BeforeArgumentsRange)
          << FixItHint::CreateRemoval(AfterArgumentsRange);
   }
 }
 

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.getBeginLoc(),
-                       Param.getLocEnd().getLocWithOffset(-1));
+                       Param.getEndLoc().getLocWithOffset(-1));
   return Param.getSourceRange();
 }
 
 } // namespace
 
 void AvoidConstParamsInDecls::registerMatchers(MatchFinder *Finder) {
   const auto ConstParamDecl =
       parmVarDecl(hasType(qualType(isConstQualified()))).bind("param");
for (unsigned int i = 0; i < Func->getNumParams(); ++i) {
         Diag << (i + 1);
         break;
       }
     }
   } else {
     Diag << Param;
   }
 
-  if (Param->getBeginLoc().isMacroID() != Param->getLocEnd().isMacroID()) {
+  if (Param->getBeginLoc().isMacroID() != Param->getEndLoc().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

 SourceLocation
 BracesAroundStatementsCheck::findRParenLoc(const IfOrWhileStmt *S,
                                            const SourceManager &SM,
                                            const ASTContext *Context) {
   // Skip macros.
   if (S->getBeginLoc().isMacroID())
     return SourceLocation();
 
-  SourceLocation CondEndLoc = S->getCond()->getLocEnd();
+  SourceLocation CondEndLoc = S->getCond()->getEndLoc();
   if (const DeclStmt *CondVar = S->getConditionVariableDeclStmt())
-    CondEndLoc = CondVar->getLocEnd();
+    CondEndLoc = CondVar->getEndLoc();
 
   if (!CondEndLoc.isValid()) {
     return SourceLocation();
   }
 
   SourceLocation PastCondEndLoc =
       Lexer::getLocForEndOfToken(CondEndLoc, 0, SM, Context->getLangOpts());
   if (PastCondEndLoc.isInvalid())

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

auto Diag = diag(
       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->getBeginLoc(),
-      Lexer::getLocForEndOfToken(IfWithDelete->getCond()->getLocEnd(), 0,
+      Lexer::getLocForEndOfToken(IfWithDelete->getCond()->getEndLoc(), 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/FunctionSizeCheck.cpp

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->getBeginLoc(), Body->getLocEnd())) {
-      FI.Lines = SM->getSpellingLineNumber(Body->getLocEnd()) -
+    if (SM->isWrittenInSameFile(Body->getBeginLoc(), Body->getEndLoc())) {
+      FI.Lines = SM->getSpellingLineNumber(Body->getEndLoc()) -
                  SM->getSpellingLineNumber(Body->getBeginLoc());
     }
   }
 
   unsigned ActualNumberParameters = Func->getNumParams();
 
   if (FI.Lines > LineThreshold || FI.Statements > StatementThreshold ||
       FI.Branches > BranchThreshold ||

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

void fixGenericExprCastToBool(DiagnosticBuilder &Diag,
   EndLocInsertion += getZeroLiteralToCompareWithForType(
       Cast->getCastKind(), SubExpr->getType(), Context);
 
   if (NeedOuterParens) {
     EndLocInsertion += ")";
   }
 
   SourceLocation EndLoc = Lexer::getLocForEndOfToken(
-      Cast->getLocEnd(), 0, Context.getSourceManager(), Context.getLangOpts());
+      Cast->getEndLoc(), 0, Context.getSourceManager(), Context.getLangOpts());
   Diag << FixItHint::CreateInsertion(EndLoc, EndLocInsertion);
 }
 
 StringRef getEquivalentBoolLiteralForExpr(const Expr *Expression,
                                           ASTContext &Context) {
   if (isNULLMacroExpansion(Expression, Context)) {
     return "false";
   }
void fixGenericExprCastFromBool(DiagnosticBuilder &Diag,
 
   Diag << FixItHint::CreateInsertion(
       Cast->getBeginLoc(),
       (Twine("static_cast<") + OtherType + ">" + (NeedParens ? "(" : ""))
           .str());
 
   if (NeedParens) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
-        Cast->getLocEnd(), 0, Context.getSourceManager(),
+        Cast->getEndLoc(), 0, Context.getSourceManager(),
         Context.getLangOpts());
 
     Diag << FixItHint::CreateInsertion(EndLoc, ")");
   }
 }
 
 StringRef getEquivalentForBoolLiteral(const CXXBoolLiteralExpr *BoolLiteral,
                                       QualType DestType, ASTContext &Context) {

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

void MisleadingIndentationCheck::danglingElseCheck(const SourceManager &SM,
                                                    ASTContext *Context,
                                                    const IfStmt *If) {
   SourceLocation IfLoc = If->getIfLoc();
   SourceLocation ElseLoc = If->getElseLoc();
 
   if (IfLoc.isMacroID() || ElseLoc.isMacroID())
     return;
 
-  if (SM.getExpansionLineNumber(If->getThen()->getLocEnd()) ==
+  if (SM.getExpansionLineNumber(If->getThen()->getEndLoc()) ==
       SM.getExpansionLineNumber(ElseLoc))
     return;
 
   // Find location of first 'if' in a 'if else if' chain.
   for (auto PrecedingIf = getPrecedingIf(SM, Context, If); PrecedingIf;
        PrecedingIf = getPrecedingIf(SM, Context, PrecedingIf))
     IfLoc = PrecedingIf->getIfLoc();
 

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

void RedundantControlFlowCheck::issueDiagnostic(
   SourceManager &SM = *Result.SourceManager;
   if (isLocationInMacroExpansion(SM, StmtRange.getBegin()))
     return;
 
   CompoundStmt::const_reverse_body_iterator Previous = ++Block->body_rbegin();
   SourceLocation Start;
   if (Previous != Block->body_rend())
     Start = Lexer::findLocationAfterToken(
-        dyn_cast<Stmt>(*Previous)->getLocEnd(), tok::semi, SM, getLangOpts(),
+        dyn_cast<Stmt>(*Previous)->getEndLoc(), tok::semi, SM, getLangOpts(),
         /*SkipTrailingWhitespaceAndNewLine=*/true);
   if (!Start.isValid())
     Start = StmtRange.getBegin();
   auto RemovedRange = CharSourceRange::getCharRange(
       Start, Lexer::findLocationAfterToken(
                  StmtRange.getEnd(), tok::semi, SM, getLangOpts(),
                  /*SkipTrailingWhitespaceAndNewLine=*/true));
 
   diag(StmtRange.getBegin(), Diag) << FixItHint::CreateRemoval(RemovedRange);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

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

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->getBeginLoc(), RHS->getLocEnd());
+    SourceRange Range(LHS->getBeginLoc(), RHS->getEndLoc());
     issueDiag(Result, Bool->getBeginLoc(), SimplifyOperatorDiagnostic, Range,
               Replacement);
   };
 
   switch (Op->getOpcode()) {
     case BO_LAnd:
       if (BoolValue) {
         // expr && true -> expr
if (const auto *If = dyn_cast<IfStmt>(*Current)) {
           if (!ChainedConditionalReturn && BeforeIf)
             continue;
 
           const Expr *Condition = If->getCond();
           std::string Replacement =
               "return " + replacementExpression(Result, Negated, Condition);
           issueDiag(
               Result, Lit->getBeginLoc(), SimplifyConditionalReturnDiagnostic,
-              SourceRange(If->getBeginLoc(), Ret->getLocEnd()), Replacement);
+              SourceRange(If->getBeginLoc(), Ret->getEndLoc()), Replacement);
           return;
         }
 
         BeforeIf = If;
       }
     } else {
       BeforeIf = nullptr;
     }

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

void SimplifySubscriptExprCheck::check(const MatchFinder::MatchResult &Result) {
   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->getBeginLoc(), "(*")
                 << FixItHint::CreateInsertion(Member->getOperatorLoc(), ")");
   DiagBuilder << FixItHint::CreateRemoval(
-      {Member->getOperatorLoc(), Call->getLocEnd()});
+      {Member->getOperatorLoc(), Call->getEndLoc()});
 }
 
 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/UniqueptrDeleteReleaseCheck.cpp

void UniqueptrDeleteReleaseCheck::check(
 
   // 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());
+      PtrExpr->getEndLoc(), 0, *Result.SourceManager, getLangOpts());
 
   diag(DeleteExpr->getBeginLoc(),
        "prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> "
        "objects")
       << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
              DeleteExpr->getBeginLoc(), PtrExpr->getBeginLoc()))
       << FixItHint::CreateReplacement(
-             CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()),
+             CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getEndLoc()),
              " = nullptr");
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

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

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->getBeginLoc(), D->getLocEnd());
+      Range = SourceRange(D->getBeginLoc(), D->getEndLoc());
     }
     diag(Range.getBegin(), "the cake is a lie") << FixItHint::CreateReplacement(
         CharSourceRange::getTokenRange(Range), "false");
   }
 };
 
 class RefactorCheck : public ClangTidyCheck {
 public: