Use stl algorithms

Author: pfultz2

lib/symboldatabase.cpp

@@ -1938,10 +1938,9 @@ void SymbolDatabase::removeSymbolsForTokens(const std::unordered_set<const Token
     }
 
     // remove from the indexes
-    for (std::size_t i = 0; i < mVariableList.size(); ++i) {
-        if (mVariableList[i] && removedVariables.count(mVariableList[i]) != 0)
-            mVariableList[i] = nullptr;
-    }
+    std::replace_if(mVariableList.begin(), mVariableList.end(), [&](const Variable* var) {
+        return var && removedVariables.count(var) != 0;
+    }, nullptr);
     functionScopes.erase(std::remove_if(functionScopes.begin(),
                                         functionScopes.end(),
                                         [&](const Scope* scope) {
@@ -2036,8 +2035,9 @@ void SymbolDatabase::addSymbolsForNewTokenRanges(const std::vector<std::pair<Tok
     {
         auto it = scopeList.begin();
         std::advance(it, oldScopeCount);
-        for (; it != scopeList.end(); ++it)
-            newScopes.push_back(&(*it));
+        std::transform(it, scopeList.end(), std::back_inserter(newScopes), [](Scope& scope) {
+            return &scope;
+        });
     }
     std::vector<std::pair<Function*, Scope*>> newFunctions; // the function and the scope it is declared in
     for (Scope& scope : scopeList) {

lib/templatesimplifier.cpp

@@ -1253,12 +1253,10 @@ std::string TemplateSimplifier::deduceFunctionTemplateArguments(
         // Can the deduction succeed later, when type information is available? Scope
         // matching is not possible yet - the declaration may be in a base class - so
         // consider all declarations with this name.
-        for (auto pos = range.first; pos != range.second; ++pos) {
-            if (deductionCache->supportedParameterCount(*pos->second) == instantiationArgs.size()) {
-                mPendingTypeDeductions = true;
-                return qualification;
-            }
-        }
+        if (std::any_of(range.first, range.second, [&](const std::pair<const std::string, const TokenAndName*>& entry) {
+            return deductionCache->supportedParameterCount(*entry.second) == instantiationArgs.size();
+        }))
+            mPendingTypeDeductions = true;
         return qualification;
     }
 
@@ -4014,8 +4012,9 @@ void TemplateSimplifier::replaceTemplateUsage(
     // remembered new token ranges that start in the erased tokens are gone
     if (!mNewTokenRanges.empty() && !removeTokens.empty()) {
         std::unordered_set<const Token*> rangeStarts;
-        for (const auto& range : mNewTokenRanges)
-            rangeStarts.insert(range.first);
+        std::transform(mNewTokenRanges.cbegin(), mNewTokenRanges.cend(), std::inserter(rangeStarts, rangeStarts.end()), [](const std::pair<Token*, Token*>& range) {
+            return range.first;
+        });
         std::unordered_set<const Token*> erasedRangeStarts;
         for (const auto& removeToken : removeTokens) {
             for (const Token* tok = removeToken.first->next(); tok && tok != removeToken.second; tok = tok->next()) {