[MLIR][Presburger] Minor bug-fix in PresburgerRelation::intersectRange from 3dd9931

[iambrj]

Summary

Fix a typo (incorrectly calling getNumDomainVars instead of
getNumRangeVars) in intersectRange from 3dd9931.

[Groverkss]

LGTM

[arjunp]

Please edit the title to mention where the bug is instead and write a one-sentence description of the bug in the patch description

[iambrj]

Address comments.

[iambrj]

Update Phabricator description.

mlir/lib/Analysis/Presburger/PresburgerRelation.cpp

 }
 
 PresburgerRelation
 PresburgerRelation::intersectDomain(const PresburgerSet &set) const {
   assert(space.getDomainSpace().isCompatible(set.getSpace()) &&
          "Domain of `this` must be compatible with range of `set`");
 
   PresburgerRelation other = set;
-  other.insertVarInPlace(VarKind::Domain, 0, getNumDomainVars());
+  other.insertVarInPlace(VarKind::Domain, 0, getNumRangeVars());
   other.inverse();
   return intersect(other);
 }
 
 PresburgerSet PresburgerRelation::getDomainSet() const {
   PresburgerSet result = PresburgerSet::getEmpty(space.getDomainSpace());
   for (const IntegerRelation &cs : disjuncts)
     result.unionInPlace(cs.getDomainSet());

mlir/unittests/Analysis/Presburger/PresburgerRelationTest.cpp

for (unsigned i = 1, e = strs.size(); i < e; ++i) {
     rel = parseIntegerPolyhedron(strs[i]);
     rel.convertVarKind(VarKind::SetDim, 0, numDomain, VarKind::Domain);
     result.unionInPlace(rel);
   }
   return result;
 }
 
 TEST(PresburgerRelationTest, intersectDomainAndRange) {
+  {
     PresburgerRelation rel = parsePresburgerRelationFromPresburgerSet(
         {// (x, y) -> (x + N, y - N)
          "(x, y, a, b)[N] : (x - a + N == 0, y - b - N == 0)",
          // (x, y) -> (x + y, x - y)
          "(x, y, a, b)[N] : (a - x - y == 0, b - x + y == 0)",
          // (x, y) -> (x - y, y - x)}
          "(x, y, a, b)[N] : (a - x + y == 0, b - y + x == 0)"},
         2);
 
-  {
     PresburgerSet set =
         parsePresburgerSet({// (2x, x)
                             "(a, b)[N] : (a - 2 * b == 0)",
                             // (x, -x)
                             "(a, b)[N] : (a + b == 0)",
                             // (N, N)
                             "(a, b)[N] : (a - N == 0, b - N == 0)"});
 
PresburgerRelation expectedRel = parsePresburgerRelationFromPresburgerSet(
          "== 0)"},
         2);
 
     PresburgerRelation computedRel = rel.intersectDomain(set);
     EXPECT_TRUE(computedRel.isEqual(expectedRel));
   }
 
   {
+    PresburgerRelation rel = parsePresburgerRelationFromPresburgerSet(
+        {// (x)[N] -> (x + N, x - N)
+         "(x, a, b)[N] : (a - x - N == 0, b - x + N == 0)",
+         // (x)[N] -> (x, -x)
+         "(x, a, b)[N] : (a - x == 0, b + x == 0)",
+         // (x)[N] -> (N - x, 2 * x)}
+         "(x, a, b)[N] : (a - N + x == 0, b - 2 * x == 0)"},
+        1);
+
     PresburgerSet set =
         parsePresburgerSet({// (2x, x)
                             "(a, b)[N] : (a - 2 * b == 0)",
                             // (x, -x)
                             "(a, b)[N] : (a + b == 0)",
                             // (N, N)
                             "(a, b)[N] : (a - N == 0, b - N == 0)"});
 
     PresburgerRelation expectedRel = parsePresburgerRelationFromPresburgerSet(
-        {"(x, y, a, b)[N] : (x - a + N == 0, y - b - N == 0, a - 2 * b == 0)",
-         "(x, y, a, b)[N] : (x - a + N == 0, y - b - N == 0, a + b == 0)",
-         "(x, y, a, b)[N] : (x - a + N == 0, y - b - N == 0, a - N == 0, b - N "
+        {"(x, a, b)[N] : (a - x - N == 0, b - x + N == 0, a - 2 * b == 0)",
+         "(x, a, b)[N] : (a - x - N == 0, b - x + N == 0, a + b == 0)",
+         "(x, a, b)[N] : (a - x - N == 0, b - x + N == 0, a - N == 0, b - N "
          "== 0)",
-         "(x, y, a, b)[N] : (a - x - y == 0, b - x + y == 0, a - 2 * b == 0)",
-         "(x, y, a, b)[N] : (a - x - y == 0, b - x + y == 0, a + b == 0)",
-         "(x, y, a, b)[N] : (a - x - y == 0, b - x + y == 0, a - N == 0, b - N "
+         "(x, a, b)[N] : (a - x == 0, b + x == 0, a - 2 * b == 0)",
+         "(x, a, b)[N] : (a - x == 0, b + x == 0, a + b == 0)",
+         "(x, a, b)[N] : (a - x == 0, b + x == 0, a - N == 0, b - N "
          "== 0)",
-         "(x, y, a, b)[N] : (a - x + y == 0, b - y + x == 0, a - 2 * b == 0)",
-         "(x, y, a, b)[N] : (a - x + y == 0, b - y + x == 0, a + b == 0)",
-         "(x, y, a, b)[N] : (a - x + y == 0, b - y + x == 0, a - N == 0, b - N "
+         "(x, a, b)[N] : (a - N + x == 0, b - 2 * x == 0, a - 2 * b == 0)",
+         "(x, a, b)[N] : (a - N + x == 0, b - 2 * x == 0, a + b == 0)",
+         "(x, a, b)[N] : (a - N + x == 0, b - 2 * x == 0, a - N == 0, b - N "
          "== 0)"},
-        2);
+        1);
 
     PresburgerRelation computedRel = rel.intersectRange(set);
     EXPECT_TRUE(computedRel.isEqual(expectedRel));
   }
 }
 
 TEST(PresburgerRelationTest, applyDomainAndRange) {
   {