[MLIR] Support symbols in emptiness checks for FlatAffineConstraints

[arjunp]

Fixed the unit test to actually EXPECT_ the expected result.

mlir/lib/Analysis/AffineStructures.cpp

for (unsigned i = 0, e = getNumEqualities(); i < e; ++i) {
     ++row;
   }
 
   return dirs;
 }
 
 bool eqInvolvesSuffixDims(const FlatAffineConstraints &fac, unsigned eqIndex,
                           unsigned numDims) {
-  for (unsigned e = fac.getNumDimIds(), j = e - numDims; j < e; ++j)
+  for (unsigned e = fac.getNumIds(), j = e - numDims; j < e; ++j)
     if (fac.atEq(eqIndex, j) != 0)
       return true;
   return false;
 }
 bool ineqInvolvesSuffixDims(const FlatAffineConstraints &fac,
                             unsigned ineqIndex, unsigned numDims) {
-  for (unsigned e = fac.getNumDimIds(), j = e - numDims; j < e; ++j)
+  for (unsigned e = fac.getNumIds(), j = e - numDims; j < e; ++j)
     if (fac.atIneq(ineqIndex, j) != 0)
       return true;
   return false;
 }
 
 void removeConstraintsInvolvingSuffixDims(FlatAffineConstraints &fac,
                                           unsigned unboundedDims) {
   // We iterate backwards so that whether we remove constraint i - 1 or not, the

mlir/lib/Analysis/LinearTransform.cpp

LinearTransform::preMultiplyColumn(ArrayRef<int64_t> colVec) const {
   for (unsigned row = 0, e = matrix.getNumRows(); row < e; row++)
     for (unsigned i = 0, e = matrix.getNumColumns(); i < e; i++)
       result[row] += matrix(row, i) * colVec[i];
   return result;
 }
 
 FlatAffineConstraints
 LinearTransform::applyTo(const FlatAffineConstraints &fac) const {
-  FlatAffineConstraints result(fac.getNumDimIds());
+  FlatAffineConstraints result(fac.getNumIds());
 
   for (unsigned i = 0, e = fac.getNumEqualities(); i < e; ++i) {
     ArrayRef<int64_t> eq = fac.getEquality(i);
 
     int64_t c = eq.back();
 
     SmallVector<int64_t, 8> newEq = postMultiplyRow(eq.drop_back());
     newEq.push_back(c);

mlir/unittests/Analysis/AffineStructuresTest.cpp

case TestFunction::Empty:
     EXPECT_EQ(!hasSample, fac.isIntegerEmpty());
     break;
   }
 }
 
 /// Construct a FlatAffineConstraints from a set of inequality and
 /// equality constraints.
 static FlatAffineConstraints
-makeFACFromConstraints(unsigned dims, ArrayRef<SmallVector<int64_t, 4>> ineqs,
-                       ArrayRef<SmallVector<int64_t, 4>> eqs) {
-  FlatAffineConstraints fac(ineqs.size(), eqs.size(), dims + 1, dims);
+makeFACFromConstraints(unsigned ids, ArrayRef<SmallVector<int64_t, 4>> ineqs,
+                       ArrayRef<SmallVector<int64_t, 4>> eqs,
+                       unsigned syms = 0) {
+  FlatAffineConstraints fac(ineqs.size(), eqs.size(), ids + 1, ids - syms,
+                            syms);
   for (const auto &eq : eqs)
     fac.addEquality(eq);
   for (const auto &ineq : ineqs)
     fac.addInequality(ineq);
   return fac;
 }
 
 /// Check sampling for all the permutations of the dimensions for the given
EXPECT_TRUE(makeFACFromConstraints(
                   {
                       {1, 0, 0, 0, 0},
                       {-1, 0, 0, 0, 100},
                       {0, 1, 0, 0, 0},
                       {0, -1, 0, 0, 100},
                   },
                   {{2, -3, 0, 0, 0}, {1, -1, 6, 0, -1}, {1, 1, 0, -6, -2}})
                   .isIntegerEmpty());
+
+  // Set with symbols.
+  FlatAffineConstraints fac6 = makeFACFromConstraints(2,
+                                                      {
+                                                          {1, 1, 0},
+                                                      },
+                                                      {
+                                                          {1, -1, 0},
+                                                      },
+                                                      1);
+  fac6.isIntegerEmpty();
 }
 
 TEST(FlatAffineConstraintsTest, removeRedundantConstraintsTest) {
   FlatAffineConstraints fac = makeFACFromConstraints(1,
                                                      {
                                                          {1, -2}, // x >= 2.
                                                          {-1, 2}  // x <= 2.
                                                      },