Revert valueflow split (danmar#6991)

Revert most of the moving passes out of valueflow.cpp. Splitting up
valueflow should be organized differently.

Author: pfultz2

Makefile

@@ -959,7 +959,8 @@ bool extractForLoopValues(const Token *forToken,
     const Token *incExpr  = forToken->next()->astOperand2()->astOperand2()->astOperand2();
     if (!initExpr || !initExpr->isBinaryOp() || initExpr->str() != "=" || !Token::Match(initExpr->astOperand1(), "%var%"))
         return false;
-    std::vector<MathLib::bigint> minInitValue = getMinValue(makeIntegralInferModel(), initExpr->astOperand2()->values());
+    std::vector<MathLib::bigint> minInitValue =
+        getMinValue(makeIntegralInferModel(), initExpr->astOperand2()->values());
     if (minInitValue.empty()) {
         const ValueFlow::Value* v = initExpr->astOperand2()->getMinValue(true);
         if (v)

lib/astutils.cpp

@@ -90,34 +90,10 @@
     <ClCompile Include="tokenlist.cpp" />
     <ClCompile Include="utils.cpp" />
     <ClCompile Include="vf_analyzers.cpp" />
-    <ClCompile Include="vf_array.cpp" />
-    <ClCompile Include="vf_arraybool.cpp" />
-    <ClCompile Include="vf_arrayelement.cpp" />
-    <ClCompile Include="vf_bailout.cpp" />
-    <ClCompile Include="vf_bitand.cpp" />
     <ClCompile Include="vf_common.cpp" />
-    <ClCompile Include="vf_conditionexpressions.cpp" />
-    <ClCompile Include="vf_debug.cpp" />
     <ClCompile Include="vf_enumvalue.cpp" />
-    <ClCompile Include="vf_functionreturn.cpp" />
-    <ClCompile Include="vf_globalconstvar.cpp" />
-    <ClCompile Include="vf_globalstaticvar.cpp" />
-    <ClCompile Include="vf_impossiblevalues.cpp" />
-    <ClCompile Include="vf_infercondition.cpp" />
-    <ClCompile Include="vf_iteratorinfer.cpp" />
-    <ClCompile Include="vf_iterators.cpp" />
     <ClCompile Include="vf_number.cpp" />
-    <ClCompile Include="vf_pointeralias.cpp" />
-    <ClCompile Include="vf_reverse.cpp" />
-    <ClCompile Include="vf_rightshift.cpp" />
-    <ClCompile Include="vf_sameexpressions.cpp" />
     <ClCompile Include="vf_settokenvalue.cpp" />
-    <ClCompile Include="vf_string.cpp" />
-    <ClCompile Include="vf_subfunction.cpp" />
-    <ClCompile Include="vf_switchvariable.cpp" />
-    <ClCompile Include="vf_symbolicinfer.cpp" />
-    <ClCompile Include="vf_symbolicoperators.cpp" />
-    <ClCompile Include="vf_unknownfunctionreturn.cpp" />
     <ClCompile Include="vfvalue.cpp" />
   </ItemGroup>
   <ItemGroup Label="HeaderFiles">
@@ -202,34 +178,10 @@
     <ClInclude Include="version.h" />
     <ClInclude Include="vf_analyze.h" />
     <ClInclude Include="vf_analyzers.h" />
-    <ClInclude Include="vf_array.h" />
-    <ClInclude Include="vf_arraybool.h" />
-    <ClInclude Include="vf_arrayelement.h" />
-    <ClInclude Include="vf_bailout.h" />
-    <ClInclude Include="vf_bitand.h" />
     <ClInclude Include="vf_common.h" />
-    <ClInclude Include="vf_conditionexpressions.h" />
-    <ClInclude Include="vf_debug.h" />
     <ClInclude Include="vf_enumvalue.h" />
-    <ClInclude Include="vf_functionreturn.h" />
-    <ClInclude Include="vf_globalconstvar.h" />
-    <ClInclude Include="vf_globalstaticvar.h" />
-    <ClInclude Include="vf_impossiblevalues.h" />
-    <ClInclude Include="vf_infercondition.h" />
-    <ClInclude Include="vf_iteratorinfer.h" />
-    <ClInclude Include="vf_iterators.h" />
     <ClInclude Include="vf_number.h" />
-    <ClInclude Include="vf_pointeralias.h" />
-    <ClInclude Include="vf_reverse.h" />
-    <ClInclude Include="vf_rightshift.h" />
-    <ClInclude Include="vf_sameexpressions.h" />
     <ClInclude Include="vf_settokenvalue.h" />
-    <ClInclude Include="vf_string.h" />
-    <ClInclude Include="vf_subfunction.h" />
-    <ClInclude Include="vf_switchvariable.h" />
-    <ClInclude Include="vf_symbolicinfer.h" />
-    <ClInclude Include="vf_symbolicoperators.h" />
-    <ClInclude Include="vf_unknownfunctionreturn.h" />
     <ClInclude Include="vfvalue.h" />
     <ClInclude Include="xml.h" />
   </ItemGroup>

lib/cppcheck.vcxproj

@@ -30,6 +30,8 @@
 #include <unordered_set>
 #include <utility>
 
+class Token;
+
 template<class Predicate, class Compare>
 static const ValueFlow::Value* getCompareValue(const std::list<ValueFlow::Value>& values, Predicate pred, Compare compare)
 {

lib/infer.cpp

@@ -27,7 +27,6 @@
 #include <string>
 #include <vector>
 
-class Token;
 template<class T> class ValuePtr;
 
 struct InferModel {

lib/infer.h

@@ -1523,14 +1523,18 @@ namespace {
                     r = evaluate(expr->str(), lhs, rhs);
                 if (expr->isComparisonOp() && (r.isUninitValue() || r.isImpossible())) {
                     if (rhs.isIntValue() && !expr->astOperand1()->values().empty()) {
-                        std::vector<ValueFlow::Value> result =
-                            infer(makeIntegralInferModel(), expr->str(), expr->astOperand1()->values(), {std::move(rhs)});
+                        std::vector<ValueFlow::Value> result = infer(makeIntegralInferModel(),
+                                                                     expr->str(),
+                                                                     expr->astOperand1()->values(),
+                                                                     {std::move(rhs)});
                         if (!result.empty() && result.front().isKnown())
                             return std::move(result.front());
                     }
                     if (lhs.isIntValue() && !expr->astOperand2()->values().empty()) {
-                        std::vector<ValueFlow::Value> result =
-                            infer(makeIntegralInferModel(), expr->str(), {std::move(lhs)}, expr->astOperand2()->values());
+                        std::vector<ValueFlow::Value> result = infer(makeIntegralInferModel(),
+                                                                     expr->str(),
+                                                                     {std::move(lhs)},
+                                                                     expr->astOperand2()->values());
                         if (!result.empty() && result.front().isKnown())
                             return std::move(result.front());
                     }