Fix #6552: false constant value warnings after overloaded extraction

Author: tzi4

lib/astutils.cpp

@@ -2712,6 +2712,20 @@ bool isVariableChanged(const Token *tok, int indirect, const Settings &settings,
     if (tok2->isCpp() && Token::Match(tok2->astParent(), ">>|&") && astIsRHS(tok2) && isLikelyStreamRead(tok2->astParent()))
         return true;
 
+    // An overloaded >>= can extract into its right-hand operand by reference.
+    if (tok2->isCpp() && Token::simpleMatch(tok2->astParent(), ">>=") && astIsRHS(tok2) &&
+        !astIsIntegral(tok2->astParent()->astOperand1(), false)) {
+        const ValueType* lhsType = tok2->astParent()->astOperand1()->valueType();
+        if (!lhsType || !lhsType->typeScope)
+            return true;
+        const auto operators = lhsType->typeScope->functionMap.equal_range("operator>>=");
+        for (auto it = operators.first; it != operators.second; ++it) {
+            const Variable* arg = it->second->getArgumentVar(0);
+            if (!arg || (!arg->isConst() && arg->isReference()))
+                return true;
+        }
+    }
+
     if (isLikelyStream(tok2))
         return true;
 

test/testastutils.cpp

@@ -229,6 +229,10 @@ class TestAstUtils : public TestFixture {
     }
 
     void isVariableChangedTest() {
+        // Built-in shifts do not modify their right-hand operand. #6552
+        ASSERT_EQUALS(false, isVariableChanged("void f(int shift, int bits) { bits >>= shift; }\n", "{", "}"));
+        ASSERT_EQUALS(false, isVariableChanged("void f(const double x, const Value& value) { value >>= x; }\n", "{", "}"));
+        ASSERT_EQUALS(true, isVariableChanged("void f(double x, const Value& value) { value >>= x; }\n", "{", "}"));
         // #8211 - no lhs for >> , do not crash
         (void)isVariableChanged("void f() {\n"
                                 "  int b;\n"

test/testcondition.cpp

@@ -129,6 +129,7 @@ class TestCondition : public TestFixture {
         TEST_CASE(knownConditionAfterBailout); // #12526
         TEST_CASE(knownConditionIncDecOperator);
         TEST_CASE(knownConditionFloating);
+        TEST_CASE(knownConditionShiftAssignment);
     }
 
     struct CheckOptions
@@ -6687,6 +6688,40 @@ class TestCondition : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void knownConditionShiftAssignment() { // #6552
+        check("struct Value { void operator>>=(double&) const; };\n"
+              "bool f(const Value& value, bool extract) {\n"
+              "    double x = 0.5;\n"
+              "    if (extract) value >>= x;\n"
+              "    return x < 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Value { void operator>>=(double) const; };\n"
+              "bool f(const Value& value) {\n"
+              "    double x = 0.5;\n"
+              "    value >>= x;\n"
+              "    return x < 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:14]: (style) Return value 'x<0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct Value { void operator>>=(const double&) const; };\n"
+              "bool f(const Value& value) {\n"
+              "    double x = 0.5;\n"
+              "    value >>= x;\n"
+              "    return x < 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:14]: (style) Return value 'x<0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct Value { void operator>>=(const double&) const; };\n"
+              "bool f(const Value& value) {\n"
+              "    const double x = 0.5;\n"
+              "    value >>= x;\n"
+              "    return x < 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:14]: (style) Return value 'x<0' is always false [knownConditionTrueFalse]\n", errout_str());
+    }
+
     void knownConditionFloating() {
         check("void foo() {\n"   // #11199
               "    float f = 1.0;\n"