llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-tools-extra Author: None (vabridgers) <details> <summary>Changes</summary> This change removes the alpha.core.IdenticalExpr static analysis checker since it's checks are present in the clang-tidy checks misc-redundant-expression and bugprone-branch-clone. This check was implemented as a static analysis check using AST matching, and since alpha and duplicated in 2 clang-tidy checks may be removed. --- Patch is 108.47 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/114715.diff 8 Files Affected: - (modified) clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone.cpp (+547) - (modified) clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp (+1325) - (modified) clang/docs/ReleaseNotes.rst (+6) - (modified) clang/docs/analyzer/checkers.rst (-30) - (modified) clang/include/clang/StaticAnalyzer/Checkers/Checkers.td (-4) - (modified) clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt (-1) - (removed) clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp (-520) - (removed) clang/test/Analysis/identical-expressions.cpp (-1564) ``````````diff diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone.cpp index 42231746149f2c..c6af207d795c5d 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone.cpp @@ -1069,3 +1069,550 @@ namespace PR62693 { } } } + +// Start of identical expressions port +int func(void) +{ + return 0; +} + +int func2(void) +{ + return 0; +} + +int funcParam(int a) +{ + return 0; +} +unsigned test_unsigned(unsigned a) { + unsigned b = 1; + a = a > 5 ? b : b; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] + return a; +} +void test_signed() { + int a = 0; + a = a > 5 ? a : a; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_bool(bool a) { + a = a > 0 ? a : a; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_float() { + float a = 0; + float b = 0; + a = a > 5 ? a : a; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +const char *test_string() { + float a = 0; + return a > 5 ? "abc" : "abc"; + // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_unsigned_expr() { + unsigned a = 0; + unsigned b = 0; + a = a > 5 ? a+b : a+b; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_signed_expr() { + int a = 0; + int b = 1; + a = a > 5 ? a+b : a+b; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_bool_expr(bool a) { + bool b = 0; + a = a > 0 ? a&&b : a&&b; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_unsigned_expr_negative() { + unsigned a = 0; + unsigned b = 0; + a = a > 5 ? a+b : b+a; // no warning +} + +void test_signed_expr_negative() { + int a = 0; + int b = 1; + a = a > 5 ? b+a : a+b; // no warning +} + +void test_bool_expr_negative(bool a) { + bool b = 0; + a = a > 0 ? a&&b : b&&a; // no warning +} + +void test_float_expr_positive() { + float a = 0; + float b = 0; + a = a > 5 ? a+b : a+b; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_expr_positive_func() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a+func() : a+func(); + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_expr_negative_func() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a+func() : a+func2(); // no warning +} + +void test_expr_positive_funcParam() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a+funcParam(b) : a+funcParam(b); + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_expr_negative_funcParam() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a+funcParam(a) : a+funcParam(b); // no warning +} + +void test_expr_positive_inc() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a++ : a++; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_expr_negative_inc() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a++ : b++; // no warning +} + +void test_expr_positive_assign() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a=1 : a=1; + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_expr_negative_assign() { + unsigned a = 0; + unsigned b = 1; + a = a > 5 ? a=1 : a=2; // no warning +} + +void test_signed_nested_expr() { + int a = 0; + int b = 1; + int c = 3; + a = a > 5 ? a+b+(c+a)*(a + b*(c+a)) : a+b+(c+a)*(a + b*(c+a)); + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_signed_nested_expr_negative() { + int a = 0; + int b = 1; + int c = 3; + a = a > 5 ? a+b+(c+a)*(a + b*(c+a)) : a+b+(c+a)*(a + b*(a+c)); // no warning +} + +void test_signed_nested_cond_expr_negative() { + int a = 0; + int b = 1; + int c = 3; + a = a > 5 ? (b > 5 ? 1 : 4) : (b > 5 ? 2 : 4); // no warning +} + +void test_signed_nested_cond_expr() { + int a = 0; + int b = 1; + int c = 3; + a = a > 5 ? (b > 5 ? 1 : 4) : (b > 5 ? 4 : 4); + // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} + +void test_identical_branches1(bool b) { + int i = 0; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + ++i; + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + ++i; + } +} + +void test_identical_branches2(bool b) { + int i = 0; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + ++i; + } else + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + ++i; +} + +void test_identical_branches3(bool b) { + int i = 0; + if (b) { // no warning + ++i; + } else { + i++; + } +} + +void test_identical_branches4(bool b) { + int i = 0; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + } +} + +void test_identical_branches_break(bool b) { + while (true) { + if (b) + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: if with identical then and else branches [bugprone-branch-clone] + break; + else + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + break; + } +} + +void test_identical_branches_continue(bool b) { + while (true) { + if (b) + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: if with identical then and else branches [bugprone-branch-clone] + continue; + else + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + continue; + } +} + +void test_identical_branches_func(bool b) { + if (b) + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + func(); + else + // CHECK-MESSAGES: :[[@LINE-1]]:3: note: else branch starts here + func(); +} + +void test_identical_branches_func_arguments(bool b) { + if (b) // no-warning + funcParam(1); + else + funcParam(2); +} + +void test_identical_branches_cast1(bool b) { + long v = -7; + if (b) // no-warning + v = (signed int) v; + else + v = (unsigned int) v; +} + +void test_identical_branches_cast2(bool b) { + long v = -7; + if (b) + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + v = (signed int) v; + else + // CHECK-MESSAGES: :[[@LINE-1]]:3: note: else branch starts here + v = (signed int) v; +} + +int test_identical_branches_return_int(bool b) { + int i = 0; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + i++; + return i; + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + i++; + return i; + } +} + +int test_identical_branches_return_func(bool b) { + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + return func(); + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + return func(); + } +} + +void test_identical_branches_for(bool b) { + int i; + int j; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + for (i = 0, j = 0; i < 10; i++) + j += 4; + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + for (i = 0, j = 0; i < 10; i++) + j += 4; + } +} + +void test_identical_branches_while(bool b) { + int i = 10; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + while (func()) + i--; + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + while (func()) + i--; + } +} + +void test_identical_branches_while_2(bool b) { + int i = 10; + if (b) { // no-warning + while (func()) + i--; + } else { + while (func()) + i++; + } +} + +void test_identical_branches_do_while(bool b) { + int i = 10; + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + do { + i--; + } while (func()); + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + do { + i--; + } while (func()); + } + // C --HECK-MESSAGES: :[[@LINE-3]]:44: warning: 'true' and 'false' expressions are equivalent [misc-redundant-expression] +} + +void test_identical_branches_if(bool b, int i) { + if (b) { + // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: if with identical then and else branches [bugprone-branch-clone] + if (i < 5) + i += 10; + } else { + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: else branch starts here + if (i < 5) + i += 10; + } +} + +void test_warn_chained_if_stmts_1(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here +} + +void test_warn_chained_if_stmts_2(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 2 starts here +} + +void test_warn_chained_if_stmts_3(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 2 starts here +} + +void test_warn_chained_if_stmts_4(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (func()) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (x == 1) + ; +} + +void test_warn_chained_if_stmts_5(int x) { + if (x & 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x & 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here +} + +void test_warn_chained_if_stmts_6(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 2 starts here + else if (x == 3) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 3 starts here +} + +void test_warn_chained_if_stmts_7(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (x == 3) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 2 starts here + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 3 starts here + else if (x == 5) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 4 starts here +} + + +void test_warn_chained_if_stmts_8(int x) { + if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (x == 3) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 2 starts here + else if (x == 2) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 3 starts here + else if (x == 5) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 4 starts here + else if (x == 3) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 5 starts here + else if (x == 7) + ; +} + +void test_nowarn_chained_if_stmts_1(int x) { + if (func()) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (func()) // no-warning + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here +} + +void test_nowarn_chained_if_stmts_2(int x) { + if (func()) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x == 1) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here + else if (func()) // no-warning + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 2 starts here +} + +void test_nowarn_chained_if_stmts_3(int x) { + if (x++) + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: repeated branch body in conditional chain + else if (x++) // no-warning + ; + // CHECK-MESSAGES: :[[@LINE-1]]:5: note: clone 1 starts here +} + +void test_warn_wchar() { + const wchar_t * a = 0 ? L"Expression" : L"Expression"; // expected-warning {{identical expressions on both sides of ':' in conditional expression}} + // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: conditional operator with identical true and false expressions [bugprone-branch-clone] +} +void test_nowarn_wchar() { + const wchar_t * a = 0 ? L"No" : L"Warning"; +} + +void test_nowarn_long() { + int a = 0, b = 0; + long c; + if (0) { + b -= a; + c = 0; + } else { // no-warning + b -= a; + c = 0LL; + } +} + +// Identical inner conditions + +void test_warn_inner_if_1(int x) { + if (x == 1) { + if (x == 1) // expected-warning {{conditions of the inner and outer statements are identical}} + ; + } + + // FIXME: Should warn here. The warning is currently not emitted because there + // is code between the conditions. + if (x == 1) { + int y = x; + if (x == 1) + ; + } +} + +void test_nowarn_inner_if_1(int x) { + // Don't warn when condition has side effects. + if (x++ == 1) { + if (x++ == 1) + ; + } + + // Don't warn when x is changed before inner condition. + if (x < 10) { + x++; + if (x < 10) + ; + } +} diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp index 1b271630e0d193..f63661a03c7c89 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp @@ -863,3 +863,1328 @@ namespace PR35857 { decltype(x + y - (x + y)) z = 10; } } + +// Ported from identical-expression + +int func(void) +{ + return 0; +} + +int func2(void) +{ + return 0; +} + +int funcParam(int a) +{ + return 0; +} + +/* '!=' operator*/ + +/* '!=' with float */ +int checkNotEqualFloatLiteralCompare1(void) { + return (5.14F != 5.14F); // no warning +} + +int checkNotEqualFloatLiteralCompare2(void) { + return (6.14F != 7.14F); // no warning +} + +int checkNotEqualFloatDeclCompare1(void) { + float f = 7.1F; + float g = 7.1F; + return (f != g); // no warning +} + +int checkNotEqualFloatDeclCompare12(void) { + float f = 7.1F; + return (f != f); // no warning +} + +int checkNotEqualFloatDeclCompare3(void) { + float f = 7.1F; + return (f != 7.1F); // no warning +} + +int checkNotEqualFloatDeclCompare4(void) { + float f = 7.1F; + return (7.1F != f); // no warning +} + +int checkNotEqualFloatDeclCompare5(void) { + float f = 7.1F; + int t = 7; + return (t != f); // no warning +} + +int checkNotEqualFloatDeclCompare6(void) { + float f = 7.1F; + int t = 7; + return (f != t); // no warning +} + + + +int checkNotEqualCastFloatDeclCompare11(void) { + float f = 7.1F; + return ((int)f != (int)f); + // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: both sides of operator are equivalent [misc-redundant-expression] +} +int checkNotEqualCastFloatDeclCompare12(void) { + float f = 7.1F; + return ((char)f != (int)f); // no warning +} +int checkNotEqualBinaryOpFloatCompare1(void) { + int res; + float f= 3.14F; + res = (f + 3.14F != f + 3.14F); // no warning + return (0); +} +int checkNotEqualBinaryOpFloatCompare2(void) { + float f = 7.1F; + float g = 7.1F; + return (f + 3.14F != g + 3.14F); // no warning +} +int checkNotEqualBinaryOpFloatCompare3(void) { + int res; + float f= 3.14F; + res = ((int)f + 3.14F != (int)f + 3.14F); // no warning + return (0); +} +int checkNotEqualBinaryOpFloatCompare4(void) { + int res; + float f= 3.14F; + res = ((int)f + 3.14F != (char)f + 3.14F); // no warning + return (0); +} + +int checkNotEqualNestedBinaryOpFloatCompare1(void) { + int res; + int t= 1; + int u= 2; + float f= 3.14F; + res = (((int)f + (3.14F - u)*t) != ((int)f + (3.14F - u)*t)); // no warning + return (0); +} + +int checkNotEqualNestedBinaryOpFloatCompare2(void) { + int res; + int t= 1; + int u= 2; + float f= 3.14F; + res = (((int)f + (u - 3.14F)*t) != ((int)f + (3.14F - u)*t)); // no warning + return (0); +} + +int checkNotEqualNestedBinaryOpFloatCompare3(void) { + int res; + int t= 1; + int u= 2; + float f= 3.14F; + res = (((int)f + (u - 3.14F)*t) != ((int)f + (3.14F - u)*(f + t != f + t))); // no warning + return (0); +} + + +/* end '!=' with float*/ +/* '!=' with int*/ + +int checkNotEqualIntLiteralCompare1(void) { + // FALSE NEGATIVE! + return (5 != 5); + // C HECK-MESSAGES: :[[@LINE-1]]:13: warning: both sides of operator are equivalent [misc-redundant-expression] +} + +int checkNotEqualIntLiteralCompare2(void) { + return (6 != 7); // no warning +} + +int checkNotEqualIntDeclCompare1(void) { + int f = 7; + int g = 7; + return (f != g); // no warning +} + +int checkNotEqualIntDeclCompare3(void) { + int f = 7; + return (f != 7); // no warning +} + +int checkNotEqualIntDeclCompare4(void) { + int f = 7; + return (7 != f); // no warning +} + +int checkNotEqualCastIntDeclCompare11(void) { + int f = 7; + return ((int)f != (int)f); + // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: both sides of operator are equivalent [misc-redundant-expression] +} +int checkNotEqualCastIntDeclCompare12(void) { + int f = 7; + return ((char)f != (int)f); // no warning +} +int checkNotEqualBinaryOpIntCompare1(void) { + int res; + int t= 1; + int u= 2; + int f= 4; + res = (f + 4 != f + 4); + // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: both sides of operator are equivalent [misc-redundant-expression] + return (0); +} +int checkNotEqualBinaryOpIntCompare2(void) { + int f = 7; + int g = 7; + return (f + 4 != g + 4); // no warning +} + +int checkNotEqualBinaryOpIntCompare3(void) { + int res; + int t= 1; + int u= 2; + int f= 4; + res = ((int)f + 4 != (int)f + 4); + // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: both sides of operator are equivalent [misc-redundant-expression] + return (0); +} +int checkNotEqualBinaryOpIntCompare4(void) { + int res; + int t= 1; + int u= 2; + int f= 4; + res = ((int)f + 4 != (char)f + 4); // no warning + return (0); +} +int checkNotEqualBinaryOpIntCompare5(void) { + int res; + int t= 1; + int u= 2; + res = (u + t != u + t); + // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: both sides of operator are equivalent [misc-redundant-expression] + return (0); +} + +int checkNotEqualNestedBinaryOpIntCompare1(void) { + int res; + int t= 1; + int u= 2; + int f= 3; + res = (((int)f + (3 - u)*t) !=... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/114715 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
