[MLIR][Presburger] Make PresburgerSpace member of PWMAFunction

[Groverkss]

Summary

This patch makes PresburgerSpace a member of PWMAFunction instead of PWMAFunction
inheriting from PresburgerSpace.

The reasoning for this patch is to prevent implicit conversion to PresburgerSpace
from PWMAFunction and to not inherit all functions exposed by PresburgerSpace
in PWMAFunction.

[Groverkss]

Going instead with private inheritance: https://reviews.llvm.org/D123076

mlir/include/mlir/Analysis/Presburger/PWMAFunction.h

 /// this class is undefined. The domains need not cover all possible points;
 /// this represents a partial function and so could be undefined at some points.
 ///
 /// As in PresburgerSets, the input ids are partitioned into dimension ids and
 /// symbolic ids.
 ///
 /// Support is provided to compare equality of two such functions as well as
 /// finding the value of the function at a point.
-class PWMAFunction : public PresburgerSpace {
+class PWMAFunction {
 public:
   PWMAFunction(const PresburgerSpace &space, unsigned numOutputs)
-      : PresburgerSpace(space), numOutputs(numOutputs) {
-    assert(getNumDomainIds() == 0 && "Set type space should zero domain ids.");
-    assert(getNumLocalIds() == 0 && "PWMAFunction cannot have local ids.");
+      : space(space), numOutputs(numOutputs) {
+    assert(space.getNumDomainIds() == 0 &&
+           "Set type space should zero domain ids.");
+    assert(space.getNumLocalIds() == 0 &&
+           "PWMAFunction cannot have local ids.");
     assert(numOutputs >= 1 && "The function must output something!");
   }
 
+  const PresburgerSpace &getSpace() const { return space; }
+
   void addPiece(const MultiAffineFunction &piece);
   void addPiece(const IntegerPolyhedron &domain, const Matrix &output);
 
   const MultiAffineFunction &getPiece(unsigned i) const { return pieces[i]; }
   unsigned getNumPieces() const { return pieces.size(); }
   unsigned getNumOutputs() const { return numOutputs; }
-  unsigned getNumInputs() const { return getNumIds(); }
+  unsigned getNumInputs() const { return space.getNumIds(); }
   MultiAffineFunction &getPiece(unsigned i) { return pieces[i]; }
 
   /// Return the domain of this piece-wise MultiAffineFunction. This is the
   /// union of the domains of all the pieces.
   PresburgerSet getDomain() const;
 
   /// Return the value at the specified point and an empty optional if the
   /// point does not lie in the domain.
   Optional<SmallVector<int64_t, 8>> valueAt(ArrayRef<int64_t> point) const;
 
   /// Return whether `this` and `other` are equal as PWMAFunctions, i.e. whether
   /// they have the same dimensions, the same domain and they take the same
   /// value at every point in the domain.
   bool isEqual(const PWMAFunction &other) const;
 
   void print(raw_ostream &os) const;
   void dump() const;
 
 private:
+  PresburgerSpace space;
+
   /// The list of pieces in this piece-wise MultiAffineFunction.
   SmallVector<MultiAffineFunction, 4> pieces;
 
   /// The number of output ids.
   unsigned numOutputs;
 };
 
 } // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H

mlir/lib/Analysis/Presburger/PWMAFunction.cpp

bool MultiAffineFunction::isEqualWhereDomainsOverlap(
   // If the whole common domain is a subset of commonDomainMatching, then they
   // are equal and the two functions match on the whole common domain.
   return commonFunc.getDomain().isSubsetOf(commonDomainMatching);
 }
 
 /// Two PWMAFunctions are equal if they have the same dimensionalities,
 /// the same domain, and take the same value at every point in the domain.
 bool PWMAFunction::isEqual(const PWMAFunction &other) const {
-  if (!isSpaceCompatible(other))
+  if (!space.isSpaceCompatible(other.getSpace()))
     return false;
 
   if (!this->getDomain().isEqual(other.getDomain()))
     return false;
 
   // Check if, whenever the domains of a piece of `this` and a piece of `other`
   // overlap, they take the same output value. If `this` and `other` have the
   // same domain (checked above), then this check passes iff the two functions
   // have the same output at every point in the domain.
   for (const MultiAffineFunction &aPiece : this->pieces)
     for (const MultiAffineFunction &bPiece : other.pieces)
       if (!aPiece.isEqualWhereDomainsOverlap(bPiece))
         return false;
   return true;
 }
 
 void PWMAFunction::addPiece(const MultiAffineFunction &piece) {
-  assert(piece.isSpaceCompatible(*this) &&
+  assert(piece.isSpaceCompatible(space) &&
          "Piece to be added is not compatible with this PWMAFunction!");
   assert(piece.isConsistent() && "Piece is internally inconsistent!");
   assert(this->getDomain()
              .intersect(PresburgerSet(piece.getDomain()))
              .isIntegerEmpty() &&
          "New piece's domain overlaps with that of existing pieces!");
   pieces.push_back(piece);
 }