Token: do not update properties in varid() when the id did not change (#7371)

Author: firewave

lib/token.cpp

@@ -126,6 +126,7 @@ void Token::update_property_info()
                 tokType(eVariable);
             else if (mTokensFrontBack.list.isKeyword(mStr) || mStr == "asm") // TODO: not a keyword
                 tokType(eKeyword);
+            // TODO: remove condition? appears to be (no longer necessary) protection for reset of varids in Tokenizer::setVarId()
             else if (mTokType != eVariable && mTokType != eFunction && mTokType != eType && mTokType != eKeyword)
                 tokType(eName);
         } else if (simplecpp::Token::isNumberLike(mStr)) {

lib/token.h

@@ -952,6 +952,9 @@ class CPPCHECKLIB Token {
         return mImpl->mVarId;
     }
     void varId(nonneg int id) {
+        if (mImpl->mVarId == id)
+            return;
+
         mImpl->mVarId = id;
         if (id != 0) {
             tokType(eVariable);

test/fixture.cpp

@@ -162,11 +162,13 @@ static std::string writestr(const std::string &str, bool gccStyle = false)
     return ostr.str();
 }
 
-void TestFixture::assert_(const char * const filename, const unsigned int linenr, const bool condition) const
+void TestFixture::assert_(const char * const filename, const unsigned int linenr, const bool condition, const std::string& msg) const
 {
     if (!condition) {
         ++fails_counter;
         errmsg << getLocationStr(filename, linenr) << ": Assertion failed." << std::endl << "_____" << std::endl;
+        if (!msg.empty())
+            errmsg << "Hint:" << std::endl << msg << std::endl;
     }
 }
 

test/fixture.h

@@ -68,7 +68,7 @@ class TestFixture : public ErrorLogger {
     virtual void teardownTestInternal() {}
     std::string getLocationStr(const char * filename, unsigned int linenr) const;
 
-    void assert_(const char * filename, unsigned int linenr, bool condition) const;
+    void assert_(const char * filename, unsigned int linenr, bool condition, const std::string& msg = "") const;
 
     template<typename T>
     void assertEquals(const char* const filename, const unsigned int linenr, const T& expected, const T& actual, const std::string& msg = "") const {
@@ -313,14 +313,18 @@ class TestInstance {
 // TODO: the asserts do not actually assert i.e. do stop executing the test
 #define ASSERT( CONDITION ) assert_(__FILE__, __LINE__, (CONDITION))
 #define ASSERT_LOC( CONDITION, FILE_, LINE_ ) assert_(FILE_, LINE_, (CONDITION))
+#define ASSERT_LOC_MSG( CONDITION, MSG, FILE_, LINE_ ) assert_(FILE_, LINE_, (CONDITION), MSG)
 // *INDENT-OFF*
 #define ASSERT_EQUALS( EXPECTED, ACTUAL ) do { try { assertEquals(__FILE__, __LINE__, (EXPECTED), (ACTUAL)); } catch (...) { assertNoThrowFail(__FILE__, __LINE__); } } while (false)
 // *INDENT-ON*
 #define ASSERT_EQUALS_WITHOUT_LINENUMBERS( EXPECTED, ACTUAL ) assertEqualsWithoutLineNumbers(__FILE__, __LINE__, EXPECTED, ACTUAL)
 #define ASSERT_EQUALS_DOUBLE( EXPECTED, ACTUAL, TOLERANCE ) assertEqualsDouble(__FILE__, __LINE__, EXPECTED, ACTUAL, TOLERANCE)
+#define ASSERT_EQUALS_LOC( EXPECTED, ACTUAL, FILE_, LINE_ ) assertEquals(FILE_, LINE_, EXPECTED, ACTUAL)
 #define ASSERT_EQUALS_LOC_MSG( EXPECTED, ACTUAL, MSG, FILE_, LINE_ ) assertEquals(FILE_, LINE_, EXPECTED, ACTUAL, MSG)
 #define ASSERT_EQUALS_MSG( EXPECTED, ACTUAL, MSG ) assertEquals(__FILE__, __LINE__, EXPECTED, ACTUAL, MSG)
 #define ASSERT_EQUALS_ENUM( EXPECTED, ACTUAL ) assertEqualsEnum(__FILE__, __LINE__, (EXPECTED), (ACTUAL))
+#define ASSERT_EQUALS_ENUM_LOC( EXPECTED, ACTUAL, FILE_, LINE_ ) assertEqualsEnum(FILE_, LINE_, (EXPECTED), (ACTUAL))
+#define ASSERT_EQUALS_ENUM_LOC_MSG( EXPECTED, ACTUAL, MSG, FILE_, LINE_ ) assertEqualsEnum(FILE_, LINE_, (EXPECTED), (ACTUAL), MSG)
 #define TODO_ASSERT_EQUALS_ENUM( WANTED, CURRENT, ACTUAL ) todoAssertEqualsEnum(__FILE__, __LINE__, WANTED, CURRENT, ACTUAL)
 #define ASSERT_THROW_EQUALS( CMD, EXCEPTION, EXPECTED ) do { try { (void)(CMD); assertThrowFail(__FILE__, __LINE__); } catch (const EXCEPTION&e) { assertEquals(__FILE__, __LINE__, EXPECTED, e.errorMessage); } catch (...) { assertThrowFail(__FILE__, __LINE__); } } while (false)
 #define ASSERT_THROW_EQUALS_2( CMD, EXCEPTION, EXPECTED ) do { try { (void)(CMD); assertThrowFail(__FILE__, __LINE__); } catch (const EXCEPTION&e) { assertEquals(__FILE__, __LINE__, EXPECTED, e.what()); } catch (...) { assertThrowFail(__FILE__, __LINE__); } } while (false)

test/testtoken.cpp

@@ -114,6 +114,8 @@ class TestToken : public TestFixture {
         TEST_CASE(expressionString);
 
         TEST_CASE(hasKnownIntValue);
+
+        TEST_CASE(varid_reset);
     }
 
     void nextprevious() const {
@@ -1224,6 +1226,37 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, token.addValue(v2));
         ASSERT_EQUALS(false, token.hasKnownIntValue());
     }
+
+#define assert_tok(...) _assert_tok(__FILE__, __LINE__, __VA_ARGS__)
+    void _assert_tok(const char* file, int line, const Token* tok, Token::Type t, bool l = false, bool std = false, bool ctrl = false) const
+    {
+        ASSERT_LOC_MSG(tok, "tok", file, line);
+        ASSERT_EQUALS_ENUM_LOC_MSG(t, tok->tokType(), "tokType", file, line);
+        ASSERT_EQUALS_LOC_MSG(l, tok->isLong(), "isLong", file, line);
+        ASSERT_EQUALS_LOC_MSG(std, tok->isStandardType(), "isStandardType", file, line);
+        ASSERT_EQUALS_LOC_MSG(ctrl, tok->isControlFlowKeyword(), "isControlFlowKeyword", file, line);
+    }
+
+    void _assert_tok(const char* file, int line, const std::string& s, Token::Type t, bool l = false, bool std = false, bool ctrl = false) const
+    {
+        TokensFrontBack tokensFrontBack(list);
+        Token tok(tokensFrontBack);
+        tok.str(s);
+        _assert_tok(file, line, &tok, t, l, std, ctrl);
+    }
+
+    void varid_reset() const
+    {
+        TokenList list_c{&settingsDefault};
+        list_c.setLang(Standards::Language::C);
+        TokensFrontBack tokensFrontBack(list_c);
+        Token tok(tokensFrontBack);
+        tok.str("int"); // not treated as keyword in TokenList::isKeyword()
+        assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+        tok.varId(0);
+        assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+    }
+#undef assert_tok
 };
 
 REGISTER_TEST(TestToken)