small PathAnalysis cleanup (danmar#7407)

Author: firewave

lib/checkstl.cpp

@@ -1136,7 +1136,6 @@ void CheckStl::invalidContainer()
 {
     logChecker("CheckStl::invalidContainer");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    const Library& library = mSettings->library;
     InvalidContainerAnalyzer analyzer;
     analyzer.analyze(symbolDatabase);
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -1189,7 +1188,7 @@ void CheckStl::invalidContainer()
                     const ValueFlow::Value* v = nullptr;
                     ErrorPath errorPath;
                     PathAnalysis::Info info =
-                        PathAnalysis{endToken, library}.forwardFind([&](const PathAnalysis::Info& info) {
+                        PathAnalysis{endToken}.forwardFind([&](const PathAnalysis::Info& info) {
                         if (!info.tok->variable())
                             return false;
                         if (info.tok->varId() == 0)
@@ -1201,7 +1200,7 @@ void CheckStl::invalidContainer()
                         if (Token::Match(info.tok->astParent(), "%assign%") && astIsLHS(info.tok))
                             skipVarIds.insert(info.tok->varId());
                         if (info.tok->variable()->isReference() && !isVariableDecl(info.tok) &&
-                            reaches(info.tok->variable()->nameToken(), tok, library, nullptr)) {
+                            reaches(info.tok->variable()->nameToken(), tok, nullptr)) {
 
                             ErrorPath ep;
                             bool addressOf = false;
@@ -1211,7 +1210,7 @@ void CheckStl::invalidContainer()
                                 // An argument always reaches
                                 if (var->isArgument() ||
                                     (!var->isReference() && !var->isRValueReference() && !isVariableDecl(tok) &&
-                                     reaches(var->nameToken(), tok, library, &ep))) {
+                                     reaches(var->nameToken(), tok, &ep))) {
                                     errorPath = std::move(ep);
                                     return true;
                                 }
@@ -1220,7 +1219,7 @@ void CheckStl::invalidContainer()
                         ErrorPath ep;
                         const ValueFlow::Value* val = getInnerLifetime(info.tok, r.tok->varId(), &ep);
                         // Check the iterator is created before the change
-                        if (val && val->tokvalue != tok && reaches(val->tokvalue, tok, library, &ep)) {
+                        if (val && val->tokvalue != tok && reaches(val->tokvalue, tok, &ep)) {
                             v = val;
                             errorPath = std::move(ep);
                             return true;

lib/pathanalysis.cpp

@@ -166,25 +166,25 @@ PathAnalysis::Progress PathAnalysis::forwardRange(const Token* startToken, const
                 return Progress::Break;
         }
         // Prevent infinite recursion
-        if (tok->next() == start)
+        if (tok->next() == mStart)
             break;
     }
     return Progress::Continue;
 }
 
 void PathAnalysis::forward(const std::function<Progress(const Info&)>& f) const
 {
-    const Scope * endScope = findOuterScope(start->scope());
+    const Scope * endScope = findOuterScope(mStart->scope());
     if (!endScope)
         return;
     const Token * endToken = endScope->bodyEnd;
-    Info info{start, ErrorPath{}, true};
-    forwardRange(start, endToken, std::move(info), f);
+    Info info{mStart, ErrorPath{}, true};
+    forwardRange(mStart, endToken, std::move(info), f);
 }
 
-bool reaches(const Token * start, const Token * dest, const Library& library, ErrorPath* errorPath)
+bool reaches(const Token * start, const Token * dest, ErrorPath* errorPath)
 {
-    PathAnalysis::Info info = PathAnalysis{start, library}.forwardFind([&](const PathAnalysis::Info& i) {
+    PathAnalysis::Info info = PathAnalysis{start}.forwardFind([&](const PathAnalysis::Info& i) {
         return (i.tok == dest);
     });
     if (!info.tok)

lib/pathanalysis.h

@@ -23,10 +23,8 @@
 
 #include <cstdint>
 #include <functional>
-#include <list>
 #include <utility>
 
-class Library;
 class Scope;
 class Token;
 
@@ -35,20 +33,17 @@ struct PathAnalysis {
         Continue,
         Break
     };
-    PathAnalysis(const Token* start, const Library& library)
-        : start(start), library(&library)
+
+    explicit PathAnalysis(const Token* start)
+        : mStart(start)
     {}
-    const Token * start;
-    const Library * library;
 
     struct Info {
         const Token* tok;
         ErrorPath errorPath;
         bool known;
     };
 
-    void forward(const std::function<Progress(const Info&)>& f) const;
-
     Info forwardFind(std::function<bool(const Info&)> pred) const {
         Info result{};
         forward([&](const Info& info) {
@@ -61,6 +56,9 @@ struct PathAnalysis {
         return result;
     }
 private:
+    const Token * mStart;
+
+    void forward(const std::function<Progress(const Info&)>& f) const;
 
     static Progress forwardRecursive(const Token* tok, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f);
     Progress forwardRange(const Token* startToken, const Token* endToken, Info info, const std::function<Progress(const Info&)>& f) const;
@@ -77,7 +75,7 @@ struct PathAnalysis {
  * @param dest The path destination
  * @param errorPath Adds the path traversal to the errorPath
  */
-bool reaches(const Token * start, const Token * dest, const Library& library, ErrorPath* errorPath);
+bool reaches(const Token * start, const Token * dest, ErrorPath* errorPath);
 
 #endif