fixed many COPY_INSTEAD_OF_MOVE Coverity warnings

firewave · firewave · commit 949bfe2a1041 · 2024-02-04T19:31:23.000+01:00
diff --git a/cli/cppcheckexecutor.cpp b/cli/cppcheckexecutor.cpp
@@ -194,7 +194,7 @@ int CppCheckExecutor::check(int argc, const char* const argv[])
     mStdLogger = new StdLogger(settings);
 
     CppCheck cppCheck(*mStdLogger, true, executeCommand);
-    cppCheck.settings() = settings;
+    cppCheck.settings() = std::move(settings);
 
     const int ret = check_wrapper(cppCheck);
 
diff --git a/lib/astutils.cpp b/lib/astutils.cpp
@@ -3068,7 +3068,7 @@ int getArgumentPos(const Variable* var, const Function* f)
     });
     if (arg_it == f->argumentList.end())
         return -1;
-    return std::distance(f->argumentList.cbegin(), arg_it);
+    return std::distance(f->argumentList.cbegin(), std::move(arg_it));
 }
 
 const Token* getIteratorExpression(const Token* tok)
@@ -3253,7 +3253,7 @@ bool isConstVarExpression(const Token *tok, std::function<bool(const Token*)> sk
     if (Token::Match(tok, "%cop%|[|.")) {
         if (tok->astOperand1() && !isConstVarExpression(tok->astOperand1(), skipPredicate))
             return false;
-        if (tok->astOperand2() && !isConstVarExpression(tok->astOperand2(), skipPredicate))
+        if (tok->astOperand2() && !isConstVarExpression(tok->astOperand2(), std::move(skipPredicate)))
             return false;
         return true;
     }
diff --git a/lib/checkautovariables.cpp b/lib/checkautovariables.cpp
@@ -575,7 +575,7 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token
             ErrorPath errorPath;
             const Variable *var = ValueFlow::getLifetimeVariable(tok, errorPath);
             if (var && isInScope(var->nameToken(), tok->scope())) {
-                errorDanglingReference(tok, var, errorPath);
+                errorDanglingReference(tok, var, std::move(errorPath));
                 continue;
             }
             // Reference to temporary
diff --git a/lib/checkautovariables.h b/lib/checkautovariables.h
@@ -97,7 +97,7 @@ class CPPCHECKLIB CheckAutoVariables : public Check {
         c.errorReturnReference(nullptr, errorPath, false);
         c.errorDanglingReference(nullptr, nullptr, errorPath);
         c.errorReturnTempReference(nullptr, errorPath, false);
-        c.errorDanglingTempReference(nullptr, errorPath, false);
+        c.errorDanglingTempReference(nullptr, std::move(errorPath), false);
         c.errorInvalidDeallocation(nullptr, nullptr);
         c.errorUselessAssignmentArg(nullptr);
         c.errorUselessAssignmentPtrArg(nullptr);
diff --git a/lib/checkclass.cpp b/lib/checkclass.cpp
@@ -3517,7 +3517,7 @@ Check::FileInfo *CheckClass::getFileInfo(const Tokenizer *tokenizer, const Setti
             continue;
 
         MyFileInfo::NameLoc nameLoc;
-        nameLoc.className = name;
+        nameLoc.className = std::move(name);
         nameLoc.fileName = tokenizer->list.file(classScope->classDef);
         nameLoc.lineNumber = classScope->classDef->linenr();
         nameLoc.column = classScope->classDef->column();
diff --git a/lib/checkcondition.cpp b/lib/checkcondition.cpp
@@ -505,7 +505,7 @@ void CheckCondition::duplicateCondition()
         ErrorPath errorPath;
         if (!findExpressionChanged(cond1, scope.classDef->next(), cond2, mSettings, mTokenizer->isCPP()) &&
             isSameExpression(mTokenizer->isCPP(), true, cond1, cond2, mSettings->library, true, true, &errorPath))
-            duplicateConditionError(cond1, cond2, errorPath);
+            duplicateConditionError(cond1, cond2, std::move(errorPath));
     }
 }
 
@@ -1193,7 +1193,7 @@ void CheckCondition::checkIncorrectLogicOperator()
                     }
 
                     const std::string cond1 = expr1 + " " + tok->str() + " (" + expr2 + " " + tok->astOperand2()->str() + " " + expr3 + ")";
-                    const std::string cond2 = expr1;
+                    const std::string cond2 = std::move(expr1);
 
                     const std::string cond1VerboseMsg = expr1VerboseMsg + " " + tok->str() + " " + expr2VerboseMsg + " " + tok->astOperand2()->str() + " " + expr3VerboseMsg;
                     const std::string& cond2VerboseMsg = expr1VerboseMsg;
@@ -1316,9 +1316,9 @@ void CheckCondition::checkIncorrectLogicOperator()
             const std::string cond2str = conditionString(not2, expr2, op2, value2);
             if (printWarning && (alwaysTrue || alwaysFalse)) {
                 const std::string text = cond1str + " " + tok->str() + " " + cond2str;
-                incorrectLogicOperatorError(tok, text, alwaysTrue, inconclusive, errorPath);
+                incorrectLogicOperatorError(tok, text, alwaysTrue, inconclusive, std::move(errorPath));
             } else if (printStyle && (firstTrue || secondTrue)) {
-                const int which = isfloat ? sufficientCondition(op1, not1, d1, op2, not2, d2, isAnd) : sufficientCondition(op1, not1, i1, op2, not2, i2, isAnd);
+                const int which = isfloat ? sufficientCondition(std::move(op1), not1, d1, std::move(op2), not2, d2, isAnd) : sufficientCondition(std::move(op1), not1, i1, std::move(op2), not2, i2, isAnd);
                 std::string text;
                 if (which != 0) {
                     text = "The condition '" + (which == 1 ? cond2str : cond1str) + "' is redundant since '" + (which == 1 ? cond1str : cond2str) + "' is sufficient.";
diff --git a/lib/checkother.cpp b/lib/checkother.cpp
@@ -2248,7 +2248,7 @@ void CheckOther::checkDuplicateBranch()
             ErrorPath errorPath;
             if (isSameExpression(mTokenizer->isCPP(), false, branchTop1->astOperand1(), branchTop2->astOperand1(), mSettings->library, true, true, &errorPath) &&
                 isSameExpression(mTokenizer->isCPP(), false, branchTop1->astOperand2(), branchTop2->astOperand2(), mSettings->library, true, true, &errorPath))
-                duplicateBranchError(scope.classDef, scope.bodyEnd->next(), errorPath);
+                duplicateBranchError(scope.classDef, scope.bodyEnd->next(), std::move(errorPath));
         }
     }
 }
@@ -2570,7 +2570,7 @@ void CheckOther::checkDuplicateExpression()
                     isConstStatement(tok->astOperand1(), cpp) && isConstStatement(tok->astOperand2(), cpp))
                     duplicateValueTernaryError(tok);
                 else if (isSameExpression(cpp, true, tok->astOperand1(), tok->astOperand2(), mSettings->library, false, true, &errorPath))
-                    duplicateExpressionTernaryError(tok, errorPath);
+                    duplicateExpressionTernaryError(tok, std::move(errorPath));
             }
         }
     }
diff --git a/lib/checkother.h b/lib/checkother.h
@@ -331,7 +331,7 @@ class CPPCHECKLIB CheckOther : public Check {
         c.oppositeExpressionError(nullptr, errorPath);
         c.duplicateExpressionError(nullptr, nullptr, nullptr, errorPath);
         c.duplicateValueTernaryError(nullptr);
-        c.duplicateExpressionTernaryError(nullptr, errorPath);
+        c.duplicateExpressionTernaryError(nullptr, std::move(errorPath));
         c.duplicateBreakError(nullptr,  false);
         c.unreachableCodeError(nullptr, nullptr,  false);
         c.unsignedLessThanZeroError(nullptr, nullptr, "varname");
diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
@@ -260,7 +260,7 @@ void CheckStl::outOfBoundsError(const Token *tok, const std::string &containerNa
         ErrorPath errorPath1 = getErrorPath(tok, containerSize, "Access out of bounds");
         ErrorPath errorPath2 = getErrorPath(tok, indexValue, "Access out of bounds");
         if (errorPath1.size() <= 1)
-            errorPath = errorPath2;
+            errorPath = std::move(errorPath2);
         else if (errorPath2.size() <= 1)
             errorPath = errorPath1;
         else {
@@ -993,7 +993,7 @@ namespace {
                     ep.emplace_front(ftok,
                                      "After calling '" + ftok->expressionString() +
                                      "', iterators or references to the container's data may be invalid .");
-                    result.emplace_back(Info::Reference{tok, ep, ftok});
+                    result.emplace_back(Info::Reference{tok, std::move(ep), ftok});
                 }
             }
             return result;
@@ -1165,7 +1165,7 @@ void CheckStl::invalidContainer()
                         // Check the iterator is created before the change
                         if (val && val->tokvalue != tok && reaches(val->tokvalue, tok, library, &ep)) {
                             v = val;
-                            errorPath = ep;
+                            errorPath = std::move(ep);
                             return true;
                         }
                         return false;
@@ -1177,7 +1177,7 @@ void CheckStl::invalidContainer()
                     if (v) {
                         invalidContainerError(info.tok, r.tok, v, errorPath);
                     } else {
-                        invalidContainerReferenceError(info.tok, r.tok, errorPath);
+                        invalidContainerReferenceError(info.tok, r.tok, std::move(errorPath));
                     }
                 }
             }
diff --git a/lib/checkstl.h b/lib/checkstl.h
@@ -246,7 +246,7 @@ class CPPCHECKLIB CheckStl : public Check {
         c.iteratorsError(nullptr, nullptr, "container0", "container1");
         c.iteratorsError(nullptr, nullptr, "container");
         c.invalidContainerLoopError(nullptr, nullptr, errorPath);
-        c.invalidContainerError(nullptr, nullptr, nullptr, errorPath);
+        c.invalidContainerError(nullptr, nullptr, nullptr, std::move(errorPath));
         c.mismatchingContainerIteratorError(nullptr, nullptr, nullptr);
         c.mismatchingContainersError(nullptr, nullptr);
         c.mismatchingContainerExpressionError(nullptr, nullptr);
diff --git a/lib/checkuninitvar.h b/lib/checkuninitvar.h
@@ -118,7 +118,7 @@ class CPPCHECKLIB CheckUninitVar : public Check {
     void uninitvarError(const Token *tok, const std::string &varname, ErrorPath errorPath);
     void uninitvarError(const Token *tok, const std::string &varname) {
         ErrorPath errorPath;
-        uninitvarError(tok, varname, errorPath);
+        uninitvarError(tok, varname, std::move(errorPath));
     }
     void uninitvarError(const Token *tok, const std::string &varname, Alloc alloc) {
         if (alloc == NO_CTOR_CALL || alloc == CTOR_CALL)
diff --git a/lib/checkunusedfunctions.cpp b/lib/checkunusedfunctions.cpp
@@ -363,7 +363,7 @@ void CheckUnusedFunctions::unusedFunctionError(ErrorLogger * const errorLogger,
         locationList.back().fileIndex = fileIndex;
     }
 
-    const ErrorMessage errmsg(locationList, emptyString, Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' is never used.", "unusedFunction", CWE561, Certainty::normal);
+    const ErrorMessage errmsg(std::move(locationList), emptyString, Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' is never used.", "unusedFunction", CWE561, Certainty::normal);
     if (errorLogger)
         errorLogger->reportErr(errmsg);
     else
diff --git a/lib/clangimport.cpp b/lib/clangimport.cpp
@@ -305,7 +305,7 @@ namespace clangimport {
             if (it != mNotFound.end()) {
                 for (Token *reftok: it->second)
                     ref(addr, reftok);
-                mNotFound.erase(it);
+                mNotFound.erase(std::move(it));
             }
         }
 
@@ -947,7 +947,7 @@ Token *clangimport::AstNode::createTokens(TokenList &tokenList)
             --addrIndex;
         const std::string addr = mExtTokens[addrIndex];
         std::string name = unquote(getSpelling());
-        Token *reftok = addtoken(tokenList, name.empty() ? "<NoName>" : name);
+        Token *reftok = addtoken(tokenList, name.empty() ? "<NoName>" : std::move(name));
         mData->ref(addr, reftok);
         return reftok;
     }
@@ -1088,7 +1088,7 @@ Token *clangimport::AstNode::createTokens(TokenList &tokenList)
         createScope(tokenList, Scope::ScopeType::eIf, thenCode, iftok);
         if (elseCode) {
             elseCode->addtoken(tokenList, "else");
-            createScope(tokenList, Scope::ScopeType::eElse, elseCode, tokenList.back());
+            createScope(tokenList, Scope::ScopeType::eElse, std::move(elseCode), tokenList.back());
         }
         return nullptr;
     }
@@ -1255,7 +1255,7 @@ Token *clangimport::AstNode::createTokens(TokenList &tokenList)
         Token *par2 = addtoken(tokenList, ")");
         par1->link(par2);
         par2->link(par1);
-        createScope(tokenList, Scope::ScopeType::eWhile, body, whiletok);
+        createScope(tokenList, Scope::ScopeType::eWhile, std::move(body), whiletok);
         return nullptr;
     }
     return addtoken(tokenList, "?" + nodeType + "?");
diff --git a/lib/cppcheck.cpp b/lib/cppcheck.cpp
@@ -287,7 +287,7 @@ static std::vector<picojson::value> executeAddon(const AddonInfo &addonInfo,
             if (pos != std::string::npos)
                 details.resize(pos + 1);
         }
-        throw InternalError(nullptr, message, details);
+        throw InternalError(nullptr, std::move(message), std::move(details));
     }
 
     std::vector<picojson::value> addonResult;
@@ -664,7 +664,7 @@ unsigned int CppCheck::checkFile(const std::string& filename, const std::string
             const ErrorMessage::FileLocation loc1(file, output.location.line, output.location.col);
             std::list<ErrorMessage::FileLocation> callstack(1, loc1);
 
-            ErrorMessage errmsg(callstack,
+            ErrorMessage errmsg(std::move(callstack),
                                 "",
                                 Severity::error,
                                 output.msg,
@@ -1041,7 +1041,7 @@ void CppCheck::internalError(const std::string &filename, const std::string &msg
     const ErrorMessage::FileLocation loc1(filename, 0, 0);
     std::list<ErrorMessage::FileLocation> callstack(1, loc1);
 
-    ErrorMessage errmsg(callstack,
+    ErrorMessage errmsg(std::move(callstack),
                         emptyString,
                         Severity::error,
                         fullmsg,
@@ -1551,7 +1551,7 @@ void CppCheck::tooManyConfigsError(const std::string &file, const int numberOfCo
         msg << " For more details, use --enable=information.";
 
 
-    ErrorMessage errmsg(loclist,
+    ErrorMessage errmsg(std::move(loclist),
                         emptyString,
                         Severity::information,
                         msg.str(),
@@ -1573,7 +1573,7 @@ void CppCheck::purgedConfigurationMessage(const std::string &file, const std::st
         loclist.emplace_back(file);
     }
 
-    ErrorMessage errmsg(loclist,
+    ErrorMessage errmsg(std::move(loclist),
                         emptyString,
                         Severity::information,
                         "The configuration '" + configuration + "' was not checked because its code equals another one.",
@@ -1756,7 +1756,7 @@ void CppCheck::analyseClangTidy(const FileSettings &fileSettings)
         else
             errmsg.severity = Severity::style;
 
-        errmsg.file0 = fixedpath;
+        errmsg.file0 = std::move(fixedpath);
         errmsg.setmsg(messageString);
         reportErr(errmsg);
     }
diff --git a/lib/errorlogger.cpp b/lib/errorlogger.cpp
@@ -337,7 +337,7 @@ void ErrorMessage::deserialize(const std::string &data)
             }
         }
 
-        results[elem++] = temp;
+        results[elem++] = std::move(temp);
     }
 
     if (!iss.good())
diff --git a/lib/importproject.cpp b/lib/importproject.cpp
@@ -337,7 +337,7 @@ void ImportProject::fsParseCommand(FileSettings& fs, const std::string& command)
             // we can only set it globally but in this context it needs to be treated per file
         }
     }
-    fsSetDefines(fs, defs);
+    fsSetDefines(fs, std::move(defs));
 }
 
 bool ImportProject::importCompileCommands(std::istream &istr)
@@ -630,7 +630,7 @@ static void importPropertyGroup(const tinyxml2::XMLElement *node, std::map<std::
             const std::string::size_type pos = path.find("$(IncludePath)");
             if (pos != std::string::npos)
                 path.replace(pos, 14U, includePath);
-            includePath = path;
+            includePath = std::move(path);
         }
     }
 }
diff --git a/lib/library.cpp b/lib/library.cpp
@@ -637,7 +637,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                         return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);
                     return Error(ErrorCode::PLATFORM_TYPE_REDEFINED, type_name);
                 }
-                mPlatformTypes[type_name] = type;
+                mPlatformTypes[type_name] = std::move(type);
             } else {
                 for (const std::string &p : platform) {
                     const PlatformType * const type_ptr = platform_type(type_name, p);
@@ -890,7 +890,7 @@ Library::Error Library::loadFunction(const tinyxml2::XMLElement * const node, co
                 wi.message = message;
             }
 
-            functionwarn[name] = wi;
+            functionwarn[name] = std::move(wi);
         } else if (functionnodename == "container") {
             const char* const action_ptr = functionnode->Attribute("action");
             Container::Action action = Container::Action::NO_ACTION;
diff --git a/lib/pathanalysis.cpp b/lib/pathanalysis.cpp
@@ -76,7 +76,7 @@ PathAnalysis::Progress PathAnalysis::forwardRecursive(const Token* tok, Info inf
     info.tok = tok;
     if (f(info) == Progress::Break)
         return Progress::Break;
-    if (tok->astOperand2() && forwardRecursive(tok->astOperand2(), info, f) == Progress::Break)
+    if (tok->astOperand2() && forwardRecursive(tok->astOperand2(), std::move(info), f) == Progress::Break)
         return Progress::Break;
     return Progress::Continue;
 }
diff --git a/lib/preprocessor.cpp b/lib/preprocessor.cpp
@@ -552,7 +552,7 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
             }
 
             configs_if.push_back((cmdtok->str() == "ifndef") ? std::string() : config);
-            configs_ifndef.push_back((cmdtok->str() == "ifndef") ? config : std::string());
+            configs_ifndef.push_back((cmdtok->str() == "ifndef") ? std::move(config) : std::string());
             ret.insert(cfg(configs_if,userDefines));
         } else if (cmdtok->str() == "elif" || cmdtok->str() == "else") {
             if (getConfigsElseIsFalse(configs_if,userDefines)) {
@@ -831,7 +831,7 @@ simplecpp::TokenList Preprocessor::preprocess(const simplecpp::TokenList &tokens
     std::list<simplecpp::IfCond> ifCond;
     simplecpp::TokenList tokens2(files);
     simplecpp::preprocess(tokens2, tokens1, files, mTokenLists, dui, &outputList, &macroUsage, &ifCond);
-    mMacroUsage = macroUsage;
+    mMacroUsage = std::move(macroUsage);
     mIfCond = ifCond;
 
     handleErrors(outputList, throwError);
@@ -910,7 +910,7 @@ void Preprocessor::error(const std::string &filename, unsigned int linenr, const
         ErrorMessage::FileLocation loc(file, linenr, 0);
         locationList.push_back(std::move(loc));
     }
-    mErrorLogger->reportErr(ErrorMessage(locationList,
+    mErrorLogger->reportErr(ErrorMessage(std::move(locationList),
                                          mFile0,
                                          Severity::error,
                                          msg,
diff --git a/lib/programmemory.cpp b/lib/programmemory.cpp
@@ -1227,7 +1227,7 @@ static bool evalSameCondition(const ProgramMemory& state,
     programMemoryParseCondition(pm, storedValue, nullptr, settings, true);
     if (pm == state)
         return false;
-    return conditionIsTrue(cond, pm, settings);
+    return conditionIsTrue(cond, std::move(pm), settings);
 }
 
 static void pruneConditions(std::vector<const Token*>& conds,
@@ -1496,13 +1496,13 @@ namespace {
                 if (expr->isComparisonOp() && (r.isUninitValue() || r.isImpossible())) {
                     if (rhs.isIntValue()) {
                         std::vector<ValueFlow::Value> result =
-                            infer(ValueFlow::makeIntegralInferModel(), expr->str(), expr->astOperand1()->values(), {rhs});
+                            infer(ValueFlow::makeIntegralInferModel(), expr->str(), expr->astOperand1()->values(), {std::move(rhs)});
                         if (!result.empty() && result.front().isKnown())
                             return result.front();
                     }
                     if (lhs.isIntValue()) {
                         std::vector<ValueFlow::Value> result =
-                            infer(ValueFlow::makeIntegralInferModel(), expr->str(), {lhs}, expr->astOperand2()->values());
+                            infer(ValueFlow::makeIntegralInferModel(), expr->str(), {std::move(lhs)}, expr->astOperand2()->values());
                         if (!result.empty() && result.front().isKnown())
                             return result.front();
                     }
diff --git a/lib/suppressions.cpp b/lib/suppressions.cpp
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
diff --git a/lib/templatesimplifier.cpp b/lib/templatesimplifier.cpp
diff --git a/lib/token.cpp b/lib/token.cpp
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp

Original file line number	Diff line number	Diff line change
`@@ -575,7 +575,7 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token`
`575`	`575`	`ErrorPath errorPath;`
`576`	`576`	`const Variable *var = ValueFlow::getLifetimeVariable(tok, errorPath);`
`577`	`577`	`if (var && isInScope(var->nameToken(), tok->scope())) {`
`578`		`- errorDanglingReference(tok, var, errorPath);`
	`578`	`+ errorDanglingReference(tok, var, std::move(errorPath));`
`579`	`579`	`continue;`
`580`	`580`	`}`
`581`	`581`	`// Reference to temporary`
Original file line number	Diff line number	Diff line change
`@@ -2248,7 +2248,7 @@ void CheckOther::checkDuplicateBranch()`
`2248`	`2248`	`ErrorPath errorPath;`
`2249`	`2249`	`if (isSameExpression(mTokenizer->isCPP(), false, branchTop1->astOperand1(), branchTop2->astOperand1(), mSettings->library, true, true, &errorPath) &&`
`2250`	`2250`	`isSameExpression(mTokenizer->isCPP(), false, branchTop1->astOperand2(), branchTop2->astOperand2(), mSettings->library, true, true, &errorPath))`
`2251`		`- duplicateBranchError(scope.classDef, scope.bodyEnd->next(), errorPath);`
	`2251`	`+ duplicateBranchError(scope.classDef, scope.bodyEnd->next(), std::move(errorPath));`
`2252`	`2252`	`}`
`2253`	`2253`	`}`
`2254`	`2254`	`}`
`@@ -2570,7 +2570,7 @@ void CheckOther::checkDuplicateExpression()`
`2570`	`2570`	`isConstStatement(tok->astOperand1(), cpp) && isConstStatement(tok->astOperand2(), cpp))`
`2571`	`2571`	`duplicateValueTernaryError(tok);`
`2572`	`2572`	`else if (isSameExpression(cpp, true, tok->astOperand1(), tok->astOperand2(), mSettings->library, false, true, &errorPath))`
`2573`		`- duplicateExpressionTernaryError(tok, errorPath);`
	`2573`	`+ duplicateExpressionTernaryError(tok, std::move(errorPath));`
`2574`	`2574`	`}`
`2575`	`2575`	`}`
`2576`	`2576`	`}`
Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@ void CheckStl::outOfBoundsError(const Token *tok, const std::string &containerNa`
`260`	`260`	`ErrorPath errorPath1 = getErrorPath(tok, containerSize, "Access out of bounds");`
`261`	`261`	`ErrorPath errorPath2 = getErrorPath(tok, indexValue, "Access out of bounds");`
`262`	`262`	`if (errorPath1.size() <= 1)`
`263`		`- errorPath = errorPath2;`
	`263`	`+ errorPath = std::move(errorPath2);`
`264`	`264`	`else if (errorPath2.size() <= 1)`
`265`	`265`	`errorPath = errorPath1;`
`266`	`266`	`else {`
`@@ -993,7 +993,7 @@ namespace {`
`993`	`993`	`ep.emplace_front(ftok,`
`994`	`994`	`"After calling '" + ftok->expressionString() +`
`995`	`995`	`"', iterators or references to the container's data may be invalid .");`
`996`		`- result.emplace_back(Info::Reference{tok, ep, ftok});`
	`996`	`+ result.emplace_back(Info::Reference{tok, std::move(ep), ftok});`
`997`	`997`	`}`
`998`	`998`	`}`
`999`	`999`	`return result;`
`@@ -1165,7 +1165,7 @@ void CheckStl::invalidContainer()`
`1165`	`1165`	`// Check the iterator is created before the change`
`1166`	`1166`	`if (val && val->tokvalue != tok && reaches(val->tokvalue, tok, library, &ep)) {`
`1167`	`1167`	`v = val;`
`1168`		`- errorPath = ep;`
	`1168`	`+ errorPath = std::move(ep);`
`1169`	`1169`	`return true;`
`1170`	`1170`	`}`
`1171`	`1171`	`return false;`
`@@ -1177,7 +1177,7 @@ void CheckStl::invalidContainer()`
`1177`	`1177`	`if (v) {`
`1178`	`1178`	`invalidContainerError(info.tok, r.tok, v, errorPath);`
`1179`	`1179`	`} else {`
`1180`		`- invalidContainerReferenceError(info.tok, r.tok, errorPath);`
	`1180`	`+ invalidContainerReferenceError(info.tok, r.tok, std::move(errorPath));`
`1181`	`1181`	`}`
`1182`	`1182`	`}`
`1183`	`1183`	`}`