From 33a5aecf9a285da9d897799faa0dfdf0e30a6e22 Mon Sep 17 00:00:00 2001 From: Tarie Nosworthy Date: Sun, 15 Nov 2026 09:45:11 -0500 Subject: [PATCH 1/2] mismatchingContainers: detect mismatched iterator ranges passed to container member functions Iterator ranges passed to insert(), assign(), append() and replace() of a container were not checked, so 'ints2.insert(it1, it2)' with iterators from two different containers went unreported (TODO in TestStl::iterator6). To support this, library container detection now recognizes nested iterator types of non-template containers and of std::span, e.g. std::string::iterator and std::span::iterator. The stale TODO in CheckStl::iterators() now points at mismatchingContainers(), which performs the check. Co-Authored-By: Claude Opus 5.5 --- cfg/std.cfg | 8 ++-- lib/checkstl.cpp | 50 +++++++++++++++++++- lib/library.cpp | 29 ++++++++++-- lib/library.h | 2 + man/reference-cfg-format.md | 4 +- releasenotes.txt | 5 +- test/testlibrary.cpp | 47 +++++++++++++++++-- test/teststl.cpp | 93 ++++++++++++++++++++++++++++++++++++- test/testsymboldatabase.cpp | 64 +++++++++++++++++++++++++ 9 files changed, 286 insertions(+), 16 deletions(-) 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" From 8ea22633c41eb4e907ae8103780e079ab7964833 Mon Sep 17 00:00:00 2001 From: Tarie Nosworthy Date: Sun, 15 Nov 2026 09:45:12 -0500 Subject: [PATCH 2/2] Fix #13105 (auto token with no type: member function of container owned by smart pointer) 'auto it = m->find(i)' where m is a std::shared_ptr> left 'it' without a value type. Member functions called through '->' on a smart pointer that owns a library container now get the container's return type. Iterators to containers owned by smart pointers are now tracked as lifetimes, so invalidContainer, derefInvalidIterator and mismatchingContainers detect bugs with them, including iterator ranges passed to p->insert()/p->assign(). Shared pointers may own the same container, so mixing iterators from two shared pointers is reported as mismatchingContainerExpression (warning). Co-Authored-By: Claude Opus 5.5 --- lib/astutils.cpp | 26 ++++++- lib/astutils.h | 5 ++ lib/checkautovariables.cpp | 4 ++ lib/checkstl.cpp | 58 +++++++++++---- lib/library.cpp | 14 +++- lib/symboldatabase.cpp | 48 +++++++++---- lib/valueflow.cpp | 13 +++- releasenotes.txt | 2 + test/testautovariables.cpp | 10 +++ test/testfunctions.cpp | 2 +- test/teststl.cpp | 136 ++++++++++++++++++++++++++++++++++++ test/testsymboldatabase.cpp | 32 +++++++++ 12 files changed, 317 insertions(+), 33 deletions(-) diff --git a/lib/astutils.cpp b/lib/astutils.cpp index e2e19b6bd91..1710792008a 100644 --- a/lib/astutils.cpp +++ b/lib/astutils.cpp @@ -252,6 +252,23 @@ bool astIsUniqueSmartPointer(const Token* tok) return tok->valueType()->smartPointer->unique; } +const Library::Container* getSmartPointerContainer(const Token* tok, const Settings& settings) +{ + if (!astIsSmartPointer(tok) || tok->valueType()->pointer != 0) + return nullptr; + const ValueType pointee = ValueType::parseDecl(tok->valueType()->smartPointerTypeToken, settings); + if (pointee.type != ValueType::Type::CONTAINER || pointee.pointer != 0) + return nullptr; + return pointee.container; +} + +bool astIsSmartPointerContainerAccess(const Token* tok, const Settings& settings) +{ + if (!Token::simpleMatch(tok ? tok->astParent() : nullptr, ".") || tok->astParent()->originalName() != "->" || !astIsLHS(tok)) + return false; + return getSmartPointerContainer(tok, settings) != nullptr; +} + bool astIsIterator(const Token *tok) { return tok && tok->valueType() && tok->valueType()->type == ValueType::Type::ITERATOR; @@ -292,8 +309,15 @@ bool astIsContainerString(const Token* tok) static std::pair getContainerFunction(const Token* tok, const Library& library) { const Library::Container* cont{}; - if (!tok || !tok->valueType() || (!tok->valueType()->container && (!(cont = library.detectContainerOrIterator(tok->valueType()->smartPointerTypeToken))))) + if (!tok || !tok->valueType()) return {}; + if (!tok->valueType()->container) { + const Token* typeTok = tok->valueType()->smartPointerTypeToken; + while (Token::Match(typeTok, "const|volatile")) + typeTok = typeTok->next(); + if (!(cont = library.detectContainerOrIterator(typeTok))) + return {}; + } const Token* parent = tok->astParent(); if (Token::Match(parent, ". %name% [(<]") && astIsLHS(tok)) { return { parent->next(), cont ? cont : tok->valueType()->container }; diff --git a/lib/astutils.h b/lib/astutils.h index 578763124ac..500d042c4e6 100644 --- a/lib/astutils.h +++ b/lib/astutils.h @@ -154,6 +154,11 @@ bool astIsPointer(const Token *tok); bool astIsSmartPointer(const Token* tok); bool astIsUniqueSmartPointer(const Token* tok); +/** If tok is a smart pointer to a library container, get that container (e.g. std::vector for std::shared_ptr>) */ +const Library::Container* getSmartPointerContainer(const Token* tok, const Settings& settings); +/** Is tok a smart pointer to a library container whose member is accessed with '->' (e.g. 'p' in 'p->begin()') */ +bool astIsSmartPointerContainerAccess(const Token* tok, const Settings& settings); + bool astIsIterator(const Token *tok); bool astIsContainer(const Token *tok); diff --git a/lib/checkautovariables.cpp b/lib/checkautovariables.cpp index de70772a279..1c57b636f39 100644 --- a/lib/checkautovariables.cpp +++ b/lib/checkautovariables.cpp @@ -625,6 +625,10 @@ void CheckAutoVariablesImpl::checkVarLifetimeScope(const Token * start, const To continue; if (!printInconclusive && val.isInconclusive()) continue; + // Iterator to a container owned by a smart pointer. The container might be shared or moved, + // so its lifetime is not bound to the smart pointer variable. + if (val.lifetimeKind == ValueFlow::Value::LifetimeKind::Iterator && astIsSmartPointer(val.tokvalue)) + continue; const Token* parent = getParentLifetime(val.tokvalue, mSettings.library); if (!exprs.insert(parent).second) continue; diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp index fa8e14a9321..6661fed525d 100644 --- a/lib/checkstl.cpp +++ b/lib/checkstl.cpp @@ -771,6 +771,21 @@ static bool sizeValueAppliesToIterator(const ValueFlow::Value& sizeValue, const (iterValue.container->exprId() != 0 && iterValue.container->exprId() == sizeValue.container->exprId()); } +// Is the lifetime an iterator to a container that is owned by a smart pointer? +static bool isSmartPointerIteratorLifetime(const ValueFlow::Value& val) +{ + return val.lifetimeKind == ValueFlow::Value::LifetimeKind::Iterator && astIsSmartPointer(val.tokvalue); +} + +// Iterators to containers owned by smart pointers. Different unique pointers can't own the same +// container, but a shared pointer or a reference to the container (auto& c = *p) can refer to it. +static bool mayBeSameSmartPointerContainer(const ValueFlow::Value& val1, const ValueFlow::Value& val2) +{ + if (!isSmartPointerIteratorLifetime(val1) && !isSmartPointerIteratorLifetime(val2)) + return false; + return !astIsUniqueSmartPointer(val1.tokvalue) || !astIsUniqueSmartPointer(val2.tokvalue); +} + bool CheckStlImpl::checkIteratorPair(const Token* tok1, const Token* tok2) { if (!tok1) @@ -779,7 +794,8 @@ bool CheckStlImpl::checkIteratorPair(const Token* tok1, const Token* tok2) return false; ValueFlow::Value val1 = getLifetimeIteratorValue(tok1); ValueFlow::Value val2 = getLifetimeIteratorValue(tok2); - if (val1.tokvalue && val2.tokvalue && val1.lifetimeKind == val2.lifetimeKind) { + if (val1.tokvalue && val2.tokvalue && val1.lifetimeKind == val2.lifetimeKind && + !mayBeSameSmartPointerContainer(val1, val2)) { if (val1.lifetimeKind == ValueFlow::Value::LifetimeKind::Lambda) return false; if (tok1->astParent() == tok2->astParent() && Token::Match(tok1->astParent(), "%comp%|-")) { @@ -817,16 +833,20 @@ bool CheckStlImpl::checkIteratorPair(const Token* tok1, const Token* tok2) } // 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. +// 'c.insert(first, last)', 'c.insert(pos, first, last)', 'c.assign(first, last)', or 'p->insert(first, last)' +// when the container is owned by a smart pointer. 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) + const Library::Container* container = nullptr; + if (astIsContainer(contTok)) + container = contTok->valueType()->container; + else if (astIsSmartPointerContainerAccess(contTok, settings)) // container owned by a smart pointer, e.g. 'p->insert(first, last)' + container = getSmartPointerContainer(contTok, settings); + if (!container) return {}; - const Library::Container* const container = contTok->valueType()->container; std::size_t first; if (ftok->str() == "insert") { @@ -973,6 +993,8 @@ void CheckStlImpl::mismatchingContainerIterator() continue; if (val.lifetimeKind != ValueFlow::Value::LifetimeKind::Iterator) continue; + if (isSmartPointerIteratorLifetime(val)) // the smart pointer might point at the container + continue; if (iterTok->str() == "*" && iterTok->astOperand1()->valueType() && iterTok->astOperand1()->valueType()->type == ValueType::ITERATOR) continue; if (isSameIteratorContainerExpression(tok, val.tokvalue, mSettings)) @@ -982,10 +1004,17 @@ void CheckStlImpl::mismatchingContainerIterator() } } -static const Token* getInvalidMethod(const Token* tok) +static const Token* getInvalidMethod(const Token* tok, const Settings& settings) { if (!astIsLHS(tok)) return nullptr; + // Container owned by a smart pointer, only member functions called with '->' change the container + const Library::Container* c = tok->valueType()->container; + if (!c) { + if (!astIsSmartPointerContainerAccess(tok, settings)) + return nullptr; + c = getSmartPointerContainer(tok, settings); + } if (Token::Match(tok->astParent(), ". assign|clear|swap")) return tok->astParent()->next(); if (Token::Match(tok->astParent(), "%assign%")) @@ -995,7 +1024,7 @@ static const Token* getInvalidMethod(const Token* tok) ftok = tok->astParent()->next(); if (!ftok) return nullptr; - if (const Library::Container * c = tok->valueType()->container) { + if (c) { const Library::Container::Action action = c->getAction(ftok->str()); if (c->unstableErase) { if (action == Library::Container::Action::ERASE) @@ -1050,6 +1079,9 @@ namespace { return result; } }; + explicit InvalidContainerAnalyzer(const Settings& settings) : settings(settings) {} + + const Settings& settings; std::unordered_map invalidMethods; std::vector invalidatesContainer(const Token* tok) const { @@ -1091,8 +1123,8 @@ namespace { } } } - } else if (astIsContainer(tok)) { - const Token* ftok = getInvalidMethod(tok); + } else if (astIsContainer(tok) || astIsSmartPointerContainerAccess(tok, settings)) { + const Token* ftok = getInvalidMethod(tok, settings); if (ftok) { ErrorPath ep; ep.emplace_front(ftok, @@ -1187,7 +1219,7 @@ void CheckStlImpl::invalidContainer() { logChecker("CheckStl::invalidContainer"); const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase(); - InvalidContainerAnalyzer analyzer; + InvalidContainerAnalyzer analyzer(mSettings); analyzer.analyze(symbolDatabase); for (const Scope * scope : symbolDatabase->functionScopes) { for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) { @@ -1219,7 +1251,7 @@ void CheckStlImpl::invalidContainer() } } else { for (const InvalidContainerAnalyzer::Info::Reference& r : analyzer.invalidatesContainer(tok)) { - if (!astIsContainer(r.tok)) + if (!astIsContainer(r.tok) && !getSmartPointerContainer(r.tok, mSettings)) continue; std::set skipVarIds; // Skip if the variable is assigned to @@ -1250,7 +1282,9 @@ void CheckStlImpl::invalidContainer() // return false; if (Token::Match(info.tok->astParent(), "%assign%") && astIsLHS(info.tok)) skipVarIds.insert(info.tok->varId()); - if (info.tok->variable()->isReference() && !isVariableDecl(info.tok) && + // References to a container owned by a smart pointer are not tracked, the + // reference refers to the container object that is not invalidated + if (info.tok->variable()->isReference() && !isVariableDecl(info.tok) && astIsContainer(r.tok) && reaches(info.tok->variable()->nameToken(), tok, nullptr)) { if ((assignExpr && Token::Match(assignExpr->astOperand1()->previous(), "& %varid%", info.tok->varId()))) { diff --git a/lib/library.cpp b/lib/library.cpp index e0d7c31426b..37fc7726896 100644 --- a/lib/library.cpp +++ b/lib/library.cpp @@ -1697,8 +1697,18 @@ const std::string& Library::returnValueType(const Token *ftok) const if (isNotLibraryFunction(ftok)) { if (Token::simpleMatch(ftok->astParent(), ".") && ftok->astParent()->astOperand1()) { const Token* contTok = ftok->astParent()->astOperand1(); - if (contTok->valueType() && contTok->valueType()->container) - return contTok->valueType()->container->getReturnType(ftok->str()); + if (const ValueType* vt = contTok->valueType()) { + if (vt->container) + return vt->container->getReturnType(ftok->str()); + // member function of a container accessed through a smart pointer + if (ftok->astParent()->originalName() == "->" && vt->type == ValueType::Type::SMART_POINTER && vt->pointer == 0) { + const Token* typeTok = vt->smartPointerTypeToken; + while (Token::Match(typeTok, "const|volatile")) + typeTok = typeTok->next(); + if (const Container* container = detectContainer(typeTok)) + return container->getReturnType(ftok->str()); + } + } } return mEmptyString; } diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp index 26801640e99..57415ac0607 100644 --- a/lib/symboldatabase.cpp +++ b/lib/symboldatabase.cpp @@ -7005,6 +7005,27 @@ static bool isContainerYieldPointer(Library::Container::Yield yield) return yield == Library::Container::Yield::BUFFER || yield == Library::Container::Yield::BUFFER_NT; } +// Get the value type of the container in a member access 'c.f' or 'p->f'. +// If 'p' is a smart pointer, the value type of the object it points at is written to 'pointee' and returned. +static const ValueType* getMemberContainerValueType(const Token* memberTok, + ValueType& pointee, + ValueType::Sign defaultSignedness, + const Settings& settings) +{ + if (!Token::simpleMatch(memberTok, ".") || !memberTok->astOperand1()) + return nullptr; + const ValueType* vt = memberTok->astOperand1()->valueType(); + if (!vt) + return nullptr; + if (vt->container) + return vt; + if (memberTok->originalName() == "->" && vt->type == ValueType::Type::SMART_POINTER && vt->pointer == 0 && + vt->smartPointerTypeToken && parsedecl(vt->smartPointerTypeToken, &pointee, defaultSignedness, settings) && + pointee.container && pointee.type == ValueType::Type::CONTAINER && pointee.pointer == 0) + return &pointee; + return nullptr; +} + void SymbolDatabase::setValueType(Token* tok, const ValueType& valuetype, const SourceLocation &loc) { auto* valuetypePtr = new ValueType(valuetype); @@ -7038,15 +7059,16 @@ void SymbolDatabase::setValueType(Token* tok, const ValueType& valuetype, const return; } - if (vt1 && vt1->container && vt1->containerTypeToken && Token::Match(parent, ". %name% (") && - isContainerYieldElement(vt1->container->getYield(parent->strAt(1)))) { + ValueType pointee; + const ValueType* contVt = Token::Match(parent, ". %name% (") ? getMemberContainerValueType(parent, pointee, mDefaultSignedness, mSettings) : nullptr; + if (contVt && contVt->containerTypeToken && isContainerYieldElement(contVt->container->getYield(parent->strAt(1)))) { ValueType item; - if (parsedecl(vt1->containerTypeToken, &item, mDefaultSignedness, mSettings)) { + if (parsedecl(contVt->containerTypeToken, &item, mDefaultSignedness, mSettings)) { if (item.constness == 0) - item.constness = vt1->constness; + item.constness = contVt->constness; if (item.volatileness == 0) - item.volatileness = vt1->volatileness; - if (isContainerYieldPointer(vt1->container->getYield(parent->strAt(1)))) + item.volatileness = contVt->volatileness; + if (isContainerYieldPointer(contVt->container->getYield(parent->strAt(1)))) item.pointer += 1; else item.reference = Reference::LValue; @@ -8235,12 +8257,11 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings, Token *to //Is iterator fetching function invoked on container? const bool isReturnIter = typestr == "iterator"; if (typestr.empty() || isReturnIter) { - if (Token::simpleMatch(tok->astOperand1(), ".") && - tok->astOperand1()->astOperand1() && - tok->astOperand1()->astOperand2() && - tok->astOperand1()->astOperand1()->valueType() && - tok->astOperand1()->astOperand1()->valueType()->container) { - const Library::Container *cont = tok->astOperand1()->astOperand1()->valueType()->container; + ValueType pointee; + const ValueType* contVt = tok->astOperand1() && tok->astOperand1()->astOperand2() ? + getMemberContainerValueType(tok->astOperand1(), pointee, mDefaultSignedness, mSettings) : nullptr; + if (contVt) { + const Library::Container *cont = contVt->container; const auto it = cont->functions.find(tok->astOperand1()->astOperand2()->str()); if (it != cont->functions.end()) { if (it->second.yield == Library::Container::Yield::START_ITERATOR || @@ -8249,8 +8270,7 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings, Token *to ValueType vt; vt.type = ValueType::Type::ITERATOR; vt.container = cont; - vt.containerTypeToken = - tok->astOperand1()->astOperand1()->valueType()->containerTypeToken; + vt.containerTypeToken = contVt->containerTypeToken; setValueType(tok, vt); continue; } diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp index 7f4cd5584e8..1dc14def29c 100644 --- a/lib/valueflow.cpp +++ b/lib/valueflow.cpp @@ -3031,12 +3031,17 @@ static void valueFlowLifetime(TokenList &tokenlist, ErrorLogger &errorLogger, co valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings); } // container lifetimes - else if (astIsContainer(tok)) { + else if (astIsContainer(tok) || astIsSmartPointerContainerAccess(tok, settings)) { Token * parent = astParentSkipParens(tok); if (!parent) continue; if (!Token::Match(parent, ". %name% (") && !Token::Match(parent->previous(), "%name% (")) continue; + // Container that is owned by a smart pointer. Only iterators are tracked, the lifetime refers + // to the smart pointer. + const bool smartPointer = !astIsContainer(tok); + if (smartPointer && !astIsIterator(parent->tokAt(2))) + continue; // Skip if its a free function that doesnt yield an iterator to the container if (Token::Match(parent->previous(), "%name% (") && @@ -3066,7 +3071,9 @@ static void valueFlowLifetime(TokenList &tokenlist, ErrorLogger &errorLogger, co } std::vector toks; - if (tok->isUnaryOp("*") || parent->originalName() == "->") { + if (smartPointer) { + toks = {tok}; + } else if (tok->isUnaryOp("*") || parent->originalName() == "->") { for (const ValueFlow::Value& v : tok->values()) { if (!v.isLocalLifetimeValue()) continue; @@ -6471,7 +6478,7 @@ static void valueFlowIterators(TokenList& tokenlist, const Settings& settings) continue; if (!tok->scope()->isExecutable()) continue; - if (!astIsContainer(tok)) + if (!astIsContainer(tok) && !astIsSmartPointerContainerAccess(tok, settings)) continue; const Token* ftok = nullptr; const Library::Container::Yield yield = findIteratorYield(tok, ftok, settings.library); diff --git a/releasenotes.txt b/releasenotes.txt index 9aa1bd2cf8a..b510733c10d 100644 --- a/releasenotes.txt +++ b/releasenotes.txt @@ -29,4 +29,6 @@ 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. +- Member functions of containers called through smart pointers (e.g. m->find(i) where m is a std::shared_ptr>) now get a value type, so 'auto' variables initialized from them are no longer untyped (#13105). +- Iterators to containers owned by smart pointers (e.g. v->begin() where v is a std::shared_ptr>) are now tracked. invalidContainer, derefInvalidIterator and mismatchingContainers (for std::unique_ptr) now detect bugs with such iterators. - 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/testautovariables.cpp b/test/testautovariables.cpp index d5ab5855c32..671a64da822 100644 --- a/test/testautovariables.cpp +++ b/test/testautovariables.cpp @@ -2502,6 +2502,16 @@ class TestAutoVariables : public TestFixture { } void danglingLifetimeContainer() { + // container owned by a smart pointer, the container might be shared or moved + check("std::vector::iterator f(std::shared_ptr> v) {\n" + " return v->begin();\n" + "}\n" + "std::vector::iterator g() {\n" + " auto v = std::make_unique>();\n" + " return v->begin();\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + check("auto f(const std::vector& x) {\n" " auto it = x.begin();\n" " return it;\n" diff --git a/test/testfunctions.cpp b/test/testfunctions.cpp index 58228b58b07..662c873f6aa 100644 --- a/test/testfunctions.cpp +++ b/test/testfunctions.cpp @@ -2264,7 +2264,7 @@ class TestFunctions : public TestFixture { " const bool b = it != m->end();\n" " return b;\n" "}\n", s); - TODO_ASSERT_EQUALS("", "[test.cpp:6:5]: (debug) auto token with no type. [autoNoType]\n", errout_str()); + ASSERT_EQUALS("", errout_str()); check("template \n" // #13509 "void f(const T& t) {\n" diff --git a/test/teststl.cpp b/test/teststl.cpp index 1c1e62c2b68..3453f3aa672 100644 --- a/test/teststl.cpp +++ b/test/teststl.cpp @@ -176,6 +176,7 @@ class TestStl : public TestFixture { TEST_CASE(loopAlgoMultipleReturn); TEST_CASE(invalidContainer); + TEST_CASE(invalidContainerSmartPointer); TEST_CASE(invalidContainerLoop); TEST_CASE(findInsert); @@ -1127,6 +1128,12 @@ class TestStl : public TestFixture { 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(const std::shared_ptr>& v) {\n" + " auto it = v->end();\n" + " return *it;\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:13]: (error) Dereference of an invalid iterator: it [derefInvalidIterator]\n", errout_str()); + check("int f(std::span s) {\n" " std::span::iterator it = s.end();\n" " return *it;\n" @@ -1408,6 +1415,53 @@ class TestStl : public TestFixture { "}\n"); ASSERT_EQUALS("[test.cpp:3:38]: (error) Iterators of different containers 's1' and 's2' are used together. [mismatchingContainers]\n", errout_str()); + // containers owned by smart pointers + check("void foo(std::unique_ptr> &a, std::unique_ptr> &b)\n" + "{\n" + " std::vector::iterator it = std::find(a->begin(), b->end(), 1);\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:47]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n", errout_str()); + + check("void foo(std::shared_ptr> sp)\n" + "{\n" + " auto& v = *sp;\n" + " v.insert(sp->begin(), 1);\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + // iterator range passed to a member function of a container owned by a smart pointer + check("void foo(std::unique_ptr> &a, std::unique_ptr> &b, std::unique_ptr> &c)\n" + "{\n" + " c->insert(c->end(), a->begin(), b->end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:25]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n", errout_str()); + + check("void foo(std::unique_ptr> &a, std::unique_ptr> &c)\n" + "{\n" + " c->insert(c->end(), a->begin(), a->end());\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + check("void foo(std::unique_ptr> &a, std::unique_ptr> &b, std::unique_ptr> &c)\n" + "{\n" + " c->assign(a->begin(), b->end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:15]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n", errout_str()); + + // shared pointers might own the same container + check("void foo(std::shared_ptr> &a, std::shared_ptr> &b, std::unique_ptr> &c)\n" + "{\n" + " c->insert(c->end(), a->begin(), b->end());\n" + "}\n"); + ASSERT_EQUALS("[test.cpp:3:25]: (warning) Iterators to containers from different expressions 'a' and 'b' are used together. [mismatchingContainerExpression]\n", errout_str()); + + // insert(hint, value) through a smart pointer + check("void foo(std::unique_ptr::iterator>> &s, std::vector &v)\n" + "{\n" + " s->insert(s->end(), v.begin());\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + // insert(hint, value) where the value is an iterator check("void foo(std::set::iterator> &s, std::vector &v)\n" "{\n" @@ -7246,6 +7300,88 @@ class TestStl : public TestFixture { errout_str()); } + void invalidContainerSmartPointer() { + check("int f(std::shared_ptr> v) {\n" + " auto it = v->begin();\n" + " v->push_back(1);\n" + " return *it;\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("[test.cpp:2:23] -> [test.cpp:3:8] -> [test.cpp:1:41] -> [test.cpp:4:13]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str()); + + check("int f(std::unique_ptr>& v) {\n" + " std::vector::iterator it = v->begin();\n" + " v->clear();\n" + " return *it;\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("[test.cpp:1:43] -> [test.cpp:2:45] -> [test.cpp:3:8] -> [test.cpp:1:42] -> [test.cpp:4:13]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str()); + + check("void f(std::shared_ptr> v) {\n" + " for (auto it = v->begin(); it != v->end(); ++it)\n" + " v->push_back(*it);\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("[test.cpp:2:28] -> [test.cpp:2:35] -> [test.cpp:3:12] -> [test.cpp:1:42] -> [test.cpp:2:32]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str()); + + check("struct S {\n" + " std::shared_ptr> m;\n" + " void add() { m->push_back(1); }\n" + " int f() {\n" + " auto it = m->begin();\n" + " add();\n" + " return *it;\n" + " }\n" + "};\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("[test.cpp:5:27] -> [test.cpp:6:9] -> [test.cpp:3:21] -> [test.cpp:7:17]: (error) Using iterator to member container 'm' that may be invalid. [invalidContainer]\n", errout_str()); + + // iterator is reassigned + check("int f(std::shared_ptr> v) {\n" + " auto it = v->begin();\n" + " v->push_back(1);\n" + " it = v->begin();\n" + " return *it;\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("", errout_str()); + + check("void f(std::shared_ptr> v) {\n" + " for (auto it = v->begin(); it != v->end();)\n" + " it = v->erase(it);\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("", errout_str()); + + // container is not changed + check("int f(std::shared_ptr> v) {\n" + " auto it = v->begin();\n" + " const int n = v->size();\n" + " return *it + n;\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("", errout_str()); + + // another shared pointer is changed + check("int f(std::shared_ptr> v, std::shared_ptr> w) {\n" + " auto it = v->begin();\n" + " w->push_back(1);\n" + " v = w;\n" + " return *it;\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("", errout_str()); + + // the reference refers to the container, which is not invalidated + check("int f(std::unique_ptr>& v) {\n" + " auto& x = *v;\n" + " v->push_back(1);\n" + " return x.size();\n" + "}\n", + dinit(CheckOptions, $.inconclusive = true)); + ASSERT_EQUALS("", errout_str()); + } + void invalidContainerLoop() { // #9435 check("void f(std::vector v) {\n" diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp index 8b95bd5369a..889a79607d0 100644 --- a/test/testsymboldatabase.cpp +++ b/test/testsymboldatabase.cpp @@ -595,6 +595,7 @@ class TestSymbolDatabase : public TestFixture { TEST_CASE(valueType2); TEST_CASE(valueTypeStringIterator); TEST_CASE(valueTypeSpanIterator); + TEST_CASE(valueTypeSmartPointerContainer); TEST_CASE(valueType3); TEST_CASE(valueTypeThis); TEST_CASE(valueTypeChar); @@ -10423,6 +10424,37 @@ class TestSymbolDatabase : public TestFixture { ASSERT(tok && (!tok->valueType() || tok->valueType()->type != ValueType::Type::ITERATOR)); } + void valueTypeSmartPointerContainer() { // #13105 + GET_SYMBOL_DB("void f(std::shared_ptr> m, std::unique_ptr> v, std::shared_ptr s) {\n" + " auto a = m->find(1);\n" + " auto b = m->size();\n" + " auto c = v->begin();\n" + " auto d = v->at(0);\n" + " auto e = s->c_str();\n" + "}\n"); + ASSERT_EQUALS("", errout_str()); + + const Token* tok = Token::findsimplematch(tokenizer.tokens(), "auto a"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: map|unordered_map <)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "auto b"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("std::size_t", tok->valueType()->originalTypeName); + + tok = Token::findsimplematch(tok, "auto c"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "( 0 )"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("const signed int &", tok->valueType()->str()); + + tok = Token::findsimplematch(tok, "auto e"); + ASSERT(tok && tok->valueType()); + ASSERT_EQUALS("const char *", tok->valueType()->str()); + } + void valueTypeSpanIterator() { GET_SYMBOL_DB("void f(std::span s, std::vector& v) {\n" " std::span::iterator it = s.begin();\n"