fix #5591

Author: clock999

lib/checkother.cpp

@@ -4367,6 +4367,41 @@ void CheckOther::overlappingWriteFunction(const Token *tok, const std::string& f
     reportError(tok, Severity::error, "overlappingWriteFunction", "Overlapping read/write in " + funcname + "() is undefined behavior");
 }
 
+void CheckOther::checkSuspiciousComma()
+{
+    if (!mSettings->severity.isEnabled(Severity::style)) {
+        return;
+    }
+
+    logChecker("CheckOther::warnSuspiciousComma");
+
+    for (const Token* tok = mTokenizer->list.front(); tok; tok = tok->next()) {
+        if (tok->str() == "," && tok->isBinaryOp()) {
+            const Token * parent = tok->astParent();
+            if (parent && Token::Match(parent->previous(), "if|while (")) {
+                if (tok->previous()->str() == ")") {
+                    const Function * func = tok->linkAt(-1)->previous()->function();
+                    if (func && func->initArgCount > 0) {
+                        const Token * r_op = tok->astOperand2();
+                        if (r_op && (r_op->isVariable() ||
+                                     r_op->tokType() == Token::eNumber ||
+                                     r_op->tokType() == Token::eString ||
+                                     r_op->tokType() == Token::eChar ||
+                                     r_op->tokType() == Token::eBoolean)) {
+                            checkSuspiciousCommaError(tok);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void CheckOther::checkSuspiciousCommaError(const Token *tok)
+{
+    reportError(tok, Severity::style, "warnSuspiciousComma", "There is an suspicious comma expression used as a condition in an if/while condition statement.");
+}
+
 void CheckOther::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
 {
     CheckOther checkOther(&tokenizer, &tokenizer.getSettings(), errorLogger);
@@ -4414,6 +4449,7 @@ void CheckOther::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
     checkOther.checkAccessOfMovedVariable();
     checkOther.checkModuloOfOne();
     checkOther.checkOverlappingWrite();
+    checkOther.checkSuspiciousComma();
 }
 
 void CheckOther::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
@@ -4486,6 +4522,7 @@ void CheckOther::getErrorMessages(ErrorLogger *errorLogger, const Settings *sett
     c.comparePointersError(nullptr, nullptr, nullptr);
     c.redundantAssignmentError(nullptr, nullptr, "var", false);
     c.redundantInitializationError(nullptr, nullptr, "var", false);
+    c.checkSuspiciousCommaError(nullptr);
 
     const std::vector<const Token *> nullvec;
     c.funcArgOrderDifferent("function", nullptr, nullptr, nullvec, nullvec);

lib/checkother.h

@@ -192,6 +192,8 @@ class CPPCHECKLIB CheckOther : public Check {
     void overlappingWriteUnion(const Token *tok);
     void overlappingWriteFunction(const Token *tok, const std::string& funcname);
 
+    void checkSuspiciousComma();
+
     // Error messages..
     void checkComparisonFunctionIsAlwaysTrueOrFalseError(const Token* tok, const std::string &functionName, const std::string &varName, bool result);
     void checkCastIntToCharAndBackError(const Token *tok, const std::string &strFunctionName);
@@ -249,6 +251,7 @@ class CPPCHECKLIB CheckOther : public Check {
     void knownPointerToBoolError(const Token* tok, const ValueFlow::Value* value);
     void comparePointersError(const Token *tok, const ValueFlow::Value *v1, const ValueFlow::Value *v2);
     void checkModuloOfOneError(const Token *tok);
+    void checkSuspiciousCommaError(const Token *tok);
 
     void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
@@ -313,6 +316,7 @@ class CPPCHECKLIB CheckOther : public Check {
                "- variable can be declared const.\n"
                "- calculating modulo of one.\n"
                "- known function argument, suspicious calculation.\n";
+               "- suspicious comma in if/while condition statement.\n";
     }
 
     bool diag(const Token* tok) {

test/testother.cpp

@@ -304,6 +304,8 @@ class TestOther : public TestFixture {
 
         TEST_CASE(knownConditionFloating);
         TEST_CASE(knownConditionPrefixed);
+
+        TEST_CASE(suspiciousComma);
     }
 
 #define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
@@ -13047,6 +13049,25 @@ class TestOther : public TestFixture {
             "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'i > +1' is always false.\n",
             errout_str());
     }
+
+    void suspiciousComma()
+    {
+        check("void f(int a, int b = 0);\n"
+              "void foo() {\n"
+              "    if (f(100), 100) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3]: (style) There is an suspicious comma expression used as a condition in an if/while condition statement.\n",
+            errout_str());
+
+        check("void f(int a, int b = 0);\n"
+              "void foo() {\n"
+              "    while (f(100), 100) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3]: (style) There is an suspicious comma expression used as a condition in an if/while condition statement.\n",
+            errout_str());
+    }
 };
 
 REGISTER_TEST(TestOther)