Fix CI issues

Author: Your Name

lib/symboldatabase.cpp

@@ -1875,17 +1875,29 @@ void SymbolDatabase::removeSymbolsForTokens(const std::unordered_set<const Token
 
     // the scopes, functions, variables, types and enumerators declared by those tokens
     std::unordered_set<const Scope*> removedScopes;
+    std::unordered_set<const Variable*> removedVariables;
+    std::unordered_set<const Enumerator*> removedEnumerators;
     for (const Scope& scope : scopeList) {
         if ((scope.classDef && removedTokens.count(scope.classDef) != 0) ||
-            (scope.bodyStart && removedTokens.count(scope.bodyStart) != 0))
+            (scope.bodyStart && removedTokens.count(scope.bodyStart) != 0)) {
             removedScopes.insert(&scope);
+            std::transform(scope.varlist.cbegin(), scope.varlist.cend(), std::inserter(removedVariables, removedVariables.end()), [](const Variable& var) {
+                return &var;
+            });
+            std::transform(scope.enumeratorList.cbegin(), scope.enumeratorList.cend(), std::inserter(removedEnumerators, removedEnumerators.end()), [](const Enumerator& enumerator) {
+                return &enumerator;
+            });
+        }
     }
     std::unordered_set<const Function*> removedFunctions;
     for (Scope& scope : scopeList) {
         for (Function& function : scope.functionList) {
-            if (function.tokenDef && removedTokens.count(function.tokenDef) != 0)
+            if (function.tokenDef && removedTokens.count(function.tokenDef) != 0) {
                 removedFunctions.insert(&function);
-            else if (function.token && removedTokens.count(function.token) != 0) {
+                std::transform(function.argumentList.cbegin(), function.argumentList.cend(), std::inserter(removedVariables, removedVariables.end()), [](const Variable& arg) {
+                    return &arg;
+                });
+            } else if (function.token && removedTokens.count(function.token) != 0) {
                 // only the function definition is removed - the declaration remains
                 function.token = nullptr;
                 function.arg = function.argDef;
@@ -1894,28 +1906,11 @@ void SymbolDatabase::removeSymbolsForTokens(const std::unordered_set<const Token
             }
         }
     }
-    std::unordered_set<const Variable*> removedVariables;
-    for (const Scope* scope : removedScopes) {
-        std::transform(scope->varlist.cbegin(), scope->varlist.cend(), std::inserter(removedVariables, removedVariables.end()), [](const Variable& var) {
-            return &var;
-        });
-    }
-    for (const Function* function : removedFunctions) {
-        std::transform(function->argumentList.cbegin(), function->argumentList.cend(), std::inserter(removedVariables, removedVariables.end()), [](const Variable& arg) {
-            return &arg;
-        });
-    }
     std::unordered_set<const Type*> removedTypes;
     for (const Type& type : typeList) {
         if (type.classDef && removedTokens.count(type.classDef) != 0)
             removedTypes.insert(&type);
     }
-    std::unordered_set<const Enumerator*> removedEnumerators;
-    for (const Scope* scope : removedScopes) {
-        std::transform(scope->enumeratorList.cbegin(), scope->enumeratorList.cend(), std::inserter(removedEnumerators, removedEnumerators.end()), [](const Enumerator& enumerator) {
-            return &enumerator;
-        });
-    }
 
     // clear the references from the surviving tokens
     for (Token* tok = mTokenizer.list.front(); tok; tok = tok->next()) {
@@ -2004,7 +1999,11 @@ void SymbolDatabase::addSymbolsForNewTokenRanges(const std::vector<std::pair<Tok
         const Scope* enclosing = anchor ? anchor->scope() : &scopeList.front();
         if (!enclosing)
             continue;
-        if (anchor && anchor == enclosing->bodyEnd)
+        // an anchor that closes the enclosing scope means the new tokens are in its parent.
+        // a namespace can consist of multiple blocks and bodyStart/bodyEnd only track the
+        // latest block - so for namespaces any closing brace with the namespace scope closes it.
+        if (anchor && anchor->str() == "}" &&
+            (anchor == enclosing->bodyEnd || enclosing->type == ScopeType::eNamespace))
             enclosing = enclosing->nestedIn ? enclosing->nestedIn : &scopeList.front();
         findAllScopes(range.first, range.second->next(), const_cast<Scope*>(enclosing));
     }

lib/token.cpp

@@ -1057,7 +1057,7 @@ void Token::function(const Function *f)
         else
             tokType(eFunction);
     } else if (mTokType == eFunction)
-        tokType(eName);
+        update_property_info(); // eType for standard types, eKeyword for keywords, eName otherwise
 }
 
 Token* Token::insertToken(const std::string& tokenStr, bool prepend)
@@ -2337,7 +2337,7 @@ void Token::type(const ::Type *t)
         tokType(eType);
         isEnumType(mImpl->mType->isEnumType());
     } else if (mTokType == eType)
-        tokType(eName);
+        update_property_info(); // eType for standard types, eKeyword for keywords, eName otherwise
 }
 
 const ::Type* Token::typeOf(const Token* tok, const Token** typeTok)

lib/token.h

@@ -1242,7 +1242,7 @@ class CPPCHECKLIB Token {
         if (v || mImpl->mVarId)
             tokType(eVariable);
         else if (mTokType == eVariable)
-            tokType(eName);
+            update_property_info(); // eType for standard types, eKeyword for keywords, eName otherwise
     }
 
     /**

lib/tokenize.cpp

@@ -4404,7 +4404,7 @@ void Tokenizer::updateTokenDataAfterTemplateSimplification()
                 if (tok == region.second)
                     break;
             }
-            list.createAst(region.first, region.second->next());
+            TokenList::createAst(region.first, region.second->next());
         }
     }
     list.validateAst(mSettings.debugnormal);
@@ -4421,7 +4421,10 @@ void Tokenizer::updateTokenDataAfterTemplateSimplification()
     for (Token* tok = list.front(); tok; tok = tok->next()) {
         if (tok->scope()) {
             lastScope = tok->scope();
-            if (tok == lastScope->bodyEnd && lastScope->nestedIn)
+            // a namespace can consist of multiple blocks and bodyStart/bodyEnd only track the
+            // latest block - so for namespaces any closing brace with the namespace scope closes it
+            if (lastScope->nestedIn &&
+                (tok == lastScope->bodyEnd || (tok->str() == "}" && lastScope->type == ScopeType::eNamespace)))
                 lastScope = lastScope->nestedIn;
         } else if (lastScope)
             tok->scope(lastScope);

test/testsimplifytemplate.cpp

@@ -301,6 +301,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeduction13); // members declared after the member function are visible
         TEST_CASE(templateTypeDeduction14); // a non template overload might be a better match
         TEST_CASE(templateTypeDeduction15); // final classes
+        TEST_CASE(templateTypeDeduction16); // template between two blocks of the same namespace
         TEST_CASE(templateTypeDeductionFullRebuild); // --template-full-rebuild gives the same result
 
         TEST_CASE(simplifyTemplateArgs1);
@@ -6918,6 +6919,22 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeduction16()
+    { // the declaration that replaces a template between two blocks of the same namespace
+      // must be added to the enclosing scope - a namespace consists of multiple blocks and
+      // bodyStart/bodyEnd only track the latest one
+        const char code[] = "namespace N { struct A {}; }\n"
+                            "template<class T> T* def(T* p, T* d) { return p ? p : d; }\n"
+                            "namespace N { struct B {}; }\n"
+                            "const char* f(const char* p) { return def(p, \"\"); }";
+        const char exp[] = "namespace N { struct A { } ; } "
+                           "const char * def<constchar> ( const char * p , const char * d ) ; "
+                           "namespace N { struct B { } ; } "
+                           "const char * f ( const char * p ) { return def<constchar> ( p , \"\" ) ; } "
+                           "const char * def<constchar> ( const char * p , const char * d ) { return p ? p : d ; }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
     void templateTypeDeductionFullRebuild()
     { // --template-full-rebuild recreates the symbol database etc. after each type
       // deduction round instead of updating them incrementally - the result must be