New warning on for-loops that never run because condition is false on the first iteration

[rtrieu]

Summary

This is a proposed warning to be added to -Wfor-loop-analysis, which is part of -Wall. This warning will catch instances where the condition will be false on the first iteration and the loop body will never be run. The warning will be emitted when:

1. The for-loop initializes or sets the value of a single variable to a constant value
2. The condition is a simple comparison between the variable and another constant value
3. If the initial value of the variable substituted into the comparison would cause the comparison to be false

In order to make step 3 work, the constant value from step 1 may need to be casted to a different type. The casts can be extracted from the comparison operand. This allows the warning to work with both integer and floating point types, as well as mixing types.

Two exceptions to this warning.

1. Parentheses around the condition will silence this warning. This is suggested in a note.
2. If the variable is used as an array index in the body, and the condition is less than a value the same as the array size.

Example:
https://reviews.llvm.org/D48498
This warning would have caught the issue that @lebedev.ri brought up about the loop not running.

[lebedev.ri]

Thank you for working on this!
This seems to be missing tests.

[rtrieu]

In D71503#1784697, @lebedev.ri wrote:

Thank you for working on this!
This seems to be missing tests.

My bad, still getting used to git. Updated with a test now.

clang/include/clang/AST/Expr.h

const Expr *skipRValueSubobjectAdjustments(
       SmallVectorImpl<const Expr *> &CommaLHS,
       SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
   const Expr *skipRValueSubobjectAdjustments() const {
     SmallVector<const Expr *, 8> CommaLHSs;
     SmallVector<SubobjectAdjustment, 8> Adjustments;
     return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
   }
 
+  // When the current Expr is a series of of casts on D, attempt to evaluate
+  // the Expr as if InitValue was substituted in for D and output resulting
+  // value to Result.
+  bool SubstituteValueWithCasts(ASTContext &Context, const APValue InitValue,
+                                const VarDecl *D, APValue &Result) const;
+
   /// Checks that the two Expr's will refer to the same value as a comparison
   /// operand.  The caller must ensure that the values referenced by the Expr's
   /// are not modified between E1 and E2 or the result my be invalid.
   static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() >= firstExprConstant &&
            T->getStmtClass() <= lastExprConstant;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_variables_not_in_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<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">;
+def warn_loop_never_run : Warning<
+  "variable %0 is set to value %1 on loop initialization, "
+  "but comparing %1 to %2 in the loop condition is false and "
+  "the loop body will never run">,
+  InGroup<ForLoopAnalysis>, DefaultIgnore;
+def note_loop_condition_silence : Note<
+  "place parentheses around the condition to silence this warning">;
 
 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<

clang/lib/AST/ExprConstant.cpp

static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
                                  QualType SrcType, const APFloat &Value,
                                  QualType DestType, APSInt &Result) {
   unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
   // Determine whether we are converting to unsigned or signed.
   bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
 
   Result = APSInt(DestWidth, !DestSigned);
   bool ignored;
-  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
-      & APFloat::opInvalidOp)
+  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored) &
+          APFloat::opInvalidOp)
+    if (E)
       return HandleOverflow(Info, E, Value, DestType);
   return true;
 }
 
 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
                                    QualType SrcType, QualType DestType,
                                    APFloat &Result) {
   APFloat Value = Result;
   bool ignored;
bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
                                  unsigned Type) const {
   if (!getType()->isPointerType())
     return false;
 
   Expr::EvalStatus Status;
   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
   return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
 }
+
+// Recursively apply casts from E to InitValue and return resulting value.
+static bool AdjustCastValue(EvalInfo &Info, const Expr *E,
+                            const APValue InitValue, const VarDecl *D,
+                            APValue &Result) {
+  const auto *Cast = dyn_cast<CastExpr>(E->IgnoreParens());
+  if (!Cast)
+    return false;
+  switch (Cast->getCastKind()) {
+    default:
+      return false;
+    case CK_LValueToRValue:
+      // Base case, just return InitValue.
+      if (const auto *DRE = dyn_cast<DeclRefExpr>(Cast->getSubExpr())) {
+        if (DRE->getDecl() == D) {
+          Result = InitValue;
+          return true;
+        }
+      }
+      return false;
+    case CK_NoOp:
+      return AdjustCastValue(Info, Cast->getSubExpr(), InitValue, D, Result);
+    case CK_IntegralCast:
+    case CK_IntegralToBoolean:
+    case CK_IntegralToFloating:
+    case CK_FloatingToIntegral:
+    case CK_FloatingToBoolean:
+    case CK_FloatingCast:
+      break;
+  }
+
+  // Casts need to be applied in reverse order they are encountered, so
+  // process the sub-expression first.
+  const auto* SubE = Cast->getSubExpr();
+  if (!AdjustCastValue(Info, SubE, InitValue, D, Result))
+    return false;
+
+  const QualType SourceType = SubE->getType();
+  const QualType DestType = E->getType();
+
+  switch (Cast->getCastKind()) {
+    default:
+      llvm_unreachable("Unhandled cast kind");
+    case CK_IntegralCast: {
+      APSInt Init = Result.getInt();
+      Result.setInt(
+          HandleIntToIntCast(Info, nullptr, DestType, SourceType, Init));
+      return true;
+    }
+    case CK_IntegralToFloating: {
+      APValue Init(APFloat(0.f));
+      Init.swap(Result);
+      return HandleIntToFloatCast(Info, nullptr, SourceType, Init.getInt(),
+                                  DestType, Result.getFloat());
+    }
+    case CK_FloatingToIntegral: {
+      APValue Init((APSInt()));
+      Init.swap(Result);
+      return HandleFloatToIntCast(Info, nullptr, SourceType, Init.getFloat(),
+                                  DestType, Result.getInt());
+    }
+    case CK_IntegralToBoolean:
+    case CK_FloatingToBoolean: {
+      bool BoolResult;
+      if (!HandleConversionToBool(Result, BoolResult))
+        return false;
+      APValue Bool(APSInt(1, true));
+      Bool.getInt() = BoolResult;
+      Result = Bool;
+
+      return true;
+    }
+    case CK_FloatingCast:
+      return HandleFloatToFloatCast(Info, nullptr, SourceType, DestType,
+                                    Result.getFloat());
+  }
+}
+
+bool Expr::SubstituteValueWithCasts(ASTContext &Context,
+                                    const APValue InitValue, const VarDecl *D,
+                                    APValue &Result) const {
+  EvalStatus Status;
+  EvalInfo Info(Context, Status, EvalInfo::EM_IgnoreSideEffects);
+  return AdjustCastValue(Info, this, InitValue, D, Result);
+}
+

clang/lib/Sema/SemaStmt.cpp

 #include "clang/Sema/SemaInternal.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
+#include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/TargetInfo.h"
void CheckForRedundantIteration(Sema &S, Expr *Third, Stmt *Body) {
     if (BreakContinueFinder(S, Body).ContinueFound()) return;
 
     S.Diag(LastDRE->getLocation(), diag::warn_redundant_loop_iteration)
          << LastDRE->getDecl() << LastIncrement;
     S.Diag(LoopDRE->getLocation(), diag::note_loop_iteration_here)
          << LoopIncrement;
   }
 
+  // Look for any array access of the form array[x] where 'x' is a given Decl
+  // and array is constant array with given size.
+  class ArrayFinder : public ConstEvaluatedExprVisitor<ArrayFinder> {
+    // Tracking boolean
+    bool FoundArray;
+    // Decl used as array index
+    const VarDecl *VD;
+    // Target size for array
+    llvm::APInt Size;
+
+  public:
+    typedef ConstEvaluatedExprVisitor<ArrayFinder> Inherited;
+    ArrayFinder(const ASTContext &Context) : Inherited(Context) { }
+
+    bool CheckForArrays(const Stmt *Body, llvm::APInt TargetArraySize,
+                        const VarDecl *D) {
+      FoundArray = false;
+      Size = TargetArraySize;
+      VD = D;
+      Visit(Body);
+      return FoundArray;
+    }
+
+    void VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
+      if (CheckArrayType(E->getBase()) && CheckIndex(E->getIdx())) {
+        FoundArray = true;
+      }
+      Inherited::VisitArraySubscriptExpr(E);
+    }
+
+  private:
+    // Helper function for checking array access.
+    bool CheckArrayType(const Expr *E) {
+      QualType ArrayTy = E->IgnoreImpCasts()->getType();
+      if (!ArrayTy->isConstantArrayType())
+        return false;
+      const ConstantArrayType *CAT = Context.getAsConstantArrayType(ArrayTy);
+      if (!CAT)
+        return false;
+      if (!llvm::APInt::isSameValue(CAT->getSize(), Size))
+        return false;
+      return true;
+    }
+
+    // Helper function for checking array access.
+    bool CheckIndex(const Expr *E) {
+      const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreImpCasts());
+      return DRE && DRE->getDecl() == VD;
+    }
+
+  };
+
+  // Emit a warning when the condition of a for-loop is false on the first
+  // iteration, making the loop body never executed.  Conditions in parenthesis
+  // will silence the warning.  Loop variables used as array accesses are also
+  // skipped.
+  void CheckFirstIterationCondition(Sema &S, const Stmt *First,
+                                    const Expr *Second, const Stmt *Body) {
+    if (!First || !Second || Second->isTypeDependent() ||
+        Second->isValueDependent())
+      return;
+    if (S.inTemplateInstantiation())
+      return;
+    if (Second->getExprLoc().isMacroID())
+      return;
+
+    if (S.Diags.isIgnored(diag::warn_loop_never_run, Second->getBeginLoc()))
+      return;
+
+    // Only work on loop conditions that are comparisons.
+    const BinaryOperator *CompareBO = dyn_cast<BinaryOperator>(Second);
+    if (!CompareBO || !CompareBO->isComparisonOp())
+      return;
+
+    // Examine the loop initilization and extract the single Decl used and its
+    // initial value.
+    const VarDecl *D = nullptr;
+    APValue InitValue;
+    if (const DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
+      // A loop variable being declared.
+      if (!DS->isSingleDecl())
+        return;
+      D = dyn_cast<VarDecl>(DS->getSingleDecl());
+      if (!D || !D->getInit())
+        return;
+      Expr::EvalResult Result;
+      if (!D->getInit()->EvaluateAsRValue(Result, S.Context))
+        return;
+      InitValue = Result.Val;
+    } else if (const Expr *E = dyn_cast<Expr>(First)) {
+      // A variable from outside the loop is being assigned a value.
+      const BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens());
+      if (!BO || BO->getOpcode() != BO_Assign)
+        return;
+      const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(BO->getLHS());
+      if (!DRE || !DRE->getDecl())
+        return;
+      D = dyn_cast<VarDecl>(DRE->getDecl());
+      if (!D)
+        return;
+      Expr::EvalResult Result;
+      if (!BO->getRHS()->EvaluateAsRValue(Result, S.Context))
+        return;
+      InitValue = Result.Val;
+    } else {
+      // Skip any other cases in the initialization.
+      return;
+    }
+
+    auto isVariable = [](const Expr *E, const Decl *D) {
+      E = E->IgnoreParenCasts();
+      const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
+      if (!DRE)
+        return false;
+      return DRE->getDecl() == D;
+    };
+
+    // Check that the variable from the initilization is one of the
+    // comparison operands.
+    const bool LHSisVariable = isVariable(CompareBO->getLHS(), D);
+    const bool RHSisVariable = isVariable(CompareBO->getRHS(), D);
+    if (!LHSisVariable && !RHSisVariable)
+      return;
+    if (LHSisVariable && RHSisVariable)
+      return;
+
+    // Normalize to Variable Opc Constant.
+    const auto Opc =
+        LHSisVariable
+            ? CompareBO->getOpcode()
+            : BinaryOperator::reverseComparisonOp(CompareBO->getOpcode());
+
+    const Expr *Variable =
+        LHSisVariable ? CompareBO->getLHS() : CompareBO->getRHS();
+    const Expr *Constant =
+        LHSisVariable ? CompareBO->getRHS() : CompareBO->getLHS();
+
+    // Convert the initial value of the variable from the variable type to
+    // the type used in the comparision.  For instance, signed/unsigned
+    // conversions or float/int conversions.
+    APValue ConvertedValue;
+    if (!Variable->SubstituteValueWithCasts(S.Context, InitValue, D,
+                                            ConvertedValue))
+      return;
+
+    // Evaluate the constant operand of the compare expression.
+    Expr::EvalResult Result;
+    if (!Constant->EvaluateAsRValue(Result, S.Context))
+      return;
+    APValue CompareValue = Result.Val;
+
+    // Perform the first iteration comparison.
+    if (CompareValue.isFloat()) {
+      auto FloatCompareResult =
+          ConvertedValue.getFloat().compare(CompareValue.getFloat());
+      if (FloatCompareResult == llvm::APFloat::cmpUnordered)
+        return;
+      switch (Opc) {
+      default:
+        llvm_unreachable("Unexpected operator kind");
+      case BO_LT:
+        if (FloatCompareResult == llvm::APFloat::cmpLessThan)
+          return;
+        break;
+      case BO_GT:
+        if (FloatCompareResult == llvm::APFloat::cmpGreaterThan)
+          return;
+        break;
+      case BO_LE:
+        if (FloatCompareResult == llvm::APFloat::cmpLessThan ||
+            FloatCompareResult == llvm::APFloat::cmpEqual)
+          return;
+        break;
+      case BO_GE:
+        if (FloatCompareResult == llvm::APFloat::cmpGreaterThan ||
+            FloatCompareResult == llvm::APFloat::cmpEqual)
+          return;
+        break;
+      case BO_EQ:
+        if (FloatCompareResult == llvm::APFloat::cmpEqual)
+          return;
+        break;
+      case BO_NE:
+        if (FloatCompareResult == llvm::APFloat::cmpLessThan ||
+            FloatCompareResult == llvm::APFloat::cmpGreaterThan)
+          return;
+        break;
+      }
+    } else if (CompareValue.isInt()) {
+      switch (Opc) {
+      default:
+        llvm_unreachable("Unexpected operator kind");
+      case BO_LT:
+        if (ConvertedValue.getInt() < CompareValue.getInt())
+          return;
+        break;
+      case BO_GT:
+        if (ConvertedValue.getInt() > CompareValue.getInt())
+          return;
+        break;
+      case BO_LE:
+        if (ConvertedValue.getInt() <= CompareValue.getInt())
+          return;
+        break;
+      case BO_GE:
+        if (ConvertedValue.getInt() >= CompareValue.getInt())
+          return;
+        break;
+      case BO_EQ:
+        if (ConvertedValue.getInt() == CompareValue.getInt())
+          return;
+        break;
+      case BO_NE:
+        if (ConvertedValue.getInt() != CompareValue.getInt())
+          return;
+        break;
+      }
+    } else {
+      // Constant is neither an int of a float.
+      return;
+    }
+
+    // Exclude loops where:
+    //   The loop variable is used as an index for array access
+    //   The comparison operator is less than
+    //   The constant comparison operand is the same as the array size
+    if (Body && CompareValue.isInt() && Opc == BO_LT) {
+      llvm::APSInt UpperRange = CompareValue.getInt();
+      if (UpperRange.isNonNegative() && UpperRange.getMinSignedBits() <= 64) {
+        if (ArrayFinder(S.Context).CheckForArrays(Body, UpperRange, D)) {
+          return;
+        }
+      }
+    }
+
+    auto PartialDiag =
+        S.PDiag(diag::warn_loop_never_run)
+        << D << InitValue.getAsString(S.Context, D->getType())
+        << CompareValue.getAsString(S.Context, Constant->getType())
+        << Second->getSourceRange();
+    S.DiagRuntimeBehavior(Second->getExprLoc(), Second, PartialDiag);
+
+    SourceLocation Open = Second->getBeginLoc();
+    SourceLocation Close =
+        S.getLocForEndOfToken(Second->getSourceRange().getEnd());
+    auto PartialDiagNote = S.PDiag(diag::note_loop_condition_silence)
+                           << Second->getSourceRange()
+                           << FixItHint::CreateInsertion(Open, "(")
+                           << FixItHint::CreateInsertion(Close, ")");
+    S.DiagRuntimeBehavior(Second->getExprLoc(), Second, PartialDiagNote);
+  }
+
 } // end namespace
 
 
 void Sema::CheckBreakContinueBinding(Expr *E) {
   if (!E || getLangOpts().CPlusPlus)
     return;
   BreakContinueFinder BCFinder(*this, E);
   Scope *BreakParent = CurScope->getBreakParent();
StmtResult Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
 
   CheckBreakContinueBinding(Second.get().second);
   CheckBreakContinueBinding(third.get());
 
   if (!Second.get().first)
     CheckForLoopConditionalStatement(*this, Second.get().second, third.get(),
                                      Body);
   CheckForRedundantIteration(*this, third.get(), Body);
+  CheckFirstIterationCondition(*this, First, Second.get().second, Body);
 
   if (Second.get().second &&
       !Diags.isIgnored(diag::warn_comma_operator,
                        Second.get().second->getExprLoc()))
     CommaVisitor(*this).Visit(Second.get().second);
 
   Expr *Third  = third.release().getAs<Expr>();
   if (isa<NullStmt>(Body))

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

+// RUN: %clang_cc1 %s -Wfor-loop-analysis -verify
+// RUN: %clang_cc1 %s -Wall -verify
+
+#define OneHundred 100
+
+void test() {
+  // Loop variable
+  for (int i = OneHundred; i < 50; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 100 on loop initialization, but comparing 100 to 50 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = OneHundred; i > 50; --i) {}
+
+  // Outside variable
+  int j;
+  for (j = OneHundred; j < 50; ++j) {}
+  // expected-warning@-1{{variable 'j' is set to value 100 on loop initialization, but comparing 100 to 50 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (j = OneHundred; j > 50; --j) {}
+
+  // int->float conversion
+  for (int i = OneHundred; i < 5e1; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 100 on loop initialization, but comparing 100 to 5.000000e+01 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = OneHundred; i > 5e1; --i) {}
+
+  // const values
+  const int kStart = 0;
+  const int kInterval = 10;
+  for (int i = kStart; i < kStart; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 0 on loop initialization, but comparing 0 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = kStart; i < kStart + kInterval; ++i) {}
+
+  // Reversed comparison operator
+  for (int i = 100; i <= 1; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 100 on loop initialization, but comparing 100 to 1 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = 100; i >= 1; --i) {}
+
+  // Range endpoints mistakes
+  const int kMin = 0;
+  const int kMax = 8;
+  for (int i = kMin; i < kMin; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 0 on loop initialization, but comparing 0 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = kMax; i < kMin; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 8 on loop initialization, but comparing 8 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = kMin; i < kMax; ++i) {}
+
+  for (int i = 16; i < 16; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 16 on loop initialization, but comparing 16 to 16 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = 8; i < 16; ++i) {}
+
+  for (int i = 1; i <= (1 >> 5); ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 1 on loop initialization, but comparing 1 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = 1; i <= (1 << 5); ++i) {}
+
+  // Complex comparion operand
+  const int TwoK = 1024 * 2;
+  for (int i = 2048; i < TwoK; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 2048 on loop initialization, but comparing 2048 to 2048 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int i = 1024; i < TwoK; ++i) {}
+
+  // Signedness mistake
+  for (unsigned i = -5; i < 5; ++i) {}
+  // expected-warning@-1{{variable 'i' is set to value 4294967291 on loop initialization, but comparing 4294967291 to 5 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (signed i = -5; i < 5; ++i) {}
+
+  for (int i = 0xffffffff; i > 10; i -= 10) {}
+  // expected-warning@-1{{variable 'i' is set to value -1 on loop initialization, but comparing -1 to 10 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (unsigned int i = 0xffffffff; i > 10; i -= 10) {}
+
+  // Floating point
+  for (double x = 0; x > 10; x += .5) {}
+  // expected-warning@-1{{variable 'x' is set to value 0.000000e+00 on loop initialization, but comparing 0.000000e+00 to 1.000000e+01 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (double x = 0; x < 10; x += .5) {}
+
+  // Typos
+  for (int x = 0; x < 0000; ++x) {};
+  // expected-warning@-1{{variable 'x' is set to value 0 on loop initialization, but comparing 0 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int x = 0; x < 10000; ++x) {};
+
+  for (char c = '0'; c <= 9; ++c) {}
+  // expected-warning@-1{{variable 'c' is set to value 48 on loop initialization, but comparing 48 to 9 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (char c = '0'; c <= '9'; ++c) {}
+
+  int array[10];
+  for (int x = 5; x < 1; ++x) { array[x] = x; }
+  // expected-warning@-1{{variable 'x' is set to value 5 on loop initialization, but comparing 5 to 1 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+  for (int x = 5; x < 10; ++x) { array[x] = x; }
+}
+
+void testConversions() {
+  // No conversion
+  for (int x = 0; x > 5; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0 on loop initialization, but comparing 0 to 5 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Int conversion
+  for (short x = 0; x > 5; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0 on loop initialization, but comparing 0 to 5 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Float conversion
+  for (float x = 0; x > 5.0; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0.000000e+00 on loop initialization, but comparing 0.000000e+00 to 5.000000e+00 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Float to Int conversion
+  for (double x = 0; static_cast<int>(x) > 5; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0.000000e+00 on loop initialization, but comparing 0.000000e+00 to 5 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Int to Float conversion
+  for (int x = 0; x > 5.0; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0 on loop initialization, but comparing 0 to 5.000000e+00 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Bool to Int conversion
+  for (bool x = false; x > 0; x = !x) {}
+  // expected-warning@-1{{variable 'x' is set to value false on loop initialization, but comparing false to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Bool to Float conversion
+  for (bool x = false; x > 0.0; x = !x) {}
+  // expected-warning@-1{{variable 'x' is set to value false on loop initialization, but comparing false to 0.000000e+00 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Float to Bool conversion
+  for (float x = 0; static_cast<bool>(x) > 0; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0.000000e+00 on loop initialization, but comparing 0.000000e+00 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+
+  // Int to Bool conversion
+  for (int x = 0; static_cast<bool>(x) > 0; ++x) {}
+  // expected-warning@-1{{variable 'x' is set to value 0 on loop initialization, but comparing 0 to 0 in the loop condition is false and the loop body will never run}}
+  // expected-note@-2{{place parentheses around the condition to silence this warning}}
+}
+
+#define size1(X) (sizeof(X) / sizeof(X[0]))
+#define size2(X) (sizeof(X) / sizeof(X[0])) / 1
+#define size3(X) sizeof(array_helper(X))
+
+using size_t = decltype(sizeof(int));
+template <typename T, size_t N>
+auto array_helper(const T (&X)[N]) -> char (&)[N];
+
+const int MIN = 10;
+const int MAX = 5;
+
+void no_warning () {
+  // Parentheses to silence warning.
+  for (int x = 0; (x > 10); ++x) {}
+
+  int array[] = {};
+  // Processing empty array.
+  for (int x = 0; x < size1(array); ++x) {
+    array[x] = x;
+  }
+  for (int x = 0; x < size2(array); ++x) {
+    array[x] = x;
+  }
+  for (int x = 0; x < sizeof(array); ++x) {
+    array[x] = x;
+  }
+  for (int x = 0; x < sizeof(array)/sizeof(*array); ++x) {
+    array[x] = x;
+  }
+
+  int array1[] = {5};
+  // Skip first array element.
+  for (int x = 1; x < size1(array1); ++x) {
+    array1[x] = array[x - 1];
+  }
+  for (int x = 1; x < size2(array1); ++x) {
+    array1[x] = array[x - 1];
+  }
+  for (int x = 1; x < size3(array1); ++x) {
+    array1[x] = array[x - 1];
+  }
+  for (int x = 1; x < sizeof(array1); ++x) {
+    array1[x] = array[x - 1];
+  }
+  for (int x = 1; x < sizeof(array1)/sizeof(*array); ++x) {
+    array1[x] = array[x - 1];
+  }
+
+  // Code flow never reaches the loop.
+  if (MIN < MAX) {
+    for (int x = MIN; x < MAX; ++x) {}
+  }
+}