Merge branch 'main' into chr_sibling

Author: chrchr-github

lib/checkstl.cpp

@@ -1986,9 +1986,11 @@ static bool isc_strCall(const Token* tok, const Library::Container* container)
 
 static bool isc_strConcat(const Token* tok)
 {
-    if (!tok->isBinaryOp() || !Token::simpleMatch(tok, "+"))
+    if (!tok->isBinaryOp() || !Token::Match(tok, "+|+="))
         return false;
     for (const Token* op : { tok->astOperand1(), tok->astOperand2() }) { // NOLINT(readability-use-anyofallof)
+        if (tok->isAssignmentOp() && astIsLHS(op))
+            continue;
         const Token* sibling = op->astSibling();
         if (!sibling->valueType())
             continue;
@@ -3338,8 +3340,8 @@ void CheckStlImpl::eraseIteratorOutOfBoundsError(const Token *ftok, const Token*
     }
 
     const Severity severity = isConditional ? Severity::warning : Severity::error;
-    const std::string id = isConditional ? "eraseIteratorOutOfBoundsCond" : "eraseIteratorOutOfBounds";
-    reportError(ftok, severity,
+    const char* id = isConditional ? "eraseIteratorOutOfBoundsCond" : "eraseIteratorOutOfBounds";
+    reportError(getErrorPath(ftok, val, msg), severity,
                 id,
                 msg, CWE628, Certainty::normal);
 }

lib/tokenize.cpp

@@ -3201,8 +3201,15 @@ bool Tokenizer::simplifyUsing()
                 continue;
             }
 
-            // skip template definitions
             if (Token::Match(tok1, "template < !!>")) {
+                Token *paramsEnd = tok1->next()->findClosingBracket();
+                bool shadowed = !paramsEnd;
+                for (const Token *param = tok1->next(); !shadowed && param != paramsEnd; param = param->next())
+                    shadowed = param->str() == nameToken->str();
+                if (!shadowed) {
+                    tok1 = paramsEnd;
+                    continue;
+                }
                 Token *declEndToken = TemplateSimplifier::findTemplateDeclarationEnd(tok1);
                 if (declEndToken)
                     tok1 = declEndToken;
@@ -9109,7 +9116,8 @@ void Tokenizer::findGarbageCode() const
             if (tok->strAt(1) == "(")
                 syntaxError(tok);
             else if (!(tok->tokType() == Token::Type::eString && Token::simpleMatch(tok->tokAt(-1), "extern")) &&
-                     !(tok->tokType() == Token::Type::eBoolean && cpp && Token::simpleMatch(tok->tokAt(-1), "requires")))
+                     !(tok->tokType() == Token::Type::eBoolean && cpp && Token::simpleMatch(tok->tokAt(-1), "requires")) &&
+                     !Token::simpleMatch(tok->linkAt(1), "} ;"))
                 syntaxError(tok);
         }
         if (Token::Match(tok, "( ) %num%|%bool%|%char%|%str%"))

lib/valueflow.cpp

@@ -1118,7 +1118,7 @@ static void valueFlowImpossibleValues(TokenList& tokenList, const Settings& sett
             value.setImpossible();
             setTokenValue(tok, std::move(value), settings);
         } else if (tok->variable() && tok->variable()->isArray() && !tok->variable()->isArgument() &&
-                   !tok->variable()->isStlType()) {
+                   tok->variable()->getTypeName() != "std::array") {
             ValueFlow::Value value{0};
             value.setImpossible();
             setTokenValue(tok, std::move(value), settings);

lib/vf_settokenvalue.cpp

@@ -617,7 +617,7 @@ namespace ValueFlow
         // ~
         else if (parent->str() == "~") {
             for (const Value &val : tok->values()) {
-                if (!val.isIntValue())
+                if (!val.isIntValue() || (val.isImpossible() && val.intvalue < 0))
                     continue;
                 Value v(val);
                 v.intvalue = ~v.intvalue;

test/testcondition.cpp

@@ -3449,6 +3449,12 @@ class TestCondition : public TestFixture {
               "}\n");
         ASSERT_EQUALS("", errout_str());
 
+        check("std::string a[3];\n" // #15065
+              "void f() {\n"
+              "   if (a) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition 'a' is always true [knownConditionTrueFalse]\n", errout_str());
+
         // Avoid FP when condition comes from macro
         check("#define NOT !\n"
               "void f() {\n"

test/testsimplifyusing.cpp

@@ -79,6 +79,7 @@ class TestSimplifyUsing : public TestFixture {
         TEST_CASE(simplifyUsing39);
         TEST_CASE(simplifyUsing40);
         TEST_CASE(simplifyUsing41);
+        TEST_CASE(simplifyUsing42);
 
         TEST_CASE(simplifyUsing8970);
         TEST_CASE(simplifyUsing8971);
@@ -956,6 +957,40 @@ class TestSimplifyUsing : public TestFixture {
         ASSERT_EQUALS(expected, tok(code));
     }
 
+    void simplifyUsing42() {
+        {
+            const char code[] = "using A = bool;\n"
+                                "template<typename T> A func() {}\n";
+            const char expected[] = "template < typename T > bool func ( ) { }";
+            ASSERT_EQUALS(expected, tok(code));
+        }
+        {
+            const char code[] = "using A = bool;\n"
+                                "template<typename A> A func() {}\n";
+            const char expected[] = "template < typename A > A func ( ) { }";
+            ASSERT_EQUALS(expected, tok(code));
+        }
+        {
+            const char code[] = "using A = bool;\n"
+                                "template<typename T> class C { A x; }\n";
+            const char expected[] = "template < typename T > class C { bool x ; }";
+            ASSERT_EQUALS(expected, tok(code));
+        }
+        {
+            const char code[] = "using A = bool;\n"
+                                "template<typename A> class C { A x; }\n";
+            const char expected[] = "template < typename A > class C { A x ; }";
+            ASSERT_EQUALS(expected, tok(code));
+        }
+        {
+            const char code[] = "using A = bool;\n"
+                                "template<typename T> class C { using A = T; A x; }\n"
+                                "C<int> c;\n";
+            const char expected[] = "class C<int> ; C<int> c ; class C<int> { int x ; }";
+            ASSERT_EQUALS(expected, tok(code));
+        }
+    }
+
     void simplifyUsing8970() {
         const char code[] = "using V = std::vector<int>;\n"
                             "struct A {\n"

test/teststl.cpp

@@ -1140,6 +1140,20 @@ class TestStl : public TestFixture {
                       "[test.cpp:3:11]: note: Assuming that condition 'i>5' is not redundant\n"
                       "[test.cpp:5:13]: note: Access out of bounds\n",
                       errout_str());
+
+        check("void f(std::vector<int>& v) {\n"
+              "    std::vector<int>::iterator it;\n"
+              "    for (it = v.begin(); it != v.end(); ++it) {\n"
+              "        if (*it == 0)\n"
+              "            break;\n"
+              "    }\n"
+              "    v.erase(it);\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:4:13]: style: Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n"
+                      "[test.cpp:7:7]: warning: Either the condition is redundant or function 'erase()' is called on the iterator 'it' which is out of bounds. [eraseIteratorOutOfBoundsCond]\n"
+                      "[test.cpp:3:29]: note: Assuming that condition 'it!=v.end()' is not redundant\n"
+                      "[test.cpp:7:7]: note: Either the condition is redundant or function 'erase()' is called on the iterator 'it' which is out of bounds.\n",
+                      errout_str());
     }
 
     void iterator1() {
@@ -2441,7 +2455,7 @@ class TestStl : public TestFixture {
               "    if (it == v.end()) {}\n"
               "    v.erase(it);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Either the condition 'it==v.end()' is redundant or function 'erase()' is called on the iterator 'it' which is out of bounds. [eraseIteratorOutOfBoundsCond]\n",
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:7]: (warning) Either the condition 'it==v.end()' is redundant or function 'erase()' is called on the iterator 'it' which is out of bounds. [eraseIteratorOutOfBoundsCond]\n",
                       errout_str());
 
         check("void f() {\n"
@@ -5161,6 +5175,12 @@ class TestStl : public TestFixture {
               "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (performance) Constructing a std::string from the result of c_str() is slow and redundant. [stlcstrConstructor]\n",
                       errout_str());
+
+        check("void f(std::string& a, const std::string& b) {\n"
+              "    a += b.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:7]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n",
+                      errout_str());
     }
 
     void uselessCalls() {

test/testtokenize.cpp

@@ -8138,6 +8138,7 @@ class TestTokenizer : public TestFixture {
         ignore_errout();
 
         ASSERT_EQUALS(";", tokenizeAndStringify("typedef std::size_t size_t;\n")); // #14809
+        ASSERT_EQUALS("struct S { int i { 0 } ; } ;", tokenizeAndStringify("struct S { int i : 1{0}; };\n")); // #15070
     }
 
 

test/testvalueflow.cpp

@@ -1263,6 +1263,15 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(~0U, values.back().intvalue);
 
+        // #15015
+        code  = "void f(unsigned u) {\n"
+                "    if (~u) {}\n"
+                "}";
+        values = tokenValues(code, "~");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(-1, values.back().intvalue);
+        ASSERT(values.back().isImpossible());
+
         // !
         code  = "void f(int x) {\n"
                 "    a = !x;\n"