1 files changed, 14 insertions, 14 deletions

diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp b/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp
index 3754768ec04..d86a97c4b78 100644
--- a/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp
@@ -703,7 +703,7 @@ void LoopConvertCheck::getIteratorLoopQualifiers(ASTContext *Context,
                                                  RangeDescriptor &Descriptor) {
   // The matchers for iterator loops provide bound nodes to obtain this
   // information.
-  const auto *InitVar = Nodes.getDeclAs<VarDecl>(InitVarName);
+  const auto *InitVar = Nodes.getNodeAs<VarDecl>(InitVarName);
   QualType CanonicalInitVarType = InitVar->getType().getCanonicalType();
   const auto *DerefByValueType =
       Nodes.getNodeAs<QualType>(DerefByValueResultName);
@@ -763,13 +763,13 @@ bool LoopConvertCheck::isConvertible(ASTContext *Context,
     return false;
 
   // Check that we have exactly one index variable and at most one end variable.
-  const auto *LoopVar = Nodes.getDeclAs<VarDecl>(IncrementVarName);
-  const auto *CondVar = Nodes.getDeclAs<VarDecl>(ConditionVarName);
-  const auto *InitVar = Nodes.getDeclAs<VarDecl>(InitVarName);
+  const auto *LoopVar = Nodes.getNodeAs<VarDecl>(IncrementVarName);
+  const auto *CondVar = Nodes.getNodeAs<VarDecl>(ConditionVarName);
+  const auto *InitVar = Nodes.getNodeAs<VarDecl>(InitVarName);
   if (!areSameVariable(LoopVar, CondVar) || !areSameVariable(LoopVar, InitVar))
     return false;
-  const auto *EndVar = Nodes.getDeclAs<VarDecl>(EndVarName);
-  const auto *ConditionEndVar = Nodes.getDeclAs<VarDecl>(ConditionEndVarName);
+  const auto *EndVar = Nodes.getNodeAs<VarDecl>(EndVarName);
+  const auto *ConditionEndVar = Nodes.getNodeAs<VarDecl>(ConditionEndVarName);
   if (EndVar && !areSameVariable(EndVar, ConditionEndVar))
     return false;
 
@@ -798,7 +798,7 @@ bool LoopConvertCheck::isConvertible(ASTContext *Context,
     }
   } else if (FixerKind == LFK_PseudoArray) {
     // This call is required to obtain the container.
-    const auto *EndCall = Nodes.getStmtAs<CXXMemberCallExpr>(EndCallName);
+    const auto *EndCall = Nodes.getNodeAs<CXXMemberCallExpr>(EndCallName);
     if (!EndCall || !dyn_cast<MemberExpr>(EndCall->getCallee()))
       return false;
   }
@@ -814,12 +814,12 @@ void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) {
   LoopFixerKind FixerKind;
   RangeDescriptor Descriptor;
 
-  if ((Loop = Nodes.getStmtAs<ForStmt>(LoopNameArray))) {
+  if ((Loop = Nodes.getNodeAs<ForStmt>(LoopNameArray))) {
     FixerKind = LFK_Array;
-  } else if ((Loop = Nodes.getStmtAs<ForStmt>(LoopNameIterator))) {
+  } else if ((Loop = Nodes.getNodeAs<ForStmt>(LoopNameIterator))) {
     FixerKind = LFK_Iterator;
   } else {
-    Loop = Nodes.getStmtAs<ForStmt>(LoopNamePseudoArray);
+    Loop = Nodes.getNodeAs<ForStmt>(LoopNamePseudoArray);
     assert(Loop && "Bad Callback. No for statement");
     FixerKind = LFK_PseudoArray;
   }
@@ -827,8 +827,8 @@ void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) {
   if (!isConvertible(Context, Nodes, Loop, FixerKind))
     return;
 
-  const auto *LoopVar = Nodes.getDeclAs<VarDecl>(IncrementVarName);
-  const auto *EndVar = Nodes.getDeclAs<VarDecl>(EndVarName);
+  const auto *LoopVar = Nodes.getNodeAs<VarDecl>(IncrementVarName);
+  const auto *EndVar = Nodes.getNodeAs<VarDecl>(EndVarName);
 
   // If the loop calls end()/size() after each iteration, lower our confidence
   // level.
@@ -837,8 +837,8 @@ void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) {
 
   // If the end comparison isn't a variable, we can try to work with the
   // expression the loop variable is being tested against instead.
-  const auto *EndCall = Nodes.getStmtAs<CXXMemberCallExpr>(EndCallName);
-  const auto *BoundExpr = Nodes.getStmtAs<Expr>(ConditionBoundName);
+  const auto *EndCall = Nodes.getNodeAs<CXXMemberCallExpr>(EndCallName);
+  const auto *BoundExpr = Nodes.getNodeAs<Expr>(ConditionBoundName);
 
   // Find container expression of iterators and pseudoarrays, and determine if
   // this expression needs to be dereferenced to obtain the container.