diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp
index 80d80a7..03efd12 100644
--- a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp
@@ -30,7 +30,7 @@
 namespace tidy {
 namespace modernize {
 
-/// \brief Tracks a stack of parent statements during traversal.
+/// Tracks a stack of parent statements during traversal.
 ///
 /// All this really does is inject push_back() before running
 /// RecursiveASTVisitor::TraverseStmt() and pop_back() afterwards. The Stmt atop
@@ -44,7 +44,7 @@
   return true;
 }
 
-/// \brief Keep track of the DeclStmt associated with each VarDecl.
+/// Keep track of the DeclStmt associated with each VarDecl.
 ///
 /// Combined with StmtAncestors, this provides roughly the same information as
 /// Scope, as we can map a VarDecl to its DeclStmt, then walk up the parent tree
@@ -57,19 +57,19 @@
   return true;
 }
 
-/// \brief record the DeclRefExpr as part of the parent expression.
+/// record the DeclRefExpr as part of the parent expression.
 bool ComponentFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *E) {
   Components.push_back(E);
   return true;
 }
 
-/// \brief record the MemberExpr as part of the parent expression.
+/// record the MemberExpr as part of the parent expression.
 bool ComponentFinderASTVisitor::VisitMemberExpr(MemberExpr *Member) {
   Components.push_back(Member);
   return true;
 }
 
-/// \brief Forward any DeclRefExprs to a check on the referenced variable
+/// Forward any DeclRefExprs to a check on the referenced variable
 /// declaration.
 bool DependencyFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *DeclRef) {
   if (auto *V = dyn_cast_or_null<VarDecl>(DeclRef->getDecl()))
@@ -77,7 +77,7 @@
   return true;
 }
 
-/// \brief Determine if any this variable is declared inside the ContainingStmt.
+/// Determine if any this variable is declared inside the ContainingStmt.
 bool DependencyFinderASTVisitor::VisitVarDecl(VarDecl *V) {
   const Stmt *Curr = DeclParents->lookup(V);
   // First, see if the variable was declared within an inner scope of the loop.
@@ -100,7 +100,7 @@
   return true;
 }
 
-/// \brief If we already created a variable for TheLoop, check to make sure
+/// If we already created a variable for TheLoop, check to make sure
 /// that the name was not already taken.
 bool DeclFinderASTVisitor::VisitForStmt(ForStmt *TheLoop) {
   StmtGeneratedVarNameMap::const_iterator I = GeneratedDecls->find(TheLoop);
@@ -111,7 +111,7 @@
   return true;
 }
 
-/// \brief If any named declaration within the AST subtree has the same name,
+/// If any named declaration within the AST subtree has the same name,
 /// then consider Name already taken.
 bool DeclFinderASTVisitor::VisitNamedDecl(NamedDecl *D) {
   const IdentifierInfo *Ident = D->getIdentifier();
@@ -122,7 +122,7 @@
   return true;
 }
 
-/// \brief Forward any declaration references to the actual check on the
+/// Forward any declaration references to the actual check on the
 /// referenced declaration.
 bool DeclFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *DeclRef) {
   if (auto *D = dyn_cast<NamedDecl>(DeclRef->getDecl()))
@@ -130,7 +130,7 @@
   return true;
 }
 
-/// \brief If the new variable name conflicts with any type used in the loop,
+/// If the new variable name conflicts with any type used in the loop,
 /// then we mark that variable name as taken.
 bool DeclFinderASTVisitor::VisitTypeLoc(TypeLoc TL) {
   QualType QType = TL.getType();
@@ -152,7 +152,7 @@
   return true;
 }
 
-/// \brief Look through conversion/copy constructors to find the explicit
+/// Look through conversion/copy constructors to find the explicit
 /// initialization expression, returning it is found.
 ///
 /// The main idea is that given
@@ -183,7 +183,7 @@
   return E;
 }
 
-/// \brief Returns true when two Exprs are equivalent.
+/// Returns true when two Exprs are equivalent.
 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second) {
   if (!First || !Second)
     return false;
@@ -194,18 +194,18 @@
   return FirstID == SecondID;
 }
 
-/// \brief Returns the DeclRefExpr represented by E, or NULL if there isn't one.
+/// Returns the DeclRefExpr represented by E, or NULL if there isn't one.
 const DeclRefExpr *getDeclRef(const Expr *E) {
   return dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
 }
 
-/// \brief Returns true when two ValueDecls are the same variable.
+/// Returns true when two ValueDecls are the same variable.
 bool areSameVariable(const ValueDecl *First, const ValueDecl *Second) {
   return First && Second &&
          First->getCanonicalDecl() == Second->getCanonicalDecl();
 }
 
-/// \brief Determines if an expression is a declaration reference to a
+/// Determines if an expression is a declaration reference to a
 /// particular variable.
 static bool exprReferencesVariable(const ValueDecl *Target, const Expr *E) {
   if (!Target || !E)
@@ -214,7 +214,7 @@
   return Decl && areSameVariable(Target, Decl->getDecl());
 }
 
-/// \brief If the expression is a dereference or call to operator*(), return the
+/// If the expression is a dereference or call to operator*(), return the
 /// operand. Otherwise, return NULL.
 static const Expr *getDereferenceOperand(const Expr *E) {
   if (const auto *Uop = dyn_cast<UnaryOperator>(E))
@@ -229,7 +229,7 @@
   return nullptr;
 }
 
-/// \brief Returns true when the Container contains an Expr equivalent to E.
+/// Returns true when the Container contains an Expr equivalent to E.
 template <typename ContainerT>
 static bool containsExpr(ASTContext *Context, const ContainerT *Container,
                          const Expr *E) {
@@ -242,7 +242,7 @@
   return false;
 }
 
-/// \brief Returns true when the index expression is a declaration reference to
+/// Returns true when the index expression is a declaration reference to
 /// IndexVar.
 ///
 /// If the index variable is `index`, this function returns true on
@@ -257,7 +257,7 @@
          areSameVariable(IndexVar, Idx->getDecl());
 }
 
-/// \brief Returns true when the index expression is a declaration reference to
+/// Returns true when the index expression is a declaration reference to
 /// IndexVar, Obj is the same expression as SourceExpr after all parens and
 /// implicit casts are stripped off.
 ///
@@ -302,7 +302,7 @@
   return false;
 }
 
-/// \brief Returns true when Opcall is a call a one-parameter dereference of
+/// Returns true when Opcall is a call a one-parameter dereference of
 /// IndexVar.
 ///
 /// For example, if the index variable is `index`, returns true for
@@ -316,7 +316,7 @@
          exprReferencesVariable(IndexVar, OpCall->getArg(0));
 }
 
-/// \brief Returns true when Uop is a dereference of IndexVar.
+/// Returns true when Uop is a dereference of IndexVar.
 ///
 /// For example, if the index variable is `index`, returns true for
 ///   *index
@@ -329,7 +329,7 @@
          exprReferencesVariable(IndexVar, Uop->getSubExpr());
 }
 
-/// \brief Determines whether the given Decl defines a variable initialized to
+/// Determines whether the given Decl defines a variable initialized to
 /// the loop object.
 ///
 /// This is intended to find cases such as
@@ -416,7 +416,7 @@
   return false;
 }
 
-/// \brief Determines whether the bound of a for loop condition expression is
+/// Determines whether the bound of a for loop condition expression is
 /// the same as the statically computable size of ArrayType.
 ///
 /// Given
@@ -489,7 +489,7 @@
     Usages.push_back(U);
 }
 
-/// \brief If the unary operator is a dereference of IndexVar, include it
+/// If the unary operator is a dereference of IndexVar, include it
 /// as a valid usage and prune the traversal.
 ///
 /// For example, if container.begin() and container.end() both return pointers
@@ -511,7 +511,7 @@
   return VisitorBase::TraverseUnaryOperator(Uop);
 }
 
-/// \brief If the member expression is operator-> (overloaded or not) on
+/// If the member expression is operator-> (overloaded or not) on
 /// IndexVar, include it as a valid usage and prune the traversal.
 ///
 /// For example, given
@@ -588,7 +588,7 @@
   return VisitorBase::TraverseMemberExpr(Member);
 }
 
-/// \brief If a member function call is the at() accessor on the container with
+/// If a member function call is the at() accessor on the container with
 /// IndexVar as the single argument, include it as a valid usage and prune
 /// the traversal.
 ///
@@ -621,7 +621,7 @@
   return VisitorBase::TraverseCXXMemberCallExpr(MemberCall);
 }
 
-/// \brief If an overloaded operator call is a dereference of IndexVar or
+/// If an overloaded operator call is a dereference of IndexVar or
 /// a subscript of the container with IndexVar as the single argument,
 /// include it as a valid usage and prune the traversal.
 ///
@@ -667,7 +667,7 @@
   return VisitorBase::TraverseCXXOperatorCallExpr(OpCall);
 }
 
-/// \brief If we encounter an array with IndexVar as the index of an
+/// If we encounter an array with IndexVar as the index of an
 /// ArraySubsriptExpression, note it as a consistent usage and prune the
 /// AST traversal.
 ///
@@ -709,7 +709,7 @@
   return true;
 }
 
-/// \brief If we encounter a reference to IndexVar in an unpruned branch of the
+/// If we encounter a reference to IndexVar in an unpruned branch of the
 /// traversal, mark this loop as unconvertible.
 ///
 /// This implements the whitelist for convertible loops: any usages of IndexVar
@@ -752,7 +752,7 @@
   return true;
 }
 
-/// \brief If the loop index is captured by a lambda, replace this capture
+/// If the loop index is captured by a lambda, replace this capture
 /// by the range-for loop variable.
 ///
 /// For example:
@@ -792,7 +792,7 @@
   return VisitorBase::TraverseLambdaCapture(LE, C, Init);
 }
 
-/// \brief If we find that another variable is created just to refer to the loop
+/// If we find that another variable is created just to refer to the loop
 /// element, note it for reuse as the loop variable.
 ///
 /// See the comments for isAliasDecl.
@@ -867,7 +867,7 @@
   return OldIndex->getName();
 }
 
-/// \brief Determines whether or not the the name \a Symbol conflicts with
+/// Determines whether or not the the name \a Symbol conflicts with
 /// language keywords or defined macros. Also checks if the name exists in
 /// LoopContext, any of its parent contexts, or any of its child statements.
 ///