[Clang-tidy] Fix copy-paste error in misc-redundant-expression detected by PVS-Studio

[Eugene.Zelenko]

Summary

Unfortunately, misc-redundant-expression didn't detect problem in own code.

I also fixed some Include What You Use and modernize-use-bool-literals warnings.

See http://www.viva64.com/en/b/0446/ for full article about problems found in LLVM code by PVS-Studio.

[aaron.ballman]

These changes all look good to me, but it would be best to split the commit into three parts: one for include what you use, one for modernize-use-bool-literals, and one for the copy pasta error. Keeping the changes logically separate helps in case we need to roll any particular change back for some reason (same is true for similar patches in the future; they should probably be multiple patch requests).

clang-tools-extra/trunk/clang-tidy/misc/RedundantExpressionCheck.cpp

 //===--- RedundantExpressionCheck.cpp - clang-tidy-------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RedundantExpressionCheck.h"
 #include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/Casting.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <set>
+#include <string>
+#include <vector>
 
 using namespace clang::ast_matchers;
 using namespace clang::tidy::matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
if (APSInt::compareValues(ValueLHS, ValueRHS) == 0) {
     case BO_GT:
       return OpcodeRHS == BO_EQ || OpcodeRHS == BO_LT || OpcodeRHS == BO_LE;
     default:
       return false;
     }
   }
 
   // Handle cases where the constants are different.
-  if ((OpcodeLHS == BO_EQ || OpcodeLHS == BO_LE || OpcodeLHS == BO_LE) &&
+  if ((OpcodeLHS == BO_EQ || OpcodeLHS == BO_LT || OpcodeLHS == BO_LE) &&
       (OpcodeRHS == BO_EQ || OpcodeRHS == BO_GT || OpcodeRHS == BO_GE))
     return true;
 
   // Handle the case where constants are off by one: x > 5 && x < 6.
   APSInt ValueLHS_plus1;
   if (OpcodeLHS == BO_GT && OpcodeRHS == BO_LT &&
       incrementWithoutOverflow(ValueLHS, ValueLHS_plus1) &&
       APSInt::compareValues(ValueLHS_plus1, ValueRHS) == 0)
if (const auto *Bin = Result.Nodes.getNodeAs<BinaryOperator>(Id)) {
     Opcode = Bin->getOpcode();
     OperandExpr = Bin;
     if (!retrieveIntegerConstantExpr(Result, Id, Value))
       return false;
   } else if (const auto *Cast = Result.Nodes.getNodeAs<CastExpr>(CastId)) {
     // Operand received with implicit comparator (cast).
     Opcode = BO_NE;
     OperandExpr = Cast;
-    Value = APSInt(32, 0);
+    Value = APSInt(32, false);
   } else {
     return false;
   }
 
   if (!retrieveSymbolicExpr(Result, Id, Symbol))
     return false;
 
   if (Result.Nodes.getNodeAs<Expr>(SwapId))