[clang] Introduce while and do..while condition checks

[stryku]

Summary

There are various checks implemented for condition expression in for loop. I thought that we could have similar in while and do..while loops. Curious what you think.

[lattner]

Cool, this conceptually makes a lot of sense to me! That said, I'm not a competent reviewer in this area anymore, @klimek can you recommend someone?

[stryku]

Great, I can see some builds have failed. Will do my best to fix that tomorrow.

[stryku]

Sorry for the delay of fixing failed builds. Full builds and tests take some time. I'm working on it, promise.
The code itself won't change much, so I think it can be reviewed. Or at least the idea can be judged if it's something desired to have in clang. @lattner or @klimek could you please recommend someone to ask for review?

[stryku]

Well, unfortunately I'm unable to reproduce the failed builds. Everything passes for me locally. @lattner or @klimek, or someone who you think is a good candidate to review this code - could you please try to test it?
Could you please assist me how to proceed with this patch?

[rsmith]

clang/lib/Sema/SemaStmt.cpp

1851–1852

Please sink this variable down to the point where we've decided we're going to emit a diagnostic, and switch from PDiag to Diag.

1851–1888

2118

[stryku]

Thank you for review! Implemented the changes

[stryku]

I think clang-format is yelling at places where formatting should not be applied, so I'm gonna ignore that.

[rtrieu]

I wrote the original for loop warning. I did try to extend it to while loops, but due to the different usage of these types of loops, there was a higher false positive rate for while loops that in for loops. For loops are generally self-contained, so checking only the loop and loop body is a good way to determine if the condition is changed. However, while loops are also used in things like multi-threaded code and the while loop is used as a wait.

void Run() {
  bool Wait = true;
  Execute(&Wait);
  while (Wait) {
    // Do some waiting
  }
}

To lower the false positive rate, I tried to add a bool to Decl's to track if they are possible referenced from other places. To do that, Sema needs to be changed to track that bit. Unfortunately, the Sema change was not accepted, so without a way to lower the false positive rate, I abandoned the warning.

Links to old discussions on mailing lists:
Patch to add warning to while loops
https://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20120604/058677.html
Patch to add reference bit to Decl
https://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20121112/068241.html

There's a few ways forward if you want to keep working on this warning.

1. Run your version of the warning over a large codebase to get more recent data on true versus false positives. If the numbers have changed since last time, it makes for a greater argument to have this warning.
2. Find another method to reduce the false positive rate, specifically, examples as listed above.
3. Instead of making it a warning, implement it in static analysis as mentioned in the review of the original patch

[stryku]

Thank you for such a detailed comment. Makes sense. I need to think how to proceed. Will ping you when I figure something out.

clang/include/clang/Basic/DiagnosticGroups.td

 def LiteralRange : DiagGroup<"literal-range">;
 def LocalTypeTemplateArgs : DiagGroup<"local-type-template-args",
                                       [CXX98CompatLocalTypeTemplateArgs]>;
 def RangeLoopConstruct : DiagGroup<"range-loop-construct">;
 def RangeLoopBindReference : DiagGroup<"range-loop-bind-reference">;
 def RangeLoopAnalysis : DiagGroup<"range-loop-analysis",
                                   [RangeLoopConstruct, RangeLoopBindReference]>;
 def ForLoopAnalysis : DiagGroup<"for-loop-analysis">;
-def LoopAnalysis : DiagGroup<"loop-analysis", [ForLoopAnalysis,
+def WhileLoopAnalysis : DiagGroup<"while-loop-analysis">;
+def LoopAnalysis : DiagGroup<"loop-analysis", [WhileLoopAnalysis,
+                                               ForLoopAnalysis,
                                                RangeLoopAnalysis]>;
 def MalformedWarningCheck : DiagGroup<"malformed-warning-check">;
 def Main : DiagGroup<"main">;
 def MainReturnType : DiagGroup<"main-return-type">;
 def MaxUnsignedZero : DiagGroup<"max-unsigned-zero">;
 def MissingBraces : DiagGroup<"missing-braces">;
 def MissingDeclarations: DiagGroup<"missing-declarations">;
 def : DiagGroup<"missing-format-attribute">;

 
 def Most : DiagGroup<"most", [
     BoolOperation,
     CharSubscript,
     Comment,
     DeleteNonVirtualDtor,
     Format,
     ForLoopAnalysis,
+    WhileLoopAnalysis,
     FrameAddress,
     Implicit,
     InfiniteRecursion,
     IntInBoolContext,
     MismatchedTags,
     MissingBraces,
     Move,
     MultiChar,

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_variables_not_in_loop_body : Warning<
   "used in loop condition not modified in loop body">,
   InGroup<ForLoopAnalysis>, DefaultIgnore;
 def warn_redundant_loop_iteration : Warning<
   "variable %0 is %select{decremented|incremented}1 both in the loop header "
   "and in the loop body">,
   InGroup<ForLoopAnalysis>, DefaultIgnore;
 def note_loop_iteration_here : Note<"%select{decremented|incremented}0 here">;
 
+// While loop analysis
+def warn_variables_not_in_while_loop_body : Warning<
+  "variable%select{s| %1|s %1 and %2|s %1, %2, and %3|s %1, %2, %3, and %4}0 "
+  "used in loop condition not modified in loop body">,
+  InGroup<WhileLoopAnalysis>, DefaultIgnore;
+
 def warn_duplicate_enum_values : Warning<
   "element %0 has been implicitly assigned %1 which another element has "
   "been assigned">, InGroup<DiagGroup<"duplicate-enum">>, DefaultIgnore;
 def note_duplicate_element : Note<"element %0 also has value %1">;
 
 // Absolute value functions
 def warn_unsigned_abs : Warning<
   "taking the absolute value of unsigned type %0 has no effect">,

clang/lib/Sema/SemaStmt.cpp

if (!Context.hasSameUnqualifiedType(SrcType, DstType) &&
             Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment)
                 << DstType.getUnqualifiedType();
           }
         }
       }
     }
 }
 
-StmtResult Sema::ActOnWhileStmt(SourceLocation WhileLoc,
-                                SourceLocation LParenLoc, ConditionResult Cond,
-                                SourceLocation RParenLoc, Stmt *Body) {
-  if (Cond.isInvalid())
-    return StmtError();
-
-  auto CondVal = Cond.get();
-  CheckBreakContinueBinding(CondVal.second);
-
-  if (CondVal.second &&
-      !Diags.isIgnored(diag::warn_comma_operator, CondVal.second->getExprLoc()))
-    CommaVisitor(*this).Visit(CondVal.second);
-
-  if (isa<NullStmt>(Body))
-    getCurCompoundScope().setHasEmptyLoopBodies();
-
-  return WhileStmt::Create(Context, CondVal.first, CondVal.second, Body,
-                           WhileLoc, LParenLoc, RParenLoc);
-}
-
-StmtResult
-Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
-                  SourceLocation WhileLoc, SourceLocation CondLParen,
-                  Expr *Cond, SourceLocation CondRParen) {
-  assert(Cond && "ActOnDoStmt(): missing expression");
-
-  CheckBreakContinueBinding(Cond);
-  ExprResult CondResult = CheckBooleanCondition(DoLoc, Cond);
-  if (CondResult.isInvalid())
-    return StmtError();
-  Cond = CondResult.get();
-
-  CondResult = ActOnFinishFullExpr(Cond, DoLoc, /*DiscardedValue*/ false);
-  if (CondResult.isInvalid())
-    return StmtError();
-  Cond = CondResult.get();
-
-  // Only call the CommaVisitor for C89 due to differences in scope flags.
-  if (Cond && !getLangOpts().C99 && !getLangOpts().CPlusPlus &&
-      !Diags.isIgnored(diag::warn_comma_operator, Cond->getExprLoc()))
-    CommaVisitor(*this).Visit(Cond);
-
-  return new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen);
-}
-
 namespace {
   // Use SetVector since the diagnostic cares about the ordering of the Decl's.
   using DeclSetVector =
       llvm::SetVector<VarDecl *, llvm::SmallVector<VarDecl *, 8>,
                       llvm::SmallPtrSet<VarDecl *, 8>>;
 
   // This visitor will traverse a conditional statement and store all
   // the evaluated decls into a vector.  Simple is set to true if none
   // of the excluded constructs are used.
   class DeclExtractor : public EvaluatedExprVisitor<DeclExtractor> {
     DeclSetVector &Decls;
     SmallVectorImpl<SourceRange> &Ranges;
     bool Simple;
   public:
     typedef EvaluatedExprVisitor<DeclExtractor> Inherited;
 
     DeclExtractor(Sema &S, DeclSetVector &Decls,
                   SmallVectorImpl<SourceRange> &Ranges) :
         Inherited(S.Context),
         Decls(Decls),
         Ranges(Ranges),
         Simple(true) {}
 
-    bool isSimple() { return Simple; }
+    bool isSimple() const { return Simple; }
 
     // Replaces the method in EvaluatedExprVisitor.
     void VisitMemberExpr(MemberExpr* E) {
       Simple = false;
     }
 
     // Any Stmt not explicitly listed will cause the condition to be marked
     // complex.
void VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
           Visit(S);
       }
     }
 
     bool FoundDeclInUse() { return FoundDecl; }
 
   };  // end class DeclMatcher
 
+  void CheckWhileLoopConditionalStatement(Sema &S, Expr *Cond, Stmt *Body) {
+
+    if (S.Diags.isIgnored(diag::warn_variables_not_in_while_loop_body,
+                          Cond->getBeginLoc()))
+      return;
+
+    DeclSetVector Decls;
+    SmallVector<SourceRange, 10> Ranges;
+    DeclExtractor DE(S, Decls, Ranges);
+    DE.Visit(Cond);
+
+    // Don't analyze complex conditionals.
+    if (!DE.isSimple())
+      return;
+
+    // No decls found.
+    if (Decls.empty())
+      return;
+
+    // Don't warn on volatile, static, or global variables.
+    if (std::any_of(Decls.begin(), Decls.end(), [](const auto *VD) {
+          return VD->getType().isVolatileQualified() || VD->hasGlobalStorage();
+        }))
+      return;
+
+    if (DeclMatcher(S, Decls, Cond).FoundDeclInUse() ||
+        DeclMatcher(S, Decls, Body).FoundDeclInUse())
+      return;
+
+    auto Diag = S.Diag(Ranges.begin()->getBegin(),
+                       diag::warn_variables_not_in_while_loop_body);
+
+    // Load decl names into diagnostic.
+    if (Decls.size() > 4) {
+      Diag << 0;
+    } else {
+      Diag << (unsigned)Decls.size();
+      for (auto *VD : Decls)
+        Diag << VD->getDeclName();
+    }
+
+    for (auto Range : Ranges)
+      Diag << Range;
+  }
+
   void CheckForLoopConditionalStatement(Sema &S, Expr *Second,
                                         Expr *Third, Stmt *Body) {
     // Condition is empty
     if (!Second) return;
 
     if (S.Diags.isIgnored(diag::warn_variables_not_in_loop_body,
                           Second->getBeginLoc()))
       return;
void CheckForRedundantIteration(Sema &S, Expr *Third, Stmt *Body) {
     S.Diag(LastDRE->getLocation(), diag::warn_redundant_loop_iteration)
          << LastDRE->getDecl() << LastIncrement;
     S.Diag(LoopDRE->getLocation(), diag::note_loop_iteration_here)
          << LoopIncrement;
   }
 
 } // end namespace
 
+StmtResult Sema::ActOnWhileStmt(SourceLocation WhileLoc,
+                                SourceLocation LParenLoc, ConditionResult Cond,
+                                SourceLocation RParenLoc, Stmt *Body) {
+  if (Cond.isInvalid())
+    return StmtError();
+
+  auto CondVal = Cond.get();
+  CheckBreakContinueBinding(CondVal.second);
+
+  if (CondVal.second &&
+      !Diags.isIgnored(diag::warn_comma_operator, CondVal.second->getExprLoc()))
+    CommaVisitor(*this).Visit(CondVal.second);
+
+  // Check only if variable is not declared inside the condition.
+  if (!CondVal.first)
+    CheckWhileLoopConditionalStatement(*this, CondVal.second, Body);
+
+  if (isa<NullStmt>(Body))
+    getCurCompoundScope().setHasEmptyLoopBodies();
+
+  return WhileStmt::Create(Context, CondVal.first, CondVal.second, Body,
+                           WhileLoc, LParenLoc, RParenLoc);
+}
+
+StmtResult Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
+                             SourceLocation WhileLoc, SourceLocation CondLParen,
+                             Expr *Cond, SourceLocation CondRParen) {
+  assert(Cond && "ActOnDoStmt(): missing expression");
+
+  CheckBreakContinueBinding(Cond);
+  ExprResult CondResult = CheckBooleanCondition(DoLoc, Cond);
+  if (CondResult.isInvalid())
+    return StmtError();
+  Cond = CondResult.get();
+
+  CondResult = ActOnFinishFullExpr(Cond, DoLoc, /*DiscardedValue*/ false);
+  if (CondResult.isInvalid())
+    return StmtError();
+  Cond = CondResult.get();
+
+  // Only call the CommaVisitor for C89 due to differences in scope flags.
+  if (Cond && !getLangOpts().C99 && !getLangOpts().CPlusPlus &&
+      !Diags.isIgnored(diag::warn_comma_operator, Cond->getExprLoc()))
+    CommaVisitor(*this).Visit(Cond);
+
+  CheckWhileLoopConditionalStatement(*this, Cond, Body);
+
+  return new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen);
+}
 
 void Sema::CheckBreakContinueBinding(Expr *E) {
   if (!E || getLangOpts().CPlusPlus)
     return;
   BreakContinueFinder BCFinder(*this, E);
   Scope *BreakParent = CurScope->getBreakParent();
   if (BCFinder.BreakFound() && BreakParent) {
     if (BreakParent->getFlags() & Scope::SwitchScope) {

clang/test/Index/pragma-diag-reparse.c

 #pragma clang diagnostic ignored "-Wtautological-compare"
 #include "pragma_disable_warning.h"
 
 int main (int argc, const char * argv[])
 {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
   int x=0;
 #pragma clang diagnostic pop
 
   return x;
 }
 
 #pragma clang diagnostic ignored "-Wmisleading-indentation"
-void foo(void) { int b=0; while (b==b); }
+void foo(void) { int b=0; while (b==b) ++b; }
 
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_FAILONERROR=1 c-index-test -test-load-source-reparse 5 local \
 // RUN: -I%S/Inputs \
 // RUN:   %s -Wall -Werror | FileCheck %s
 
 // CHECK: pragma-diag-reparse.c:8:7: VarDecl=x:8:7 (Definition) Extent=[8:3 - 8:10]

clang/test/Misc/warning-wall.c

 CHECK-NEXT:      -Wformat-extra-args
 CHECK-NEXT:      -Wformat-zero-length
 CHECK-NEXT:      -Wnonnull
 CHECK-NEXT:      -Wformat-security
 CHECK-NEXT:      -Wformat-y2k
 CHECK-NEXT:      -Wformat-invalid-specifier
 CHECK-NEXT:      -Wformat-insufficient-args
 CHECK-NEXT:    -Wfor-loop-analysis
+CHECK-NEXT:    -Wwhile-loop-analysis
 CHECK-NEXT:    -Wframe-address
 CHECK-NEXT:    -Wimplicit
 CHECK-NEXT:      -Wimplicit-function-declaration
 CHECK-NEXT:      -Wimplicit-int
 CHECK-NEXT:    -Winfinite-recursion
 CHECK-NEXT:    -Wint-in-bool-context
 CHECK-NEXT:    -Wmismatched-tags
 CHECK-NEXT:    -Wmissing-braces

clang/test/Preprocessor/pragma_diagnostic_sections.cpp

 // RUN: %clang_cc1 -fsyntax-only -Wall -Wunused-macros -Wunused-parameter -Wno-uninitialized -verify %s
 
 // rdar://8365684
 struct S {
-    void m1() { int b; while (b==b); } // expected-warning {{always evaluates to true}}
+    void m1() { int b; while (b==b) ++b; } // expected-warning {{always evaluates to true}}
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wtautological-compare"
-    void m2() { int b; while (b==b); }
+    void m2() { int b; while (b==b) ++b; }
 #pragma clang diagnostic pop
 
-    void m3() { int b; while (b==b); } // expected-warning {{always evaluates to true}}
+    void m3() { int b; while (b==b) ++b; } // expected-warning {{always evaluates to true}}
 };
 
 //------------------------------------------------------------------------------
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wtautological-compare"
 template <typename T>
 struct TS {
-    void m() { T b; while (b==b); }
+    void m() { T b; while (b==b) ++b; }
 };
 #pragma clang diagnostic pop
 
 void f() {
     TS<int> ts;
     ts.m();
 }
 

clang/test/SemaCXX/warn-loop-analysis.cpp

exit_loop:
 
   for (int *i, *j; i < j; ++i) {}
   for (int *i, *j; i < j;) {}  // expected-warning {{variables 'i' and 'j' used in loop condition not modified in loop body}}
 
   // Dereferencing pointers is ignored for now.
   for (int *i; *i; ) {}
 }
 
+void test_while1() {
+  S s;
+  int i, j;
+  while (!s.stop()) {}
+  while (s.keep_running) {}
+  while (i < 1) { ++i; }
+  while (i < 1) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i < 1) { return; }
+  while (i < 1) { break; }
+  while (i < 1) { goto exit_loop; }
+  
+exit_loop:
+  while (i < 1) { by_ref(i); }
+  while (i < 1) { by_value(i); } // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i < 1) { by_pointer(&i); }
+
+  while (i < 1) {
+    while (j < 1) { ++j; }
+    ++i;
+  }
+  while (i < 1) {
+    while (j < 1) { ++i; } // expected-warning {{variable 'j' used in loop condition not modified in loop body}}
+    ++i;
+  }
+  while (i < 1) {
+    while (i < 1) { ++j; } // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+    ++i;
+  }
+
+  int *ip, *jp;
+  while (ip < jp) { ++ip; }
+  while (ip < jp) {} // expected-warning {{variables 'ip' and 'jp' used in loop condition not modified in loop body}}
+
+  // Dereferencing pointers is ignored for now.
+  while (*ip) {}
+}
+
+void test_do_while1() {
+  S s;
+  int i, j;
+  do {} while (!s.stop());
+  do {} while (s.keep_running);
+  do { ++i; } while (i < 1);
+  do {} while (i < 1); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { return; } while (i < 1);
+  do { break; } while (i < 1);
+  do { goto exit_loop; } while (i < 1);
+
+exit_loop:
+  do { by_ref(i); } while (i < 1);
+  do { by_value(i); } while (i < 1); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { by_pointer(&i); } while (i < 1);
+
+  do {
+    do { ++j; } while (j < 1);
+    ++i;
+  } while (i < 1);
+
+  do {
+    do { ++i; } while (j < 1); // expected-warning {{variable 'j' used in loop condition not modified in loop body}}
+    ++i;
+  } while (i < 1);
+
+  do {
+    do { ++j; } while (i < 1); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+    ++i;
+  } while (i < 1);
+
+  int *ip, *jp;
+  do { ++ip; } while (ip < jp);
+  do {} while (ip < jp); // expected-warning {{variables 'ip' and 'jp' used in loop condition not modified in loop body}}
+
+  // Dereferencing pointers is ignored for now.
+  do {} while (*ip);
+}
+
 void test2() {
   int i, j, k;
   int *ptr;
 
   // Testing CastExpr
   for (; i; ) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
   for (; i; ) { i = 5; }
 
void test2() {
   for (; (i); ) { ++i; }
 
   // Testing non-evaluated variables
   for (; i < sizeof(j); ) { }  // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
   for (; i < sizeof(j); ) { ++j; }  // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
   for (; i < sizeof(j); ) { ++i; }
 }
 
+void test_while2() {
+  int i, j, k;
+  int *ptr;
+
+  // Testing CastExpr
+  while (i) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i) { i = 5; }
+
+  // Testing BinaryOperator
+  while (i < j) {} // expected-warning {{variables 'i' and 'j' used in loop condition not modified in loop body}}
+  while (i < j) { i = 5; }
+  while (i < j) { j = 5; }
+
+  // Testing IntegerLiteral
+  while (i < 5) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i < 5) { i = 5; }
+
+  // Testing FloatingLiteral
+  while (i < 5.0) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i < 5.0) { i = 5; }
+
+  // Testing CharacterLiteral
+  while (i == 'a') {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i == 'a') { i = 5; }
+
+  // Testing CXXBoolLiteralExpr
+  while (i == true) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i == true) { i = 5; }
+
+  // Testing GNUNullExpr
+  while (ptr == __null) {} // expected-warning {{variable 'ptr' used in loop condition not modified in loop body}}
+  while (ptr == __null) { ptr = &i; }
+
+  // Testing UnaryOperator
+  while (-i > 5) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (-i > 5) { ++i; }
+
+  // Testing ImaginaryLiteral
+  while (i != 3i) {} // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i != 3i) { ++i; }
+
+  // Testing ConditionalOperator
+  while (i ? j : k) {} // expected-warning {{variables 'i', 'j', and 'k' used in loop condition not modified in loop body}}
+  while (i ? j : k) { ++i; }
+  while (i ? j : k) { ++j; }
+  while (i ? j : k) { ++k; }
+  while (i) { j = i ? i : i; } // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i) { j = (i = 1) ? i : i; }
+  while (i) { j = i ? i : ++i; }
+
+  // Testing BinaryConditionalOperator
+  while (i ?: j) {} // expected-warning {{variables 'i' and 'j' used in loop condition not modified in loop body}}
+  while (i ?: j) { ++i; }
+  while (i ?: j) { ++j; }
+  while (i) { j = i ?: i; }  // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+
+  // Testing ParenExpr
+  while ((i)) { }  // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while ((i)) { ++i; }
+
+  // Testing non-evaluated variables
+  while (i < sizeof(j)) { } // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i < sizeof(j)) { ++j; } // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  while (i < sizeof(j)) { ++i; }
+}
+
+void test_do_while2() {
+  int i, j, k;
+  int *ptr;
+
+  // Testing CastExpr
+  do {} while (i); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { i = 5; } while (i);
+
+  // Testing BinaryOperator
+  do {} while (i < j); // expected-warning {{variables 'i' and 'j' used in loop condition not modified in loop body}}
+  do { i = 5; } while (i < j);
+  do { j = 5; } while (i < j);
+
+  // Testing IntegerLiteral
+  do {} while (i < 5); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { i = 5; } while (i < 5);
+
+  // Testing FloatingLiteral
+  do {} while (i < 5.0); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { i = 5; } while (i < 5.0);
+
+  // Testing CharacterLiteral
+  do {} while (i == 'a'); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { i = 5; } while (i == 'a');
+
+  // Testing CXXBoolLiteralExpr
+  do {} while (i == true); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do  { i = 5; } while (i == true);
+
+  // Testing GNUNullExpr
+  do {} while (ptr == __null); // expected-warning {{variable 'ptr' used in loop condition not modified in loop body}}
+  do { ptr = &i; } while (ptr == __null);
+
+  // Testing UnaryOperator
+  do {} while (-i > 5); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { ++i; } while (-i > 5);
+
+  // Testing ImaginaryLiteral
+  do {} while (i != 3i); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { ++i; } while (i != 3i);
+
+  // Testing ConditionalOperator
+  do {} while (i ? j : k); // expected-warning {{variables 'i', 'j', and 'k' used in loop condition not modified in loop body}}
+  do { ++i; } while (i ? j : k);
+  do { ++j; } while (i ? j : k);
+  do { ++k; } while (i ? j : k);
+  do { j = i ? i : i; } while (i); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { j = (i = 1) ? i : i; } while (i);
+  do { j = i ? i : ++i; } while (i);
+
+  // Testing BinaryConditionalOperator
+  do {} while (i ?: j); // expected-warning {{variables 'i' and 'j' used in loop condition not modified in loop body}}
+  do { ++i; } while (i ?: j);
+  do { ++j; } while (i ?: j);
+  do { j = i ?: i; } while (i); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+
+  // Testing ParenExpr
+  do {} while ((i)); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { ++i; } while ((i));
+
+  // Testing non-evaluated variables
+  do {} while (i < sizeof(j)); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { ++j; } while (i < sizeof(j)); // expected-warning {{variable 'i' used in loop condition not modified in loop body}}
+  do { ++i; } while (i < sizeof(j));
+}
+
 // False positive and how to silence.
 void test3() {
   int x;
   int *ptr = &x;
   for (;x<5;) { *ptr = 6; }  // expected-warning {{variable 'x' used in loop condition not modified in loop body}}
 
   for (;x<5;) {
     *ptr = 6;
     (void)x;
   }
 }
 
+void test_while3() {
+  int x;
+  int *ptr = &x;
+  while (x < 5) { *ptr = 6; }  // expected-warning {{variable 'x' used in loop condition not modified in loop body}}
+
+  while (x < 5) {
+    *ptr = 6;
+    (void)x;
+  }
+}
+
+void test_do_while3() {
+  int x;
+  int *ptr = &x;
+  do { *ptr = 6; } while (x < 5); // expected-warning {{variable 'x' used in loop condition not modified in loop body}}
+
+  do {
+    *ptr = 6;
+    (void)x;
+  } while (x < 5);
+}
+
 // Check ordering and printing of variables.  Max variables is currently 4.
 void test4() {
   int a, b, c, d, e, f;
   for (; a;);  // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
   for (; a + b;);  // expected-warning {{variables 'a' and 'b' used in loop condition not modified in loop body}}
   for (; a + b + c;);  // expected-warning {{variables 'a', 'b', and 'c' used in loop condition not modified in loop body}}
   for (; a + b + c + d;);  // expected-warning {{variables 'a', 'b', 'c', and 'd' used in loop condition not modified in loop body}}
   for (; a + b + c + d + e;);  // expected-warning {{variables used in loop condition not modified in loop body}}
   for (; a + b + c + d + e + f;);  // expected-warning {{variables used in loop condition not modified in loop body}}
   for (; a + c + d + b;);  // expected-warning {{variables 'a', 'c', 'd', and 'b' used in loop condition not modified in loop body}}
   for (; d + c + b + a;);  // expected-warning {{variables 'd', 'c', 'b', and 'a' used in loop condition not modified in loop body}}
 }
 
+void test_while4() {
+  int a, b, c, d, e, f;
+  while (a);  // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  while (a + b);  // expected-warning {{variables 'a' and 'b' used in loop condition not modified in loop body}}
+  while (a + b + c);  // expected-warning {{variables 'a', 'b', and 'c' used in loop condition not modified in loop body}}
+  while (a + b + c + d);  // expected-warning {{variables 'a', 'b', 'c', and 'd' used in loop condition not modified in loop body}}
+  while (a + b + c + d + e);  // expected-warning {{variables used in loop condition not modified in loop body}}
+  while (a + b + c + d + e + f);  // expected-warning {{variables used in loop condition not modified in loop body}}
+  while (a + c + d + b);  // expected-warning {{variables 'a', 'c', 'd', and 'b' used in loop condition not modified in loop body}}
+  while (d + c + b + a);  // expected-warning {{variables 'd', 'c', 'b', and 'a' used in loop condition not modified in loop body}}
+}
+
+void test_do_while4() {
+  int a, b, c, d, e, f;
+  do {} while (a);  // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  do {} while (a + b);  // expected-warning {{variables 'a' and 'b' used in loop condition not modified in loop body}}
+  do {} while (a + b + c);  // expected-warning {{variables 'a', 'b', and 'c' used in loop condition not modified in loop body}}
+  do {} while (a + b + c + d);  // expected-warning {{variables 'a', 'b', 'c', and 'd' used in loop condition not modified in loop body}}
+  do {} while (a + b + c + d + e);  // expected-warning {{variables used in loop condition not modified in loop body}}
+  do {} while (a + b + c + d + e + f);  // expected-warning {{variables used in loop condition not modified in loop body}}
+  do {} while (a + c + d + b);  // expected-warning {{variables 'a', 'c', 'd', and 'b' used in loop condition not modified in loop body}}
+  do {} while (d + c + b + a);  // expected-warning {{variables 'd', 'c', 'b', and 'a' used in loop condition not modified in loop body}}
+}
+
 // Ensure that the warning doesn't fail when lots of variables are used
 // in the conditional.
 void test5() {
   for (int a; a+a+a+a+a+a+a+a+a+a;); // \
    // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
   for (int a; a+a+a+a+a+a+a+a+a+a+a;); // \
    // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
   for (int a; a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a;);  // \
    // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
   for (int a; a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a;);//\
    // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
 }
 
+void test_while5() {
+  int a;
+  while (a+a+a+a+a+a+a+a+a+a); // \
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  while (a+a+a+a+a+a+a+a+a+a+a); // \
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  while (a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a);  // \
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  while (a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a);//\
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+}
+
+void test_do_while5() {
+  int a;
+  do {} while (a+a+a+a+a+a+a+a+a+a); // \
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  do {} while (a+a+a+a+a+a+a+a+a+a+a); // \
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  do {} while (a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a);  // \
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+  do {} while (a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a+a);//\
+   // expected-warning {{variable 'a' used in loop condition not modified in loop body}}
+}
+
 // Ignore global variables and static variables.
 int x6;
 void test6() {
   static int y;
   for (;x6;);
   for (;y;);
 }
 
+void test_while6() {
+  static int y;
+  while (x6);
+  while (y);
+}
+
+void test_do_while6() {
+  static int y;
+  do {} while (x6);
+  do {} while (y);
+}
+
 void test7() {
   int i;
   for (;;i++) {  // expected-note{{incremented here}}
     if (true) test7();
     i++;  // expected-warning{{incremented both}}
   }
   for (;;i++) {  // expected-note{{incremented here}}
     if (true) break;

 }
 
 int f(int);
 void test9() {
   // Don't warn when variable is defined by the loop condition.
   for (int i = 0; int x = f(i); ++i) {}
 }
 
+void test_while9() {
+  // Don't warn when variable is defined by the loop condition.
+  int i = 0;
+  while (int x = f(i)) { ++i; }
+}
+
 // Don't warn when decomposition variables are in the loop condition.
 // TODO: BindingDecl's which make a copy should warn.
 void test10() {
   int arr[] = {1, 2, 3};
   for (auto[i, j, k] = arr;;) { }
   for (auto[i, j, k] = arr; i < j; ++i, ++j) { }
 
   for (auto[i, j, k] = arr; i;) { }
   for (auto[i, j, k] = arr; i < j;) { }
   for (auto[i, j, k] = arr; i < j; ++arr[0]) { }
 
   int a = 1, b = 2;
   for (auto[i, j, k] = arr; a < b;) { }  // expected-warning{{variables 'a' and 'b' used in loop condition not modified in loop body}}
   for (auto[i, j, k] = arr; a < b; ++a) { }
 
   for (auto [i, j, k] = arr; i < a;) { }
   for (auto[i, j, k] = arr; i < a; ++a) { }
   for (auto[i, j, k] = arr; i < a; ++i) { }
   for (auto[i, j, k] = arr; i < a; ++arr[0]) { }
 };
+
+void test_while10() {
+  int arr[] = {1, 2, 3};
+  auto[i, j, k] = arr;
+  while (i < j) { ++i; ++j; }
+
+  while (i) {}
+  while (i < j) {}
+  while (i < j ) { ++arr[0]; }
+
+  int a = 1, b = 2;
+  while (a < b) {}  // expected-warning{{variables 'a' and 'b' used in loop condition not modified in loop body}}
+  while (a < b ) { ++a; }
+
+  while (i < a) {}
+  while (i < a) { ++a; }
+  while (i < a) { ++i; }
+  while (i < a) { ++arr[0]; }
+};
+
+void test_do_while10() {
+  int arr[] = {1, 2, 3};
+  auto[i, j, k] = arr;
+  do { ++i; ++j; } while(i < j);
+
+  do {} while (i);
+  do  {} while (i < j);
+  do { ++arr[0]; } while (i < j );
+
+  int a = 1, b = 2;
+  do {} while (a < b);  // expected-warning{{variables 'a' and 'b' used in loop condition not modified in loop body}}
+  do { ++a; } while (a < b );
+
+  do {} while (i < a);
+  do { ++a; } while (i < a);
+  do { ++i; } while (i < a);
+  do { ++arr[0]; } while (i < a);
+};