[analyzer][solver] Remove reference to RangedConstraintManager

[martong]

Summary

We no longer need a reference to RangedConstraintManager, we call top
level State->assume functions.

[steakhal]

Yey, it looks good.

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

1608

It seems odd, that sometimes it's called Builder and more frequently simply SVB.
We should consider consolidating this.

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

public:
   LLVM_NODISCARD static inline Optional<bool>
   areEqual(ProgramStateRef State, SymbolRef First, SymbolRef Second);
 
   /// Remove one member from the class.
   LLVM_NODISCARD ProgramStateRef removeMember(ProgramStateRef State,
                                               const SymbolRef Old);
 
   /// Iterate over all symbols and try to simplify them.
-  LLVM_NODISCARD static inline ProgramStateRef
-  simplify(SValBuilder &SVB, RangeSet::Factory &F, RangedConstraintManager &RCM,
-           ProgramStateRef State, EquivalenceClass Class);
+  LLVM_NODISCARD static inline ProgramStateRef simplify(SValBuilder &SVB,
+                                                        RangeSet::Factory &F,
+                                                        ProgramStateRef State,
+                                                        EquivalenceClass Class);
 
   void dumpToStream(ProgramStateRef State, raw_ostream &os) const;
   LLVM_DUMP_METHOD void dump(ProgramStateRef State) const {
     dumpToStream(State, llvm::errs());
   }
 
   /// Check equivalence data for consistency.
   LLVM_NODISCARD LLVM_ATTRIBUTE_UNUSED static bool

 /// 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, RangeConstraintManager &RCM,
-         SValBuilder &Builder, RangeSet::Factory &F, ClassOrSymbol CoS,
-         RangeSet NewConstraint) {
+  assign(ProgramStateRef State, SValBuilder &Builder, RangeSet::Factory &F,
+         ClassOrSymbol CoS, RangeSet NewConstraint) {
     if (!State || NewConstraint.isEmpty())
       return nullptr;
 
-    ConstraintAssignor Assignor{State, RCM, Builder, F};
+    ConstraintAssignor Assignor{State, Builder, F};
     return Assignor.assign(CoS, NewConstraint);
   }
 
   /// Handle expressions like: a % b != 0.
   template <typename SymT>
   bool handleRemainderOp(const SymT *Sym, RangeSet Constraint) {
     if (Sym->getOpcode() != BO_Rem)
       return true;
public:
   inline bool assignSymIntExprToRangeSet(const SymIntExpr *Sym,
                                          RangeSet Constraint) {
     return handleRemainderOp(Sym, Constraint);
   }
   inline bool assignSymSymExprToRangeSet(const SymSymExpr *Sym,
                                          RangeSet Constraint);
 
 private:
-  ConstraintAssignor(ProgramStateRef State, RangeConstraintManager &RCM,
-                     SValBuilder &Builder, RangeSet::Factory &F)
-      : State(State), RCM(RCM), Builder(Builder), RangeFactory(F) {}
+  ConstraintAssignor(ProgramStateRef State, SValBuilder &Builder,
+                     RangeSet::Factory &F)
+      : State(State), 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) {
 
     if (!Constraint.containsZero())
       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;
   // Iterate over all equivalence classes and try to simplify them.
   ClassMembersTy Members = State->get<ClassMembers>();
   for (std::pair<EquivalenceClass, SymbolSet> ClassToSymbolSet : Members) {
     EquivalenceClass Class = ClassToSymbolSet.first;
-    State =
-        EquivalenceClass::simplify(Builder, RangeFactory, RCM, State, Class);
+    State = EquivalenceClass::simplify(Builder, RangeFactory, State, Class);
     if (!State)
       return false;
     SimplifiedClasses.insert(Class);
   }
 
   // Trivial equivalence classes (those that have only one symbol member) are
   // not stored in the State. Thus, we must skim through the constraints as
   // well. And we try to simplify symbols in the constraints.
   ConstraintRangeTy Constraints = State->get<ConstraintRange>();
   for (std::pair<EquivalenceClass, RangeSet> ClassConstraint : Constraints) {
     EquivalenceClass Class = ClassConstraint.first;
     if (SimplifiedClasses.count(Class)) // Already simplified.
       continue;
-    State =
-        EquivalenceClass::simplify(Builder, RangeFactory, RCM, State, Class);
+    State = EquivalenceClass::simplify(Builder, RangeFactory, State, Class);
     if (!State)
       return false;
   }
 
   // We may have trivial equivalence classes in the disequality info as
   // well, and we need to simplify them.
   DisequalityMapTy DisequalityInfo = State->get<DisequalityMap>();
   for (std::pair<EquivalenceClass, ClassSet> DisequalityEntry :
        DisequalityInfo) {
     EquivalenceClass Class = DisequalityEntry.first;
     ClassSet DisequalClasses = DisequalityEntry.second;
-    State =
-        EquivalenceClass::simplify(Builder, RangeFactory, RCM, State, Class);
+    State = EquivalenceClass::simplify(Builder, RangeFactory, State, Class);
     if (!State)
       return false;
   }
 
   return true;
 }
 
 bool ConstraintAssignor::assignSymSymExprToRangeSet(const SymSymExpr *Sym,
return State->assumeInclusiveRange(DefinedVal, Constraint->getMinValue(),
                                      Constraint->getMaxValue(), true);
 }
 
 // Iterate over all symbols and try to simplify them. Once a symbol is
 // simplified then we check if we can merge the simplified symbol's equivalence
 // class to this class. This way, we simplify not just the symbols but the
 // classes as well: we strive to keep the number of the classes to be the
 // absolute minimum.
-LLVM_NODISCARD ProgramStateRef EquivalenceClass::simplify(
-    SValBuilder &SVB, RangeSet::Factory &F, RangedConstraintManager &RCM,
+LLVM_NODISCARD ProgramStateRef
+EquivalenceClass::simplify(SValBuilder &SVB, RangeSet::Factory &F,
                            ProgramStateRef State, EquivalenceClass Class) {
   SymbolSet ClassMembers = Class.getClassMembers(State);
   for (const SymbolRef &MemberSym : ClassMembers) {
 
     const SVal SimplifiedMemberVal = simplifyToSVal(State, MemberSym);
     const SymbolRef SimplifiedMemberSym = SimplifiedMemberVal.getAsSymbol();
 
     // The symbol is collapsed to a constant, check if the current State is
     // still feasible.

 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, *this, getSValBuilder(), F, Sym,
-                                    Range);
+  return ConstraintAssignor::assign(State, 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