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"