Fix CI failures

Author: pfultz2

lib/templatesimplifier.cpp

@@ -796,41 +796,39 @@ static bool isTemplateInstantion(const Token* tok)
     return Token::Match(tok->tokAt(-2), "(|{|}|;|=|<<|:|.|*|&|return|<|,|!|[ :: %name% ::|<|(");
 }
 
-namespace {
 // A function template parameter with a form that is supported by type deduction:
 // "T", "T &", "const T &", "T *", "const T *" or a concrete single token type
-    struct ParameterShape {
-        const Token* typeTok = nullptr;
-        int templateParameterIndex = -1; // -1 => a concrete type, nothing is deduced
-        bool isConst = false;
-        bool isPointer = false;
-        bool isReference = false;
-    };
+struct ParameterShape {
+    const Token* typeTok = nullptr;
+    int templateParameterIndex = -1; // -1 => a concrete type, nothing is deduced
+    bool isConst = false;
+    bool isPointer = false;
+    bool isReference = false;
+};
 
 // The type deduced for a template parameter from a function call argument
-    struct DeducedType {
-        std::string typeStr;                // base type, e.g. "int" or "MyClass"
-        std::vector<std::string> qualification; // enclosing scopes for record types, outermost first
-        unsigned int constness = 0;         // bit 0 = data const, bit 1 = first '*' const, ..
-        unsigned int pointer = 0;           // number of '*'
-        bool isUnsigned = false;
-        bool isLong = false;
-
-        bool operator==(const DeducedType& other) const
-        {
-            return typeStr == other.typeStr && qualification == other.qualification && constness == other.constness &&
-                   pointer == other.pointer && isUnsigned == other.isUnsigned && isLong == other.isLong;
-        }
-    };
+struct DeducedType {
+    std::string typeStr;                // base type, e.g. "int" or "MyClass"
+    std::vector<std::string> qualification; // enclosing scopes for record types, outermost first
+    unsigned int constness = 0;         // bit 0 = data const, bit 1 = first '*' const, ..
+    unsigned int pointer = 0;           // number of '*'
+    bool isUnsigned = false;
+    bool isLong = false;
+
+    bool operator==(const DeducedType& other) const
+    {
+        return typeStr == other.typeStr && qualification == other.qualification && constness == other.constness &&
+               pointer == other.pointer && isUnsigned == other.isUnsigned && isLong == other.isLong;
+    }
+};
 
 // A parsed function template declaration that type deduction supports. Invalid
 // (typeParameters is empty) when the declaration is not supported.
-    struct DeductionCandidate {
-        std::vector<const Token*> typeParameters;
-        std::vector<ParameterShape> parameterShapes;
-        std::string signature;
-    };
-} // namespace
+struct DeductionCandidate {
+    std::vector<const Token*> typeParameters;
+    std::vector<ParameterShape> parameterShapes;
+    std::string signature;
+};
 
 // Parse a function parameter of a template declaration. The returned shape has no
 // typeTok when the parameter does not have a supported form.

test/testsimplifytemplate.cpp

@@ -27,7 +27,9 @@
 #include "tokenize.h"
 #include "tokenlist.h"
 
+#include <algorithm>
 #include <cstring>
+#include <iterator>
 #include <set>
 #include <sstream>
 #include <string>
@@ -421,11 +423,10 @@ class TestSimplifyTemplate : public TestFixture {
         const Scope* scope = tokenizer.getSymbolDatabase()->findScopeByName(scopeName);
         if (!scope)
             return nullptr;
-        for (const Function& function : scope->functionList) {
-            if (function.name() == functionName)
-                return &function;
-        }
-        return nullptr;
+        const auto it = std::find_if(scope->functionList.cbegin(), scope->functionList.cend(), [&](const Function& function) {
+            return function.name() == functionName;
+        });
+        return it == scope->functionList.cend() ? nullptr : &*it;
     }
 
     // is the token in the token list of the tokenizer?
@@ -7155,8 +7156,9 @@ class TestSimplifyTemplate : public TestFixture {
 
             // every variable in the symbol table belongs to a scope of the database
             std::set<const Scope*> scopes;
-            for (const Scope& scope : symbolDatabase->scopeList)
-                scopes.insert(&scope);
+            std::transform(symbolDatabase->scopeList.cbegin(), symbolDatabase->scopeList.cend(), std::inserter(scopes, scopes.end()), [](const Scope& scope) {
+                return &scope;
+            });
             for (const Variable* var : symbolDatabase->variableList()) {
                 if (var && var->scope())
                     ASSERT(scopes.count(var->scope()) != 0);