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/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 0b3bd405c3d..6661fed525d 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(); @@ -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%|-")) { @@ -816,6 +832,53 @@ 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)', 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(); + 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 {}; + + 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 +906,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) { @@ -925,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)) @@ -934,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%")) @@ -947,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) @@ -1002,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 { @@ -1043,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, @@ -1139,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()) { @@ -1171,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 @@ -1202,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 6c80e88e5cc..37fc7726896 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; @@ -1674,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/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/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/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..b510733c10d 100644 --- a/releasenotes.txt +++ b/releasenotes.txt @@ -26,4 +26,9 @@ 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. +- 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/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..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); @@ -1126,6 +1127,27 @@ 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(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" + "}\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 +1360,121 @@ 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()); + + // 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" + " 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 +2428,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" @@ -7155,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 85ee8430a77..889a79607d0 100644 --- a/test/testsymboldatabase.cpp +++ b/test/testsymboldatabase.cpp @@ -593,6 +593,9 @@ class TestSymbolDatabase : public TestFixture { TEST_CASE(valueType1); TEST_CASE(valueType2); + TEST_CASE(valueTypeStringIterator); + TEST_CASE(valueTypeSpanIterator); + TEST_CASE(valueTypeSmartPointerContainer); TEST_CASE(valueType3); TEST_CASE(valueTypeThis); TEST_CASE(valueTypeChar); @@ -10392,6 +10395,99 @@ 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 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" + " 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"