[MLIR][Presburger] Use PresburgerSpace in SetCoalescer

[Groverkss]

Summary

This patch changes the implementation of SetCoalescer to use PresburgerSpace
instead of reimplementing parts of PresburgerSpace.

[arjunp]

LGTM!

mlir/lib/Analysis/Presburger/PresburgerRelation.cpp

 public:
   /// Simplifies the representation of a PresburgerSet.
   PresburgerRelation coalesce();
 
   /// Construct a SetCoalescer from a PresburgerSet.
   SetCoalescer(const PresburgerRelation &s);
 
 private:
-  /// The dimensionality of the set the SetCoalescer is coalescing.
-  unsigned numDomainIds;
-  unsigned numRangeIds;
-  unsigned numSymbolIds;
+  /// The space of the set the SetCoalescer is coalescing.
+  PresburgerSpace space;
 
   /// The current list of `IntegerRelation`s that the currently coalesced set is
   /// the union of.
   SmallVector<IntegerRelation, 2> disjuncts;
   /// The list of `Simplex`s constructed from the elements of `disjuncts`.
   SmallVector<Simplex, 2> simplices;
 
   /// The list of all inversed equalities during typing. This ensures that
private:
   /// successfully coalesced. The simplices in `simplices` need to be the ones
   /// constructed from `disjuncts`. At this point, there are no empty
   /// disjuncts in `disjuncts` left.
   LogicalResult coalescePair(unsigned i, unsigned j);
 };
 
 /// Constructs a `SetCoalescer` from a `PresburgerRelation`. Only adds non-empty
 /// `IntegerRelation`s to the `disjuncts` vector.
-SetCoalescer::SetCoalescer(const PresburgerRelation &s) {
+SetCoalescer::SetCoalescer(const PresburgerRelation &s) : space(s.getSpace()) {
 
   disjuncts = s.disjuncts;
 
   simplices.reserve(s.getNumDisjuncts());
   // Note that disjuncts.size() changes during the loop.
   for (unsigned i = 0; i < disjuncts.size();) {
     disjuncts[i].removeRedundantConstraints();
     Simplex simp(disjuncts[i]);
     if (simp.isEmpty()) {
       disjuncts[i] = disjuncts[disjuncts.size() - 1];
       disjuncts.pop_back();
       continue;
     }
     ++i;
     simplices.push_back(simp);
   }
-  numDomainIds = s.getNumDomainIds();
-  numRangeIds = s.getNumRangeIds();
-  numSymbolIds = s.getNumSymbolIds();
 }
 
 /// Simplifies the representation of a PresburgerSet.
 PresburgerRelation SetCoalescer::coalesce() {
   // For all tuples of IntegerRelations, check whether they can be
   // coalesced. When coalescing is successful, the contained IntegerRelation
   // is swapped with the last element of `disjuncts` and subsequently erased
   // and similarly for simplices.
for (unsigned i = 0; i < disjuncts.size();) {
 
     // Only if the inner loop was not broken, i is incremented. This is
     // required as otherwise, if a coalescing occurs, the IntegerRelation
     // now at position i is not compared.
     if (!broken)
       ++i;
   }
 
-  PresburgerRelation newSet =
-      PresburgerRelation::getEmpty(PresburgerSpace::getRelationSpace(
-          numDomainIds, numRangeIds, numSymbolIds));
+  PresburgerRelation newSet = PresburgerRelation::getEmpty(space);
   for (unsigned i = 0, e = disjuncts.size(); i < e; ++i)
     newSet.unionInPlace(disjuncts[i]);
 
   return newSet;
 }
 
 /// Given a Simplex `simp` and one of its inequalities `ineq`, check
 /// that all inequalities of `cuttingIneqsB` are redundant for the facet of