removed emptyString and its remaining usage

firewave · firewave · commit d06efe0f8d01 · 2025-03-13T07:56:08.000+01:00
diff --git a/lib/analyzer.h b/lib/analyzer.h
@@ -186,7 +186,7 @@ struct Analyzer {
     /// Update the state of the program at the token
     virtual void updateState(const Token* tok) = 0;
     /// Return analyzer for expression at token
-    virtual ValuePtr<Analyzer> reanalyze(Token* tok, const std::string& msg = emptyString) const = 0;
+    virtual ValuePtr<Analyzer> reanalyze(Token* tok, const std::string& msg = "") const = 0;
     virtual bool invalid() const {
         return false;
     }
diff --git a/lib/checkclass.cpp b/lib/checkclass.cpp
@@ -3066,7 +3066,7 @@ static std::vector<DuplMemberFuncInfo> getDuplInheritedMemberFunctionsRecursive(
                 if (classFuncIt.name() == parentClassFuncIt.name() &&
                     (parentClassFuncIt.access != AccessControl::Private || !skipPrivate) &&
                     !classFuncIt.isConstructor() && !classFuncIt.isDestructor() &&
-                    classFuncIt.argsMatch(parentClassIt.type->classScope, parentClassFuncIt.argDef, classFuncIt.argDef, emptyString, 0) &&
+                    classFuncIt.argsMatch(parentClassIt.type->classScope, parentClassFuncIt.argDef, classFuncIt.argDef, "", 0) &&
                     (classFuncIt.isConst() == parentClassFuncIt.isConst() || Function::returnsConst(&classFuncIt) == Function::returnsConst(&parentClassFuncIt)) &&
                     !(classFuncIt.isDelete() || parentClassFuncIt.isDelete()))
                     results.emplace_back(&classFuncIt, &parentClassFuncIt, &parentClassIt);
diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
@@ -203,7 +203,7 @@ void CheckStl::outOfBounds()
     }
 }
 
-static std::string indexValueString(const ValueFlow::Value& indexValue, const std::string& containerName = emptyString)
+static std::string indexValueString(const ValueFlow::Value& indexValue, const std::string& containerName = "")
 {
     if (indexValue.isIteratorStartValue())
         return "at position " + MathLib::toString(indexValue.intvalue) + " from the beginning";
diff --git a/lib/checkuninitvar.cpp b/lib/checkuninitvar.cpp
@@ -145,11 +145,11 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
             continue;
 
         if (Token::Match(var.nameToken(), "%name% =")) { // Variable is initialized, but Rhs might be not
-            checkRhs(var.nameToken(), var, NO_ALLOC, 0U, emptyString);
+            checkRhs(var.nameToken(), var, NO_ALLOC, 0U, "");
             continue;
         }
         if (Token::Match(var.nameToken(), "%name% ) (") && Token::simpleMatch(var.nameToken()->linkAt(2), ") =")) { // Function pointer is initialized, but Rhs might be not
-            checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, emptyString);
+            checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, "");
             continue;
         }
 
@@ -181,7 +181,7 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
             continue;
 
         if (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "for (") && Token::simpleMatch(tok->astParent()->link()->next(), "{") &&
-            checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, emptyString, true))
+            checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, "", true))
             continue;
 
         if (var.isArray()) {
@@ -195,14 +195,14 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
             if (!init) {
                 Alloc alloc = ARRAY;
                 std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());
-                checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);
+                checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);
             }
             continue;
         }
         if (stdtype || var.isPointer()) {
             Alloc alloc = NO_ALLOC;
             std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());
-            checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);
+            checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);
         }
         if (var.type())
             checkStruct(tok, var);
@@ -227,7 +227,7 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
                     else if (arg.typeStartToken()->isStandardType() || arg.typeStartToken()->isEnumType()) {
                         Alloc alloc = NO_ALLOC;
                         std::map<nonneg int, VariableValue> variableValue;
-                        checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, emptyString, variableValue);
+                        checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, "", variableValue);
                     }
                 }
             }
diff --git a/lib/config.h b/lib/config.h
@@ -133,9 +133,6 @@
 
 #define REQUIRES(msg, ...) class=typename std::enable_if<__VA_ARGS__::value>::type
 
-#include <string>
-static const std::string emptyString;
-
 // Use the nonneg macro when you want to assert that a variable/argument is not negative
 #ifdef __CPPCHECK__
 #define nonneg   __cppcheck_low__(0)
diff --git a/lib/errorlogger.h b/lib/errorlogger.h
@@ -158,8 +158,8 @@ class CPPCHECKLIB ErrorMessage {
      * @return formatted string
      */
     std::string toString(bool verbose,
-                         const std::string &templateFormat = emptyString,
-                         const std::string &templateLocation = emptyString) const;
+                         const std::string &templateFormat = "",
+                         const std::string &templateLocation = "") const;
 
     std::string serialize() const;
     void deserialize(const std::string &data);
diff --git a/lib/library.cpp b/lib/library.cpp
@@ -753,7 +753,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                     unknown_elements.insert(typenodename);
             }
             if (platform.empty()) {
-                const PlatformType * const type_ptr = platform_type(type_name, emptyString);
+                const PlatformType * const type_ptr = platform_type(type_name, "");
                 if (type_ptr) {
                     if (*type_ptr == type)
                         return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);
diff --git a/lib/library.h b/lib/library.h
@@ -397,7 +397,7 @@ class CPPCHECKLIB Library {
     const Token* getContainerFromYield(const Token* tok, Container::Yield yield) const;
     const Token* getContainerFromAction(const Token* tok, Container::Action action) const;
 
-    static bool isContainerYield(const Token* cond, Library::Container::Yield y, const std::string& fallback = emptyString);
+    static bool isContainerYield(const Token* cond, Library::Container::Yield y, const std::string& fallback = "");
     static Library::Container::Yield getContainerYield(const Token* cond);
 
     bool isreflection(const std::string &token) const;
diff --git a/lib/preprocessor.cpp b/lib/preprocessor.cpp
@@ -616,7 +616,7 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
         } else if (cmdtok->str() == "error") {
             if (!configs_ifndef.empty() && !configs_ifndef.back().empty()) {
                 if (configs_ifndef.size() == 1U)
-                    ret.erase(emptyString);
+                    ret.erase("");
                 std::vector<std::string> configs(configs_if);
                 configs.push_back(configs_ifndef.back());
                 ret.erase(cfg(configs, userDefines));
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
@@ -686,7 +686,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                     bool newFunc = true; // Is this function already in the database?
                     auto range = scope->functionMap.equal_range(tok->str());
                     for (std::multimap<std::string, const Function*>::const_iterator it = range.first; it != range.second; ++it) {
-                        if (it->second->argsMatch(scope, it->second->argDef, argStart, emptyString, 0)) {
+                        if (it->second->argsMatch(scope, it->second->argDef, argStart, "", 0)) {
                             newFunc = false;
                             break;
                         }
@@ -770,7 +770,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                             bool newFunc = true; // Is this function already in the database?
                             auto range = scope->functionMap.equal_range(ftok->str());
                             for (std::multimap<std::string, const Function*>::const_iterator it = range.first; it != range.second; ++it) {
-                                if (it->second->argsMatch(scope, it->second->argDef, argStart, emptyString, 0)) {
+                                if (it->second->argsMatch(scope, it->second->argDef, argStart, "", 0)) {
                                     newFunc = false;
                                     break;
                                 }
@@ -3234,7 +3234,7 @@ Function* SymbolDatabase::addGlobalFunction(Scope*& scope, const Token*& tok, co
             const Function *f = it->second;
             if (f->hasBody())
                 continue;
-            if (f->argsMatch(scope, f->argDef, argStart, emptyString, 0)) {
+            if (f->argsMatch(scope, f->argDef, argStart, "", 0)) {
                 function = const_cast<Function *>(it->second);
                 break;
             }
@@ -3592,7 +3592,7 @@ std::string Type::name() const
     else if (start->str() == "class")
         start = start->tokAt(1);
     else if (!start->isName())
-        return emptyString;
+        return "";
     const Token* next = start;
     while (Token::Match(next, "::|<|>|(|)|[|]|*|&|&&|%name%")) {
         if (Token::Match(next, "<|(|[") && next->link())
@@ -4676,7 +4676,7 @@ const Function * Function::getOverriddenFunctionRecursive(const ::Type* baseType
                 }
 
                 // check for matching function parameters
-                match = match && argsMatch(baseType->classScope, func->argDef, argDef, emptyString, 0);
+                match = match && argsMatch(baseType->classScope, func->argDef, argDef, "", 0);
 
                 // check for matching cv-ref qualifiers
                 match = match
@@ -6248,7 +6248,7 @@ static T* findTypeImpl(S& thisScope, const std::string & name)
         return it->second;
 
     // is type defined in anonymous namespace..
-    it = thisScope.definedTypesMap.find(emptyString);
+    it = thisScope.definedTypesMap.find("");
     if (it != thisScope.definedTypesMap.end()) {
         for (S *scope : thisScope.nestedList) {
             if (scope->className.empty() && (scope->type == ScopeType::eNamespace || scope->isClassOrStructOrUnion())) {
diff --git a/lib/templatesimplifier.cpp b/lib/templatesimplifier.cpp
@@ -1581,7 +1581,7 @@ void TemplateSimplifier::addNamespace(const TokenAndName &templateDeclaration, c
             }
         } else {
             if (insert)
-                mTokenList.back()->tokAt(offset)->insertToken(token, emptyString);
+                mTokenList.back()->tokAt(offset)->insertToken(token, "");
             else
                 mTokenList.addtoken(token, tok->linenr(), tok->column(), tok->fileIndex());
         }
@@ -1592,10 +1592,10 @@ void TemplateSimplifier::addNamespace(const TokenAndName &templateDeclaration, c
     if (token != tokStart->str() || tok->strAt(-1) != "::") {
         if (insert) {
             if (!inTemplate)
-                mTokenList.back()->tokAt(offset)->insertToken(templateDeclaration.scope().substr(start), emptyString);
+                mTokenList.back()->tokAt(offset)->insertToken(templateDeclaration.scope().substr(start), "");
             else
                 mTokenList.back()->tokAt(offset)->str(mTokenList.back()->strAt(offset) + templateDeclaration.scope().substr(start));
-            mTokenList.back()->tokAt(offset)->insertToken("::", emptyString);
+            mTokenList.back()->tokAt(offset)->insertToken("::", "");
         } else {
             if (!inTemplate)
                 mTokenList.addtoken(templateDeclaration.scope().substr(start), tok->linenr(), tok->column(), tok->fileIndex());
diff --git a/lib/token.h b/lib/token.h
@@ -772,12 +772,12 @@ class CPPCHECKLIB Token {
     }
 
     bool isCChar() const {
-        return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', emptyString)) ||
-                ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', emptyString) && (replaceEscapeSequences(getCharLiteral(mStr)).size() == 1)));
+        return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', "")) ||
+                ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "") && (replaceEscapeSequences(getCharLiteral(mStr)).size() == 1)));
     }
 
     bool isCMultiChar() const {
-        return (mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', emptyString) && (replaceEscapeSequences(getCharLiteral(mStr)).size() > 1);
+        return (mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "") && (replaceEscapeSequences(getCharLiteral(mStr)).size() > 1);
     }
 
     /**
@@ -933,9 +933,9 @@ class CPPCHECKLIB Token {
      * @param prepend Insert the new token before this token when it's not
      * the first one on the tokens list.
      */
-    RET_NONNULL Token* insertToken(const std::string& tokenStr, const std::string& originalNameStr = emptyString, const std::string& macroNameStr = emptyString, bool prepend = false);
+    RET_NONNULL Token* insertToken(const std::string& tokenStr, const std::string& originalNameStr = "", const std::string& macroNameStr = "", bool prepend = false);
 
-    RET_NONNULL Token* insertTokenBefore(const std::string& tokenStr, const std::string& originalNameStr = emptyString, const std::string& macroNameStr = emptyString)
+    RET_NONNULL Token* insertTokenBefore(const std::string& tokenStr, const std::string& originalNameStr = "", const std::string& macroNameStr = "")
     {
         return insertToken(tokenStr, originalNameStr, macroNameStr, true);
     }
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
@@ -2565,7 +2565,7 @@ namespace {
                 }
 
                 if (!added)
-                    scopeInfo = scopeInfo->addChild(ScopeInfo3::Other, emptyString, tok, tok->link());
+                    scopeInfo = scopeInfo->addChild(ScopeInfo3::Other, "", tok, tok->link());
             }
             return;
         }
@@ -2969,7 +2969,7 @@ bool Tokenizer::simplifyUsing()
             structEnd = structEnd->link();
 
             // add ';' after end of struct
-            structEnd->insertToken(";", emptyString);
+            structEnd->insertToken(";", "");
 
             // add name for anonymous struct
             if (!hasName) {
@@ -2979,8 +2979,8 @@ bool Tokenizer::simplifyUsing()
                 else
                     newName = "Unnamed" + std::to_string(mUnnamedCount++);
                 TokenList::copyTokens(structEnd->next(), tok, start);
-                structEnd->tokAt(5)->insertToken(newName, emptyString);
-                start->insertToken(newName, emptyString);
+                structEnd->tokAt(5)->insertToken(newName, "");
+                start->insertToken(newName, "");
             } else
                 TokenList::copyTokens(structEnd->next(), tok, start->next());
 
diff --git a/test/testerrorlogger.cpp b/test/testerrorlogger.cpp
@@ -202,7 +202,7 @@ class TestErrorLogger : public TestFixture {
         const auto reportType = ReportType::misraC;
         const auto mapping = createGuidelineMapping(reportType);
         const std::string format = "{severity} {id}";
-        ErrorMessage msg(std::move(locs), emptyString, Severity::error, "", "unusedVariable", Certainty::normal);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "", "unusedVariable", Certainty::normal);
         msg.guideline = getGuideline(msg.id, reportType, mapping, msg.severity);
         msg.classification = getClassification(msg.guideline, reportType);
         ASSERT_EQUALS("Advisory", msg.classification);
@@ -215,7 +215,7 @@ class TestErrorLogger : public TestFixture {
         const auto reportType = ReportType::certC;
         const auto mapping = createGuidelineMapping(reportType);
         const std::string format = "{severity} {id}";
-        ErrorMessage msg(std::move(locs), emptyString, Severity::error, "", "resourceLeak", Certainty::normal);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "", "resourceLeak", Certainty::normal);
         msg.guideline = getGuideline(msg.id, reportType, mapping, msg.severity);
         msg.classification = getClassification(msg.guideline, reportType);
         ASSERT_EQUALS("L3", msg.classification);

Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ struct Analyzer {`
`186`	`186`	`/// Update the state of the program at the token`
`187`	`187`	`virtual void updateState(const Token* tok) = 0;`
`188`	`188`	`/// Return analyzer for expression at token`
`189`		`- virtual ValuePtr<Analyzer> reanalyze(Token* tok, const std::string& msg = emptyString) const = 0;`
	`189`	`+ virtual ValuePtr<Analyzer> reanalyze(Token* tok, const std::string& msg = "") const = 0;`
`190`	`190`	`virtual bool invalid() const {`
`191`	`191`	`return false;`
`192`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ void CheckStl::outOfBounds()`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
`206`		`-static std::string indexValueString(const ValueFlow::Value& indexValue, const std::string& containerName = emptyString)`
	`206`	`+static std::string indexValueString(const ValueFlow::Value& indexValue, const std::string& containerName = "")`
`207`	`207`	`{`
`208`	`208`	`if (indexValue.isIteratorStartValue())`
`209`	`209`	`return "at position " + MathLib::toString(indexValue.intvalue) + " from the beginning";`
Original file line number	Diff line number	Diff line change
`@@ -145,11 +145,11 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`145`	`145`	`continue;`
`146`	`146`
`147`	`147`	`if (Token::Match(var.nameToken(), "%name% =")) { // Variable is initialized, but Rhs might be not`
`148`		`- checkRhs(var.nameToken(), var, NO_ALLOC, 0U, emptyString);`
	`148`	`+ checkRhs(var.nameToken(), var, NO_ALLOC, 0U, "");`
`149`	`149`	`continue;`
`150`	`150`	`}`
`151`	`151`	`if (Token::Match(var.nameToken(), "%name% ) (") && Token::simpleMatch(var.nameToken()->linkAt(2), ") =")) { // Function pointer is initialized, but Rhs might be not`
`152`		`- checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, emptyString);`
	`152`	`+ checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, "");`
`153`	`153`	`continue;`
`154`	`154`	`}`
`155`	`155`
`@@ -181,7 +181,7 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`181`	`181`	`continue;`
`182`	`182`
`183`	`183`	`if (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "for (") && Token::simpleMatch(tok->astParent()->link()->next(), "{") &&`
`184`		`- checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, emptyString, true))`
	`184`	`+ checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, "", true))`
`185`	`185`	`continue;`
`186`	`186`
`187`	`187`	`if (var.isArray()) {`
`@@ -195,14 +195,14 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`195`	`195`	`if (!init) {`
`196`	`196`	`Alloc alloc = ARRAY;`
`197`	`197`	`std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());`
`198`		`- checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);`
	`198`	`+ checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);`
`199`	`199`	`}`
`200`	`200`	`continue;`
`201`	`201`	`}`
`202`	`202`	`if (stdtype \|\| var.isPointer()) {`
`203`	`203`	`Alloc alloc = NO_ALLOC;`
`204`	`204`	`std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());`
`205`		`- checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);`
	`205`	`+ checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);`
`206`	`206`	`}`
`207`	`207`	`if (var.type())`
`208`	`208`	`checkStruct(tok, var);`
`@@ -227,7 +227,7 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`227`	`227`	`else if (arg.typeStartToken()->isStandardType() \|\| arg.typeStartToken()->isEnumType()) {`
`228`	`228`	`Alloc alloc = NO_ALLOC;`
`229`	`229`	`std::map<nonneg int, VariableValue> variableValue;`
`230`		`- checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, emptyString, variableValue);`
	`230`	`+ checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, "", variableValue);`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -753,7 +753,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)`
`753`	`753`	`unknown_elements.insert(typenodename);`
`754`	`754`	`}`
`755`	`755`	`if (platform.empty()) {`
`756`		`- const PlatformType * const type_ptr = platform_type(type_name, emptyString);`
	`756`	`+ const PlatformType * const type_ptr = platform_type(type_name, "");`
`757`	`757`	`if (type_ptr) {`
`758`	`758`	`if (*type_ptr == type)`
`759`	`759`	`return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);`