avoid unnecessary copies with push_back() and push_front() (#4451)

firewave · web-flow · commit d46ea7ba86e2 · 2022-09-08T09:21:35.000+02:00
diff --git a/lib/astutils.cpp b/lib/astutils.cpp
@@ -1135,7 +1135,7 @@ static void followVariableExpressionError(const Token *tok1, const Token *tok2,
     ErrorPathItem item = std::make_pair(tok2, "'" + tok1->str() + "' is assigned value '" + tok2->expressionString() + "' here.");
     if (std::find(errors->begin(), errors->end(), item) != errors->end())
         return;
-    errors->push_back(item);
+    errors->push_back(std::move(item));
 }
 
 std::vector<ReferenceToken> followAllReferences(const Token* tok,
diff --git a/lib/checkclass.cpp b/lib/checkclass.cpp
@@ -3089,7 +3089,7 @@ Check::FileInfo *CheckClass::getFileInfo(const Tokenizer *tokenizer, const Setti
         }
         nameLoc.hash = std::hash<std::string> {}(def);
 
-        classDefinitions.push_back(nameLoc);
+        classDefinitions.push_back(std::move(nameLoc));
     }
 
     if (classDefinitions.empty())
@@ -3132,7 +3132,7 @@ Check::FileInfo * CheckClass::loadFileInfoFromXml(const tinyxml2::XMLElement *xm
             nameLoc.lineNumber = std::atoi(line);
             nameLoc.column = std::atoi(col);
             nameLoc.hash = MathLib::toULongNumber(hash);
-            fileInfo->classDefinitions.push_back(nameLoc);
+            fileInfo->classDefinitions.push_back(std::move(nameLoc));
         }
     }
     if (fileInfo->classDefinitions.empty()) {
diff --git a/lib/checkunusedfunctions.cpp b/lib/checkunusedfunctions.cpp
@@ -346,7 +346,7 @@ void CheckUnusedFunctions::unusedFunctionError(ErrorLogger * const errorLogger,
         ErrorMessage::FileLocation fileLoc;
         fileLoc.setfile(filename);
         fileLoc.line = lineNumber;
-        locationList.push_back(fileLoc);
+        locationList.push_back(std::move(fileLoc));
     }
 
     const ErrorMessage errmsg(locationList, emptyString, Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' is never used.", "unusedFunction", CWE561, Certainty::normal);
diff --git a/lib/clangimport.cpp b/lib/clangimport.cpp
@@ -1607,9 +1607,9 @@ void clangimport::parseClangAstDump(Tokenizer *tokenizer, std::istream &f)
         AstNodePtr newNode = std::make_shared<AstNode>(nodeType, ext, &data);
         tree[level - 1]->children.push_back(newNode);
         if (level >= tree.size())
-            tree.push_back(newNode);
+            tree.push_back(std::move(newNode));
         else
-            tree[level] = newNode;
+            tree[level] = std::move(newNode);
     }
 
     if (!tree.empty())
diff --git a/lib/cppcheck.cpp b/lib/cppcheck.cpp
@@ -417,7 +417,7 @@ static bool reportClangErrors(std::istream &is, std::function<void(const ErrorMe
                             Certainty::normal);
 
         if (line.compare(pos3, 10, ": warning:") == 0) {
-            warnings->push_back(errmsg);
+            warnings->push_back(std::move(errmsg));
             continue;
         }
 
@@ -909,13 +909,13 @@ unsigned int CppCheck::checkFile(const std::string& filename, const std::string
                 std::list<ErrorMessage::FileLocation> locationList;
                 if (e.token) {
                     ErrorMessage::FileLocation loc(e.token, &tokenizer.list);
-                    locationList.push_back(loc);
+                    locationList.push_back(std::move(loc));
                 } else {
                     ErrorMessage::FileLocation loc2(filename, 0, 0);
-                    locationList.push_back(loc2);
+                    locationList.push_back(std::move(loc2));
                     if (filename != tokenizer.list.getSourceFilePath()) {
                         ErrorMessage::FileLocation loc(tokenizer.list.getSourceFilePath(), 0, 0);
-                        locationList.push_back(loc);
+                        locationList.push_back(std::move(loc));
                     }
                 }
                 ErrorMessage errmsg(std::move(locationList),
@@ -1463,7 +1463,7 @@ void CppCheck::tooManyConfigsError(const std::string &file, const int numberOfCo
     if (!file.empty()) {
         ErrorMessage::FileLocation location;
         location.setfile(file);
-        loclist.push_back(location);
+        loclist.push_back(std::move(location));
     }
 
     std::ostringstream msg;
@@ -1501,7 +1501,7 @@ void CppCheck::purgedConfigurationMessage(const std::string &file, const std::st
     if (!file.empty()) {
         ErrorMessage::FileLocation location;
         location.setfile(file);
-        loclist.push_back(location);
+        loclist.push_back(std::move(location));
     }
 
     ErrorMessage errmsg(loclist,
diff --git a/lib/ctu.cpp b/lib/ctu.cpp
@@ -237,11 +237,11 @@ void CTU::FileInfo::loadFromXml(const tinyxml2::XMLElement *xmlElement)
         if (std::strcmp(e->Name(), "function-call") == 0) {
             FunctionCall functionCall;
             if (functionCall.loadFromXml(e))
-                functionCalls.push_back(functionCall);
+                functionCalls.push_back(std::move(functionCall));
         } else if (std::strcmp(e->Name(), "nested-call") == 0) {
             NestedCall nestedCall;
             if (nestedCall.loadFromXml(e))
-                nestedCalls.push_back(nestedCall);
+                nestedCalls.push_back(std::move(nestedCall));
         }
     }
 }
@@ -273,7 +273,7 @@ std::list<CTU::FileInfo::UnsafeUsage> CTU::loadUnsafeUsageListFromXml(const tiny
         unsafeUsage.value = readAttrInt(e, ATTR_VALUE, &error);
 
         if (!error)
-            ret.push_back(unsafeUsage);
+            ret.push_back(std::move(unsafeUsage));
     }
     return ret;
 }
@@ -353,9 +353,9 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
                         loc.line = i.first->linenr();
                         loc.column = i.first->column();
                         loc.setinfo(i.second);
-                        functionCall.callValuePath.push_back(loc);
+                        functionCall.callValuePath.push_back(std::move(loc));
                     }
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                 }
                 // array
                 if (argtok->variable() && argtok->variable()->isArray() && argtok->variable()->dimensions().size() == 1) {
@@ -368,7 +368,7 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
                     functionCall.callArgumentExpression = argtok->expressionString();
                     functionCall.callArgValue = argtok->variable()->dimension(0) * argtok->valueType()->typeSize(*tokenizer->getSettings());
                     functionCall.warning = false;
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                 }
                 // &var => buffer
                 if (argtok->isUnaryOp("&") && argtok->astOperand1()->variable() && argtok->astOperand1()->valueType() && !argtok->astOperand1()->variable()->isArray()) {
@@ -381,7 +381,7 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
                     functionCall.callArgumentExpression = argtok->expressionString();
                     functionCall.callArgValue = argtok->astOperand1()->valueType()->typeSize(*tokenizer->getSettings());
                     functionCall.warning = false;
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                 }
                 // pointer/reference to uninitialized data
                 auto isAddressOfArg = [](const Token* argtok) -> const Token* {
@@ -414,7 +414,7 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
                     functionCall.callArgValue = 0;
                     functionCall.callArgumentExpression = argtok->expressionString();
                     functionCall.warning = false;
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                     continue;
                 }
             }
@@ -428,7 +428,7 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
                 FileInfo::NestedCall nestedCall(tokenizer, scopeFunction, tok);
                 nestedCall.myArgNr = argnr + 1;
                 nestedCall.callArgNr = argnr2;
-                fileInfo->nestedCalls.push_back(nestedCall);
+                fileInfo->nestedCalls.push_back(std::move(nestedCall));
             }
         }
     }
@@ -580,12 +580,12 @@ std::list<ErrorMessage::FileLocation> CTU::FileInfo::getErrorPath(InvalidValueTy
 
         ErrorMessage::FileLocation fileLoc(path[index]->location.fileName, path[index]->location.lineNumber, path[index]->location.column);
         fileLoc.setinfo("Calling function " + path[index]->callFunctionName + ", " + MathLib::toString(path[index]->callArgNr) + getOrdinalText(path[index]->callArgNr) + " argument is " + value1);
-        locationList.push_back(fileLoc);
+        locationList.push_back(std::move(fileLoc));
     }
 
     ErrorMessage::FileLocation fileLoc2(unsafeUsage.location.fileName, unsafeUsage.location.lineNumber, unsafeUsage.location.column);
     fileLoc2.setinfo(replaceStr(info, "ARG", unsafeUsage.myArgumentName));
-    locationList.push_back(fileLoc2);
+    locationList.push_back(std::move(fileLoc2));
 
     return locationList;
 }
diff --git a/lib/errorlogger.cpp b/lib/errorlogger.cpp
@@ -334,7 +334,7 @@ bool ErrorMessage::deserialize(const std::string &data)
         if (substrings.size() == 5)
             loc.setinfo(substrings[4]);
 
-        callStack.push_back(loc);
+        callStack.push_back(std::move(loc));
 
         if (callStack.size() >= stackSize)
             break;
diff --git a/lib/importproject.cpp b/lib/importproject.cpp
@@ -164,7 +164,7 @@ void ImportProject::FileSettings::setIncludePaths(const std::string &basepath, c
         if (s[0] == '/' || (s.size() > 1U && s.compare(1,2,":/") == 0)) {
             if (!endsWith(s,'/'))
                 s += '/';
-            includePaths.push_back(s);
+            includePaths.push_back(std::move(s));
             continue;
         }
 
@@ -312,7 +312,7 @@ void ImportProject::FileSettings::parseCommand(std::string command)
             if (i.size() > 1 && i[0] == '\"' && i.back() == '\"')
                 i = unescape(i.substr(1, i.size() - 2));
             if (std::find(includePaths.begin(), includePaths.end(), i) == includePaths.end())
-                includePaths.push_back(i);
+                includePaths.push_back(std::move(i));
         } else if (F=='s' && fval.compare(0,2,"td") == 0) {
             ++pos;
             const std::string stdval = readUntil(command, &pos, " ");
@@ -341,8 +341,8 @@ void ImportProject::FileSettings::parseCommand(std::string command)
             }
         } else if (F == 'i' && fval == "system") {
             ++pos;
-            const std::string isystem = readUntil(command, &pos, " ");
-            systemIncludePaths.push_back(isystem);
+            std::string isystem = readUntil(command, &pos, " ");
+            systemIncludePaths.push_back(std::move(isystem));
         } else if (F=='m') {
             if (fval == "unicode") {
                 defs += "UNICODE";
@@ -444,7 +444,7 @@ bool ImportProject::importCompileCommands(std::istream &istr)
         fs.parseCommand(command); // read settings; -D, -I, -U, -std, -m*, -f*
         std::map<std::string, std::string, cppcheck::stricmp> variables;
         fs.setIncludePaths(directory, fs.includePaths, variables);
-        fileSettings.push_back(fs);
+        fileSettings.push_back(std::move(fs));
     }
 
     return true;
@@ -804,7 +804,7 @@ bool ImportProject::importVcxproj(const std::string &filename, std::map<std::str
             }
             fs.setDefines(fs.defines);
             fs.setIncludePaths(Path::getPathFromFilename(filename), toStringList(includePath + ';' + additionalIncludePaths), variables);
-            fileSettings.push_back(fs);
+            fileSettings.push_back(std::move(fs));
         }
     }
 
@@ -1071,7 +1071,7 @@ bool ImportProject::importBcb6Prj(const std::string &projectFilename)
         fs.setIncludePaths(projectDir, toStringList(includePath), variables);
         fs.setDefines(cppMode ? cppDefines : defines);
         fs.filename = Path::simplifyPath(Path::isAbsolute(c) ? c : projectDir + c);
-        fileSettings.push_back(fs);
+        fileSettings.push_back(std::move(fs));
     }
 
     return true;
@@ -1180,7 +1180,7 @@ bool ImportProject::importCppcheckGuiProject(std::istream &istr, Settings *setti
                 s.lineNumber = child->IntAttribute("lineNumber", Suppressions::Suppression::NO_LINE);
                 s.symbolName = read(child->Attribute("symbolName"), "");
                 std::istringstream(read(child->Attribute("hash"), "0")) >> s.hash;
-                suppressions.push_back(s);
+                suppressions.push_back(std::move(s));
             }
         } else if (strcmp(node->Name(), CppcheckXml::VSConfigurationElementName) == 0)
             guiProject.checkVsConfigs = readXmlStringList(node, emptyString, CppcheckXml::VSConfigurationName, nullptr);
diff --git a/lib/infer.cpp b/lib/infer.cpp
@@ -321,21 +321,21 @@ std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
             ValueFlow::Value value(diff.getScalar());
             addToErrorPath(value, refs);
             setValueKind(value, refs);
-            result.push_back(value);
+            result.push_back(std::move(value));
         } else {
             if (!diff.minvalue.empty()) {
                 ValueFlow::Value value(diff.minvalue.front() - 1);
                 value.setImpossible();
                 value.bound = ValueFlow::Value::Bound::Upper;
                 addToErrorPath(value, diff.minRef);
-                result.push_back(value);
+                result.push_back(std::move(value));
             }
             if (!diff.maxvalue.empty()) {
                 ValueFlow::Value value(diff.maxvalue.front() + 1);
                 value.setImpossible();
                 value.bound = ValueFlow::Value::Bound::Lower;
                 addToErrorPath(value, diff.maxRef);
-                result.push_back(value);
+                result.push_back(std::move(value));
             }
         }
     } else if ((op == "!=" || op == "==") && lhs.isScalarOrEmpty() && rhs.isScalarOrEmpty()) {
@@ -344,7 +344,7 @@ std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
             ValueFlow::Value value(calculate(op, lhs.getScalar(), rhs.getScalar()));
             addToErrorPath(value, refs);
             setValueKind(value, refs);
-            result.push_back(value);
+            result.push_back(std::move(value));
         } else {
             std::vector<const ValueFlow::Value*> refs;
             if (lhs.isScalar() && inferNotEqual(rhsValues, lhs.getScalar()))
@@ -355,7 +355,7 @@ std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
                 ValueFlow::Value value(op == "!=");
                 addToErrorPath(value, refs);
                 setValueKind(value, refs);
-                result.push_back(value);
+                result.push_back(std::move(value));
             }
         }
     } else {
@@ -365,7 +365,7 @@ std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
             ValueFlow::Value value(r.front());
             addToErrorPath(value, refs);
             setValueKind(value, refs);
-            result.push_back(value);
+            result.push_back(std::move(value));
         }
     }
 
diff --git a/lib/preprocessor.cpp b/lib/preprocessor.cpp
@@ -123,7 +123,7 @@ static bool parseInlineSuppressionCommentToken(const simplecpp::Token *tok, std:
             return false;
 
         if (!s.errorId.empty())
-            inlineSuppressions.push_back(s);
+            inlineSuppressions.push_back(std::move(s));
 
         if (!errmsg.empty())
             bad->emplace_back(tok->location, errmsg);
@@ -231,7 +231,7 @@ void Preprocessor::setDirectives(const simplecpp::TokenList &tokens)
                 else
                     directive.str += tok2->str();
             }
-            mDirectives.push_back(directive);
+            mDirectives.push_back(std::move(directive));
         }
     }
 }
@@ -474,7 +474,7 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
                 std::string config = readcondition(cmdtok, defined, undefined);
                 if (isUndefined(config,undefined))
                     config.clear();
-                configs_if.push_back(config);
+                configs_if.push_back(std::move(config));
                 ret.insert(cfg(configs_if, userDefines));
             } else if (!configs_ifndef.empty()) {
                 configs_if.push_back(configs_ifndef.back());
@@ -588,7 +588,7 @@ static void splitcfg(const std::string &cfg, std::list<std::string> &defines, co
         std::string def = (defineEndPos == std::string::npos) ? cfg.substr(defineStartPos) : cfg.substr(defineStartPos, defineEndPos - defineStartPos);
         if (!defaultValue.empty() && def.find('=') == std::string::npos)
             def += '=' + defaultValue;
-        defines.push_back(def);
+        defines.push_back(std::move(def));
         if (defineEndPos == std::string::npos)
             break;
         defineStartPos = defineEndPos + 1U;
@@ -615,7 +615,7 @@ static simplecpp::DUI createDUI(const Settings &mSettings, const std::string &cf
         } else {
             s[s.find(')')+1] = '=';
         }
-        dui.defines.push_back(s);
+        dui.defines.push_back(std::move(s));
     }
 
     dui.undefined = mSettings.userUndefs; // -U
@@ -825,8 +825,8 @@ void Preprocessor::error(const std::string &filename, unsigned int linenr, const
         if (mSettings.relativePaths)
             file = Path::getRelativePath(file, mSettings.basePaths);
 
-        const ErrorMessage::FileLocation loc(file, linenr, 0);
-        locationList.push_back(loc);
+        ErrorMessage::FileLocation loc(file, linenr, 0);
+        locationList.push_back(std::move(loc));
     }
     mErrorLogger->reportErr(ErrorMessage(locationList,
                                          mFile0,
@@ -865,7 +865,7 @@ void Preprocessor::missingInclude(const std::string &filename, unsigned int line
             ErrorMessage::FileLocation loc;
             loc.line = linenr;
             loc.setfile(Path::toNativeSeparators(filename));
-            locationList.push_back(loc);
+            locationList.push_back(std::move(loc));
         }
         ErrorMessage errmsg(locationList, mFile0, Severity::information,
                             (headerType==SystemHeader) ?
diff --git a/lib/summaries.cpp b/lib/summaries.cpp
@@ -110,7 +110,7 @@ static std::vector<std::string> getSummaryFiles(const std::string &filename)
             continue;
         std::string f = line.substr(0,colon);
         f[dotA + 1] = 's';
-        ret.push_back(f);
+        ret.push_back(std::move(f));
     }
     return ret;
 }
diff --git a/lib/suppressions.cpp b/lib/suppressions.cpp
@@ -166,7 +166,7 @@ std::vector<Suppressions::Suppression> Suppressions::parseMultiSuppressComment(c
             }
         }
 
-        suppressions.push_back(s);
+        suppressions.push_back(std::move(s));
     }
 
     return suppressions;
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
@@ -3319,7 +3319,7 @@ const Token *Type::initBaseInfo(const Token *tok, const Token *tok1)
                 base.type = baseType;
 
             // save pattern for base class name
-            derivedFrom.push_back(base);
+            derivedFrom.push_back(std::move(base));
         } else
             tok2 = tok2->next();
     }
diff --git a/lib/symboldatabase.h b/lib/symboldatabase.h
diff --git a/lib/token.cpp b/lib/token.cpp
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
diff --git a/lib/tokenlist.cpp b/lib/tokenlist.cpp
diff --git a/lib/tokenlist.h b/lib/tokenlist.h
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp

Original file line number	Diff line number	Diff line change
`@@ -1135,7 +1135,7 @@ static void followVariableExpressionError(const Token tok1, const Token tok2,`
`1135`	`1135`	`ErrorPathItem item = std::make_pair(tok2, "'" + tok1->str() + "' is assigned value '" + tok2->expressionString() + "' here.");`
`1136`	`1136`	`if (std::find(errors->begin(), errors->end(), item) != errors->end())`
`1137`	`1137`	`return;`
`1138`		`- errors->push_back(item);`
	`1138`	`+ errors->push_back(std::move(item));`
`1139`	`1139`	`}`
`1140`	`1140`
`1141`	`1141`	`std::vector<ReferenceToken> followAllReferences(const Token* tok,`
Original file line number	Diff line number	Diff line change
`@@ -3089,7 +3089,7 @@ Check::FileInfo CheckClass::getFileInfo(const Tokenizer tokenizer, const Setti`
`3089`	`3089`	`}`
`3090`	`3090`	`nameLoc.hash = std::hash<std::string> {}(def);`
`3091`	`3091`
`3092`		`- classDefinitions.push_back(nameLoc);`
	`3092`	`+ classDefinitions.push_back(std::move(nameLoc));`
`3093`	`3093`	`}`
`3094`	`3094`
`3095`	`3095`	`if (classDefinitions.empty())`
`@@ -3132,7 +3132,7 @@ Check::FileInfo * CheckClass::loadFileInfoFromXml(const tinyxml2::XMLElement *xm`
`3132`	`3132`	`nameLoc.lineNumber = std::atoi(line);`
`3133`	`3133`	`nameLoc.column = std::atoi(col);`
`3134`	`3134`	`nameLoc.hash = MathLib::toULongNumber(hash);`
`3135`		`- fileInfo->classDefinitions.push_back(nameLoc);`
	`3135`	`+ fileInfo->classDefinitions.push_back(std::move(nameLoc));`
`3136`	`3136`	`}`
`3137`	`3137`	`}`
`3138`	`3138`	`if (fileInfo->classDefinitions.empty()) {`
Original file line number	Diff line number	Diff line change
`@@ -346,7 +346,7 @@ void CheckUnusedFunctions::unusedFunctionError(ErrorLogger * const errorLogger,`
`346`	`346`	`ErrorMessage::FileLocation fileLoc;`
`347`	`347`	`fileLoc.setfile(filename);`
`348`	`348`	`fileLoc.line = lineNumber;`
`349`		`- locationList.push_back(fileLoc);`
	`349`	`+ locationList.push_back(std::move(fileLoc));`
`350`	`350`	`}`
`351`	`351`
`352`	`352`	`const ErrorMessage errmsg(locationList, emptyString, Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' is never used.", "unusedFunction", CWE561, Certainty::normal);`
Original file line number	Diff line number	Diff line change
`@@ -237,11 +237,11 @@ void CTU::FileInfo::loadFromXml(const tinyxml2::XMLElement *xmlElement)`
`237`	`237`	`if (std::strcmp(e->Name(), "function-call") == 0) {`
`238`	`238`	`FunctionCall functionCall;`
`239`	`239`	`if (functionCall.loadFromXml(e))`
`240`		`- functionCalls.push_back(functionCall);`
	`240`	`+ functionCalls.push_back(std::move(functionCall));`
`241`	`241`	`} else if (std::strcmp(e->Name(), "nested-call") == 0) {`
`242`	`242`	`NestedCall nestedCall;`
`243`	`243`	`if (nestedCall.loadFromXml(e))`
`244`		`- nestedCalls.push_back(nestedCall);`
	`244`	`+ nestedCalls.push_back(std::move(nestedCall));`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`	`}`
`@@ -273,7 +273,7 @@ std::list<CTU::FileInfo::UnsafeUsage> CTU::loadUnsafeUsageListFromXml(const tiny`
`273`	`273`	`unsafeUsage.value = readAttrInt(e, ATTR_VALUE, &error);`
`274`	`274`
`275`	`275`	`if (!error)`
`276`		`- ret.push_back(unsafeUsage);`
	`276`	`+ ret.push_back(std::move(unsafeUsage));`
`277`	`277`	`}`
`278`	`278`	`return ret;`
`279`	`279`	`}`
`@@ -353,9 +353,9 @@ CTU::FileInfo CTU::getFileInfo(const Tokenizer tokenizer)`
`353`	`353`	`loc.line = i.first->linenr();`
`354`	`354`	`loc.column = i.first->column();`
`355`	`355`	`loc.setinfo(i.second);`
`356`		`- functionCall.callValuePath.push_back(loc);`
	`356`	`+ functionCall.callValuePath.push_back(std::move(loc));`
`357`	`357`	`}`
`358`		`- fileInfo->functionCalls.push_back(functionCall);`
	`358`	`+ fileInfo->functionCalls.push_back(std::move(functionCall));`
`359`	`359`	`}`
`360`	`360`	`// array`
`361`	`361`	`if (argtok->variable() && argtok->variable()->isArray() && argtok->variable()->dimensions().size() == 1) {`
`@@ -368,7 +368,7 @@ CTU::FileInfo CTU::getFileInfo(const Tokenizer tokenizer)`
`368`	`368`	`functionCall.callArgumentExpression = argtok->expressionString();`
`369`	`369`	`functionCall.callArgValue = argtok->variable()->dimension(0) * argtok->valueType()->typeSize(*tokenizer->getSettings());`
`370`	`370`	`functionCall.warning = false;`
`371`		`- fileInfo->functionCalls.push_back(functionCall);`
	`371`	`+ fileInfo->functionCalls.push_back(std::move(functionCall));`
`372`	`372`	`}`
`373`	`373`	`// &var => buffer`
`374`	`374`	`if (argtok->isUnaryOp("&") && argtok->astOperand1()->variable() && argtok->astOperand1()->valueType() && !argtok->astOperand1()->variable()->isArray()) {`
`@@ -381,7 +381,7 @@ CTU::FileInfo CTU::getFileInfo(const Tokenizer tokenizer)`
`381`	`381`	`functionCall.callArgumentExpression = argtok->expressionString();`
`382`	`382`	`functionCall.callArgValue = argtok->astOperand1()->valueType()->typeSize(*tokenizer->getSettings());`
`383`	`383`	`functionCall.warning = false;`
`384`		`- fileInfo->functionCalls.push_back(functionCall);`
	`384`	`+ fileInfo->functionCalls.push_back(std::move(functionCall));`
`385`	`385`	`}`
`386`	`386`	`// pointer/reference to uninitialized data`
`387`	`387`	`auto isAddressOfArg = [](const Token* argtok) -> const Token* {`
`@@ -414,7 +414,7 @@ CTU::FileInfo CTU::getFileInfo(const Tokenizer tokenizer)`
`414`	`414`	`functionCall.callArgValue = 0;`
`415`	`415`	`functionCall.callArgumentExpression = argtok->expressionString();`
`416`	`416`	`functionCall.warning = false;`
`417`		`- fileInfo->functionCalls.push_back(functionCall);`
	`417`	`+ fileInfo->functionCalls.push_back(std::move(functionCall));`
`418`	`418`	`continue;`
`419`	`419`	`}`
`420`	`420`	`}`
`@@ -428,7 +428,7 @@ CTU::FileInfo CTU::getFileInfo(const Tokenizer tokenizer)`
`428`	`428`	`FileInfo::NestedCall nestedCall(tokenizer, scopeFunction, tok);`
`429`	`429`	`nestedCall.myArgNr = argnr + 1;`
`430`	`430`	`nestedCall.callArgNr = argnr2;`
`431`		`- fileInfo->nestedCalls.push_back(nestedCall);`
	`431`	`+ fileInfo->nestedCalls.push_back(std::move(nestedCall));`
`432`	`432`	`}`
`433`	`433`	`}`
`434`	`434`	`}`
`@@ -580,12 +580,12 @@ std::list<ErrorMessage::FileLocation> CTU::FileInfo::getErrorPath(InvalidValueTy`
`580`	`580`
`581`	`581`	`ErrorMessage::FileLocation fileLoc(path[index]->location.fileName, path[index]->location.lineNumber, path[index]->location.column);`
`582`	`582`	`fileLoc.setinfo("Calling function " + path[index]->callFunctionName + ", " + MathLib::toString(path[index]->callArgNr) + getOrdinalText(path[index]->callArgNr) + " argument is " + value1);`
`583`		`- locationList.push_back(fileLoc);`
	`583`	`+ locationList.push_back(std::move(fileLoc));`
`584`	`584`	`}`
`585`	`585`
`586`	`586`	`ErrorMessage::FileLocation fileLoc2(unsafeUsage.location.fileName, unsafeUsage.location.lineNumber, unsafeUsage.location.column);`
`587`	`587`	`fileLoc2.setinfo(replaceStr(info, "ARG", unsafeUsage.myArgumentName));`
`588`		`- locationList.push_back(fileLoc2);`
	`588`	`+ locationList.push_back(std::move(fileLoc2));`
`589`	`589`
`590`	`590`	`return locationList;`
`591`	`591`	`}`