fix new warnings

ludviggunne · ludviggunne · commit 144a9f761289 · 2026-06-02T13:24:47.000+02:00
diff --git a/lib/filesettings.h b/lib/filesettings.h
@@ -46,9 +46,9 @@ class FileWithDetails
             throw std::runtime_error("empty path specified");
     }
 
-    void setPath(std::string path)
+    void setPath(std::string p)
     {
-        mPath = std::move(path);
+        mPath = std::move(p);
         mPathSimplified = Path::simplifyPath(mPath);
         mPathAbsolute.clear();
     }
@@ -76,9 +76,9 @@ class FileWithDetails
         return mSize;
     }
 
-    void setLang(Standards::Language lang)
+    void setLang(Standards::Language language)
     {
-        mLang = lang;
+        mLang = language;
     }
 
     Standards::Language lang() const
diff --git a/lib/token.h b/lib/token.h
@@ -249,35 +249,35 @@ class CPPCHECKLIB Token {
      * For example index 1 would return next token, and 2
      * would return next from that one.
      */
-    const Token *tokAt(int index) const
+    const Token *tokAt(int idx) const
     {
-        return tokAtImpl(this, index);
+        return tokAtImpl(this, idx);
     }
-    Token *tokAt(int index)
+    Token *tokAt(int idx)
     {
-        return tokAtImpl(this, index);
+        return tokAtImpl(this, idx);
     }
 
     /**
      * @return the link to the token in given index, related to this token.
      * For example index 1 would return the link to next token.
      */
-    const Token *linkAt(int index) const
+    const Token *linkAt(int idx) const
     {
-        return linkAtImpl(this, index);
+        return linkAtImpl(this, idx);
     }
-    Token *linkAt(int index)
+    Token *linkAt(int idx)
     {
-        return linkAtImpl(this, index);
+        return linkAtImpl(this, idx);
     }
 
     /**
      * @return String of the token in given index, related to this token.
      * If that token does not exist, an empty string is being returned.
      */
-    const std::string &strAt(int index) const
+    const std::string &strAt(int idx) const
     {
-        const Token *tok = this->tokAt(index);
+        const Token *tok = this->tokAt(idx);
         return tok ? tok->mStr : mEmptyString;
     }
 
@@ -604,11 +604,11 @@ class CPPCHECKLIB Token {
     bool hasAttributeCleanup() const {
         return !mImpl->mAttributeCleanup.empty();
     }
-    void setCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint value) {
-        mImpl->setCppcheckAttribute(type, value);
+    void setCppcheckAttribute(CppcheckAttributesType attrType, MathLib::bigint value) {
+        mImpl->setCppcheckAttribute(attrType, value);
     }
-    bool getCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint &value) const {
-        return mImpl->getCppcheckAttribute(type, value);
+    bool getCppcheckAttribute(CppcheckAttributesType attrType, MathLib::bigint &value) const {
+        return mImpl->getCppcheckAttribute(attrType, value);
     }
     // cppcheck-suppress unusedFunction
     bool hasCppcheckAttributes() const {
@@ -891,15 +891,15 @@ class CPPCHECKLIB Token {
 
 private:
     template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-    static T *tokAtImpl(T *tok, int index)
+    static T *tokAtImpl(T *tok, int idx)
     {
-        while (index > 0 && tok) {
+        while (idx > 0 && tok) {
             tok = tok->next();
-            --index;
+            --idx;
         }
-        while (index < 0 && tok) {
+        while (idx < 0 && tok) {
             tok = tok->previous();
-            ++index;
+            ++idx;
         }
         return tok;
     }
@@ -908,9 +908,9 @@ class CPPCHECKLIB Token {
      * @throws InternalError thrown if index is out of range
      */
     template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-    static T *linkAtImpl(T *thisTok, int index)
+    static T *linkAtImpl(T *thisTok, int idx)
     {
-        T *tok = thisTok->tokAt(index);
+        T *tok = thisTok->tokAt(idx);
         if (!tok) {
             throw InternalError(thisTok, "Internal error. Token::linkAt called with index outside the tokens range.");
         }
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
@@ -568,23 +568,23 @@ namespace {
                 const std::pair<Token*, Token*> rangeBefore(start, Token::findsimplematch(start, "{"));
 
                 // find typedef name token
-                Token* nameToken = rangeBefore.second->link()->next();
-                while (Token::Match(nameToken, "%name%|* %name%|*"))
-                    nameToken = nameToken->next();
-                const std::pair<Token*, Token*> rangeQualifiers(rangeBefore.second->link()->next(), nameToken);
+                Token* nameTok = rangeBefore.second->link()->next();
+                while (Token::Match(nameTok, "%name%|* %name%|*"))
+                    nameTok = nameTok->next();
+                const std::pair<Token*, Token*> rangeQualifiers(rangeBefore.second->link()->next(), nameTok);
 
-                if (Token::Match(nameToken, "%name% ;")) {
+                if (Token::Match(nameTok, "%name% ;")) {
                     if (Token::Match(rangeBefore.second->previous(), "enum|struct|union|class {"))
-                        rangeBefore.second->previous()->insertToken(nameToken->str());
+                        rangeBefore.second->previous()->insertToken(nameTok->str());
                     mRangeType = rangeBefore;
                     mRangeTypeQualifiers = rangeQualifiers;
                     Token* typeName = rangeBefore.second->previous();
                     if (typeName->isKeyword()) {
                         // TODO typeName->insertToken("T:" + std::to_string(num++));
-                        typeName->insertToken(nameToken->str());
+                        typeName->insertToken(nameTok->str());
                     }
-                    mNameToken = nameToken;
-                    mEndToken = nameToken->next();
+                    mNameTok = nameTok;
+                    mEndToken = nameTok->next();
                     return;
                 }
             }
diff --git a/test/testpreprocessor.cpp b/test/testpreprocessor.cpp
@@ -140,8 +140,8 @@ class TestPreprocessor : public TestFixture {
             cfgs = preprocessor.getConfigs();
         for (const std::string & config : cfgs) {
             try {
-                const bool writeLocations = (strstr(code, "#file") != nullptr) || (strstr(code, "#include") != nullptr);
-                cfgcode[config] = preprocessor.getcode(config, files, writeLocations);
+                const bool writeLocs = (strstr(code, "#file") != nullptr) || (strstr(code, "#include") != nullptr);
+                cfgcode[config] = preprocessor.getcode(config, files, writeLocs);
             } catch (const simplecpp::Output &) {
                 cfgcode[config] = "";
             }

Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,9 @@ class FileWithDetails`
`46`	`46`	`throw std::runtime_error("empty path specified");`
`47`	`47`	`}`
`48`	`48`
`49`		`- void setPath(std::string path)`
	`49`	`+ void setPath(std::string p)`
`50`	`50`	`{`
`51`		`- mPath = std::move(path);`
	`51`	`+ mPath = std::move(p);`
`52`	`52`	`mPathSimplified = Path::simplifyPath(mPath);`
`53`	`53`	`mPathAbsolute.clear();`
`54`	`54`	`}`
`@@ -76,9 +76,9 @@ class FileWithDetails`
`76`	`76`	`return mSize;`
`77`	`77`	`}`
`78`	`78`
`79`		`- void setLang(Standards::Language lang)`
	`79`	`+ void setLang(Standards::Language language)`
`80`	`80`	`{`
`81`		`- mLang = lang;`
	`81`	`+ mLang = language;`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`Standards::Language lang() const`
Original file line number	Diff line number	Diff line change
`@@ -249,35 +249,35 @@ class CPPCHECKLIB Token {`
`249`	`249`	`* For example index 1 would return next token, and 2`
`250`	`250`	`* would return next from that one.`
`251`	`251`	`*/`
`252`		`- const Token *tokAt(int index) const`
	`252`	`+ const Token *tokAt(int idx) const`
`253`	`253`	`{`
`254`		`- return tokAtImpl(this, index);`
	`254`	`+ return tokAtImpl(this, idx);`
`255`	`255`	`}`
`256`		`- Token *tokAt(int index)`
	`256`	`+ Token *tokAt(int idx)`
`257`	`257`	`{`
`258`		`- return tokAtImpl(this, index);`
	`258`	`+ return tokAtImpl(this, idx);`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`/**`
`262`	`262`	`* @return the link to the token in given index, related to this token.`
`263`	`263`	`* For example index 1 would return the link to next token.`
`264`	`264`	`*/`
`265`		`- const Token *linkAt(int index) const`
	`265`	`+ const Token *linkAt(int idx) const`
`266`	`266`	`{`
`267`		`- return linkAtImpl(this, index);`
	`267`	`+ return linkAtImpl(this, idx);`
`268`	`268`	`}`
`269`		`- Token *linkAt(int index)`
	`269`	`+ Token *linkAt(int idx)`
`270`	`270`	`{`
`271`		`- return linkAtImpl(this, index);`
	`271`	`+ return linkAtImpl(this, idx);`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`/**`
`275`	`275`	`* @return String of the token in given index, related to this token.`
`276`	`276`	`* If that token does not exist, an empty string is being returned.`
`277`	`277`	`*/`
`278`		`- const std::string &strAt(int index) const`
	`278`	`+ const std::string &strAt(int idx) const`
`279`	`279`	`{`
`280`		`- const Token *tok = this->tokAt(index);`
	`280`	`+ const Token *tok = this->tokAt(idx);`
`281`	`281`	`return tok ? tok->mStr : mEmptyString;`
`282`	`282`	`}`
`283`	`283`
`@@ -604,11 +604,11 @@ class CPPCHECKLIB Token {`
`604`	`604`	`bool hasAttributeCleanup() const {`
`605`	`605`	`return !mImpl->mAttributeCleanup.empty();`
`606`	`606`	`}`
`607`		`- void setCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint value) {`
`608`		`- mImpl->setCppcheckAttribute(type, value);`
	`607`	`+ void setCppcheckAttribute(CppcheckAttributesType attrType, MathLib::bigint value) {`
	`608`	`+ mImpl->setCppcheckAttribute(attrType, value);`
`609`	`609`	`}`
`610`		`- bool getCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint &value) const {`
`611`		`- return mImpl->getCppcheckAttribute(type, value);`
	`610`	`+ bool getCppcheckAttribute(CppcheckAttributesType attrType, MathLib::bigint &value) const {`
	`611`	`+ return mImpl->getCppcheckAttribute(attrType, value);`
`612`	`612`	`}`
`613`	`613`	`// cppcheck-suppress unusedFunction`
`614`	`614`	`bool hasCppcheckAttributes() const {`
`@@ -891,15 +891,15 @@ class CPPCHECKLIB Token {`
`891`	`891`
`892`	`892`	`private:`
`893`	`893`	`template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`894`		`- static T tokAtImpl(T tok, int index)`
	`894`	`+ static T tokAtImpl(T tok, int idx)`
`895`	`895`	`{`
`896`		`- while (index > 0 && tok) {`
	`896`	`+ while (idx > 0 && tok) {`
`897`	`897`	`tok = tok->next();`
`898`		`- --index;`
	`898`	`+ --idx;`
`899`	`899`	`}`
`900`		`- while (index < 0 && tok) {`
	`900`	`+ while (idx < 0 && tok) {`
`901`	`901`	`tok = tok->previous();`
`902`		`- ++index;`
	`902`	`+ ++idx;`
`903`	`903`	`}`
`904`	`904`	`return tok;`
`905`	`905`	`}`
`@@ -908,9 +908,9 @@ class CPPCHECKLIB Token {`
`908`	`908`	`* @throws InternalError thrown if index is out of range`
`909`	`909`	`*/`
`910`	`910`	`template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`911`		`- static T linkAtImpl(T thisTok, int index)`
	`911`	`+ static T linkAtImpl(T thisTok, int idx)`
`912`	`912`	`{`
`913`		`- T *tok = thisTok->tokAt(index);`
	`913`	`+ T *tok = thisTok->tokAt(idx);`
`914`	`914`	`if (!tok) {`
`915`	`915`	`throw InternalError(thisTok, "Internal error. Token::linkAt called with index outside the tokens range.");`
`916`	`916`	`}`