[mlir] Remove dead code in Analysis/FlatLinearValueConstraints.

[Groverkss]

LGTM.

mlir/include/mlir/Analysis/FlatLinearValueConstraints.h

FlatLinearConstraints(unsigned numDims = 0, unsigned numSymbols = 0,
                               numDims, numSymbols, numLocals) {}
 
   FlatLinearConstraints(const IntegerPolyhedron &fac)
       : IntegerPolyhedron(fac) {}
 
   /// Return the kind of this object.
   Kind getKind() const override { return Kind::FlatLinearConstraints; }
 
-  static bool classof(const IntegerRelation *cst) {
-    return cst->getKind() >= Kind::FlatLinearConstraints &&
-           cst->getKind() <= Kind::FlatAffineRelation;
-  }
-
-  /// Clones this object.
-  std::unique_ptr<FlatLinearConstraints> clone() const;
-
   /// Adds a bound for the variable at the specified position with constraints
   /// being drawn from the specified bound map. In case of an EQ bound, the
   /// bound map is expected to have exactly one result. In case of a LB/UB, the
   /// bound map may have more than one result, for each of which an inequality
   /// is added.
   ///
   /// The bound can be added as open or closed by specifying isClosedBound. In
   /// case of a LB/UB, isClosedBound = false means the bound is added internally
if (valArgs.empty())
       values.resize(getNumDimAndSymbolVars(), std::nullopt);
     else
       values.append(valArgs.begin(), valArgs.end());
   }
 
   /// Creates an affine constraint system from an IntegerSet.
   explicit FlatLinearValueConstraints(IntegerSet set, ValueRange operands = {});
 
-  // Construct a hyperrectangular constraint set from ValueRanges that represent
-  // induction variables, lower and upper bounds. `ivs`, `lbs` and `ubs` are
-  // expected to match one to one. The order of variables and constraints is:
-  //
-  // ivs | lbs | ubs | eq/ineq
-  // ----+-----+-----+---------
-  //   1   -1     0      >= 0
-  // ----+-----+-----+---------
-  //  -1    0     1      >= 0
-  //
-  // All dimensions as set as VarKind::SetDim.
-  static FlatLinearValueConstraints
-  getHyperrectangular(ValueRange ivs, ValueRange lbs, ValueRange ubs);
-
   /// Return the kind of this object.
   Kind getKind() const override { return Kind::FlatLinearValueConstraints; }
 
   static bool classof(const IntegerRelation *cst) {
     return cst->getKind() >= Kind::FlatLinearValueConstraints &&
            cst->getKind() <= Kind::FlatAffineRelation;
   }
 
inline void getValues(unsigned start, unsigned end,
                         SmallVectorImpl<Value> *values) const {
     assert(end <= getNumDimAndSymbolVars() && "invalid end position");
     assert(start <= end && "invalid start position");
     values->clear();
     values->reserve(end - start);
     for (unsigned i = start; i < end; i++)
       values->push_back(getValue(i));
   }
-  inline void getAllValues(SmallVectorImpl<Value> *values) const {
-    getValues(0, getNumDimAndSymbolVars(), values);
-  }
 
   inline ArrayRef<std::optional<Value>> getMaybeValues() const {
     return {values.data(), values.size()};
   }
 
   inline ArrayRef<std::optional<Value>>
   getMaybeValues(presburger::VarKind kind) const {
     assert(kind != VarKind::Local &&
            "Local variables do not have any value attached to them.");
     return {values.data() + getVarKindOffset(kind), getNumVarKind(kind)};
   }
 
   /// Returns true if the pos^th variable has an associated Value.
   inline bool hasValue(unsigned pos) const {
     assert(pos < getNumDimAndSymbolVars() && "Invalid position");
     return values[pos].has_value();
   }
 
-  /// Returns true if at least one variable has an associated Value.
-  bool hasValues() const;
-
   unsigned appendDimVar(ValueRange vals);
   using FlatLinearConstraints::appendDimVar;
 
   unsigned appendSymbolVar(ValueRange vals);
   using FlatLinearConstraints::appendSymbolVar;
 
   unsigned insertDimVar(unsigned pos, ValueRange vals);
   using FlatLinearConstraints::insertDimVar;

mlir/lib/Analysis/FlatLinearValueConstraints.cpp

return ::getFlattenedAffineExprs(set.getConstraints(), set.getNumDims(),
                                    set.getNumSymbols(), flattenedExprs,
                                    localVarCst);
 }
 
 //===----------------------------------------------------------------------===//
 // FlatLinearConstraints
 //===----------------------------------------------------------------------===//
 
-std::unique_ptr<FlatLinearConstraints> FlatLinearConstraints::clone() const {
-  return std::make_unique<FlatLinearConstraints>(*this);
-}
-
 // Similar to `composeMap` except that no Values need be associated with the
 // constraint system nor are they looked at -- the dimensions and symbols of
 // `other` are expected to correspond 1:1 to `this` system.
 LogicalResult FlatLinearConstraints::composeMatchingMap(AffineMap other) {
   assert(other.getNumDims() == getNumDimVars() && "dim mismatch");
   assert(other.getNumSymbols() == getNumSymbolVars() && "symbol mismatch");
 
   std::vector<SmallVector<int64_t, 8>> flatExprs;
for (unsigned i = 0, e = flatExprs.size(); i < e; ++i) {
     } else {
       addInequality(flatExpr);
     }
   }
   // Add the other constraints involving local vars from flattening.
   append(localVarCst);
 }
 
-// Construct a hyperrectangular constraint set from ValueRanges that represent
-// induction variables, lower and upper bounds. `ivs`, `lbs` and `ubs` are
-// expected to match one to one. The order of variables and constraints is:
-//
-// ivs | lbs | ubs | eq/ineq
-// ----+-----+-----+---------
-//   1   -1     0      >= 0
-// ----+-----+-----+---------
-//  -1    0     1      >= 0
-//
-// All dimensions as set as VarKind::SetDim.
-FlatLinearValueConstraints
-FlatLinearValueConstraints::getHyperrectangular(ValueRange ivs, ValueRange lbs,
-                                                ValueRange ubs) {
-  FlatLinearValueConstraints res;
-  unsigned nIvs = ivs.size();
-  assert(nIvs == lbs.size() && "expected as many lower bounds as ivs");
-  assert(nIvs == ubs.size() && "expected as many upper bounds as ivs");
-
-  if (nIvs == 0)
-    return res;
-
-  res.appendDimVar(ivs);
-  unsigned lbsStart = res.appendDimVar(lbs);
-  unsigned ubsStart = res.appendDimVar(ubs);
-
-  MLIRContext *ctx = ivs.front().getContext();
-  for (int ivIdx = 0, e = nIvs; ivIdx < e; ++ivIdx) {
-    // iv - lb >= 0
-    AffineMap lb = AffineMap::get(/*dimCount=*/3 * nIvs, /*symbolCount=*/0,
-                                  getAffineDimExpr(lbsStart + ivIdx, ctx));
-    if (failed(res.addBound(BoundType::LB, ivIdx, lb)))
-      llvm_unreachable("Unexpected FlatLinearValueConstraints creation error");
-    // -iv + ub >= 0
-    AffineMap ub = AffineMap::get(/*dimCount=*/3 * nIvs, /*symbolCount=*/0,
-                                  getAffineDimExpr(ubsStart + ivIdx, ctx));
-    if (failed(res.addBound(BoundType::UB, ivIdx, ub)))
-      llvm_unreachable("Unexpected FlatLinearValueConstraints creation error");
-  }
-  return res;
-}
-
 unsigned FlatLinearValueConstraints::appendDimVar(ValueRange vals) {
   unsigned pos = getNumDimVars();
   return insertVar(VarKind::SetDim, pos, vals);
 }
 
 unsigned FlatLinearValueConstraints::appendSymbolVar(ValueRange vals) {
   unsigned pos = getNumSymbolVars();
   return insertVar(VarKind::Symbol, pos, vals);
unsigned FlatLinearValueConstraints::insertVar(VarKind kind, unsigned pos,
   for (unsigned i = 0; i < num; ++i)
     values.insert(values.begin() + absolutePos + i,
                   vals[i] ? std::optional<Value>(vals[i]) : std::nullopt);
 
   assert(values.size() == getNumDimAndSymbolVars());
   return absolutePos;
 }
 
-bool FlatLinearValueConstraints::hasValues() const {
-  return llvm::any_of(
-      values, [](const std::optional<Value> &var) { return var.has_value(); });
-}
-
 /// Checks if two constraint systems are in the same space, i.e., if they are
 /// associated with the same set of variables, appearing in the same order.
 static bool areVarsAligned(const FlatLinearValueConstraints &a,
                            const FlatLinearValueConstraints &b) {
   return a.getNumDimVars() == b.getNumDimVars() &&
          a.getNumSymbolVars() == b.getNumSymbolVars() &&
          a.getNumVars() == b.getNumVars() &&
          a.getMaybeValues().equals(b.getMaybeValues());