[Analyzer][NFC] Add RangedConstraintManager to ConstraintAssignor

[martong]

Summary

In this patch we store a reference to RangedConstraintManager in the
ConstraintAssignor. This way it is possible to call back and reuse some
functions of it. This patch is exclusively needed for its child patches,
it is not intended to be a standalone patch.

[steakhal]

It looks good.
Do you think we could remove the RangedConstraintManager abstraction?
It shouldn't be hard to get rid of it.

Regardless, it's good to go, but let's wait for the child revision.

[martong]

In D111640#3058304, @steakhal wrote:

It looks good.
Do you think we could remove the RangedConstraintManager abstraction?

Definitely. What's more, we could split out cohesive implementation details like RangeSet, EquivalenceClass from RangeConstraintManager.cpp into their own implementation files.

[ASDenysPetrov]

In D111640#3058622, @martong wrote:

In D111640#3058304, @steakhal wrote:

It looks good.
Do you think we could remove the RangedConstraintManager abstraction?

Definitely. What's more, we could split out cohesive implementation details like RangeSet, EquivalenceClass from RangeConstraintManager.cpp into their own implementation files.

Sound thought! +1

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

 /// It has a nice symmetry with SymbolicRangeInferrer.  When the latter
 /// can provide more precise ranges by looking into the operands of the
 /// expression in question, ConstraintAssignor looks into the operands
 /// to see if we can imply more from the new constraint.
 class ConstraintAssignor : public ConstraintAssignorBase<ConstraintAssignor> {
 public:
   template <class ClassOrSymbol>
   LLVM_NODISCARD static ProgramStateRef
-  assign(ProgramStateRef State, SValBuilder &Builder, RangeSet::Factory &F,
-         ClassOrSymbol CoS, RangeSet NewConstraint) {
+  assign(ProgramStateRef State, RangeConstraintManager &RCM,
+         SValBuilder &Builder, RangeSet::Factory &F, ClassOrSymbol CoS,
+         RangeSet NewConstraint) {
     if (!State || NewConstraint.isEmpty())
       return nullptr;
 
-    ConstraintAssignor Assignor{State, Builder, F};
+    ConstraintAssignor Assignor{State, RCM, Builder, F};
     return Assignor.assign(CoS, NewConstraint);
   }
 
   inline bool assignSymExprToConst(const SymExpr *Sym, Const Constraint);
   inline bool assignSymSymExprToRangeSet(const SymSymExpr *Sym,
                                          RangeSet Constraint);
 
 private:
-  ConstraintAssignor(ProgramStateRef State, SValBuilder &Builder,
-                     RangeSet::Factory &F)
-      : State(State), Builder(Builder), RangeFactory(F) {}
+  ConstraintAssignor(ProgramStateRef State, RangeConstraintManager &RCM,
+                     SValBuilder &Builder, RangeSet::Factory &F)
+      : State(State), RCM(RCM), Builder(Builder), RangeFactory(F) {}
   using Base = ConstraintAssignorBase<ConstraintAssignor>;
 
   /// Base method for handling new constraints for symbols.
   LLVM_NODISCARD ProgramStateRef assign(SymbolRef Sym, RangeSet NewConstraint) {
     // All constraints are actually associated with equivalence classes, and
     // that's what we are going to do first.
     State = assign(EquivalenceClass::find(State, Sym), NewConstraint);
     if (!State)
LLVM_NODISCARD Optional<bool> interpreteAsBool(RangeSet Constraint) {
     Const Zero = T.getZeroValue();
     if (!Constraint.contains(Zero))
       return true;
 
     return llvm::None;
   }
 
   ProgramStateRef State;
+  RangeConstraintManager &RCM;
   SValBuilder &Builder;
   RangeSet::Factory &RangeFactory;
 };
 
 
 bool ConstraintAssignor::assignSymExprToConst(const SymExpr *Sym,
                                               const llvm::APSInt &Constraint) {
   llvm::SmallSet<EquivalenceClass, 4> SimplifiedClasses;

 RangeSet RangeConstraintManager::getRange(ProgramStateRef State,
                                           SymbolRef Sym) {
   return SymbolicRangeInferrer::inferRange(F, State, Sym);
 }
 
 ProgramStateRef RangeConstraintManager::setRange(ProgramStateRef State,
                                                  SymbolRef Sym,
                                                  RangeSet Range) {
-  return ConstraintAssignor::assign(State, getSValBuilder(), F, Sym, Range);
+  return ConstraintAssignor::assign(State, *this, getSValBuilder(), F, Sym,
+                                    Range);
 }
 
 //===------------------------------------------------------------------------===
 // assumeSymX methods: protected interface for RangeConstraintManager.
 //===------------------------------------------------------------------------===/
 
 // The syntax for ranges below is mathematical, using [x, y] for closed ranges
 // and (x, y) for open ranges. These ranges are modular, corresponding with