diff --git a/cfg/std.cfg b/cfg/std.cfg index 033fc15d2d6..ff65096fa39 100644 --- a/cfg/std.cfg +++ b/cfg/std.cfg @@ -9106,7 +9106,7 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init - + @@ -9126,10 +9126,10 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init - - + + - + diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp index 0b3bd405c3d..fa8e14a9321 100644 --- a/lib/checkstl.cpp +++ b/lib/checkstl.cpp @@ -542,7 +542,7 @@ void CheckStlImpl::iterators() break; bool inconclusiveType2=false; if (isIterator(par2->variable(), inconclusiveType2)) - break; // TODO: check if iterator points at same container + break; // iterator range insert(first, last): mismatchingContainers() checks that both iterators refer to the same container if (par2->str() == "(") par2 = par2->link(); par2 = par2->next(); @@ -816,6 +816,49 @@ bool CheckStlImpl::checkIteratorPair(const Token* tok1, const Token* tok2) return false; } +// Get the iterator range [first, last) that is passed to a member function of a container, e.g. +// 'c.insert(first, last)', 'c.insert(pos, first, last)', 'c.assign(first, last)'. Both iterators must +// refer to the same container. +static std::pair getMemberIteratorRange(const Token* ftok, const std::vector& args, const Settings& settings) +{ + if (!Token::simpleMatch(ftok->astParent(), ".") || ftok->astParent()->astOperand2() != ftok) + return {}; + const Token* const contTok = ftok->astParent()->astOperand1(); + if (!astIsContainer(contTok) || !contTok->valueType()->container) + return {}; + const Library::Container* const container = contTok->valueType()->container; + + std::size_t first; + if (ftok->str() == "insert") { + if (args.size() == 3) // insert(pos, first, last) + first = 1; + else if (args.size() == 2 && container->stdAssociativeLike) // insert(first, last) or insert(hint, value) + first = 0; + else + return {}; + } else if (Token::Match(ftok, "assign|append") && args.size() == 2) { // assign(first, last) + first = 0; + } else if (ftok->str() == "replace" && args.size() == 4 && container->stdStringLike) { // replace(pos1, pos2, first, last) + first = 2; + } else { + return {}; + } + + const Token* const firstTok = args[first]; + const Token* const lastTok = args[first + 1]; + if (!astIsIterator(firstTok) || !astIsIterator(lastTok)) + return {}; + + if (args.size() == 2 && ftok->str() == "insert") { + // The first argument is a hint if it is an iterator to the container itself. + // Then this is insert(hint, value) where value is an iterator stored in the container. + const ValueFlow::Value val = getLifetimeIteratorValue(firstTok); + if (!val.tokvalue || isSameIteratorContainerExpression(contTok, val.tokvalue, settings)) + return {}; + } + return {firstTok, lastTok}; +} + namespace { struct ArgIteratorInfo { const Token* tok; @@ -843,6 +886,11 @@ void CheckStlImpl::mismatchingContainers() if (args.size() < 2) continue; + // Iterator range passed to member function of container + const std::pair range = getMemberIteratorRange(ftok, args, mSettings); + if (range.first && checkIteratorPair(range.first, range.second)) + continue; + // Group args together by container std::map> containers; for (size_t argnr = 1; argnr <= args.size(); ++argnr) { diff --git a/lib/library.cpp b/lib/library.cpp index 6c80e88e5cc..e0d7c31426b 100644 --- a/lib/library.cpp +++ b/lib/library.cpp @@ -621,6 +621,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc) if (!endsWith(container.startPattern, '<')) container.startPattern2 += " !!::"; container.startPatternHasStd = startsWith(container.startPattern2, "std :: "); + container.startPatternTokenCount = 1 + static_cast(std::count(container.startPattern.cbegin(), container.startPattern.cend(), ' ')); } const char* const endPattern = node->Attribute("endPattern"); if (endPattern) @@ -1412,11 +1413,33 @@ const Library::Container* Library::detectContainerInternal(const Token* const ty const int offset = (withoutStd && container.startPatternHasStd) ? 7 : 0; - // If endPattern is undefined, it will always match, but itEndPattern has to be defined. - if (detect != IteratorOnly && container.endPattern.empty()) { - if (!Token::Match(typeStart, container.startPattern2.c_str() + offset)) + // If endPattern is undefined the container is a non-template container (e.g. std::string) or + // a container whose template arguments can be deduced (e.g. std::span). + // The iterator type is then matched with itEndPattern after the container type. + if (container.endPattern.empty()) { + if (!Token::Match(typeStart, container.startPattern.c_str() + offset)) continue; + // find the token after the container type (and its template arguments, if any) + const Token* endTok = typeStart->tokAt(container.startPatternTokenCount - (offset > 0 ? 3 : 1)); + if (endTok && endTok->str() == "<" && endTok->link()) + endTok = endTok->link(); + endTok = endTok ? endTok->next() : nullptr; + if (endTok && endTok->str() == "<" && endTok->link()) + endTok = endTok->link()->next(); + + if (Token::simpleMatch(endTok, "::")) { + // a type that is nested in the container, e.g. std::string::iterator or std::span::size_type + if (detect != ContainerOnly && !container.itEndPattern.empty() && Token::Match(endTok, container.itEndPattern.c_str())) { + if (isIterator) + *isIterator = true; + return &container; + } + continue; + } + + if (detect == IteratorOnly) + continue; if (isIterator) *isIterator = false; return &container; diff --git a/lib/library.h b/lib/library.h index 709a0db2b90..aa7af2ffc82 100644 --- a/lib/library.h +++ b/lib/library.h @@ -226,6 +226,8 @@ class CPPCHECKLIB Library { int templateParameter; // TODO: use this }; std::string startPattern, startPattern2, endPattern, itEndPattern; + /** Number of tokens matched by startPattern */ + int startPatternTokenCount{}; std::map functions; int type_templateArgNo = -1; std::vector rangeItemRecordType; diff --git a/man/reference-cfg-format.md b/man/reference-cfg-format.md index 596fd6cb856..441a6a16c74 100644 --- a/man/reference-cfg-format.md +++ b/man/reference-cfg-format.md @@ -577,7 +577,9 @@ The size of the type is specified in bytes. Possible values for the "sign" attri # `` -A lot of C++ libraries, among those the STL itself, provide containers with very similar functionality. Libraries can be used to tell cppcheck about their behaviour. Each container needs a unique ID. It can optionally have a startPattern, which must be a valid Token::Match pattern and an endPattern that is compared to the linked token of the first token with such a link. The optional attribute "inherits" takes an ID from a previously defined container. +A lot of C++ libraries, among those the STL itself, provide containers with very similar functionality. Libraries can be used to tell cppcheck about their behaviour. Each container needs a unique ID. It can optionally have a startPattern, which must be a valid Token::Match pattern and an endPattern that is compared to the linked token of the first token with such a link. The itEndPattern is compared in the same way to detect iterators of the container (e.g. `> :: iterator|const_iterator`). The optional attribute "inherits" takes an ID from a previously defined container. + +If the container is not a template (e.g. `std::string`) or if its template arguments can be deduced (e.g. `std::span`), set endPattern to an empty string. The itEndPattern is then compared to the tokens following the container type and its template arguments, if there are any (e.g. `:: iterator|const_iterator`). The `hasInitializerListConstructor` attribute can be set when the container has a constructor taking an initializer list. diff --git a/releasenotes.txt b/releasenotes.txt index e70c9230171..9aa1bd2cf8a 100644 --- a/releasenotes.txt +++ b/releasenotes.txt @@ -26,4 +26,7 @@ Infrastructure & dependencies: and rule files work unchanged. On Windows the Visual Studio project now expects pcre2-8.lib and pcre2.h in externals. Other: -- +- Iterators of non-template library containers (e.g. std::string::iterator, std::string_view::const_iterator, QString::iterator, wxString::iterator) are now detected as iterators. + Previously such variables had no value type, so several iterator checks (e.g. containerOutOfBounds, mismatchingContainerIterator) missed bugs involving them. +- Iterators of std::span and gsl::span (e.g. std::span::iterator) are now detected as iterators instead of containers, and nested types such as std::span::size_type are no longer treated as containers. +- mismatchingContainers now detects iterator ranges from different containers passed to container member functions, e.g. s.insert(a.begin(), b.end()), v.insert(v.end(), a.begin(), b.end()), v.assign(a.begin(), b.end()) and str.append(a.begin(), b.end()). diff --git a/test/testlibrary.cpp b/test/testlibrary.cpp index c0ccbea0831..7909a86f532 100644 --- a/test/testlibrary.cpp +++ b/test/testlibrary.cpp @@ -994,10 +994,11 @@ class TestLibrary : public TestFixture { SimpleTokenizer var(*this); ASSERT(var.tokenize("std::F::iterator I;\n")); ASSERT(!library.detectContainer(var.tokens())); - TODO_ASSERT(library.detectIterator(var.tokens())); + ASSERT_EQUALS(&F, library.detectIterator(var.tokens())); bool isIterator = false; - TODO_ASSERT_EQUALS(reinterpret_cast(&F), 0, reinterpret_cast(library.detectContainerOrIterator(var.tokens(), &isIterator))); - TODO_ASSERT(isIterator); + ASSERT_EQUALS(&F, library.detectContainerOrIterator(var.tokens(), &isIterator)); + ASSERT(isIterator); + ASSERT(!library.detectContainerOrIterator(var.tokens(), nullptr, true)); } { @@ -1007,8 +1008,44 @@ class TestLibrary : public TestFixture { ASSERT(!library.detectIterator(var.tokens())); ASSERT(!library.detectContainerOrIterator(var.tokens())); bool isIterator = false; - TODO_ASSERT_EQUALS(reinterpret_cast(&F), 0, reinterpret_cast(library.detectContainerOrIterator(var.tokens(), &isIterator, true))); - TODO_ASSERT(isIterator); + ASSERT_EQUALS(&F, library.detectContainerOrIterator(var.tokens(), &isIterator, true)); + ASSERT(isIterator); + } + + { + SimpleTokenizer var(*this); + ASSERT(var.tokenize("std::F f;\n")); + ASSERT_EQUALS(&F, library.detectContainer(var.tokens())); + ASSERT(!library.detectIterator(var.tokens())); + bool isIterator = true; + ASSERT_EQUALS(&F, library.detectContainerOrIterator(var.tokens(), &isIterator)); + ASSERT(!isIterator); + } + + { + SimpleTokenizer var(*this); + ASSERT(var.tokenize("std::F::iterator I;\n")); + ASSERT(!library.detectContainer(var.tokens())); + ASSERT_EQUALS(&F, library.detectIterator(var.tokens())); + bool isIterator = false; + ASSERT_EQUALS(&F, library.detectContainerOrIterator(var.tokens(), &isIterator)); + ASSERT(isIterator); + } + + { + SimpleTokenizer var(*this); + ASSERT(var.tokenize("std::F::size_type s;\n")); + ASSERT(!library.detectContainer(var.tokens())); + ASSERT(!library.detectIterator(var.tokens())); + ASSERT(!library.detectContainerOrIterator(var.tokens())); + } + + { + SimpleTokenizer var(*this); + ASSERT(var.tokenize("std::F::size_type s;\n")); + ASSERT(!library.detectContainer(var.tokens())); + ASSERT(!library.detectIterator(var.tokens())); + ASSERT(!library.detectContainerOrIterator(var.tokens())); } } diff --git a/test/teststl.cpp b/test/teststl.cpp index 7dbdf7793f0..1c1e62c2b68 100644 --- a/test/teststl.cpp +++ b/test/teststl.cpp @@ -1126,6 +1126,21 @@ class TestStl : public TestFixture { "}\n"); ASSERT_EQUALS("[test.cpp:4:6]: (error) Out of bounds access in expression 'it' because 'vec' is empty. [containerOutOfBounds]\n", errout_str()); + + check("int f(std::span s) {\n" + " std::span::iterator it = s.end();\n" + " return *it;\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:13]: (error) Dereference of an invalid iterator: it [derefInvalidIterator]\n", errout_str()); + + // iterators of non-template containers + check("void f() {\n" + " std::string s;\n" + " std::string::iterator it = s.begin();\n" + " *it = 'a';\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:4:6]: (error) Out of bounds access in expression 'it' because 's' is empty. [containerOutOfBounds]\n", + errout_str()); } void outOfBoundsErrorPath() { @@ -1338,7 +1353,74 @@ class TestStl : public TestFixture { " std::set::iterator it2 = ints2.end();\n" " ints2.insert(it1, it2);\n" "}\n"); - TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterators of different containers are used together.\n", "", errout_str()); + ASSERT_EQUALS("[test.cpp:4:35]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n", errout_str()); + + check("void foo(const std::set &ints1, std::set &ints2)\n" + "{\n" + " ints2.insert(ints1.begin(), ints2.end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:18]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n", errout_str()); + + check("void foo(const std::map &m1, const std::map &m2, std::map &m3)\n" + "{\n" + " m3.insert(m1.begin(), m2.end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:15]: (error) Iterators of different containers 'm1' and 'm2' are used together. [mismatchingContainers]\n", errout_str()); + + // insert(pos, first, last) + check("void foo(const std::vector &v1, const std::vector &v2, std::vector &v3)\n" + "{\n" + " v3.insert(v3.end(), v1.begin(), v2.end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:25]: (error) Iterators of different containers 'v1' and 'v2' are used together. [mismatchingContainers]\n", errout_str()); + + check("void foo(const std::vector &v1, std::vector &v3)\n" + "{\n" + " v3.insert(v3.end(), v1.begin(), v1.end());\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + // assign(first, last), append(first, last) + check("void foo(const std::vector &v1, const std::vector &v2, std::vector &v3)\n" + "{\n" + " v3.assign(v1.begin(), v2.end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:15]: (error) Iterators of different containers 'v1' and 'v2' are used together. [mismatchingContainers]\n", errout_str()); + + check("void foo(const std::vector &v1, std::vector &v3)\n" + "{\n" + " v3.assign(v1.begin(), v1.end());\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + check("void foo(const std::string &s1, const std::string &s2, std::string &s3)\n" + "{\n" + " s3.append(s1.begin(), s2.end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:15]: (error) Iterators of different containers 's1' and 's2' are used together. [mismatchingContainers]\n", errout_str()); + + // replace(first1, last1, first2, last2) + check("void foo(const std::string &s1, const std::string &s2, std::string &s3)\n" + "{\n" + " s3.replace(s3.begin(), s3.end(), s1.begin(), s2.end());\n" + " s3.replace(s3.begin(), s3.end(), s1.begin(), s1.end());\n" + " s3.replace(s3.begin(), s3.end(), 3, 'c');\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:38]: (error) Iterators of different containers 's1' and 's2' are used together. [mismatchingContainers]\n", errout_str()); + + // insert(hint, value) where the value is an iterator + check("void foo(std::set::iterator> &s, std::vector &v)\n" + "{\n" + " s.insert(s.end(), v.begin());\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + // insert(pos, value) where the value is an iterator + check("void foo(std::vector::iterator> &s, std::vector &v)\n" + "{\n" + " s.insert(s.end(), v.begin());\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); } void iterator7() { @@ -2292,6 +2374,15 @@ class TestStl : public TestFixture { "}\n"); ASSERT_EQUALS("[test.cpp:2:5]: (error) Iterator 'b.begin()' referring to container 'b' is used with container 'a'. [mismatchingContainerIterator]\n", errout_str()); + // iterators of non-template containers + check("void f(std::string& a, std::string& b) {\n" + " std::string::iterator it = b.begin();\n" + " a.erase(it);\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:5]: (error) Same iterator is used with different containers 'b' and 'a'. [iterators1]\n" + "[test.cpp:3:5]: (error) Iterator 'it' referring to container 'b' is used with container 'a'. [mismatchingContainerIterator]\n", + errout_str()); + // #9973 check("void f() {\n" " std::list l1;\n" diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp index 85ee8430a77..8b95bd5369a 100644 --- a/test/testsymboldatabase.cpp +++ b/test/testsymboldatabase.cpp @@ -593,6 +593,8 @@ class TestSymbolDatabase : public TestFixture { TEST_CASE(valueType1); TEST_CASE(valueType2); + TEST_CASE(valueTypeStringIterator); + TEST_CASE(valueTypeSpanIterator); TEST_CASE(valueType3); TEST_CASE(valueTypeThis); TEST_CASE(valueTypeChar); @@ -10392,6 +10394,68 @@ class TestSymbolDatabase : public TestFixture { } } + void valueTypeStringIterator() { + GET_SYMBOL_DB("void f(std::string& s, std::wstring_view w) {\n" + " std::string::iterator it = s.begin();\n" + " std::string::const_reverse_iterator rit = s.crbegin();\n" + " std::wstring_view::const_iterator wit = w.begin();\n" + " std::string::size_type n = s.size();\n" + " func(it, rit, wit, n);\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + const Token* tok = Token::findsimplematch(tokenizer.tokens(), "func ("); + ASSERT(tok); + + tok = Token::findsimplematch(tok, "it"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: string|wstring|u16string|u32string)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "rit"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: string|wstring|u16string|u32string)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "wit"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: string_view|wstring_view|u16string_view|u32string_view)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "n"); + ASSERT(tok && (!tok->valueType() || tok->valueType()->type != ValueType::Type::ITERATOR)); + } + + void valueTypeSpanIterator() { + GET_SYMBOL_DB("void f(std::span s, std::vector& v) {\n" + " std::span::iterator it = s.begin();\n" + " std::span::reverse_iterator rit = s.rbegin();\n" + " std::span::size_type n = s.size();\n" + " std::span t{v};\n" + " func(s, it, rit, n, t);\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + const Token* tok = Token::findsimplematch(tokenizer.tokens(), "func ("); + ASSERT(tok); + + tok = Token::findsimplematch(tok, "s"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("container(std :: span)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "it"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: span)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "rit"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: span)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "n"); + ASSERT(tok && (!tok->valueType() || (tok->valueType()->type != ValueType::Type::CONTAINER && tok->valueType()->type != ValueType::Type::ITERATOR))); + + tok = Token::findsimplematch(tok, "t"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("container(std :: span)", tok->valueType()->str()); + } + void valueType3() { { GET_SYMBOL_DB("void f(std::vector>>& v, int i, int j) {\n"