removed emptyString and its remaining usage

firewave · firewave · commit ad89c5887441 · 2025-10-22T21:29:04.000+02: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
@@ -2221,7 +2221,7 @@ void CheckClass::checkConst()
                         return false;
                     if (!ovl->functionScope)
                         return true;
-                    return func.argCount() == ovl->argCount() && func.argsMatch(ovl->functionScope, ovl->argDef, func.argDef, emptyString, 0);
+                    return func.argCount() == ovl->argCount() && func.argsMatch(ovl->functionScope, ovl->argDef, func.argDef, "", 0);
                 }))
                     continue;
             }
@@ -3120,7 +3120,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
@@ -146,11 +146,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;
         }
 
@@ -182,7 +182,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()) {
@@ -196,14 +196,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);
@@ -228,7 +228,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/library.cpp b/lib/library.cpp
@@ -813,7 +813,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
@@ -401,7 +401,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
@@ -722,7 +722,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;
                         }
@@ -806,7 +806,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;
                                 }
@@ -3444,7 +3444,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;
             }
@@ -3802,7 +3802,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())
@@ -4894,7 +4894,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
@@ -6473,7 +6473,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/token.h b/lib/token.h
@@ -805,12 +805,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);
     }
 
     /**
diff --git a/test/testerrorlogger.cpp b/test/testerrorlogger.cpp
@@ -322,7 +322,7 @@ class TestErrorLogger : public TestFixture {
         std::list<ErrorMessage::FileLocation> locs = { fooCpp5 };
         const auto mapping = createGuidelineMapping(reportType);
 
-        ErrorMessage msg(std::move(locs), emptyString, severity, "", errorId, Certainty::normal);
+        ErrorMessage msg(std::move(locs), "", severity, "", errorId, Certainty::normal);
         msg.guideline = getGuideline(msg.id, reportType, mapping, msg.severity);
         msg.classification = getClassification(msg.guideline, reportType);
 

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
`@@ -146,11 +146,11 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`146`	`146`	`continue;`
`147`	`147`
`148`	`148`	`if (Token::Match(var.nameToken(), "%name% =")) { // Variable is initialized, but Rhs might be not`
`149`		`- checkRhs(var.nameToken(), var, NO_ALLOC, 0U, emptyString);`
	`149`	`+ checkRhs(var.nameToken(), var, NO_ALLOC, 0U, "");`
`150`	`150`	`continue;`
`151`	`151`	`}`
`152`	`152`	`if (Token::Match(var.nameToken(), "%name% ) (") && Token::simpleMatch(var.nameToken()->linkAt(2), ") =")) { // Function pointer is initialized, but Rhs might be not`
`153`		`- checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, emptyString);`
	`153`	`+ checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, "");`
`154`	`154`	`continue;`
`155`	`155`	`}`
`156`	`156`
`@@ -182,7 +182,7 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`182`	`182`	`continue;`
`183`	`183`
`184`	`184`	`if (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "for (") && Token::simpleMatch(tok->astParent()->link()->next(), "{") &&`
`185`		`- checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, emptyString, true))`
	`185`	`+ checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, "", true))`
`186`	`186`	`continue;`
`187`	`187`
`188`	`188`	`if (var.isArray()) {`
`@@ -196,14 +196,14 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`196`	`196`	`if (!init) {`
`197`	`197`	`Alloc alloc = ARRAY;`
`198`	`198`	`std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());`
`199`		`- checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);`
	`199`	`+ checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);`
`200`	`200`	`}`
`201`	`201`	`continue;`
`202`	`202`	`}`
`203`	`203`	`if (stdtype \|\| var.isPointer()) {`
`204`	`204`	`Alloc alloc = NO_ALLOC;`
`205`	`205`	`std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());`
`206`		`- checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);`
	`206`	`+ checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);`
`207`	`207`	`}`
`208`	`208`	`if (var.type())`
`209`	`209`	`checkStruct(tok, var);`
`@@ -228,7 +228,7 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>`
`228`	`228`	`else if (arg.typeStartToken()->isStandardType() \|\| arg.typeStartToken()->isEnumType()) {`
`229`	`229`	`Alloc alloc = NO_ALLOC;`
`230`	`230`	`std::map<nonneg int, VariableValue> variableValue;`
`231`		`- checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, emptyString, variableValue);`
	`231`	`+ checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, "", variableValue);`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`	`}`
Original file line number	Diff line number	Diff line change
`@@ -813,7 +813,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)`
`813`	`813`	`unknown_elements.insert(typenodename);`
`814`	`814`	`}`
`815`	`815`	`if (platform.empty()) {`
`816`		`- const PlatformType * const type_ptr = platform_type(type_name, emptyString);`
	`816`	`+ const PlatformType * const type_ptr = platform_type(type_name, "");`
`817`	`817`	`if (type_ptr) {`
`818`	`818`	`if (*type_ptr == type)`
`819`	`819`	`return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);`
Original file line number	Diff line number	Diff line change
`@@ -805,12 +805,12 @@ class CPPCHECKLIB Token {`
`805`	`805`	`}`
`806`	`806`
`807`	`807`	`bool isCChar() const {`
`808`		`- return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', emptyString)) \|\|`
`809`		`- ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', emptyString) && (replaceEscapeSequences(getCharLiteral(mStr)).size() == 1)));`
	`808`	`+ return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', "")) \|\|`
	`809`	`+ ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "") && (replaceEscapeSequences(getCharLiteral(mStr)).size() == 1)));`
`810`	`810`	`}`
`811`	`811`
`812`	`812`	`bool isCMultiChar() const {`
`813`		`- return (mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', emptyString) && (replaceEscapeSequences(getCharLiteral(mStr)).size() > 1);`
	`813`	`+ return (mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "") && (replaceEscapeSequences(getCharLiteral(mStr)).size() > 1);`
`814`	`814`	`}`
`815`	`815`
`816`	`816`	`/**`