Fix #15143 Improve performance of setVarIdPass2

https://trac.cppcheck.net/ticket/15143

Tokenizer::setVarIdPass2() tried every out-of-class member definition
for every class. matchMemberName() can only succeed when the innermost
scope name of the class matches a name in the member's scope, in one of
its "using namespace" or in its qualification. The members are now
indexed by those names, in their original order, so each class only
tries its candidates. The index and matchMemberName() walk the
qualification with the same skipQualification().

On the same project total CPU time drops further from 61.6 to 52.9
minutes, with identical output for every translation unit.

Author: Oipo

lib/tokenize.cpp

@@ -5220,6 +5220,20 @@ static std::string getScopeName(const std::list<ScopeInfo2> &scopeInfo)
     return ret;
 }
 
+// If tok is the name in a qualification "name ::" or "name < ... > ::", return the token after the "::"
+static Token * skipQualification(Token *tok)
+{
+    if (!Token::Match(tok, "%name% ::|<"))
+        return nullptr;
+    if (tok->strAt(1) == "<") {
+        tok = tok->next()->findClosingBracket();
+        if (!Token::simpleMatch(tok, "> ::"))
+            return nullptr;
+    }
+    return tok->tokAt(2);
+}
+
+// indexMembersByScopeName() relies on how this matches the scope names: keep the two in sync
 static Token * matchMemberName(const std::list<std::string> &scope, const Token *nsToken, Token *memberToken, const std::list<ScopeInfo2> &scopeInfo)
 {
     auto scopeIt = scopeInfo.cbegin();
@@ -5252,16 +5266,11 @@ static Token * matchMemberName(const std::list<std::string> &scope, const Token
 
     // Parse member tokens..
     while (scopeIt != scopeInfo.end()) {
-        if (!Token::Match(memberToken, "%name% ::|<"))
+        if (!Token::Match(memberToken, "%name%") || memberToken->str() != scopeIt->name)
             return nullptr;
-        if (memberToken->str() != scopeIt->name)
+        memberToken = skipQualification(memberToken);
+        if (!memberToken)
             return nullptr;
-        if (memberToken->strAt(1) == "<") {
-            memberToken = memberToken->next()->findClosingBracket();
-            if (!Token::simpleMatch(memberToken, "> ::"))
-                return nullptr;
-        }
-        memberToken = memberToken->tokAt(2);
         ++scopeIt;
     }
 
@@ -5288,6 +5297,47 @@ static Token * matchMemberName(const Member &member, const std::list<ScopeInfo2>
     return nullptr;
 }
 
+using MembersByScopeName = std::unordered_map<std::string, std::vector<const Member *>>;
+
+// matchMemberName() can only match when the last scope name is matched by a name in the
+// member's scope, in one of its "using namespace" or in its qualification. Index the members
+// by these names, keeping their order, so that each scope only tries its candidates.
+static MembersByScopeName indexMembersByScopeName(const std::list<Member> &members)
+{
+    MembersByScopeName index;
+    for (const Member &member : members) {
+        // members are visited in order, so a member that is already a candidate is the last one
+        const auto addCandidate = [&](const std::string &name) {
+            std::vector<const Member *> &candidates = index[name];
+            if (candidates.empty() || candidates.back() != &member)
+                candidates.push_back(&member);
+        };
+        for (const std::string &name : member.scope)
+            addCandidate(name);
+        for (const Token *ns : member.usingnamespaces) {
+            for (; Token::Match(ns, "%name% ::"); ns = ns->tokAt(2))
+                addCandidate(ns->str());
+            if (Token::Match(ns, "%name%"))
+                addCandidate(ns->str());
+        }
+        Token *tok = member.tok;
+        while (Token *next = skipQualification(tok)) {
+            addCandidate(tok->str());
+            tok = next;
+        }
+    }
+    return index;
+}
+
+static const std::vector<const Member *> &membersForScope(const MembersByScopeName &index, const std::list<ScopeInfo2> &scopeInfo)
+{
+    static const std::vector<const Member *> none;
+    if (scopeInfo.empty())
+        return none;
+    const auto it = index.find(scopeInfo.back().name);
+    return it == index.end() ? none : it->second;
+}
+
 static Token * matchMemberVarName(const Member &var, const std::list<ScopeInfo2> &scopeInfo)
 {
     Token *tok = matchMemberName(var, scopeInfo);
@@ -5399,6 +5449,9 @@ void Tokenizer::setVarIdPass2()
         }
     }
 
+    const MembersByScopeName memberFunctionsByScopeName = indexMembersByScopeName(allMemberFunctions);
+    const MembersByScopeName memberVarsByScopeName = indexMembersByScopeName(allMemberVars);
+
     std::list<ScopeInfo2> scopeInfo;
 
     // class members..
@@ -5515,8 +5568,8 @@ void Tokenizer::setVarIdPass2()
             continue;
 
         // Member variables
-        for (const Member &var : allMemberVars) {
-            Token *tok2 = matchMemberVarName(var, scopeInfo);
+        for (const Member *var : membersForScope(memberVarsByScopeName, scopeInfo)) {
+            Token *tok2 = matchMemberVarName(*var, scopeInfo);
             if (!tok2)
                 continue;
             if (tok2->varId() == 0)
@@ -5527,8 +5580,8 @@ void Tokenizer::setVarIdPass2()
             continue;
 
         // Set variable ids in member functions for this class..
-        for (const Member &func : allMemberFunctions) {
-            Token *tok2 = matchMemberFunctionName(func, scopeInfo);
+        for (const Member *func : membersForScope(memberFunctionsByScopeName, scopeInfo)) {
+            Token *tok2 = matchMemberFunctionName(*func, scopeInfo);
             if (!tok2)
                 continue;
 

test/testvarid.cpp

@@ -240,6 +240,8 @@ class TestVarID : public TestFixture {
         TEST_CASE(usingNamespace1);
         TEST_CASE(usingNamespace2);
         TEST_CASE(usingNamespace3);
+        TEST_CASE(usingNamespace4);
+        TEST_CASE(usingNamespace5);
 
         TEST_CASE(setVarIdStructMembers1);
 
@@ -4410,6 +4412,48 @@ class TestVarID : public TestFixture {
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
+    void usingNamespace4() {
+        // the innermost scope name is matched by the qualification of the member, after a template argument list
+        const char code[] = "namespace A {\n"
+                            "    namespace B {\n"
+                            "        template<class T> struct C {\n"
+                            "            struct D { int x; void f(); };\n"
+                            "        };\n"
+                            "    }\n"
+                            "}\n"
+                            "using namespace A;\n"
+                            "template<class T> void B::C<T>::D::f() { x = 0; }\n";
+
+        const char expected[] = "1: namespace A {\n"
+                                "2: namespace B {\n"
+                                "3: template < class T > struct C {\n"
+                                "4: struct D { int x@1 ; void f ( ) ; } ;\n"
+                                "5: } ;\n"
+                                "6: }\n"
+                                "7: }\n"
+                                "8: using namespace A ;\n"
+                                "9: template < class T > void B :: C < T > :: D :: f ( ) { x@1 = 0 ; }\n";
+
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void usingNamespace5() {
+        // the innermost scope name is matched by the "using namespace"
+        const char code[] = "namespace A {\n"
+                            "    namespace B { int x; }\n"
+                            "}\n"
+                            "using namespace A::B;\n"
+                            "void f() { x = 0; }\n";
+
+        const char expected[] = "1: namespace A {\n"
+                                "2: namespace B { int x@1 ; }\n"
+                                "3: }\n"
+                                "4: using namespace A :: B ;\n"
+                                "5: void f ( ) { x@1 = 0 ; }\n";
+
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
     void setVarIdStructMembers1() {
         const char code[] = "void f(Foo foo)\n"
                             "{\n"