bugfix in InfiniteLoopCheck to not print warnings for unevaluated loops

[usama54321]

Summary

Added a separate check for unevaluated statements. Updated InfiniteLoopCheck to use new check

clang-tools-extra/clang-tidy/bugprone/InfiniteLoopCheck.cpp

if (const auto *While = dyn_cast<WhileStmt>(LoopStmt)) {
     if (const VarDecl *LoopVarDecl = While->getConditionVariable()) {
       if (const Expr *Init = LoopVarDecl->getInit()) {
         ShouldHaveConditionVariables = false;
         Cond = Init;
       }
     }
   }
 
+  if (ExprMutationAnalyzer::isUnevaluated(LoopStmt, *LoopStmt, *Result.Context))
+    return;
+
   if (isAtLeastOneCondVarChanged(Func, LoopStmt, Cond, Result.Context))
     return;
 
   std::string CondVarNames = getCondVarNames(Cond);
   if (ShouldHaveConditionVariables && CondVarNames.empty())
     return;
 
   if (CondVarNames.empty()) {

clang-tools-extra/test/clang-tidy/checkers/bugprone-infinite-loop.cpp

void test_dependent_condition() {
   do {
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this loop is infinite; none of its condition variables (val3) are updated in the loop body [bugprone-infinite-loop]
   } while (1, (true) && val3 == 1);
 
   const int val4 = some_template_fn<T>();
   do {
   } while (1, (false) && val4 == 1);
 }
+
+void test_typeof() {
+  __typeof__({
+    for (int i = 0; i < 10; ++i) {
+    }
+    0;
+  }) x;
+}
+
+void test_typeof_infinite() {
+  __typeof__({
+    for (int i = 0; i < 10;) {
+    }
+    0;
+  }) x;
+}
+
+void test_typeof_while_infinite() {
+  __typeof__({
+    int i = 0;
+    while (i < 10) {
+    }
+    0;
+  }) x;
+}
+
+void test_typeof_dowhile_infinite() {
+  __typeof__({
+    int i = 0;
+    do {
+
+    } while (i < 10);
+    0;
+  }) x;
+}

clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h

public:
   bool isPointeeMutated(const Expr *Exp) {
     return findPointeeMutation(Exp) != nullptr;
   }
   bool isPointeeMutated(const Decl *Dec) {
     return findPointeeMutation(Dec) != nullptr;
   }
   const Stmt *findPointeeMutation(const Expr *Exp);
   const Stmt *findPointeeMutation(const Decl *Dec);
+  static bool isUnevaluated(const Stmt *Smt, const Stmt &Stm,
+                            ASTContext &Context);
+  static bool isUnevaluated(const Expr *Exp, const Stmt &Stm,
+                            ASTContext &Context);
 
 private:
   using MutationFinder = const Stmt *(ExprMutationAnalyzer::*)(const Expr *);
   using ResultMap = llvm::DenseMap<const Expr *, const Stmt *>;
 
   const Stmt *findMutationMemoized(const Expr *Exp,
                                    llvm::ArrayRef<MutationFinder> Finders,
                                    ResultMap &MemoizedResults);

clang/lib/Analysis/ExprMutationAnalyzer.cpp

const Stmt *ExprMutationAnalyzer::tryEachDeclRef(const Decl *Dec,
   for (const auto &RefNodes : Refs) {
     const auto *E = RefNodes.getNodeAs<Expr>(NodeID<Expr>::value);
     if ((this->*Finder)(E))
       return E;
   }
   return nullptr;
 }
 
-bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp) {
-  return selectFirst<Expr>(
-             NodeID<Expr>::value,
-             match(
-                 findAll(
-                     expr(canResolveToExpr(equalsNode(Exp)),
-                          anyOf(
-                              // `Exp` is part of the underlying expression of
-                              // decltype/typeof if it has an ancestor of
-                              // typeLoc.
-                              hasAncestor(typeLoc(unless(
-                                  hasAncestor(unaryExprOrTypeTraitExpr())))),
-                              hasAncestor(expr(anyOf(
-                                  // `UnaryExprOrTypeTraitExpr` is unevaluated
-                                  // unless it's sizeof on VLA.
-                                  unaryExprOrTypeTraitExpr(unless(sizeOfExpr(
-                                      hasArgumentOfType(variableArrayType())))),
-                                  // `CXXTypeidExpr` is unevaluated unless it's
-                                  // applied to an expression of glvalue of
-                                  // polymorphic class type.
-                                  cxxTypeidExpr(
-                                      unless(isPotentiallyEvaluated())),
-                                  // The controlling expression of
-                                  // `GenericSelectionExpr` is unevaluated.
-                                  genericSelectionExpr(hasControllingExpr(
-                                      hasDescendant(equalsNode(Exp)))),
-                                  cxxNoexceptExpr())))))
+auto isUnevaluatedMatcher(const Stmt *Exp) {
+  return anyOf(
+      hasAncestor(typeLoc(unless(hasAncestor(unaryExprOrTypeTraitExpr())))),
+          unaryExprOrTypeTraitExpr(
+              unless(sizeOfExpr(hasArgumentOfType(variableArrayType())))),
+          cxxTypeidExpr(unless(isPotentiallyEvaluated())),
+          genericSelectionExpr(
+              hasControllingExpr(hasDescendant(equalsNode(Exp)))),
+          cxxNoexceptExpr()))));
+}
+
+bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp, const Stmt &Stm,
+                                         ASTContext &Context) {
+  return selectFirst<Expr>(NodeID<Expr>::value,
+                           match(findAll(expr(canResolveToExpr(equalsNode(Exp)),
+                                              isUnevaluatedMatcher(Exp))
                                              .bind(NodeID<Expr>::value)),
                                  Stm, Context)) != nullptr;
 }
 
+bool ExprMutationAnalyzer::isUnevaluated(const Stmt *Exp, const Stmt &Stm,
+                                         ASTContext &Context) {
+  return selectFirst<Stmt>(
+             NodeID<Expr>::value,
+             match(findAll(stmt(equalsNode(Exp), isUnevaluatedMatcher(Exp))
+                               .bind(NodeID<Expr>::value)),
+                   Stm, Context)) != nullptr;
+}
+
+bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp) {
+  return isUnevaluated(Exp, Stm, Context);
+}
+
 const Stmt *
 ExprMutationAnalyzer::findExprMutation(ArrayRef<BoundNodes> Matches) {
   return tryEachMatch<Expr>(Matches, this, &ExprMutationAnalyzer::findMutation);
 }
 
 const Stmt *
 ExprMutationAnalyzer::findDeclMutation(ArrayRef<BoundNodes> Matches) {
   return tryEachMatch<Decl>(Matches, this, &ExprMutationAnalyzer::findMutation);