moved SymbolicInferModel to infer.{cpp|h}

Author: firewave

lib/infer.cpp

@@ -408,6 +408,32 @@ ValuePtr<InferModel> makeIntegralInferModel()
     return IntegralInferModel{};
 }
 
+namespace {
+    struct SymbolicInferModel : InferModel {
+        const Token* expr;
+        explicit SymbolicInferModel(const Token* tok) : expr(tok) {
+            assert(expr->exprId() != 0);
+        }
+        bool match(const ValueFlow::Value& value) const override
+        {
+            return value.isSymbolicValue() && value.tokvalue && value.tokvalue->exprId() == expr->exprId();
+        }
+        ValueFlow::Value yield(MathLib::bigint value) const override
+        {
+            ValueFlow::Value result(value);
+            result.valueType = ValueFlow::Value::ValueType::SYMBOLIC;
+            result.tokvalue = expr;
+            result.setKnown();
+            return result;
+        }
+    };
+}
+
+ValuePtr<InferModel> makeSymbolicInferModel(const Token* token)
+{
+    return SymbolicInferModel{token};
+}
+
 ValueFlow::Value inferCondition(const std::string& op, const Token* varTok, MathLib::bigint val)
 {
     if (!varTok)

lib/infer.h

@@ -59,6 +59,8 @@ std::vector<MathLib::bigint> getMaxValue(const ValuePtr<InferModel>& model, cons
 
 ValuePtr<InferModel> makeIntegralInferModel();
 
+ValuePtr<InferModel> makeSymbolicInferModel(const Token* token);
+
 ValueFlow::Value inferCondition(const std::string& op, const Token* varTok, MathLib::bigint val);
 
 #endif

lib/vf_symbolicinfer.cpp

@@ -20,39 +20,18 @@
 
 #include "astutils.h"
 #include "infer.h"
-#include "mathlib.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "valueptr.h"
 #include "vfvalue.h"
 
 #include "vf_settokenvalue.h"
 
-#include <cassert>
 #include <utility>
 #include <vector>
 
 namespace ValueFlow
 {
-    struct SymbolicInferModel : InferModel {
-        const Token* expr;
-        explicit SymbolicInferModel(const Token* tok) : expr(tok) {
-            assert(expr->exprId() != 0);
-        }
-        bool match(const Value& value) const override
-        {
-            return value.isSymbolicValue() && value.tokvalue && value.tokvalue->exprId() == expr->exprId();
-        }
-        Value yield(MathLib::bigint value) const override
-        {
-            Value result(value);
-            result.valueType = Value::ValueType::SYMBOLIC;
-            result.tokvalue = expr;
-            result.setKnown();
-            return result;
-        }
-    };
-
     void valueFlowSymbolicInfer(const SymbolDatabase& symboldatabase, const Settings& settings)
     {
         for (const Scope* scope : symboldatabase.functionScopes) {
@@ -78,10 +57,10 @@ namespace ValueFlow
                 if (astIsFloat(tok->astOperand2(), false))
                     continue;
 
-                SymbolicInferModel leftModel{tok->astOperand1()};
+                auto leftModel = makeSymbolicInferModel(tok->astOperand1());
                 std::vector<Value> values = infer(leftModel, tok->str(), 0, tok->astOperand2()->values());
                 if (values.empty()) {
-                    SymbolicInferModel rightModel{tok->astOperand2()};
+                    auto rightModel = makeSymbolicInferModel(tok->astOperand2());
                     values = infer(rightModel, tok->str(), tok->astOperand1()->values(), 0);
                 }
                 for (Value& value : values) {