Fix #14319: originalName missing from the dumpfile

Author: swasti16

lib/tokenize.cpp

@@ -669,7 +669,7 @@ namespace {
             return mNameToken ? mNameToken->str() : "";
         }
 
-        void replace(Token* tok) {
+        void replace(Token* tok, const std::string &originalname) {
             if (tok == mNameToken)
                 return;
 
@@ -701,7 +701,7 @@ namespace {
                         insertTokens(tok2, mRangeTypeQualifiers);
                     }
                     else { // functional-style cast
-                        tok->originalName(tok->str());
+                        tok->originalName(originalname);
                         tok->isSimplifiedTypedef(true);
                         tok->str("(");
                         Token* tok2 = insertTokens(tok, mRangeType);
@@ -721,22 +721,22 @@ namespace {
             if (isFunctionPointer && isCast(tok->previous())) {
                 tok->insertToken("*");
                 Token* const tok_1 = insertTokens(tok, std::pair<Token*, Token*>(mRangeType.first, mNameToken->linkAt(1)));
-                tok_1->originalName(tok->str());
+                tok_1->originalName(originalname);
                 tok->deleteThis();
                 return;
             }
 
             // Inherited type => skip "struct" / "class"
             if (Token::Match(mRangeType.first, "const| struct|class %name% {") && Token::Match(tok->previous(), "public|protected|private|<")) {
-                tok->originalName(tok->str());
+                tok->originalName(originalname);
                 tok->str(mRangeType.second->strAt(-1));
                 return;
             }
 
             if (Token::Match(tok, "%name% ::")) {
                 if (Token::Match(mRangeType.first, "const| struct|class|union|enum %name% %name%|{") ||
                     Token::Match(mRangeType.first, "%name% %name% ;")) {
-                    tok->originalName(tok->str());
+                    tok->originalName(originalname);
                     tok->str(mRangeType.second->strAt(-1));
                 } else {
                     mReplaceFailed = true;
@@ -790,8 +790,8 @@ namespace {
             Token* const tok2 = insertTokens(tok, rangeType);
             Token* const tok3 = insertTokens(tok2, mRangeTypeQualifiers);
 
-            tok2->originalName(tok->str());
-            tok3->originalName(tok->str());
+            tok2->originalName(originalname);
+            tok3->originalName(originalname);
             Token *after = tok3;
             while (Token::Match(after, "%name%|*|&|&&|::"))
                 after = after->next();
@@ -1023,12 +1023,20 @@ void Tokenizer::simplifyTypedef()
 {
     // Simplify global typedefs that are not redefined with the fast 1-pass simplification.
     // Then use the slower old typedef simplification.
-    std::map<std::string, int> numberOfTypedefs;
+    std::map<std::string, std::set<std::string>> numberOfTypedefs;
     for (Token* tok = list.front(); tok; tok = tok->next()) {
         if (tok->str() == "typedef") {
             TypedefSimplifier ts(tok);
+            if (ts.name().empty())
+                continue;
+            const Token* t = tok->next();
+            std::string existing_data_type;
+            while (t && t->str() != ts.name()) {
+                existing_data_type += t->str() + " ";
+                t = t->next();
+            }
             if (!ts.fail())
-                numberOfTypedefs[ts.name()]++;
+                numberOfTypedefs[ts.name()].insert(existing_data_type);
             continue;
         }
     }
@@ -1046,8 +1054,7 @@ void Tokenizer::simplifyTypedef()
 
         if (indentlevel == 0 && tok->str() == "typedef") {
             TypedefSimplifier ts(tok);
-            if (!ts.fail() && numberOfTypedefs[ts.name()] == 1 &&
-                (numberOfTypedefs.find(ts.getTypedefToken()->strAt(1)) == numberOfTypedefs.end() || ts.getTypedefToken()->strAt(2) == "(")) {
+            if (!ts.fail() && numberOfTypedefs[ts.name()].size() == 1) {
                 if (mSettings.severity.isEnabled(Severity::portability) && ts.isInvalidConstFunctionType(typedefs))
                     invalidConstFunctionTypeError(tok->next());
                 typedefs.emplace(ts.name(), ts);
@@ -1060,8 +1067,11 @@ void Tokenizer::simplifyTypedef()
         auto it = typedefs.find(tok->str());
         if (it != typedefs.end() && it->second.canReplace(tok)) {
             std::set<std::string> r;
+            std::string originalname;
             while (it != typedefs.end() && r.insert(tok->str()).second) {
-                it->second.replace(tok);
+                if (originalname.empty())
+                    originalname = tok->str();
+                it->second.replace(tok, originalname);
                 it = typedefs.find(tok->str());
             }
         } else if (tok->str() == "enum") {

test/testsimplifytypedef.cpp

@@ -246,7 +246,8 @@ class TestSimplifyTypedef : public TestFixture {
 
         TEST_CASE(simplifyTypedefMacro);
 
-        TEST_CASE(simplifyTypedefOriginalName);
+        TEST_CASE(simplifyTypedefOriginalName1);
+        TEST_CASE(simplifyTypedefOriginalName2);
 
         TEST_CASE(simplifyTypedefTokenColumn1);
         TEST_CASE(simplifyTypedefTokenColumn2);
@@ -1284,7 +1285,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "LPCSTR ccp;";
 
         const char expected[] =
-            "; char c ; "
+            "char c ; "
             "char * cp ; "
             "const char * ccp ;";
 
@@ -3679,7 +3680,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "Y y;\n"
                             "Yp yp;\n"
                             "Ya ya;\n";
-        exp = "long y ; long * yp ; long ya [ 3 ] ;";
+        exp = "; long y ; long * yp ; long ya [ 3 ] ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -4444,7 +4445,7 @@ class TestSimplifyTypedef : public TestFixture {
                       simplifyTypedefP(code));
     }
 
-    void simplifyTypedefOriginalName() {
+    void simplifyTypedefOriginalName1() {
         const char code[] = "typedef unsigned char uint8_t;"
                             "typedef float (*rFunctionPointer_fp)(uint8_t, uint8_t);"
                             "typedef enum eEnumDef {"
@@ -4500,6 +4501,26 @@ class TestSimplifyTypedef : public TestFixture {
         ASSERT_EQUALS("rFunctionPointer_fp", token->originalName());
     }
 
+    void simplifyTypedefOriginalName2() {
+        const char code[] = "typedef unsigned short uint16;\n"
+                            "typedef uint16 A;\n"
+                            "A a;";
+        TokenList tokenlist{ settings1, Standards::Language::C };
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+
+        try {
+            tokenizer.validate();
+        }
+        catch (const InternalError&) {
+            ASSERT_EQUALS_MSG(false, true, "Validation of Tokenizer failed");
+        }
+        const Token* token = Token::findsimplematch(tokenizer.list.front(), "short");
+        ASSERT_EQUALS("A", token->originalName());
+    }
+
     void simplifyTypedefTokenColumn1() {  // #13155
         const char code[] = "void foo(void) {\n"
                             "    typedef signed int MY_INT;\n"