[mlir][Interfaces][NFC] ValueBoundsConstraintSet: Simplify constructor

[springerm]

Summary

Depends On: D151422

mlir/include/mlir/Interfaces/ValueBoundsOpInterface.h

 protected:
   /// Dimension identifier to indicate a value is index-typed. This is used for
   /// internal data structures/API only.
   static constexpr int64_t kIndexValue = -1;
 
   /// An index-typed value or the dimension of a shaped-type value.
   using ValueDim = std::pair<Value, int64_t>;
 
-  ValueBoundsConstraintSet(Value value, std::optional<int64_t> dim);
+  ValueBoundsConstraintSet(MLIRContext *ctx);
 
   /// Iteratively process all elements on the worklist until an index-typed
   /// value or shaped value meets `stopCondition`. Such values are not processed
   /// any further.
   void processWorklist(StopConditionFn stopCondition);
 
   /// Bound the given column in the underlying constraint set by the given
   /// expression.

mlir/lib/Interfaces/ValueBoundsOpInterface.cpp

static std::optional<int64_t> getConstantIntValue(OpFoldResult ofr) {
   }
   // Case 2: Check for IntegerAttr.
   Attribute attr = ofr.dyn_cast<Attribute>();
   if (auto intAttr = dyn_cast_or_null<IntegerAttr>(attr))
     return intAttr.getValue().getSExtValue();
   return std::nullopt;
 }
 
-ValueBoundsConstraintSet::ValueBoundsConstraintSet(Value value,
-                                                   std::optional<int64_t> dim)
-    : builder(value.getContext()) {
-  insert(value, dim, /*isSymbol=*/false);
-}
+ValueBoundsConstraintSet::ValueBoundsConstraintSet(MLIRContext *ctx)
+    : builder(ctx) {}
 
 #ifndef NDEBUG
 static void assertValidValueDim(Value value, std::optional<int64_t> dim) {
   if (value.getType().isIndex()) {
     assert(!dim.has_value() && "invalid dim value");
   } else if (auto shapedType = dyn_cast<ShapedType>(value.getType())) {
     assert(*dim >= 0 && "invalid dim value");
     if (shapedType.hasRank())
if (stopCondition(value, dim)) {
     resultMap = AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0,
                                b.getAffineDimExpr(0));
     return success();
   }
 
   // Process the backward slice of `value` (i.e., reverse use-def chain) until
   // `stopCondition` is met.
   ValueDim valueDim = std::make_pair(value, dim.value_or(kIndexValue));
-  ValueBoundsConstraintSet cstr(value, dim);
+  ValueBoundsConstraintSet cstr(value.getContext());
+  int64_t pos = cstr.insert(value, dim, /*isSymbol=*/false);
   cstr.processWorklist(stopCondition);
 
   // Project out all variables (apart from `valueDim`) that do not match the
   // stop condition.
   cstr.projectOut([&](ValueDim p) {
     // Do not project out `valueDim`.
     if (valueDim == p)
       return false;
     auto maybeDim =
         p.second == kIndexValue ? std::nullopt : std::make_optional(p.second);
     return !stopCondition(p.first, maybeDim);
   });
 
   // Compute lower and upper bounds for `valueDim`.
-  int64_t pos = cstr.getPos(value, dim);
   SmallVector<AffineMap> lb(1), ub(1);
   cstr.cstr.getSliceBounds(pos, 1, value.getContext(), &lb, &ub,
                            /*getClosedUB=*/true);
 
   // Note: There are TODOs in the implementation of `getSliceBounds`. In such a
   // case, no lower/upper bound can be computed at the moment.
   // EQ, UB bounds: upper bound is needed.
   if ((type != BoundType::LB) &&
FailureOr<int64_t> ValueBoundsConstraintSet::computeConstantBound(
     presburger::BoundType type, Value value, std::optional<int64_t> dim,
     StopConditionFn stopCondition, bool closedUB) {
 #ifndef NDEBUG
   assertValidValueDim(value, dim);
 #endif // NDEBUG
 
   // Process the backward slice of `value` (i.e., reverse use-def chain) until
   // `stopCondition` is met.
-  ValueBoundsConstraintSet cstr(value, dim);
-  int64_t pos = cstr.getPos(value, dim);
+  ValueBoundsConstraintSet cstr(value.getContext());
+  int64_t pos = cstr.insert(value, dim, /*isSymbol=*/false);
   if (stopCondition) {
     cstr.processWorklist(stopCondition);
   } else {
     // No stop condition specified: Keep adding constraints until a bound could
     // be computed.
     cstr.processWorklist(
         /*stopCondition=*/[&](Value v, std::optional<int64_t> dim) {
           return cstr.cstr.getConstantBound64(type, pos).has_value();