[clang-tidy] Fix assertion failure on `at` function in modernize-loop-convert.

[hokein]

Fix a typo in doc.

[alexfh]

LG. Thank you!

clang-tidy/modernize/LoopConvertUtils.cpp

case Stmt::CXXOperatorCallExprClass: {
     break;
   }
 
   case Stmt::CXXMemberCallExprClass: {
     const auto *MemCall = cast<CXXMemberCallExpr>(Init);
     // This check is needed because getMethodDecl can return nullptr if the
     // callee is a member function pointer.
     const auto *MDecl = MemCall->getMethodDecl();
-    if (MDecl && !isa<CXXConversionDecl>(MDecl) && MDecl->getName() == "at") {
-      assert(MemCall->getNumArgs() == 1);
+    if (MDecl && !isa<CXXConversionDecl>(MDecl) && MDecl->getName() == "at" &&
+        MemCall->getNumArgs() == 1) {
       return isIndexInSubscriptExpr(MemCall->getArg(0), IndexVar);
     }
     return false;
   }
 
   default:
     break;
   }

docs/clang-tidy/checks/modernize-loop-convert.rst

.. code-block:: c++
   v.push_back(3);
 
   // safe conversion
   for (int i = 0; i < N; ++i)
     cout << arr[i];
 
   // reasonable conversion
   for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
-    cout << *it;*
+    cout << *it;
 
   // reasonable conversion
   for (int i = 0; i < v.size(); ++i)
     cout << v[i];
 
 After applying the check with minimum confidence level set to ``reasonable`` (default):
 
 .. code-block:: c++

test/clang-tidy/Inputs/modernize-loop-convert/structures.h

public:
   const_iterator begin() const;
   const_iterator end() const;
   iterator begin();
   iterator end();
   unsigned size() const;
   ElemType & operator[](unsigned);
   const ElemType & operator[](unsigned) const;
   ElemType & at(unsigned);
+  ElemType & at(unsigned, unsigned);
   const ElemType & at(unsigned) const;
 
   // Intentionally evil.
   dependent<ElemType> operator*();
 
   void foo();
   void constFoo() const;
 };

test/clang-tidy/modernize-loop-convert-extra.cpp

for (dependent<int>::iterator It = Dep.begin(), E = Dep.end(); It != E; ++It) {
     unsigned Othersize = Other.size();
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
   // CHECK-FIXES: for (int & It : Dep)
   // CHECK-FIXES-NEXT: printf("%d\n", It);
   // CHECK-FIXES-NEXT: const int& Idx = Other[0];
   // CHECK-FIXES-NEXT: unsigned Othersize = Other.size();
 
+  for (int i = 0; i <  Other.size(); ++i) {
+    Other.at(i);
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
+  // CHECK-FIXES: for (int & i : Other)
+  // CHECK-FIXES: i;
+
   for (int I = 0, E = Dep.size(); I != E; ++I) {
     int Idx = Other.at(I);
+    Other.at(I, I);  // Should not trigger assert failure.
   }
 }
 
 struct MemberNaming {
   const static int N = 10;
   int Ints[N], Ints_[N];
   dependent<int> DInts;
   void loops() {