Fixed a crash in misc-redundant-expression ClangTidy checker

[gribozavr]

Summary

It was trying to pass a dependent expression into constant evaluator.

[ilya-biryukov]

LGTM

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

 // Checks for expressions like (X == 4) && (Y != 9)
 static bool areSidesBinaryConstExpressions(const BinaryOperator *&BinOp, const ASTContext *AstCtx) {
   const auto *LhsBinOp = dyn_cast<BinaryOperator>(BinOp->getLHS());
   const auto *RhsBinOp = dyn_cast<BinaryOperator>(BinOp->getRHS());
 
   if (!LhsBinOp || !RhsBinOp)
     return false;
 
-  if ((LhsBinOp->getLHS()->isIntegerConstantExpr(*AstCtx) ||
-       LhsBinOp->getRHS()->isIntegerConstantExpr(*AstCtx)) &&
-      (RhsBinOp->getLHS()->isIntegerConstantExpr(*AstCtx) ||
-       RhsBinOp->getRHS()->isIntegerConstantExpr(*AstCtx)))
+  auto IsIntegerConstantExpr = [AstCtx](const Expr *E) {
+    return !E->isValueDependent() && E->isIntegerConstantExpr(*AstCtx);
+  };
+
+  if ((IsIntegerConstantExpr(LhsBinOp->getLHS()) ||
+       IsIntegerConstantExpr(LhsBinOp->getRHS())) &&
+      (IsIntegerConstantExpr(RhsBinOp->getLHS()) ||
+       IsIntegerConstantExpr(RhsBinOp->getRHS())))
     return true;
   return false;
 }
 
 // Retrieves integer constant subexpressions from binary operator expressions
 // that have two equivalent sides.
 // E.g.: from (X == 5) && (X == 5) retrieves 5 and 5.
 static bool retrieveConstExprFromBothSides(const BinaryOperator *&BinOp,
                                            BinaryOperatorKind &MainOpcode,
                                            BinaryOperatorKind &SideOpcode,
                                            const Expr *&LhsConst,
                                            const Expr *&RhsConst,
                                            const ASTContext *AstCtx) {
   assert(areSidesBinaryConstExpressions(BinOp, AstCtx) &&
          "Both sides of binary operator must be constant expressions!");
 
   MainOpcode = BinOp->getOpcode();
 
   const auto *BinOpLhs = cast<BinaryOperator>(BinOp->getLHS());
   const auto *BinOpRhs = cast<BinaryOperator>(BinOp->getRHS());
 
-  LhsConst = BinOpLhs->getLHS()->isIntegerConstantExpr(*AstCtx)
-                 ? BinOpLhs->getLHS()
+  auto IsIntegerConstantExpr = [AstCtx](const Expr *E) {
+    return !E->isValueDependent() && E->isIntegerConstantExpr(*AstCtx);
+  };
+
+  LhsConst = IsIntegerConstantExpr(BinOpLhs->getLHS()) ? BinOpLhs->getLHS()
                                                        : BinOpLhs->getRHS();
-  RhsConst = BinOpRhs->getLHS()->isIntegerConstantExpr(*AstCtx)
-                 ? BinOpRhs->getLHS()
+  RhsConst = IsIntegerConstantExpr(BinOpRhs->getLHS()) ? BinOpRhs->getLHS()
                                                        : BinOpRhs->getRHS();
 
   if (!LhsConst || !RhsConst)
     return false;
 
   assert(BinOpLhs->getOpcode() == BinOpRhs->getOpcode() &&
          "Sides of the binary operator must be equivalent expressions!");
 
   SideOpcode = BinOpLhs->getOpcode();

clang-tools-extra/trunk/test/clang-tidy/misc-redundant-expression.cpp

int TestSimpleEquivalent(int X, int Y) {
   if (P1.x < P2.x && P1.x < P2.x) return 1;
   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: both sides of operator are equivalent
   if (P2.a[P1.x + 2] < P2.x && P2.a[(P1.x) + (2)] < (P2.x)) return 1;
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: both sides of operator are equivalent
 
   return 0;
 }
 
+template <int DX>
+int TestSimpleEquivalentDependent() {
+  if (DX > 0 && DX > 0) return 1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: both sides of operator are equivalent
+
+  return 0;
+}
+
 int Valid(int X, int Y) {
   if (X != Y) return 1;
   if (X == Y + 0) return 1;
   if (P.x == P.y) return 1;
   if (P.a[P.x] < P.a[P.y]) return 1;
   if (P.a[0] < P.a[1]) return 1;
 
   if (P.a[0] < P.a[0ULL]) return 1;
int TestWithMinMaxInt(int X) {
   return 0;
 }
 
 #define FLAG1 1
 #define FLAG2 2
 #define FLAG3 4
 #define FLAGS (FLAG1 | FLAG2 | FLAG3)
 #define NOTFLAGS !(FLAG1 | FLAG2 | FLAG3)
-int operatorConfusion(int X, int Y, long Z)
+int TestOperatorConfusion(int X, int Y, long Z)
 {
   // Ineffective & expressions.
   Y = (Y << 8) & 0xff;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: ineffective bitwise and operation
   Y = (Y << 12) & 0xfff;
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: ineffective bitwise and
   Y = (Y << 12) & 0xff;
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: ineffective bitwise and
int TestOperatorConfusion(int X, int Y, long Z)
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: ineffective logical negation operator
   // CHECK-FIXES: {{^}}  int NotFlags = ~FLAGS;{{$}}
   NotFlags = NOTFLAGS;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: ineffective logical negation operator
   return !(1 | 2 | 4);
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: ineffective logical negation operator
   // CHECK-FIXES: {{^}}  return ~(1 | 2 | 4);{{$}}
 }
+
+template <int Shift, int Mask>
+int TestOperatorConfusionDependent(int Y) {
+  int r1 = (Y << Shift) & 0xff;
+  int r2 = (Y << 8) & Mask;
+}
 #undef FLAG1
 #undef FLAG2
 #undef FLAG3
 
 namespace no_crash {
 struct Foo {};
 bool operator<(const Foo&, const Foo&);
 template <class T>
 struct Bar {
   static const Foo &GetFoo();
   static bool Test(const T & maybe_foo, const Foo& foo) {
     return foo < GetFoo() && foo < maybe_foo;
   }
 };
 }