Give long double literals out of the range of double no value

Review of the previous commit: a long double literal larger than double,
such as 1e400L, became a known value of infinity, so different literals
compared equal and gave false positives:
  1e400L / 1e500L                   duplicateExpression
  x == 1e400L || x == 1e500L        knownConditionTrueFalse
  x > 1e400L && x < 1e500L          incorrectLogicOperator
Infinity is right for literals without suffix or with f (HUGE_VAL), not
for long double. MathLib::isLongDoubleOutOfDoubleRange() tells them apart;
ValueFlow gives such a literal no value and CheckCondition does not
compare it.

Author: pduchi

lib/checkcondition.cpp

@@ -1301,6 +1301,10 @@ void CheckConditionImpl::checkIncorrectLogicOperator()
             if (isfloat && (op1 == "==" || op1 == "!=" || op2 == "==" || op2 == "!="))
                 continue;
 
+            // no double value to compare (1e400L would become infinity)
+            if (isfloat && (MathLib::isLongDoubleOutOfDoubleRange(value1) || MathLib::isLongDoubleOutOfDoubleRange(value2)))
+                continue;
+
             // the expr are not the token of the value but they provide better context
             const double d1 = isfloat ? MathLib::toDoubleNumber(value1) : 0;
             const double d2 = isfloat ? MathLib::toDoubleNumber(value2) : 0;

lib/mathlib.cpp

@@ -591,6 +591,13 @@ bool MathLib::isFloat(const std::string &str)
     return isDecimalFloat(str) || isFloatHex(str);
 }
 
+bool MathLib::isLongDoubleOutOfDoubleRange(const std::string &str)
+{
+    if (str.empty() || (str.back() != 'l' && str.back() != 'L') || !isFloat(str))
+        return false;
+    return std::isinf(toDoubleNumber(str));
+}
+
 bool MathLib::isDecimalFloat(const std::string &str)
 {
     if (str.empty())

lib/mathlib.h

@@ -115,6 +115,8 @@ class CPPCHECKLIB MathLib {
 
     static bool isInt(const std::string & str);
     static bool isFloat(const std::string &str);
+    /** @brief a long double literal out of the range of double, such as 1e400L, which toDoubleNumber() makes infinity */
+    static bool isLongDoubleOutOfDoubleRange(const std::string &str);
     static bool isDecimalFloat(const std::string &str);
     static bool isNegative(const std::string &str);
     static bool isPositive(const std::string &str);

lib/vf_common.cpp

@@ -139,12 +139,16 @@ namespace ValueFlow
                 // Bad character literal
             }
         } else if (tok->isNumber() && MathLib::isFloat(tok->str())) {
-            Value value;
-            value.valueType = Value::ValueType::FLOAT;
-            value.floatValue = MathLib::toDoubleNumber(tok);
-            if (!tok->isTemplateArg())
-                value.setKnown();
-            setTokenValue(tok, std::move(value), settings);
+            // A long double literal out of the range of double (1e400L) has no
+            // double value: infinity would make different literals compare equal.
+            if (!MathLib::isLongDoubleOutOfDoubleRange(tok->str())) {
+                Value value;
+                value.valueType = Value::ValueType::FLOAT;
+                value.floatValue = MathLib::toDoubleNumber(tok);
+                if (!tok->isTemplateArg())
+                    value.setKnown();
+                setTokenValue(tok, std::move(value), settings);
+            }
         } else if (tok->enumerator() && tok->enumerator()->value_known) {
             Value value(tok->enumerator()->value);
             if (!tok->isTemplateArg())

test/testcondition.cpp

@@ -69,6 +69,7 @@ class TestCondition : public TestFixture {
         TEST_CASE(incorrectLogicOperator15);
         TEST_CASE(incorrectLogicOperator16); // #10070
         TEST_CASE(incorrectLogicOperator17);
+        TEST_CASE(incorrectLogicOperator18); // #12282
         TEST_CASE(secondAlwaysTrueFalseWhenFirstTrueError);
         TEST_CASE(incorrectLogicOp_condSwapping);
         TEST_CASE(testBug5895);
@@ -1758,6 +1759,17 @@ class TestCondition : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void incorrectLogicOperator18() { // #12282
+        // long double literals out of the range of double are different values
+        check("int f(long double x) {\n"
+              "    return x > 1e400L && x < 1e500L;\n"
+              "}\n"
+              "int g() {\n"
+              "    return 1e400L < 1e500L;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void incorrectLogicOperator17() { // #12471
         check("struct R {\n"
               "    void set() { i = 1; }\n"

test/testmathlib.cpp

@@ -45,6 +45,7 @@ class TestMathLib : public TestFixture {
         TEST_CASE(isnegative);
         TEST_CASE(ispositive);
         TEST_CASE(isFloat);
+        TEST_CASE(isLongDoubleOutOfDoubleRange);
         TEST_CASE(isDecimalFloat);
         TEST_CASE(isGreater);
         TEST_CASE(isGreaterEqual);
@@ -599,6 +600,16 @@ class TestMathLib : public TestFixture {
         // TODO: test with 128-bit values
     }
 
+    void isLongDoubleOutOfDoubleRange() const {
+        ASSERT_EQUALS(true, MathLib::isLongDoubleOutOfDoubleRange("1e400L"));
+        ASSERT_EQUALS(true, MathLib::isLongDoubleOutOfDoubleRange("1.0e4931l"));
+        ASSERT_EQUALS(false, MathLib::isLongDoubleOutOfDoubleRange("1e300L"));
+        ASSERT_EQUALS(false, MathLib::isLongDoubleOutOfDoubleRange("1e10000"));
+        ASSERT_EQUALS(false, MathLib::isLongDoubleOutOfDoubleRange("1e10000f"));
+        ASSERT_EQUALS(false, MathLib::isLongDoubleOutOfDoubleRange("10L"));
+        ASSERT_EQUALS(false, MathLib::isLongDoubleOutOfDoubleRange(""));
+    }
+
     void toDoubleNumber() const {
         // float values
         ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1."),       0.001);

test/testother.cpp

@@ -204,6 +204,7 @@ class TestOther : public TestFixture {
         TEST_CASE(duplicateExpression20);
         TEST_CASE(duplicateExpression21);
         TEST_CASE(duplicateExpression22);
+        TEST_CASE(duplicateExpression23); // #12282
         TEST_CASE(duplicateExpressionLoop);
         TEST_CASE(duplicateValueTernary);
         TEST_CASE(duplicateValueTernarySizeof); // #13773
@@ -8498,6 +8499,17 @@ class TestOther : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void duplicateExpression23() { // #12282
+        // long double literals out of the range of double are different values
+        check("long double f() {\n"
+              "    return 1e400L / 1e500L;\n"
+              "}\n"
+              "int g(long double x) {\n"
+              "    return x == 1e400L || x == 1e500L;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void duplicateExpression22() {
         check("int f() {\n" // #14913
               "    return 0x1 | (0x2 | 0x4) | 0x1;\n"