[MLIR][Presburger] Rename variable/identifier -> variable

[Groverkss]

Summary

Currently, in the Presburger library, we use the words "variables" and
"identifiers" interchangeably. This patch changes this to only use "variables" to
refer to the variables of PresburgerSpace.

The reasoning behind this change is that the current usage of the word "identifier"
is misleading. variables do not "identify" anything. The information attached to them is the
actual "identifier" for the variable. The word "identifier", will later be used
to refer to the information attached to each variable in space.

mlir/include/mlir/Analysis/Presburger/IntegerRelation.h

 //===- IntegerRelation.h - MLIR IntegerRelation Class ---------*- C++ -*---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // A class to represent a relation over integer tuples. A relation is
 // represented as a constraint system over a space of tuples of integer valued
-// variables supporting symbolic identifiers and existential quantification.
+// variables supporting symbolic variables and existential quantification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_INTEGERRELATION_H
 #define MLIR_ANALYSIS_PRESBURGER_INTEGERRELATION_H
 
 #include "mlir/Analysis/Presburger/Fraction.h"
 #include "mlir/Analysis/Presburger/Matrix.h"

 /// An IntegerRelation represents the set of points from a PresburgerSpace that
 /// satisfy a list of affine constraints. Affine constraints can be inequalities
 /// or equalities in the form:
 ///
 /// Inequality: c_0*x_0 + c_1*x_1 + .... + c_{n-1}*x_{n-1} + c_n >= 0
 /// Equality  : c_0*x_0 + c_1*x_1 + .... + c_{n-1}*x_{n-1} + c_n == 0
 ///
 /// where c_0, c_1, ..., c_n are integers and n is the total number of
-/// identifiers in the space.
+/// variables in the space.
 ///
 /// Such a relation corresponds to the set of integer points lying in a convex
 /// polyhedron. For example, consider the relation:
 ///         (x) -> (y) : (1 <= x <= 7, x = 2y)
 /// These can be thought of as points in the polyhedron:
 ///         (x, y) : (1 <= x <= 7, x = 2y)
 /// This relation contains the pairs (2, 1), (4, 2), and (6, 3).
 ///
-/// Since IntegerRelation makes a distinction between dimensions, IdKind::Range
-/// and IdKind::Domain should be used to refer to dimension identifiers.
+/// Since IntegerRelation makes a distinction between dimensions, VarKind::Range
+/// and VarKind::Domain should be used to refer to dimension variables.
 class IntegerRelation {
 public:
   /// All derived classes of IntegerRelation.
   enum class Kind {
     FlatAffineConstraints,
     FlatAffineValueConstraints,
     IntegerRelation,
     IntegerPolyhedron,
   };
 
   /// Constructs a relation reserving memory for the specified number
-  /// of constraints and identifiers.
+  /// of constraints and variables.
   IntegerRelation(unsigned numReservedInequalities,
                   unsigned numReservedEqualities, unsigned numReservedCols,
                   const PresburgerSpace &space)
-      : space(space), equalities(0, space.getNumIds() + 1,
+      : space(space), equalities(0, space.getNumVars() + 1,
                                  numReservedEqualities, numReservedCols),
-        inequalities(0, space.getNumIds() + 1, numReservedInequalities,
+        inequalities(0, space.getNumVars() + 1, numReservedInequalities,
                      numReservedCols) {
-    assert(numReservedCols >= space.getNumIds() + 1);
+    assert(numReservedCols >= space.getNumVars() + 1);
   }
 
   /// Constructs a relation with the specified number of dimensions and symbols.
   explicit IntegerRelation(const PresburgerSpace &space)
       : IntegerRelation(/*numReservedInequalities=*/0,
                         /*numReservedEqualities=*/0,
-                        /*numReservedCols=*/space.getNumIds() + 1, space) {}
+                        /*numReservedCols=*/space.getNumVars() + 1, space) {}
 
   virtual ~IntegerRelation() = default;
 
   /// Return a system with no constraints, i.e., one which is satisfied by all
   /// points.
   static IntegerRelation getUniverse(const PresburgerSpace &space) {
     return IntegerRelation(space);
   }
public:
   /// `oSpace` can have fewer ids than the current space; in that case, the
   /// the extra ids in `this` that are not accounted for by `oSpace` will be
   /// considered as local ids. `oSpace` should not have more ids than the
   /// current space; this will result in an assert failure.
   void setSpaceExceptLocals(const PresburgerSpace &oSpace);
 
   /// Returns a copy of the space without locals.
   PresburgerSpace getSpaceWithoutLocals() const {
-    return PresburgerSpace::getRelationSpace(space.getNumDomainIds(),
-                                             space.getNumRangeIds(),
-                                             space.getNumSymbolIds());
+    return PresburgerSpace::getRelationSpace(space.getNumDomainVars(),
+                                             space.getNumRangeVars(),
+                                             space.getNumSymbolVars());
   }
 
   /// Appends constraints from `other` into `this`. This is equivalent to an
   /// intersection with no simplification of any sort attempted.
   void append(const IntegerRelation &other);
 
   /// Return the intersection of the two sets.
   /// If there are locals, they will be merged.
inline int64_t atIneq(unsigned i, unsigned j) const {
     return inequalities(i, j);
   }
   inline int64_t &atIneq(unsigned i, unsigned j) { return inequalities(i, j); }
 
   unsigned getNumConstraints() const {
     return getNumInequalities() + getNumEqualities();
   }
 
-  unsigned getNumDomainIds() const { return space.getNumDomainIds(); }
-  unsigned getNumRangeIds() const { return space.getNumRangeIds(); }
-  unsigned getNumSymbolIds() const { return space.getNumSymbolIds(); }
-  unsigned getNumLocalIds() const { return space.getNumLocalIds(); }
-
-  unsigned getNumDimIds() const { return space.getNumDimIds(); }
-  unsigned getNumDimAndSymbolIds() const {
-    return space.getNumDimAndSymbolIds();
+  unsigned getNumDomainVars() const { return space.getNumDomainVars(); }
+  unsigned getNumRangeVars() const { return space.getNumRangeVars(); }
+  unsigned getNumSymbolVars() const { return space.getNumSymbolVars(); }
+  unsigned getNumLocalVars() const { return space.getNumLocalVars(); }
+
+  unsigned getNumDimVars() const { return space.getNumDimVars(); }
+  unsigned getNumDimAndSymbolVars() const {
+    return space.getNumDimAndSymbolVars();
   }
-  unsigned getNumIds() const { return space.getNumIds(); }
+  unsigned getNumVars() const { return space.getNumVars(); }
 
   /// Returns the number of columns in the constraint system.
-  inline unsigned getNumCols() const { return space.getNumIds() + 1; }
+  inline unsigned getNumCols() const { return space.getNumVars() + 1; }
 
   inline unsigned getNumEqualities() const { return equalities.getNumRows(); }
 
   inline unsigned getNumInequalities() const {
     return inequalities.getNumRows();
   }
 
   inline unsigned getNumReservedEqualities() const {
     return equalities.getNumReservedRows();
   }
 
   inline unsigned getNumReservedInequalities() const {
     return inequalities.getNumReservedRows();
   }
 
   inline ArrayRef<int64_t> getEquality(unsigned idx) const {
     return equalities.getRow(idx);
   }
 
   inline ArrayRef<int64_t> getInequality(unsigned idx) const {
     return inequalities.getRow(idx);
   }
 
-  /// Get the number of ids of the specified kind.
-  unsigned getNumIdKind(IdKind kind) const { return space.getNumIdKind(kind); };
+  /// Get the number of vars of the specified kind.
+  unsigned getNumVarKind(VarKind kind) const {
+    return space.getNumVarKind(kind);
+  };
 
-  /// Return the index at which the specified kind of id starts.
-  unsigned getIdKindOffset(IdKind kind) const {
-    return space.getIdKindOffset(kind);
+  /// Return the index at which the specified kind of vars starts.
+  unsigned getVarKindOffset(VarKind kind) const {
+    return space.getVarKindOffset(kind);
   };
 
-  /// Return the index at Which the specified kind of id ends.
-  unsigned getIdKindEnd(IdKind kind) const { return space.getIdKindEnd(kind); };
+  /// Return the index at Which the specified kind of vars ends.
+  unsigned getVarKindEnd(VarKind kind) const {
+    return space.getVarKindEnd(kind);
+  };
 
   /// Get the number of elements of the specified kind in the range
-  /// [idStart, idLimit).
-  unsigned getIdKindOverlap(IdKind kind, unsigned idStart,
-                            unsigned idLimit) const {
-    return space.getIdKindOverlap(kind, idStart, idLimit);
+  /// [varStart, varLimit).
+  unsigned getVarKindOverlap(VarKind kind, unsigned varStart,
+                             unsigned varLimit) const {
+    return space.getVarKindOverlap(kind, varStart, varLimit);
   };
 
-  /// Return the IdKind of the id at the specified position.
-  IdKind getIdKindAt(unsigned pos) const { return space.getIdKindAt(pos); };
+  /// Return the VarKind of the var at the specified position.
+  VarKind getVarKindAt(unsigned pos) const { return space.getVarKindAt(pos); };
 
-  /// The struct CountsSnapshot stores the count of each IdKind, and also of
+  /// The struct CountsSnapshot stores the count of each VarKind, and also of
   /// each constraint type. getCounts() returns a CountsSnapshot object
   /// describing the current state of the IntegerRelation. truncate() truncates
-  /// all ids of each IdKind and all constraints of both kinds beyond the counts
-  /// in the specified CountsSnapshot object. This can be used to achieve
+  /// all vars of each VarKind and all constraints of both kinds beyond the
+  /// counts in the specified CountsSnapshot object. This can be used to achieve
   /// rudimentary rollback support. As long as none of the existing constraints
-  /// or ids are disturbed, and only additional ids or constraints are added,
+  /// or vars are disturbed, and only additional vars or constraints are added,
   /// this addition can be rolled back using truncate.
   struct CountsSnapshot {
   public:
     CountsSnapshot(const PresburgerSpace &space, unsigned numIneqs,
                    unsigned numEqs)
         : space(space), numIneqs(numIneqs), numEqs(numEqs) {}
     const PresburgerSpace &getSpace() const { return space; };
     unsigned getNumIneqs() const { return numIneqs; }
     unsigned getNumEqs() const { return numEqs; }
 
   private:
     PresburgerSpace space;
     unsigned numIneqs, numEqs;
   };
   CountsSnapshot getCounts() const;
   void truncate(const CountsSnapshot &counts);
 
-  /// Insert `num` identifiers of the specified kind at position `pos`.
-  /// Positions are relative to the kind of identifier. The coefficient columns
-  /// corresponding to the added identifiers are initialized to zero. Return the
-  /// absolute column position (i.e., not relative to the kind of identifier)
-  /// of the first added identifier.
-  virtual unsigned insertId(IdKind kind, unsigned pos, unsigned num = 1);
+  /// Insert `num` variables of the specified kind at position `pos`.
+  /// Positions are relative to the kind of variable. The coefficient columns
+  /// corresponding to the added variables are initialized to zero. Return the
+  /// absolute column position (i.e., not relative to the kind of variable)
+  /// of the first added variable.
+  virtual unsigned insertVar(VarKind kind, unsigned pos, unsigned num = 1);
 
-  /// Append `num` identifiers of the specified kind after the last identifier.
+  /// Append `num` variables of the specified kind after the last variable.
   /// of that kind. Return the position of the first appended column relative to
-  /// the kind of identifier. The coefficient columns corresponding to the added
-  /// identifiers are initialized to zero.
-  unsigned appendId(IdKind kind, unsigned num = 1);
+  /// the kind of variable. The coefficient columns corresponding to the added
+  /// variables are initialized to zero.
+  unsigned appendVar(VarKind kind, unsigned num = 1);
 
   /// Adds an inequality (>= 0) from the coefficients specified in `inEq`.
   void addInequality(ArrayRef<int64_t> inEq);
   /// Adds an equality from the coefficients specified in `eq`.
   void addEquality(ArrayRef<int64_t> eq);
 
-  /// Eliminate the `posB^th` local identifier, replacing every instance of it
-  /// with the `posA^th` local identifier. This should be used when the two
+  /// Eliminate the `posB^th` local variable, replacing every instance of it
+  /// with the `posA^th` local variable. This should be used when the two
   /// local variables are known to always take the same values.
-  virtual void eliminateRedundantLocalId(unsigned posA, unsigned posB);
+  virtual void eliminateRedundantLocalVar(unsigned posA, unsigned posB);
 
-  /// Removes identifiers of the specified kind with the specified pos (or
+  /// Removes variables of the specified kind with the specified pos (or
   /// within the specified range) from the system. The specified location is
-  /// relative to the first identifier of the specified kind.
-  void removeId(IdKind kind, unsigned pos);
-  virtual void removeIdRange(IdKind kind, unsigned idStart, unsigned idLimit);
+  /// relative to the first variable of the specified kind.
+  void removeVar(VarKind kind, unsigned pos);
+  virtual void removeVarRange(VarKind kind, unsigned varStart,
+                              unsigned varLimit);
 
-  /// Removes the specified identifier from the system.
-  void removeId(unsigned pos);
+  /// Removes the specified variable from the system.
+  void removeVar(unsigned pos);
 
   void removeEquality(unsigned pos);
   void removeInequality(unsigned pos);
 
   /// Remove the (in)equalities at positions [start, end).
   void removeEqualityRange(unsigned start, unsigned end);
   void removeInequalityRange(unsigned start, unsigned end);
 
   /// Get the lexicographically minimum rational point satisfying the
   /// constraints. Returns an empty optional if the relation is empty or if
   /// the lexmin is unbounded. Symbols are not supported and will result in
   /// assert-failure. Note that Domain is minimized first, then range.
   MaybeOptimum<SmallVector<Fraction, 8>> findRationalLexMin() const;
 
   /// Same as above, but returns lexicographically minimal integer point.
   /// Note: this should be used only when the lexmin is really required.
   /// For a generic integer sampling operation, findIntegerSample is more
   /// robust and should be preferred. Note that Domain is minimized first, then
   /// range.
   MaybeOptimum<SmallVector<int64_t, 8>> findIntegerLexMin() const;
 
-  /// Swap the posA^th identifier with the posB^th identifier.
-  virtual void swapId(unsigned posA, unsigned posB);
+  /// Swap the posA^th variable with the posB^th variable.
+  virtual void swapVar(unsigned posA, unsigned posB);
 
   /// Removes all equalities and inequalities.
   void clearConstraints();
 
-  /// Sets the `values.size()` identifiers starting at `po`s to the specified
+  /// Sets the `values.size()` variables starting at `po`s to the specified
   /// values and removes them.
   void setAndEliminate(unsigned pos, ArrayRef<int64_t> values);
 
   /// Replaces the contents of this IntegerRelation with `other`.
   virtual void clearAndCopyFrom(const IntegerRelation &other);
 
-  /// Gather positions of all lower and upper bounds of the identifier at `pos`,
+  /// Gather positions of all lower and upper bounds of the variable at `pos`,
   /// and optionally any equalities on it. In addition, the bounds are to be
-  /// independent of identifiers in position range [`offset`, `offset` + `num`).
+  /// independent of variables in position range [`offset`, `offset` + `num`).
   void
   getLowerAndUpperBoundIndices(unsigned pos,
                                SmallVectorImpl<unsigned> *lbIndices,
                                SmallVectorImpl<unsigned> *ubIndices,
                                SmallVectorImpl<unsigned> *eqIndices = nullptr,
                                unsigned offset = 0, unsigned num = 0) const;
 
   /// Checks for emptiness by performing variable elimination on all
-  /// identifiers, running the GCD test on each equality constraint, and
+  /// variables, running the GCD test on each equality constraint, and
   /// checking for invalid constraints. Returns true if the GCD test fails for
   /// any equality, or if any invalid constraints are discovered on any row.
   /// Returns false otherwise.
   bool isEmpty() const;
 
   /// Runs the GCD test on all equality constraints. Returns true if this test
   /// fails on any equality. Returns false otherwise.
   /// This test can be used to disprove the existence of a solution. If it
public:
   /// branch and bound algorithm with generalized basis reduction, with some
   /// additional processing using Simplex for unbounded sets.
   ///
   /// Returns an integer sample point if one exists, or an empty Optional
   /// otherwise.
   Optional<SmallVector<int64_t, 8>> findIntegerSample() const;
 
   /// Compute an overapproximation of the number of integer points in the
-  /// relation. Symbol ids are currently not supported. If the computed
+  /// relation. Symbol vars currently not supported. If the computed
   /// overapproximation is infinite, an empty optional is returned.
   Optional<uint64_t> computeVolume() const;
 
   /// Returns true if the given point satisfies the constraints, or false
-  /// otherwise. Takes the values of all ids including locals.
+  /// otherwise. Takes the values of all vars including locals.
   bool containsPoint(ArrayRef<int64_t> point) const;
-  /// Given the values of non-local ids, return a satisfying assignment to the
+  /// Given the values of non-local vars, return a satisfying assignment to the
   /// local if one exists, or an empty optional otherwise.
   Optional<SmallVector<int64_t, 8>>
   containsPointNoLocal(ArrayRef<int64_t> point) const;
 
-  /// Find equality and pairs of inequality contraints identified by their
+  /// Find equality and pairs of inequality constraints identified by their
   /// position indices, using which an explicit representation for each local
   /// variable can be computed. The indices of the constraints are stored in
   /// `MaybeLocalRepr` struct. If no such pair can be found, the kind attribute
   /// in `MaybeLocalRepr` is set to None.
   ///
   /// The dividends of the explicit representations are stored in `dividends`
   /// and the denominators in `denominators`. If no explicit representation
-  /// could be found for the `i^th` local identifier, `denominators[i]` is set
+  /// could be found for the `i^th` local variable, `denominators[i]` is set
   /// to 0.
   void getLocalReprs(std::vector<SmallVector<int64_t, 8>> &dividends,
                      SmallVector<unsigned, 4> &denominators,
                      std::vector<MaybeLocalRepr> &repr) const;
   void getLocalReprs(std::vector<MaybeLocalRepr> &repr) const;
   void getLocalReprs(std::vector<SmallVector<int64_t, 8>> &dividends,
                      SmallVector<unsigned, 4> &denominators) const;
 
   /// The type of bound: equal, lower bound or upper bound.
   enum BoundType { EQ, LB, UB };
 
-  /// Adds a constant bound for the specified identifier.
+  /// Adds a constant bound for the specified variable.
   void addBound(BoundType type, unsigned pos, int64_t value);
 
   /// Adds a constant bound for the specified expression.
   void addBound(BoundType type, ArrayRef<int64_t> expr, int64_t value);
 
-  /// Adds a new local identifier as the floordiv of an affine function of other
-  /// identifiers, the coefficients of which are provided in `dividend` and with
+  /// Adds a new local variable as the floordiv of an affine function of other
+  /// variables, the coefficients of which are provided in `dividend` and with
   /// respect to a positive constant `divisor`. Two constraints are added to the
   /// system to capture equivalence with the floordiv:
   /// q = dividend floordiv c    <=>   c*q <= dividend <= c*q + c - 1.
   void addLocalFloorDiv(ArrayRef<int64_t> dividend, int64_t divisor);
 
-  /// Projects out (aka eliminates) `num` identifiers starting at position
+  /// Projects out (aka eliminates) `num` variables starting at position
   /// `pos`. The resulting constraint system is the shadow along the dimensions
   /// that still exist. This method may not always be integer exact.
   // TODO: deal with integer exactness when necessary - can return a value to
   // mark exactness for example.
   void projectOut(unsigned pos, unsigned num);
   inline void projectOut(unsigned pos) { return projectOut(pos, 1); }
 
-  /// Tries to fold the specified identifier to a constant using a trivial
+  /// Tries to fold the specified variable to a constant using a trivial
   /// equality detection; if successful, the constant is substituted for the
-  /// identifier everywhere in the constraint system and then removed from the
+  /// variable everywhere in the constraint system and then removed from the
   /// system.
-  LogicalResult constantFoldId(unsigned pos);
+  LogicalResult constantFoldVar(unsigned pos);
 
-  /// This method calls `constantFoldId` for the specified range of identifiers,
-  /// `num` identifiers starting at position `pos`.
-  void constantFoldIdRange(unsigned pos, unsigned num);
+  /// This method calls `constantFoldVar` for the specified range of variables,
+  /// `num` variables starting at position `pos`.
+  void constantFoldVarRange(unsigned pos, unsigned num);
 
   /// Updates the constraints to be the smallest bounding (enclosing) box that
   /// contains the points of `this` set and that of `other`, with the symbols
   /// being treated specially. For each of the dimensions, the min of the lower
   /// bounds (symbolic) and the max of the upper bounds (symbolic) is computed
   /// to determine such a bounding box. `other` is expected to have the same
-  /// dimensional identifiers as this constraint system (in the same order).
+  /// dimensional variables as this constraint system (in the same order).
   ///
   /// E.g.:
   /// 1) this   = {0 <= d0 <= 127},
   ///    other  = {16 <= d0 <= 192},
   ///    output = {0 <= d0 <= 192}
   /// 2) this   = {s0 + 5 <= d0 <= s0 + 20},
   ///    other  = {s0 + 1 <= d0 <= s0 + 9},
   ///    output = {s0 + 1 <= d0 <= s0 + 20}
   /// 3) this   = {0 <= d0 <= 5, 1 <= d1 <= 9}
   ///    other  = {2 <= d0 <= 6, 5 <= d1 <= 15},
   ///    output = {0 <= d0 <= 6, 1 <= d1 <= 15}
   LogicalResult unionBoundingBox(const IntegerRelation &other);
 
   /// Returns the smallest known constant bound for the extent of the specified
-  /// identifier (pos^th), i.e., the smallest known constant that is greater
+  /// variable (pos^th), i.e., the smallest known constant that is greater
   /// than or equal to 'exclusive upper bound' - 'lower bound' of the
-  /// identifier. This constant bound is guaranteed to be non-negative. Returns
+  /// variable. This constant bound is guaranteed to be non-negative. Returns
   /// None if it's not a constant. This method employs trivial (low complexity /
-  /// cost) checks and detection. Symbolic identifiers are treated specially,
+  /// cost) checks and detection. Symbolic variables are treated specially,
   /// i.e., it looks for constant differences between affine expressions
-  /// involving only the symbolic identifiers. `lb` and `ub` (along with the
+  /// involving only the symbolic variables. `lb` and `ub` (along with the
   /// `boundFloorDivisor`) are set to represent the lower and upper bound
   /// associated with the constant difference: `lb`, `ub` have the coefficients,
   /// and `boundFloorDivisor`, their divisor. `minLbPos` and `minUbPos` if
   /// non-null are set to the position of the constant lower bound and upper
   /// bound respectively (to the same if they are from an equality). Ex: if the
   /// lower bound is [(s0 + s2 - 1) floordiv 32] for a system with three
-  /// symbolic identifiers, *lb = [1, 0, 1], lbDivisor = 32. See comments at
+  /// symbolic variables, *lb = [1, 0, 1], lbDivisor = 32. See comments at
   /// function definition for examples.
   Optional<int64_t> getConstantBoundOnDimSize(
       unsigned pos, SmallVectorImpl<int64_t> *lb = nullptr,
       int64_t *boundFloorDivisor = nullptr,
       SmallVectorImpl<int64_t> *ub = nullptr, unsigned *minLbPos = nullptr,
       unsigned *minUbPos = nullptr) const;
 
-  /// Returns the constant bound for the pos^th identifier if there is one;
+  /// Returns the constant bound for the pos^th variable if there is one;
   /// None otherwise.
   Optional<int64_t> getConstantBound(BoundType type, unsigned pos) const;
 
   /// Removes constraints that are independent of (i.e., do not have a
-  /// coefficient) identifiers in the range [pos, pos + num).
+  /// coefficient) variables in the range [pos, pos + num).
   void removeIndependentConstraints(unsigned pos, unsigned num);
 
   /// Returns true if the set can be trivially detected as being
-  /// hyper-rectangular on the specified contiguous set of identifiers.
+  /// hyper-rectangular on the specified contiguous set of variables.
   bool isHyperRectangular(unsigned pos, unsigned num) const;
 
   /// Removes duplicate constraints, trivially true constraints, and constraints
   /// that can be detected as redundant as a result of differing only in their
   /// constant term part. A constraint of the form <non-negative constant> >= 0
   /// is considered trivially true. This method is a linear time method on the
   /// constraints, does a single scan, and updates in place. It also normalizes
   /// constraints by their GCD and performs GCD tightening on inequalities.
   void removeTrivialRedundancy();
 
   /// A more expensive check than `removeTrivialRedundancy` to detect redundant
   /// inequalities.
   void removeRedundantInequalities();
 
   /// Removes redundant constraints using Simplex. Although the algorithm can
   /// theoretically take exponential time in the worst case (rare), it is known
   /// to perform much better in the average case. If V is the number of vertices
   /// in the polytope and C is the number of constraints, the algorithm takes
   /// O(VC) time.
   void removeRedundantConstraints();
 
   void removeDuplicateDivs();
 
-  /// Converts identifiers of kind srcKind in the range [idStart, idLimit) to
+  /// Converts variables of kind srcKind in the range [varStart, varLimit) to
   /// variables of kind dstKind. If `pos` is given, the variables are placed at
   /// position `pos` of dstKind, otherwise they are placed after all the other
   /// variables of kind dstKind. The internal ordering among the moved variables
   /// is preserved.
-  void convertIdKind(IdKind srcKind, unsigned idStart, unsigned idLimit,
-                     IdKind dstKind, unsigned pos);
-  void convertIdKind(IdKind srcKind, unsigned idStart, unsigned idLimit,
-                     IdKind dstKind) {
-    convertIdKind(srcKind, idStart, idLimit, dstKind, getNumIdKind(dstKind));
+  void covertVarKind(VarKind srcKind, unsigned varStart, unsigned varLimit,
+                     VarKind dstKind, unsigned pos);
+  void convertVarKind(VarKind srcKind, unsigned varStart, unsigned varLimit,
+                      VarKind dstKind) {
+    covertVarKind(srcKind, varStart, varLimit, dstKind, getNumVarKind(dstKind));
   }
-  void convertToLocal(IdKind kind, unsigned idStart, unsigned idLimit) {
-    convertIdKind(kind, idStart, idLimit, IdKind::Local);
+  void convertToLocal(VarKind kind, unsigned varStart, unsigned varLimit) {
+    convertVarKind(kind, varStart, varLimit, VarKind::Local);
   }
 
-  /// Adds additional local ids to the sets such that they both have the union
-  /// of the local ids in each set, without changing the set of points that
+  /// Adds additional local vars to the sets such that they both have the union
+  /// of the local vars in each set, without changing the set of points that
   /// lie in `this` and `other`.
   ///
-  /// While taking union, if a local id in `other` has a division representation
-  /// which is a duplicate of division representation, of another local id, it
-  /// is not added to the final union of local ids and is instead merged. The
-  /// new ordering of local ids is:
+  /// While taking union, if a local var in `other` has a division
+  /// representation which is a duplicate of division representation, of another
+  /// local var, it is not added to the final union of local vars and is instead
+  /// merged. The new ordering of local vars is:
   ///
-  /// [Local ids of `this`] [Non-merged local ids of `other`]
+  /// [Local vars of `this`] [Non-merged local vars of `other`]
   ///
-  /// The relative ordering of local ids is same as before.
+  /// The relative ordering of local vars is same as before.
   ///
   /// After merging, if the `i^th` local variable in one set has a known
   /// division representation, then the `i^th` local variable in the other set
   /// either has the same division representation or no known division
   /// representation.
   ///
   /// The spaces of both relations should be compatible.
   ///
-  /// Returns the number of non-merged local ids of `other`, i.e. the number of
+  /// Returns the number of non-merged local vars of `other`, i.e. the number of
   /// locals that have been added to `this`.
-  unsigned mergeLocalIds(IntegerRelation &other);
+  unsigned mergeLocalVars(IntegerRelation &other);
 
   /// Check whether all local ids have a division representation.
   bool hasOnlyDivLocals() const;
 
   /// Changes the partition between dimensions and symbols. Depending on the new
-  /// symbol count, either a chunk of dimensional identifiers immediately before
+  /// symbol count, either a chunk of dimensional variables immediately before
   /// the split become symbols, or some of the symbols immediately after the
   /// split become dimensions.
   void setDimSymbolSeparation(unsigned newSymbolCount) {
-    space.setDimSymbolSeparation(newSymbolCount);
+    space.setVarSymbolSeperation(newSymbolCount);
   }
 
   /// Return a set corresponding to all points in the domain of the relation.
   IntegerPolyhedron getDomainSet() const;
 
   /// Return a set corresponding to all points in the range of the relation.
   IntegerPolyhedron getRangeSet() const;
 
protected:
   /// false otherwise.
   bool hasInvalidConstraint() const;
 
   /// Returns the constant lower bound bound if isLower is true, and the upper
   /// bound if isLower is false.
   template <bool isLower>
   Optional<int64_t> computeConstantLowerOrUpperBound(unsigned pos);
 
-  /// Eliminates a single identifier at `position` from equality and inequality
-  /// constraints. Returns `success` if the identifier was eliminated, and
+  /// Eliminates a single variable at `position` from equality and inequality
+  /// constraints. Returns `success` if the variable was eliminated, and
   /// `failure` otherwise.
-  inline LogicalResult gaussianEliminateId(unsigned position) {
-    return success(gaussianEliminateIds(position, position + 1) == 1);
+  inline LogicalResult gaussianEliminateVar(unsigned position) {
+    return success(gaussianEliminateVars(position, position + 1) == 1);
   }
 
   /// Removes local variables using equalities. Each equality is checked if it
   /// can be reduced to the form: `e = affine-expr`, where `e` is a local
   /// variable and `affine-expr` is an affine expression not containing `e`.
   /// If an equality satisfies this form, the local variable is replaced in
   /// each constraint and then removed. The equality used to replace this local
   /// variable is also removed.
   void removeRedundantLocalVars();
 
-  /// Eliminates identifiers from equality and inequality constraints
+  /// Eliminates variables from equality and inequality constraints
   /// in column range [posStart, posLimit).
   /// Returns the number of variables eliminated.
-  unsigned gaussianEliminateIds(unsigned posStart, unsigned posLimit);
+  unsigned gaussianEliminateVars(unsigned posStart, unsigned posLimit);
 
-  /// Eliminates the identifier at the specified position using Fourier-Motzkin
+  /// Eliminates the variable at the specified position using Fourier-Motzkin
   /// variable elimination, but uses Gaussian elimination if there is an
-  /// equality involving that identifier. If the result of the elimination is
+  /// equality involving that variable. If the result of the elimination is
   /// integer exact, `*isResultIntegerExact` is set to true. If `darkShadow` is
   /// set to true, a potential under approximation (subset) of the rational
   /// shadow / exact integer shadow is computed.
   // See implementation comments for more details.
   virtual void fourierMotzkinEliminate(unsigned pos, bool darkShadow = false,
                                        bool *isResultIntegerExact = nullptr);
 
   /// Tightens inequalities given that we are dealing with integer spaces. This
protected:
   /// Returns true and sets row found in search in `rowIdx`, false otherwise.
   bool findConstraintWithNonZeroAt(unsigned colIdx, bool isEq,
                                    unsigned *rowIdx) const;
 
   /// Returns true if the pos^th column is all zero for both inequalities and
   /// equalities.
   bool isColZero(unsigned pos) const;
 
-  /// Returns false if the fields corresponding to various identifier counts, or
+  /// Returns false if the fields corresponding to various variable counts, or
   /// equality/inequality buffer sizes aren't consistent; true otherwise. This
   /// is meant to be used within an assert internally.
   virtual bool hasConsistentState() const;
 
   /// Prints the number of constraints, dimensions, symbols and locals in the
   /// IntegerRelation.
   virtual void printSpace(raw_ostream &os) const;
 
-  /// Removes identifiers in the column range [idStart, idLimit), and copies any
+  /// Removes variables in the column range [varStart, varLimit), and copies any
   /// remaining valid data into place, updates member variables, and resizes
   /// arrays as needed.
-  void removeIdRange(unsigned idStart, unsigned idLimit);
+  void removeVarRange(unsigned varStart, unsigned varLimit);
 
-  /// Truncate the ids of the specified kind to the specified number by dropping
-  /// some ids at the end. `num` must be less than the current number.
-  void truncateIdKind(IdKind kind, unsigned num);
+  /// Truncate the vars of the specified kind to the specified number by
+  /// dropping some vars at the end. `num` must be less than the current number.
+  void truncateVarKind(VarKind kind, unsigned num);
 
-  /// Truncate the ids to the number in the space of the specified
+  /// Truncate the vars to the number in the space of the specified
   /// CountsSnapshot.
-  void truncateIdKind(IdKind kind, const CountsSnapshot &counts);
+  void truncateVarKind(VarKind kind, const CountsSnapshot &counts);
 
   /// A parameter that controls detection of an unrealistic number of
   /// constraints. If the number of constraints is this many times the number of
   /// variables, we consider such a system out of line with the intended use
   /// case of IntegerRelation.
   // The rationale for 32 is that in the typical simplest of cases, an
-  // identifier is expected to have one lower bound and one upper bound
-  // constraint. With a level of tiling or a connection to another identifier
+  // variable is expected to have one lower bound and one upper bound
+  // constraint. With a level of tiling or a connection to another variable
   // through a div or mod, an extra pair of bounds gets added. As a limit, we
-  // don't expect an identifier to have more than 32 lower/upper/equality
+  // don't expect a variable to have more than 32 lower/upper/equality
   // constraints. This is conservatively set low and can be raised if needed.
   constexpr static unsigned kExplosionFactor = 32;
 
   PresburgerSpace space;
 
   /// Coefficients of affine equalities (in == 0 form).
   Matrix equalities;
 
   /// Coefficients of affine inequalities (in >= 0 form).
   Matrix inequalities;
 };
 
 struct SymbolicLexMin;
 
 /// An IntegerPolyhedron represents the set of points from a PresburgerSpace
 /// that satisfy a list of affine constraints. Affine constraints can be
 /// inequalities or equalities in the form:
 ///
 /// Inequality: c_0*x_0 + c_1*x_1 + .... + c_{n-1}*x_{n-1} + c_n >= 0
 /// Equality  : c_0*x_0 + c_1*x_1 + .... + c_{n-1}*x_{n-1} + c_n == 0
 ///
 /// where c_0, c_1, ..., c_n are integers and n is the total number of
-/// identifiers in the space.
+/// variables in the space.
 ///
 /// An IntegerPolyhedron is similar to an IntegerRelation but it does not make a
-/// distinction between Domain and Range identifiers. Internally,
-/// IntegerPolyhedron is implemented as a IntegerRelation with zero domain ids.
+/// distinction between Domain and Range variables. Internally,
+/// IntegerPolyhedron is implemented as a IntegerRelation with zero domain vars.
 ///
 /// Since IntegerPolyhedron does not make a distinction between kinds of
-/// dimensions, IdKind::SetDim should be used to refer to dimension identifiers.
+/// dimensions, VarKind::SetDim should be used to refer to dimension
+/// variables.
 class IntegerPolyhedron : public IntegerRelation {
 public:
   /// Constructs a set reserving memory for the specified number
-  /// of constraints and identifiers.
+  /// of constraints and variables.
   IntegerPolyhedron(unsigned numReservedInequalities,
                     unsigned numReservedEqualities, unsigned numReservedCols,
                     const PresburgerSpace &space)
       : IntegerRelation(numReservedInequalities, numReservedEqualities,
                         numReservedCols, space) {
-    assert(space.getNumDomainIds() == 0 &&
-           "Number of domain id's should be zero in Set kind space.");
+    assert(space.getNumDomainVars() == 0 &&
+           "Number of domain vars should be zero in Set kind space.");
   }
 
   /// Constructs a relation with the specified number of dimensions and
   /// symbols.
   explicit IntegerPolyhedron(const PresburgerSpace &space)
       : IntegerPolyhedron(/*numReservedInequalities=*/0,
                           /*numReservedEqualities=*/0,
-                          /*numReservedCols=*/space.getNumIds() + 1, space) {}
+                          /*numReservedCols=*/space.getNumVars() + 1, space) {}
 
   /// Construct a set from an IntegerRelation. The relation should have
-  /// no domain ids.
+  /// no domain vars.
   explicit IntegerPolyhedron(const IntegerRelation &rel)
       : IntegerRelation(rel) {
-    assert(space.getNumDomainIds() == 0 &&
-           "Number of domain id's should be zero in Set kind space.");
+    assert(space.getNumDomainVars() == 0 &&
+           "Number of domain vars should be zero in Set kind space.");
   }
 
   /// Construct a set from an IntegerRelation, but instead of creating a copy,
-  /// use move constructor. The relation should have no domain ids.
+  /// use move constructor. The relation should have no domain vars.
   explicit IntegerPolyhedron(IntegerRelation &&rel) : IntegerRelation(rel) {
-    assert(space.getNumDomainIds() == 0 &&
-           "Number of domain id's should be zero in Set kind space.");
+    assert(space.getNumDomainVars() == 0 &&
+           "Number of domain vars should be zero in Set kind space.");
   }
 
   /// Return a system with no constraints, i.e., one which is satisfied by all
   /// points.
   static IntegerPolyhedron getUniverse(const PresburgerSpace &space) {
     return IntegerPolyhedron(space);
   }
 
   /// Return the kind of this IntegerRelation.
   Kind getKind() const override { return Kind::IntegerPolyhedron; }
 
   static bool classof(const IntegerRelation *cst) {
     return cst->getKind() == Kind::IntegerPolyhedron;
   }
 
   // Clones this object.
   std::unique_ptr<IntegerPolyhedron> clone() const;
 
-  /// Insert `num` identifiers of the specified kind at position `pos`.
-  /// Positions are relative to the kind of identifier. Return the absolute
-  /// column position (i.e., not relative to the kind of identifier) of the
-  /// first added identifier.
-  unsigned insertId(IdKind kind, unsigned pos, unsigned num = 1) override;
+  /// Insert `num` variables of the specified kind at position `pos`.
+  /// Positions are relative to the kind of variable. Return the absolute
+  /// column position (i.e., not relative to the kind of variable) of the
+  /// first added variable.
+  unsigned insertVar(VarKind kind, unsigned pos, unsigned num = 1) override;
 
   /// Compute an equivalent representation of the same set, such that all local
   /// ids have division representations. This representation may involve
   /// local ids that correspond to divisions, and may also be a union of convex
   /// disjuncts.
   PresburgerSet computeReprWithOnlyDivLocals() const;
 
   /// Compute the symbolic integer lexmin of the polyhedron.

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

 //===- PWMAFunction.h - MLIR PWMAFunction Class------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Support for piece-wise multi-affine functions. These are functions that are
 // defined on a domain that is a union of IntegerPolyhedrons, and on each domain
 // the value of the function is a tuple of integers, with each value in the
-// tuple being an affine expression in the ids of the IntegerPolyhedron.
+// tuple being an affine expression in the vars of the IntegerPolyhedron.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H
 #define MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H
 
 #include "mlir/Analysis/Presburger/IntegerRelation.h"
 #include "mlir/Analysis/Presburger/PresburgerRelation.h"
 
 namespace mlir {
 namespace presburger {
 
 /// This class represents a multi-affine function whose domain is given by an
 /// IntegerPolyhedron. This can be thought of as an IntegerPolyhedron with a
 /// tuple of integer values attached to every point in the polyhedron, with the
-/// value of each element of the tuple given by an affine expression in the ids
+/// value of each element of the tuple given by an affine expression in the vars
 /// of the polyhedron. For example we could have the domain
 ///
 /// (x, y) : (x >= 5, y >= x)
 ///
 /// and a tuple of three integers defined at every point in the polyhedron:
 ///
 /// (x, y) -> (x + 2, 2*x - 3y + 5, 2*x + y).
 ///
 /// In this way every point in the polyhedron has a tuple of integers associated
-/// with it. If the integer polyhedron has local ids, then the output
+/// with it. If the integer polyhedron has local vars, then the output
 /// expressions can use them as well. The output expressions are represented as
 /// a matrix with one row for every element in the output vector one column for
-/// each id, and an extra column at the end for the constant term.
+/// each var, and an extra column at the end for the constant term.
 ///
 /// Checking equality of two such functions is supported, as well as finding the
 /// value of the function at a specified point.
 class MultiAffineFunction {
 public:
   MultiAffineFunction(const IntegerPolyhedron &domain, const Matrix &output)
       : domainSet(domain), output(output) {}
   MultiAffineFunction(const Matrix &output, const PresburgerSpace &space)
       : domainSet(space), output(output) {}
 
-  unsigned getNumInputs() const { return domainSet.getNumDimAndSymbolIds(); }
+  unsigned getNumInputs() const { return domainSet.getNumDimAndSymbolVars(); }
   unsigned getNumOutputs() const { return output.getNumRows(); }
   bool isConsistent() const {
-    return output.getNumColumns() == domainSet.getNumIds() + 1;
+    return output.getNumColumns() == domainSet.getNumVars() + 1;
   }
   const IntegerPolyhedron &getDomain() const { return domainSet; }
   const PresburgerSpace &getDomainSpace() const { return domainSet.getSpace(); }
 
-  /// Insert `num` identifiers of the specified kind at position `pos`.
-  /// Positions are relative to the kind of identifier. The coefficient columns
-  /// corresponding to the added identifiers are initialized to zero. Return the
-  /// absolute column position (i.e., not relative to the kind of identifier)
-  /// of the first added identifier.
-  unsigned insertId(IdKind kind, unsigned pos, unsigned num = 1);
+  /// Insert `num` variables of the specified kind at position `pos`.
+  /// Positions are relative to the kind of variable. The coefficient columns
+  /// corresponding to the added variables are initialized to zero. Return the
+  /// absolute column position (i.e., not relative to the kind of variable)
+  /// of the first added variable.
+  unsigned insertVar(VarKind kind, unsigned pos, unsigned num = 1);
 
-  /// Remove the specified range of ids.
-  void removeIdRange(IdKind kind, unsigned idStart, unsigned idLimit);
+  /// Remove the specified range of vars.
+  void removeVarRange(VarKind kind, unsigned varStart, unsigned varLimit);
 
-  /// Given a MAF `other`, merges local identifiers such that both funcitons
-  /// have union of local ids, without changing the set of points in domain or
+  /// Given a MAF `other`, merges local variables such that both funcitons
+  /// have union of local vars, without changing the set of points in domain or
   /// the output.
-  void mergeLocalIds(MultiAffineFunction &other);
+  void mergeLocalVars(MultiAffineFunction &other);
 
   /// Return whether the outputs of `this` and `other` agree wherever both
   /// functions are defined, i.e., the outputs should be equal for all points in
   /// the intersection of the domains.
   bool isEqualWhereDomainsOverlap(MultiAffineFunction other) const;
 
   /// Return whether the `this` and `other` are equal. This is the case if
   /// they lie in the same space, i.e. have the same dimensions, and their
   /// domains are identical and their outputs are equal on their domain.
   bool isEqual(const MultiAffineFunction &other) const;
 
   /// Get the value of the function at the specified point. If the point lies
   /// outside the domain, an empty optional is returned.
   Optional<SmallVector<int64_t, 8>> valueAt(ArrayRef<int64_t> point) const;
 
   /// Truncate the output dimensions to the first `count` dimensions.
   ///
-  /// TODO: refactor so that this can be accomplished through removeIdRange.
+  /// TODO: refactor so that this can be accomplished through removeVarRange.
   void truncateOutput(unsigned count);
 
   void print(raw_ostream &os) const;
   void dump() const;
 
 private:
   /// The IntegerPolyhedron representing the domain over which the function is
   /// defined.

 /// f(x, y) = (2*x + y, y - 4)  if x >= 0, y >= 0
 ///         = (-2*x + y, y + 4) if x < 0,  y < 0
 ///         = (4, 1)            if x < 0,  y >= 0
 ///
 /// Note that the domains all have to be *disjoint*. Otherwise, the behaviour of
 /// 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.
+/// As in PresburgerSets, the input vars are partitioned into dimension vars and
+/// symbolic vars.
 ///
 /// 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:
   PWMAFunction(const PresburgerSpace &space, unsigned numOutputs)
       : space(space), numOutputs(numOutputs) {
-    assert(space.getNumDomainIds() == 0 &&
-           "Set type space should have zero domain ids.");
-    assert(space.getNumLocalIds() == 0 &&
-           "PWMAFunction cannot have local ids.");
+    assert(space.getNumDomainVars() == 0 &&
+           "Set type space should have zero domain vars.");
+    assert(space.getNumLocalVars() == 0 &&
+           "PWMAFunction cannot have local vars.");
     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 space.getNumIds(); }
+  unsigned getNumInputs() const { return space.getNumVars(); }
   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;
 
   /// Truncate the output dimensions to the first `count` dimensions.
   ///
-  /// TODO: refactor so that this can be accomplished through removeIdRange.
+  /// TODO: refactor so that this can be accomplished through removeVarRange.
   void truncateOutput(unsigned count);
 
   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.
+  /// The number of output vars.
   unsigned numOutputs;
 };
 
 } // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H

mlir/include/mlir/Analysis/Presburger/PresburgerRelation.h

public:
   /// Return a universe set of the specified type that contains all points.
   static PresburgerRelation getUniverse(const PresburgerSpace &space);
 
   /// Return an empty set of the specified type that contains no points.
   static PresburgerRelation getEmpty(const PresburgerSpace &space);
 
   explicit PresburgerRelation(const IntegerRelation &disjunct);
 
-  unsigned getNumDomainIds() const { return space.getNumDomainIds(); }
-  unsigned getNumRangeIds() const { return space.getNumRangeIds(); }
-  unsigned getNumSymbolIds() const { return space.getNumSymbolIds(); }
-  unsigned getNumLocalIds() const { return space.getNumLocalIds(); }
-  unsigned getNumIds() const { return space.getNumIds(); }
+  unsigned getNumDomainVars() const { return space.getNumDomainVars(); }
+  unsigned getNumRangeVars() const { return space.getNumRangeVars(); }
+  unsigned getNumSymbolVars() const { return space.getNumSymbolVars(); }
+  unsigned getNumLocalVars() const { return space.getNumLocalVars(); }
+  unsigned getNumVars() const { return space.getNumVars(); }
 
   /// Return the number of disjuncts in the union.
   unsigned getNumDisjuncts() const;
 
   const PresburgerSpace &getSpace() const { return space; }
 
   /// Set the space to `oSpace`. `oSpace` should not contain any local ids.
   /// `oSpace` need not have the same number of ids as the current space;
public:
   /// false otherwise.
   bool isIntegerEmpty() const;
 
   /// Find an integer sample from the given set. This should not be called if
   /// any of the disjuncts in the union are unbounded.
   bool findIntegerSample(SmallVectorImpl<int64_t> &sample);
 
   /// Compute an overapproximation of the number of integer points in the
-  /// disjunct. Symbol ids are currently not supported. If the computed
+  /// disjunct. Symbol vars are currently not supported. If the computed
   /// overapproximation is infinite, an empty optional is returned.
   ///
   /// This currently just sums up the overapproximations of the volumes of the
   /// disjuncts, so the approximation might be far from the true volume in the
   /// case when there is a lot of overlap between disjuncts.
   Optional<uint64_t> computeVolume() const;
 
   /// Simplifies the representation of a PresburgerRelation.
   ///
   /// In particular, removes all disjuncts which are subsets of other
   /// disjuncts in the union.
   PresburgerRelation coalesce() const;
 
   /// Check whether all local ids in all disjuncts have a div representation.
   bool hasOnlyDivLocals() const;
 
   /// Print the set's internal state.
   void print(raw_ostream &os) const;
   void dump() const;
 
 protected:
   /// Construct an empty PresburgerRelation with the specified number of
   /// dimension and symbols.
   explicit PresburgerRelation(const PresburgerSpace &space) : space(space) {
-    assert(space.getNumLocalIds() == 0 &&
-           "PresburgerRelation cannot have local ids.");
+    assert(space.getNumLocalVars() == 0 &&
+           "PresburgerRelation cannot have local vars.");
   }
 
   PresburgerSpace space;
 
   /// The list of disjuncts that this set is the union of.
   SmallVector<IntegerRelation, 2> disjuncts;
 
   friend class SetCoalescer;
public:
   PresburgerSet subtract(const PresburgerRelation &set) const;
   PresburgerSet coalesce() const;
 
 protected:
   /// Construct an empty PresburgerRelation with the specified number of
   /// dimension and symbols.
   explicit PresburgerSet(const PresburgerSpace &space)
       : PresburgerRelation(space) {
-    assert(space.getNumDomainIds() == 0 && "Set type cannot have domain ids.");
-    assert(space.getNumLocalIds() == 0 &&
-           "PresburgerRelation cannot have local ids.");
+    assert(space.getNumDomainVars() == 0 &&
+           "Set type cannot have domain vars.");
+    assert(space.getNumLocalVars() == 0 &&
+           "PresburgerRelation cannot have local vars.");
   }
 };
 
 } // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PRESBURGERRELATION_H

mlir/include/mlir/Analysis/Presburger/PresburgerSpace.h

 //===- PresburgerSpace.h - MLIR PresburgerSpace Class -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Classes representing space information like number of identifiers and kind of
-// identifiers.
+// Classes representing space information like number of variables and kind of
+// variables.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_PRESBURGERSPACE_H
 #define MLIR_ANALYSIS_PRESBURGER_PRESBURGERSPACE_H
 
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 namespace presburger {
 
-/// Kind of identifier. Implementation wise SetDims are treated as Range
-/// ids, and spaces with no distinction between dimension ids are treated
-/// as relations with zero domain ids.
-enum class IdKind { Symbol, Local, Domain, Range, SetDim = Range };
+/// Kind of variable. Implementation wise SetDims are treated as Range
+/// vars, and spaces with no distinction between dimension vars are treated
+/// as relations with zero domain vars.
+enum class VarKind { Symbol, Local, Domain, Range, SetDim = Range };
 
 /// PresburgerSpace is the space of all possible values of a tuple of integer
-/// valued variables/identifiers. Each identifier has one of the three types:
+/// valued variables/variables. Each variable has one of the three types:
 ///
 /// Dimension: Ordinary variables over which the space is represented.
 ///
-/// Symbol: Symbol identifiers correspond to fixed but unknown values.
-/// Mathematically, a space with symbolic identifiers is like a
-/// family of spaces indexed by the symbolic identifiers.
+/// Symbol: Symbol variables correspond to fixed but unknown values.
+/// Mathematically, a space with symbolic variables is like a
+/// family of spaces indexed by the symbolic variables.
 ///
-/// Local: Local identifiers correspond to existentially quantified variables.
+/// Local: Local variables correspond to existentially quantified variables.
 /// For example, consider the space: `(x, exists q)` where x is a dimension
-/// identifier and q is a local identifier. Let us put the constraints:
+/// variable and q is a local variable. Let us put the constraints:
 ///       `1 <= x <= 7, x = 2q`
 /// on this space to get the set:
 ///       `(x) : (exists q : q <= x <= 7, x = 2q)`.
 /// An assignment to symbolic and dimension variables is valid if there
 /// exists some assignment to the local variable `q` satisfying these
 /// constraints. For this example, the set is equivalent to {2, 4, 6}.
 /// Mathematically, existential quantification can be thought of as the result
 /// of projection. In this example, `q` is existentially quantified. This can be
 /// thought of as the result of projecting out `q` from the previous example,
 /// i.e. we obtained {2, 4, 6} by projecting out the second dimension from
 /// {(2, 1), (4, 2), (6, 2)}.
 ///
-/// Dimension identifiers are further divided into Domain and Range identifiers
+/// Dimension variables are further divided into Domain and Range variables
 /// to support building relations.
 ///
-/// Identifiers are stored in the following order:
+/// Variables are stored in the following order:
 ///       [Domain, Range, Symbols, Locals]
 ///
-/// A space with no distinction between types of dimension identifiers can
-/// be implemented as a space with zero domain. IdKind::SetDim should be used
+/// A space with no distinction between types of dimension variables can
+/// be implemented as a space with zero domain. VarKind::SetDim should be used
 /// to refer to dimensions in such spaces.
 ///
-/// Compatibility of two spaces implies that number of identifiers of each kind
+/// Compatibility of two spaces implies that number of variables of each kind
 /// other than Locals are equal. Equality of two spaces implies that number of
-/// identifiers of each kind are equal.
+/// variables of each kind are equal.
 ///
 /// PresburgerSpace optionally also supports attaching attachments to each
 /// variable in space. `resetAttachments<AttachmentType>` enables attaching
 /// attachments to space. All attachments must be of the same type,
 /// `AttachmentType`. `AttachmentType` must have a
 /// `llvm::PointerLikeTypeTraits` specialization available and should be
 /// supported via mlir::TypeID.
 ///
public:
 
   static PresburgerSpace getSetSpace(unsigned numDims = 0,
                                      unsigned numSymbols = 0,
                                      unsigned numLocals = 0) {
     return PresburgerSpace(/*numDomain=*/0, /*numRange=*/numDims, numSymbols,
                            numLocals);
   }
 
-  unsigned getNumDomainIds() const { return numDomain; }
-  unsigned getNumRangeIds() const { return numRange; }
-  unsigned getNumSetDimIds() const { return numRange; }
-  unsigned getNumSymbolIds() const { return numSymbols; }
-  unsigned getNumLocalIds() const { return numLocals; }
+  unsigned getNumDomainVars() const { return numDomain; }
+  unsigned getNumRangeVars() const { return numRange; }
+  unsigned getNumSetDimVars() const { return numRange; }
+  unsigned getNumSymbolVars() const { return numSymbols; }
+  unsigned getNumLocalVars() const { return numLocals; }
 
-  unsigned getNumDimIds() const { return numDomain + numRange; }
-  unsigned getNumDimAndSymbolIds() const {
+  unsigned getNumDimVars() const { return numDomain + numRange; }
+  unsigned getNumDimAndSymbolVars() const {
     return numDomain + numRange + numSymbols;
   }
-  unsigned getNumIds() const {
+  unsigned getNumVars() const {
     return numDomain + numRange + numSymbols + numLocals;
   }
 
-  /// Get the number of ids of the specified kind.
-  unsigned getNumIdKind(IdKind kind) const;
+  /// Get the number of vars of the specified kind.
+  unsigned getNumVarKind(VarKind kind) const;
 
-  /// Return the index at which the specified kind of id starts.
-  unsigned getIdKindOffset(IdKind kind) const;
+  /// Return the index at which the specified kind of var starts.
+  unsigned getVarKindOffset(VarKind kind) const;
 
-  /// Return the index at Which the specified kind of id ends.
-  unsigned getIdKindEnd(IdKind kind) const;
+  /// Return the index at Which the specified kind of var ends.
+  unsigned getVarKindEnd(VarKind kind) const;
 
   /// Get the number of elements of the specified kind in the range
-  /// [idStart, idLimit).
-  unsigned getIdKindOverlap(IdKind kind, unsigned idStart,
-                            unsigned idLimit) const;
-
-  /// Return the IdKind of the id at the specified position.
-  IdKind getIdKindAt(unsigned pos) const;
-
-  /// Insert `num` identifiers of the specified kind at position `pos`.
-  /// Positions are relative to the kind of identifier. Return the absolute
-  /// column position (i.e., not relative to the kind of identifier) of the
-  /// first added identifier.
+  /// [varStart, varLimit).
+  unsigned getVarKindOverlap(VarKind kind, unsigned varStart,
+                             unsigned varLimit) const;
+
+  /// Return the VarKind of the var at the specified position.
+  VarKind getVarKindAt(unsigned pos) const;
+
+  /// Insert `num` variables of the specified kind at position `pos`.
+  /// Positions are relative to the kind of variable. Return the absolute
+  /// column position (i.e., not relative to the kind of variable) of the
+  /// first added variable.
   ///
   /// If attachments are being used, the newly added variables have no
   /// attachments.
-  unsigned insertId(IdKind kind, unsigned pos, unsigned num = 1);
+  unsigned insertVar(VarKind kind, unsigned pos, unsigned num = 1);
 
-  /// Removes identifiers of the specified kind in the column range [idStart,
-  /// idLimit). The range is relative to the kind of identifier.
-  void removeIdRange(IdKind kind, unsigned idStart, unsigned idLimit);
+  /// Removes variables of the specified kind in the column range [varStart,
+  /// varLimit). The range is relative to the kind of variable.
+  void removeVarRange(VarKind kind, unsigned varStart, unsigned varLimit);
 
   /// Swaps the posA^th variable of kindA and posB^th variable of kindB.
-  void swapId(IdKind kindA, IdKind kindB, unsigned posA, unsigned posB);
+  void swapVar(VarKind kindA, VarKind kindB, unsigned posA, unsigned posB);
 
   /// Returns true if both the spaces are compatible i.e. if both spaces have
-  /// the same number of identifiers of each kind (excluding locals).
+  /// the same number of variables of each kind (excluding locals).
   bool isCompatible(const PresburgerSpace &other) const;
 
-  /// Returns true if both the spaces are equal including local identifiers i.e.
-  /// if both spaces have the same number of identifiers of each kind (including
+  /// Returns true if both the spaces are equal including local variables i.e.
+  /// if both spaces have the same number of variables of each kind (including
   /// locals).
   bool isEqual(const PresburgerSpace &other) const;
 
   /// Changes the partition between dimensions and symbols. Depending on the new
-  /// symbol count, either a chunk of dimensional identifiers immediately before
+  /// symbol count, either a chunk of dimensional variables immediately before
   /// the split become symbols, or some of the symbols immediately after the
   /// split become dimensions.
-  void setDimSymbolSeparation(unsigned newSymbolCount);
+  void setVarSymbolSeperation(unsigned newSymbolCount);
 
   void print(llvm::raw_ostream &os) const;
   void dump() const;
 
   //===--------------------------------------------------------------------===//
   //     Attachment Interactions
   //===--------------------------------------------------------------------===//
 
   /// Set the attachment for `i^th` variable to `attachment`. `T` here should
   /// match the type used to enable attachments.
   template <typename T>
-  void setAttachment(IdKind kind, unsigned i, T attachment) {
+  void setAttachment(VarKind kind, unsigned i, T attachment) {
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(TypeID::get<T>() == attachmentType && "Type mismatch");
 #endif
     atAttachment(kind, i) =
         llvm::PointerLikeTypeTraits<T>::getAsVoidPointer(attachment);
   }
 
   /// Get the attachment for `i^th` variable casted to type `T`. `T` here
   /// should match the type used to enable attachments.
   template <typename T>
-  T getAttachment(IdKind kind, unsigned i) const {
+  T getAttachment(VarKind kind, unsigned i) const {
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(TypeID::get<T>() == attachmentType && "Type mismatch");
 #endif
     return llvm::PointerLikeTypeTraits<T>::getFromVoidPointer(
         atAttachment(kind, i));
   }
 
   /// Check if the i^th variable of the specified kind has a non-null
   /// attachment.
-  bool hasAttachment(IdKind kind, unsigned i) const {
+  bool hasAttachment(VarKind kind, unsigned i) const {
     return atAttachment(kind, i) != nullptr;
   }
 
   /// Check if the spaces are compatible, as well as have the same attachments
   /// for each variable.
   bool isAligned(const PresburgerSpace &other) const;
   /// Check if the number of variables of the specified kind match, and have
   /// same attachments with the other space.
-  bool isAligned(const PresburgerSpace &other, IdKind kind) const;
+  bool isAligned(const PresburgerSpace &other, VarKind kind) const;
 
   /// Find the variable of the specified kind with attachment `val`.
   /// PresburgerSpace::kIdNotFound if attachment is not found.
   template <typename T>
-  unsigned findId(IdKind kind, T val) const {
+  unsigned findId(VarKind kind, T val) const {
     unsigned i = 0;
-    for (unsigned e = getNumIdKind(kind); i < e; ++i)
+    for (unsigned e = getNumVarKind(kind); i < e; ++i)
       if (hasAttachment(kind, i) && getAttachment<T>(kind, i) == val)
         return i;
     return kIdNotFound;
   }
   static const unsigned kIdNotFound = UINT_MAX;
 
   /// Returns if attachments are being used.
   bool isUsingAttachments() const { return usingAttachments; }
 
   /// Reset the stored attachments in the space. Enables `usingAttachments` if
   /// it was `false` before.
   template <typename T>
   void resetAttachments() {
     attachments.clear();
-    attachments.resize(getNumDimAndSymbolIds());
+    attachments.resize(getNumDimAndSymbolVars());
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
     attachmentType = TypeID::get<T>();
 #endif
 
     usingAttachments = true;
   }
 
   /// Disable attachments being stored in space.
   void disableAttachments() {
     attachments.clear();
     usingAttachments = false;
   }
 
 protected:
   PresburgerSpace(unsigned numDomain = 0, unsigned numRange = 0,
                   unsigned numSymbols = 0, unsigned numLocals = 0)
       : numDomain(numDomain), numRange(numRange), numSymbols(numSymbols),
         numLocals(numLocals) {}
 
-  void *&atAttachment(IdKind kind, unsigned i) {
+  void *&atAttachment(VarKind kind, unsigned i) {
     assert(usingAttachments &&
            "Cannot access attachments when `usingAttachments` is false.");
-    assert(kind != IdKind::Local && "Local variables cannot have attachments.");
-    return attachments[getIdKindOffset(kind) + i];
+    assert(kind != VarKind::Local &&
+           "Local variables cannot have attachments.");
+    return attachments[getVarKindOffset(kind) + i];
   }
 
-  void *atAttachment(IdKind kind, unsigned i) const {
+  void *atAttachment(VarKind kind, unsigned i) const {
     assert(usingAttachments &&
            "Cannot access attachments when `usingAttachments` is false.");
-    assert(kind != IdKind::Local && "Local variables cannot have attachments.");
-    return attachments[getIdKindOffset(kind) + i];
+    assert(kind != VarKind::Local &&
+           "Local variables cannot have attachments.");
+    return attachments[getVarKindOffset(kind) + i];
   }
 
 private:
-  // Number of identifiers corresponding to domain identifiers.
+  // Number of variables corresponding to domain variables.
   unsigned numDomain;
 
-  // Number of identifiers corresponding to range identifiers.
+  // Number of variables corresponding to range variables.
   unsigned numRange;
 
-  /// Number of identifiers corresponding to symbols (unknown but constant for
+  /// Number of variables corresponding to symbols (unknown but constant for
   /// analysis).
   unsigned numSymbols;
 
-  /// Number of identifers corresponding to locals (identifiers corresponding
+  /// Number of variables corresponding to locals (variables corresponding
   /// to existentially quantified variables).
   unsigned numLocals;
 
   /// Stores whether or not attachments are being used in this space.
   bool usingAttachments = false;
 
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
   /// TypeID of the attachments in space. This should be used in asserts only.
   TypeID attachmentType;
 #endif
 
-  /// Stores a attachment for each non-local identifier as a `void` pointer.
+  /// Stores a attachment for each non-local variable as a `void` pointer.
   SmallVector<void *, 0> attachments;
 };
 
 } // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PRESBURGERSPACE_H

mlir/include/mlir/Analysis/Presburger/Simplex.h

public:
 
   /// Get a snapshot of the current state. This is used for rolling back.
   unsigned getSnapshot() { return SimplexBase::getSnapshotBasis(); }
 
 protected:
   LexSimplexBase(unsigned nVar, unsigned symbolOffset, unsigned nSymbol)
       : SimplexBase(nVar, /*mustUseBigM=*/true, symbolOffset, nSymbol) {}
   explicit LexSimplexBase(const IntegerRelation &constraints)
-      : LexSimplexBase(constraints.getNumIds(),
-                       constraints.getIdKindOffset(IdKind::Symbol),
-                       constraints.getNumSymbolIds()) {
+      : LexSimplexBase(constraints.getNumVars(),
+                       constraints.getVarKindOffset(VarKind::Symbol),
+                       constraints.getNumSymbolVars()) {
     intersectIntegerRelation(constraints);
   }
 
   /// Add new symbolic variables to the end of the list of variables.
   void appendSymbol();
 
   /// Try to move the specified row to column orientation while preserving the
   /// lexicopositivity of the basis transform. The row must have a non-positive

 /// A class for lexicographic optimization without any symbols. This also
 /// provides support for integer-exact redundancy and separateness checks.
 class LexSimplex : public LexSimplexBase {
 public:
   explicit LexSimplex(unsigned nVar)
       : LexSimplexBase(nVar, /*symbolOffset=*/0, /*nSymbol=*/0) {}
   explicit LexSimplex(const IntegerRelation &constraints)
       : LexSimplexBase(constraints) {
-    assert(constraints.getNumSymbolIds() == 0 &&
+    assert(constraints.getNumSymbolVars() == 0 &&
            "LexSimplex does not support symbols!");
   }
 
   /// Return the lexicographically minimum rational solution to the constraints.
   MaybeOptimum<SmallVector<Fraction, 8>> findRationalLexMin();
 
   /// Return the lexicographically minimum integer solution to the constraints.
   ///

 /// the pivot to be performed does depend on the value of the symbols. We
 /// handle this by splitting the symbol domain. We run the algorithm for the
 /// case where the row isn't violated, and then come back and run the case
 /// where it is.
 class SymbolicLexSimplex : public LexSimplexBase {
 public:
   /// `constraints` is the set for which the symbolic lexmin will be computed.
   /// `symbolDomain` is the set of values of the symbols for which the lexmin
-  /// will be computed. `symbolDomain` should have a dim id for every symbol in
-  /// `constraints`, and no other ids.
+  /// will be computed. `symbolDomain` should have a dim var for every symbol in
+  /// `constraints`, and no other vars.
   SymbolicLexSimplex(const IntegerPolyhedron &constraints,
                      const IntegerPolyhedron &symbolDomain)
       : SymbolicLexSimplex(constraints,
-                           constraints.getIdKindOffset(IdKind::Symbol),
+                           constraints.getVarKindOffset(VarKind::Symbol),
                            symbolDomain) {
-    assert(constraints.getNumSymbolIds() == symbolDomain.getNumIds());
+    assert(constraints.getNumSymbolVars() == symbolDomain.getNumVars());
   }
 
   /// An overload to select some other subrange of ids as symbols for lexmin.
   /// The symbol ids are the range of ids with absolute index
-  /// [symbolOffset, symbolOffset + symbolDomain.getNumIds())
+  /// [symbolOffset, symbolOffset + symbolDomain.getNumVars())
   /// symbolDomain should only have dim ids.
   SymbolicLexSimplex(const IntegerPolyhedron &constraints,
                      unsigned symbolOffset,
                      const IntegerPolyhedron &symbolDomain)
-      : LexSimplexBase(/*nVar=*/constraints.getNumIds(), symbolOffset,
-                       symbolDomain.getNumIds()),
+      : LexSimplexBase(/*nVar=*/constraints.getNumVars(), symbolOffset,
+                       symbolDomain.getNumVars()),
         domainPoly(symbolDomain), domainSimplex(symbolDomain) {
     // TODO consider supporting this case. It amounts
     // to just returning the input constraints.
-    assert(domainPoly.getNumIds() > 0 &&
+    assert(domainPoly.getNumVars() > 0 &&
            "there must be some non-symbols to optimize!");
-    assert(domainPoly.getNumIds() == domainPoly.getNumDimIds());
+    assert(domainPoly.getNumVars() == domainPoly.getNumDimVars());
     intersectIntegerRelation(constraints);
   }
 
   /// The lexmin will be stored as a function `lexmin` from symbols to
   /// non-symbols in the result.
   ///
   /// For some values of the symbols, the lexmin may be unbounded.
   /// These parts of the symbol domain will be stored in `unboundedDomain`.

 public:
   enum class Direction { Up, Down };
 
   Simplex() = delete;
   explicit Simplex(unsigned nVar)
       : SimplexBase(nVar, /*mustUseBigM=*/false, /*symbolOffset=*/0,
                     /*nSymbol=*/0) {}
   explicit Simplex(const IntegerRelation &constraints)
-      : Simplex(constraints.getNumIds()) {
+      : Simplex(constraints.getNumVars()) {
     intersectIntegerRelation(constraints);
   }
   ~Simplex() override = default;
 
   /// Add an inequality to the tableau. If coeffs is c_0, c_1, ... c_n, where n
   /// is the current number of variables, then the corresponding inequality is
   /// c_n + c_0*x_0 + c_1*x_1 + ... + c_{n-1}*x_{n-1} >= 0.
   ///

mlir/include/mlir/Analysis/Presburger/Utils.h

if (kind == OptimumKind::Bounded)
       return f(optimum);
     return kind;
   }
 };
 
 /// `ReprKind` enum is used to set the constraint type in `MaybeLocalRepr`.
 enum class ReprKind { Inequality, Equality, None };
 
-/// `MaybeLocalRepr` contains the indices of the contraints that can be
+/// `MaybeLocalRepr` contains the indices of the constraints that can be
 /// expressed as a floordiv of an affine function. If it's an `equality`
-/// contraint `equalityIdx` is set, in case of `inequality` the `lowerBoundIdx`
-/// and `upperBoundIdx` is set. By default the kind attribute is set to None.
+/// constraint, `equalityIdx` is set, in case of `inequality` the
+/// `lowerBoundIdx` and `upperBoundIdx` is set. By default the kind attribute is
+/// set to None.
 struct MaybeLocalRepr {
   ReprKind kind = ReprKind::None;
   explicit operator bool() const { return kind != ReprKind::None; }
   union {
     unsigned equalityIdx;
     struct {
       unsigned lowerBoundIdx, upperBoundIdx;
     } inequalityPair;
   } repr;
 };
 
-/// Check if the pos^th identifier can be expressed as a floordiv of an affine
-/// function of other identifiers (where the divisor is a positive constant).
-/// `foundRepr` contains a boolean for each identifier indicating if the
-/// explicit representation for that identifier has already been computed.
+/// Check if the pos^th variable can be expressed as a floordiv of an affine
+/// function of other variables (where the divisor is a positive constant).
+/// `foundRepr` contains a boolean for each variable indicating if the
+/// explicit representation for that variable has already been computed.
 /// Returns the `MaybeLocalRepr` struct which contains the indices of the
 /// constraints that can be expressed as a floordiv of an affine function. If
 /// the representation could be computed, `dividend` and `denominator` are set.
 /// If the representation could not be computed, the kind attribute in
 /// `MaybeLocalRepr` is set to None.
 MaybeLocalRepr computeSingleVarRepr(const IntegerRelation &cst,
                                     ArrayRef<bool> foundRepr, unsigned pos,
                                     SmallVector<int64_t, 8> &dividend,
                                     unsigned &divisor);
 
 /// Given dividends of divisions `divs` and denominators `denoms`, detects and
 /// removes duplicate divisions. `localOffset` is the offset in dividend of a
-/// division from where local identifiers start.
+/// division from where local variables start.
 ///
 /// On every possible duplicate division found, `merge(i, j)`, where `i`, `j`
 /// are current index of the duplicate divisions, is called and division at
 /// index `j` is merged into division at index `i`. If `merge(i, j)` returns
 /// `true`, the divisions are merged i.e. `j^th` division gets eliminated and
 /// it's each instance is replaced by `i^th` division. If it returns `false`,
 /// the divisions are not merged. `merge` can also do side effects, For example
-/// it can merge the local identifiers in IntegerRelation.
+/// it can merge the local variables in IntegerRelation.
 void removeDuplicateDivs(
     std::vector<SmallVector<int64_t, 8>> &divs,
     SmallVectorImpl<unsigned> &denoms, unsigned localOffset,
     llvm::function_ref<bool(unsigned i, unsigned j)> merge);
 
-/// Given two relations, A and B, add additional local ids to the sets such
-/// that both have the union of the local ids in each set, without changing
+/// Given two relations, A and B, add additional local vars to the sets such
+/// that both have the union of the local vars in each set, without changing
 /// the set of points that lie in A and B.
 ///
-/// While taking union, if a local id in any set has a division representation
-/// which is a duplicate of division representation, of another local id in any
-/// set, it is not added to the final union of local ids and is instead merged.
+/// While taking union, if a local var in any set has a division representation
+/// which is a duplicate of division representation, of another local var in any
+/// set, it is not added to the final union of local vars and is instead merged.
 ///
 /// On every possible merge, `merge(i, j)` is called. `i`, `j` are position
-/// of local identifiers in both sets which are being merged. If `merge(i, j)`
+/// of local variables in both sets which are being merged. If `merge(i, j)`
 /// returns true, the divisions are merged, otherwise the divisions are not
 /// merged.
-void mergeLocalIds(IntegerRelation &relA, IntegerRelation &relB,
+void mergeLocalVars(IntegerRelation &relA, IntegerRelation &relB,
                     llvm::function_ref<bool(unsigned i, unsigned j)> merge);
 
 /// Compute the gcd of the range.
 int64_t gcdRange(ArrayRef<int64_t> range);
 
 /// Divide the range by its gcd and return the gcd.
 int64_t normalizeRange(MutableArrayRef<int64_t> range);
 
 /// Normalize the given (numerator, denominator) pair by dividing out the

mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h

 bool isLoopMemoryParallel(AffineForOp forOp);
 
 /// Returns in `affineApplyOps`, the sequence of those AffineApplyOp
 /// Operations that are reachable via a search starting from `operands` and
 /// ending at those operands that are not the result of an AffineApplyOp.
 void getReachableAffineApplyOps(ArrayRef<Value> operands,
                                 SmallVectorImpl<Operation *> &affineApplyOps);
 
-/// Builds a system of constraints with dimensional identifiers corresponding to
+/// Builds a system of constraints with dimensional variables corresponding to
 /// the loop IVs of the forOps and AffineIfOp's operands appearing in
 /// that order. Bounds of the loop are used to add appropriate inequalities.
 /// Constraints from the index sets of AffineIfOp are also added. Any symbols
 /// founds in the bound operands are added as symbols in the system. Returns
 /// failure for the yet unimplemented cases. `ops` accepts both AffineForOp and
 /// AffineIfOp.
 //  TODO: handle non-unit strides.
 LogicalResult getIndexSet(MutableArrayRef<Operation *> ops,

mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h

 class AffineValueMap;
 class IntegerSet;
 class MLIRContext;
 class Value;
 class MemRefType;
 struct MutableAffineMap;
 
 /// FlatAffineValueConstraints represents an extension of IntegerPolyhedron
-/// where each non-local identifier can have an SSA Value attached to it.
+/// where each non-local variable can have an SSA Value attached to it.
 class FlatAffineValueConstraints : public presburger::IntegerPolyhedron {
 public:
   /// Constructs a constraint system reserving memory for the specified number
-  /// of constraints and identifiers.
+  /// of constraints and variables.
   FlatAffineValueConstraints(unsigned numReservedInequalities,
                              unsigned numReservedEqualities,
                              unsigned numReservedCols, unsigned numDims,
                              unsigned numSymbols, unsigned numLocals,
                              ArrayRef<Optional<Value>> valArgs = {})
       : IntegerPolyhedron(numReservedInequalities, numReservedEqualities,
                           numReservedCols,
                           presburger::PresburgerSpace::getSetSpace(
                               numDims, numSymbols, numLocals)) {
-    assert(numReservedCols >= getNumIds() + 1);
-    assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolIds());
+    assert(numReservedCols >= getNumVars() + 1);
+    assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolVars());
     values.reserve(numReservedCols);
     if (valArgs.empty())
-      values.resize(getNumDimAndSymbolIds(), None);
+      values.resize(getNumDimAndSymbolVars(), None);
     else
       values.append(valArgs.begin(), valArgs.end());
   }
 
   /// Constructs a constraint system with the specified number of
   /// dimensions and symbols.
   FlatAffineValueConstraints(unsigned numDims = 0, unsigned numSymbols = 0,
                              unsigned numLocals = 0,
                              ArrayRef<Optional<Value>> valArgs = {})
       : FlatAffineValueConstraints(/*numReservedInequalities=*/0,
                                    /*numReservedEqualities=*/0,
                                    /*numReservedCols=*/numDims + numSymbols +
                                        numLocals + 1,
                                    numDims, numSymbols, numLocals, valArgs) {}
 
   FlatAffineValueConstraints(const IntegerPolyhedron &fac,
                              ArrayRef<Optional<Value>> valArgs = {})
       : IntegerPolyhedron(fac) {
-    assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolIds());
+    assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolVars());
     if (valArgs.empty())
-      values.resize(getNumDimAndSymbolIds(), None);
+      values.resize(getNumDimAndSymbolVars(), None);
     else
       values.append(valArgs.begin(), valArgs.end());
   }
 
   /// Create a flat affine constraint system from an AffineValueMap or a list of
   /// these. The constructed system will only include equalities.
   explicit FlatAffineValueConstraints(const AffineValueMap &avm);
   explicit FlatAffineValueConstraints(ArrayRef<const AffineValueMap *> avmRef);
public:
   // 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 DimId.
+  // All dimensions as set as VarKind::SetDim.
   static FlatAffineValueConstraints
   getHyperrectangular(ValueRange ivs, ValueRange lbs, ValueRange ubs);
 
   /// Return the kind of this FlatAffineConstraints.
   Kind getKind() const override { return Kind::FlatAffineValueConstraints; }
 
   static bool classof(const IntegerRelation *cst) {
     return cst->getKind() == Kind::FlatAffineValueConstraints;
public:
   void reset(unsigned numDims, unsigned numSymbols, unsigned numLocals,
              ArrayRef<Value> valArgs);
 
   /// Clones this object.
   std::unique_ptr<FlatAffineValueConstraints> clone() const;
 
   /// Adds constraints (lower and upper bounds) for the specified 'affine.for'
   /// operation's Value using IR information stored in its bound maps. The
-  /// right identifier is first looked up using `forOp`'s Value. Asserts if the
+  /// right variable is first looked up using `forOp`'s Value. Asserts if the
   /// Value corresponding to the 'affine.for' operation isn't found in the
   /// constraint system. Returns failure for the yet unimplemented/unsupported
-  /// cases.  Any new identifiers that are found in the bound operands of the
-  /// 'affine.for' operation are added as trailing identifiers (either
+  /// cases.  Any new variables that are found in the bound operands of the
+  /// 'affine.for' operation are added as trailing variables (either
   /// dimensional or symbolic depending on whether the operand is a valid
   /// symbol).
   //  TODO: add support for non-unit strides.
   LogicalResult addAffineForOpDomain(AffineForOp forOp);
 
   /// Adds constraints (lower and upper bounds) for each loop in the loop nest
   /// described by the bound maps `lbMaps` and `ubMaps` of a computation slice.
   /// Every pair (`lbMaps[i]`, `ubMaps[i]`) describes the bounds of a loop in
   /// the nest, sorted outer-to-inner. `operands` contains the bound operands
   /// for a single bound map. All the bound maps will use the same bound
   /// operands. Note that some loops described by a computation slice might not
-  /// exist yet in the IR so the Value attached to those dimension identifiers
+  /// exist yet in the IR so the Value attached to those dimension variables
   /// might be empty. For that reason, this method doesn't perform Value
-  /// look-ups to retrieve the dimension identifier positions. Instead, it
-  /// assumes the position of the dim identifiers in the constraint system is
+  /// look-ups to retrieve the dimension variable positions. Instead, it
+  /// assumes the position of the dim variables in the constraint system is
   /// the same as the position of the loop in the loop nest.
   LogicalResult addDomainFromSliceMaps(ArrayRef<AffineMap> lbMaps,
                                        ArrayRef<AffineMap> ubMaps,
                                        ArrayRef<Value> operands);
 
   /// Adds constraints imposed by the `affine.if` operation. These constraints
   /// are collected from the IntegerSet attached to the given `affine.if`
   /// instance argument (`ifOp`). It is asserted that:
   /// 1) The IntegerSet of the given `affine.if` instance should not contain
   /// semi-affine expressions,
   /// 2) The columns of the constraint system created from `ifOp` should match
   /// the columns in the current one regarding numbers and values.
   void addAffineIfOpDomain(AffineIfOp ifOp);
 
-  /// Adds a bound for the identifier at the specified position with constraints
+  /// 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
   /// as a closed bound by +1/-1 respectively. In case of an EQ bound, it can
   /// only be added as a closed bound.
   ///
   /// Note: The dimensions/symbols of this FlatAffineConstraints must match the
   /// dimensions/symbols of the affine map.
   LogicalResult addBound(BoundType type, unsigned pos, AffineMap boundMap,
                          bool isClosedBound);
 
-  /// Adds a bound for the identifier at the specified position with constraints
+  /// 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.
   /// Note: The dimensions/symbols of this FlatAffineConstraints must match the
   /// dimensions/symbols of the affine map. By default the lower bound is closed
   /// and the upper bound is open.
   LogicalResult addBound(BoundType type, unsigned pos, AffineMap boundMap);
 
-  /// Adds a bound for the identifier at the specified position with constraints
+  /// Adds a bound for the variable at the specified position with constraints
   /// being drawn from the specified bound map and operands. 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.
   LogicalResult addBound(BoundType type, unsigned pos, AffineMap boundMap,
                          ValueRange operands);
 
-  /// Adds a constant bound for the identifier associated with the given Value.
+  /// Adds a constant bound for the variable associated with the given Value.
   void addBound(BoundType type, Value val, int64_t value);
 
   /// The `addBound` overload above hides the inherited overloads by default, so
   /// we explicitly introduce them here.
   using IntegerPolyhedron::addBound;
 
   /// Returns the constraint system as an integer set. Returns a null integer
   /// set if the system has no constraints, or if an integer set couldn't be
   /// constructed as a result of a local variable's explicit representation not
   /// being known and such a local variable appearing in any of the constraints.
   IntegerSet getAsIntegerSet(MLIRContext *context) const;
 
   /// Computes the lower and upper bounds of the first `num` dimensional
-  /// identifiers (starting at `offset`) as an affine map of the remaining
-  /// identifiers (dimensional and symbolic). This method is able to detect
-  /// identifiers as floordiv's and mod's of affine expressions of other
-  /// identifiers with respect to (positive) constants. Sets bound map to a
+  /// variables (starting at `offset`) as an affine map of the remaining
+  /// variables (dimensional and symbolic). This method is able to detect
+  /// variables as floordiv's and mod's of affine expressions of other
+  /// variables with respect to (positive) constants. Sets bound map to a
   /// null AffineMap if such a bound can't be found (or yet unimplemented).
   ///
   /// By default the returned lower bounds are closed and upper bounds are open.
   /// This can be changed by getClosedUB.
   void getSliceBounds(unsigned offset, unsigned num, MLIRContext *context,
                       SmallVectorImpl<AffineMap> *lbMaps,
                       SmallVectorImpl<AffineMap> *ubMaps,
                       bool getClosedUB = false);
 
   /// Composes an affine map whose dimensions and symbols match one to one with
   /// the dimensions and symbols of this FlatAffineConstraints. The results of
   /// the map `other` are added as the leading dimensions of this constraint
   /// system. Returns failure if `other` is a semi-affine map.
   LogicalResult composeMatchingMap(AffineMap other);
 
-  /// Gets the lower and upper bound of the `offset` + `pos`th identifier
+  /// Gets the lower and upper bound of the `offset` + `pos`th variable
   /// treating [0, offset) U [offset + num, symStartPos) as dimensions and
-  /// [symStartPos, getNumDimAndSymbolIds) as symbols, and `pos` lies in
+  /// [symStartPos, getNumDimAndSymbolVars) as symbols, and `pos` lies in
   /// [0, num). The multi-dimensional maps in the returned pair represent the
   /// max and min of potentially multiple affine expressions. The upper bound is
   /// exclusive. `localExprs` holds pre-computed AffineExpr's for all local
-  /// identifiers in the system.
+  /// variables in the system.
   std::pair<AffineMap, AffineMap>
   getLowerAndUpperBound(unsigned pos, unsigned offset, unsigned num,
                         unsigned symStartPos, ArrayRef<AffineExpr> localExprs,
                         MLIRContext *context) const;
 
-  /// Returns the bound for the identifier at `pos` from the inequality at
+  /// Returns the bound for the variable at `pos` from the inequality at
   /// `ineqPos` as a 1-d affine value map (affine map + operands). The returned
   /// affine value map can either be a lower bound or an upper bound depending
   /// on the sign of atIneq(ineqPos, pos). Asserts if the row at `ineqPos` does
-  /// not involve the `pos`th identifier.
+  /// not involve the `pos`th variable.
   void getIneqAsAffineValueMap(unsigned pos, unsigned ineqPos,
                                AffineValueMap &vmap,
                                MLIRContext *context) const;
 
   /// Adds slice lower bounds represented by lower bounds in `lbMaps` and upper
-  /// bounds in `ubMaps` to each identifier in the constraint system which has
+  /// bounds in `ubMaps` to each variable in the constraint system which has
   /// a value in `values`. Note that both lower/upper bounds share the same
   /// operand list `operands`.
   /// This function assumes `values.size` == `lbMaps.size` == `ubMaps.size`.
   /// Note that both lower/upper bounds use operands from `operands`.
   LogicalResult addSliceBounds(ArrayRef<Value> values,
                                ArrayRef<AffineMap> lbMaps,
                                ArrayRef<AffineMap> ubMaps,
                                ArrayRef<Value> operands);
 
-  /// Looks up the position of the identifier with the specified Value. Returns
+  /// Looks up the position of the variable with the specified Value. Returns
   /// true if found (false otherwise). `pos` is set to the (column) position of
-  /// the identifier.
-  bool findId(Value val, unsigned *pos) const;
+  /// the variable.
+  bool findVar(Value val, unsigned *pos) const;
 
-  /// Returns true if an identifier with the specified Value exists, false
+  /// Returns true if an variable with the specified Value exists, false
   /// otherwise.
-  bool containsId(Value val) const;
+  bool containsVar(Value mayBeVar) const;
 
-  /// Swap the posA^th identifier with the posB^th identifier.
-  void swapId(unsigned posA, unsigned posB) override;
+  /// Swap the posA^th variable with the posB^th variable.
+  void swapVar(unsigned posA, unsigned posB) override;
 
-  /// Insert identifiers of the specified kind at position `pos`. Positions are
-  /// relative to the kind of identifier. The coefficient columns corresponding
-  /// to the added identifiers are initialized to zero. `vals` are the Values
-  /// corresponding to the identifiers. Values should not be used with
-  /// IdKind::Local since values can only be attached to non-local identifiers.
+  /// Insert variables of the specified kind at position `pos`. Positions are
+  /// relative to the kind of variable. The coefficient columns corresponding
+  /// to the added variables are initialized to zero. `vals` are the Values
+  /// corresponding to the variables. Values should not be used with
+  /// VarKind::Local since values can only be attached to non-local variables.
   /// Return the absolute column position (i.e., not relative to the kind of
-  /// identifier) of the first added identifier.
+  /// variable) of the first added variable.
   ///
   /// Note: Empty Values are allowed in `vals`.
-  unsigned insertDimId(unsigned pos, unsigned num = 1) {
-    return insertId(IdKind::SetDim, pos, num);
+  unsigned insertDimVar(unsigned pos, unsigned num = 1) {
+    return insertVar(VarKind::SetDim, pos, num);
   }
-  unsigned insertSymbolId(unsigned pos, unsigned num = 1) {
-    return insertId(IdKind::Symbol, pos, num);
+  unsigned insertSymbolVar(unsigned pos, unsigned num = 1) {
+    return insertVar(VarKind::Symbol, pos, num);
   }
-  unsigned insertLocalId(unsigned pos, unsigned num = 1) {
-    return insertId(IdKind::Local, pos, num);
+  unsigned insertLocalVar(unsigned pos, unsigned num = 1) {
+    return insertVar(VarKind::Local, pos, num);
   }
-  unsigned insertDimId(unsigned pos, ValueRange vals);
-  unsigned insertSymbolId(unsigned pos, ValueRange vals);
-  unsigned insertId(presburger::IdKind kind, unsigned pos,
+  unsigned insertDimVar(unsigned pos, ValueRange vals);
+  unsigned insertSymbolVar(unsigned pos, ValueRange vals);
+  unsigned insertVar(presburger::VarKind kind, unsigned pos,
                      unsigned num = 1) override;
-  unsigned insertId(presburger::IdKind kind, unsigned pos, ValueRange vals);
+  unsigned insertVar(presburger::VarKind kind, unsigned pos, ValueRange vals);
 
-  /// Append identifiers of the specified kind after the last identifier of that
-  /// kind. The coefficient columns corresponding to the added identifiers are
+  /// Append variables of the specified kind after the last variable of that
+  /// kind. The coefficient columns corresponding to the added variables are
   /// initialized to zero. `vals` are the Values corresponding to the
-  /// identifiers. Return the position of the first added column.
+  /// variables. Return the position of the first added column.
   ///
   /// Note: Empty Values are allowed in `vals`.
-  unsigned appendDimId(ValueRange vals);
-  unsigned appendSymbolId(ValueRange vals);
-  unsigned appendDimId(unsigned num = 1) {
-    return appendId(IdKind::SetDim, num);
+  unsigned appendDimVar(ValueRange vals);
+  unsigned appendSymbolVar(ValueRange vals);
+  unsigned appendDimVar(unsigned num = 1) {
+    return appendVar(VarKind::SetDim, num);
   }
-  unsigned appendSymbolId(unsigned num = 1) {
-    return appendId(IdKind::Symbol, num);
+  unsigned appendSymbolVar(unsigned num = 1) {
+    return appendVar(VarKind::Symbol, num);
   }
-  unsigned appendLocalId(unsigned num = 1) {
-    return appendId(IdKind::Local, num);
+  unsigned appendLocalVar(unsigned num = 1) {
+    return appendVar(VarKind::Local, num);
   }
 
-  /// Removes identifiers in the column range [idStart, idLimit), and copies any
+  /// Removes variables in the column range [varStart, varLimit), and copies any
   /// remaining valid data into place, updates member variables, and resizes
   /// arrays as needed.
-  void removeIdRange(presburger::IdKind kind, unsigned idStart,
-                     unsigned idLimit) override;
-  using IntegerPolyhedron::removeIdRange;
-
-  /// Add the specified values as a dim or symbol id depending on its nature, if
-  /// it already doesn't exist in the system. `val` has to be either a terminal
-  /// symbol or a loop IV, i.e., it cannot be the result affine.apply of any
-  /// symbols or loop IVs. The identifier is added to the end of the existing
-  /// dims or symbols. Additional information on the identifier is extracted
-  /// from the IR and added to the constraint system.
+  void removeVarRange(presburger::VarKind kind, unsigned varStart,
+                      unsigned varLimit) override;
+  using IntegerPolyhedron::removeVarRange;
+
+  /// Add the specified values as a dim or symbol var depending on its nature,
+  /// if it already doesn't exist in the system. `val` has to be either a
+  /// terminal symbol or a loop IV, i.e., it cannot be the result affine.apply
+  /// of any symbols or loop IVs. The variable is added to the end of the
+  /// existing dims or symbols. Additional information on the variable is
+  /// extracted from the IR and added to the constraint system.
   void addInductionVarOrTerminalSymbol(Value val);
 
   /// Align `map` with this constraint system based on `operands`. Each operand
   /// must already have a corresponding dim/symbol in this constraint system.
   AffineMap computeAlignedMap(AffineMap map, ValueRange operands) const;
 
   /// Composes the affine value map with this FlatAffineValueConstrains, adding
   /// the results of the map as dimensions at the front
   /// [0, vMap->getNumResults()) and with the dimensions set to the equalities
   /// specified by the value map.
   ///
   /// Returns failure if the composition fails (when vMap is a semi-affine map).
   /// The vMap's operand Value's are used to look up the right positions in
   /// the FlatAffineConstraints with which to associate. Every operand of vMap
   /// should have a matching dim/symbol column in this constraint system (with
   /// the same associated Value).
   LogicalResult composeMap(const AffineValueMap *vMap);
 
-  /// Projects out the identifier that is associate with Value.
+  /// Projects out the variable that is associate with Value.
   void projectOut(Value val);
   using IntegerPolyhedron::projectOut;
 
-  /// Changes all symbol identifiers which are loop IVs to dim identifiers.
+  /// Changes all symbol variables which are loop IVs to dim variables.
   void convertLoopIVSymbolsToDims();
 
   /// Updates the constraints to be the smallest bounding (enclosing) box that
   /// contains the points of `this` set and that of `other`, with the symbols
   /// being treated specially. For each of the dimensions, the min of the lower
   /// bounds (symbolic) and the max of the upper bounds (symbolic) is computed
   /// to determine such a bounding box. `other` is expected to have the same
-  /// dimensional identifiers as this constraint system (in the same order).
+  /// dimensional variables as this constraint system (in the same order).
   ///
   /// E.g.:
   /// 1) this   = {0 <= d0 <= 127},
   ///    other  = {16 <= d0 <= 192},
   ///    output = {0 <= d0 <= 192}
   /// 2) this   = {s0 + 5 <= d0 <= s0 + 20},
   ///    other  = {s0 + 1 <= d0 <= s0 + 9},
   ///    output = {s0 + 1 <= d0 <= s0 + 20}
   /// 3) this   = {0 <= d0 <= 5, 1 <= d1 <= 9}
   ///    other  = {2 <= d0 <= 6, 5 <= d1 <= 15},
   ///    output = {0 <= d0 <= 6, 1 <= d1 <= 15}
   LogicalResult unionBoundingBox(const FlatAffineValueConstraints &other);
   using IntegerPolyhedron::unionBoundingBox;
 
-  /// Merge and align the identifiers of `this` and `other` starting at
+  /// Merge and align the variables of `this` and `other` starting at
   /// `offset`, so that both constraint systems get the union of the contained
-  /// identifiers that is dimension-wise and symbol-wise unique; both
+  /// variables that is dimension-wise and symbol-wise unique; both
   /// constraint systems are updated so that they have the union of all
-  /// identifiers, with `this`'s original identifiers appearing first followed
-  /// by any of `other`'s identifiers that didn't appear in `this`. Local
-  /// identifiers in `other` that have the same division representation as local
-  /// identifiers in `this` are merged into one.
+  /// variables, with `this`'s original variables appearing first followed
+  /// by any of `other`'s variables that didn't appear in `this`. Local
+  /// variables in `other` that have the same division representation as local
+  /// variables in `this` are merged into one.
   //  E.g.: Input: `this`  has (%i, %j) [%M, %N]
   //               `other` has (%k, %j) [%P, %N, %M]
   //        Output: both `this`, `other` have (%i, %j, %k) [%M, %N, %P]
   //
-  void mergeAndAlignIdsWithOther(unsigned offset,
+  void mergeAndAlignVarsWithOther(unsigned offset,
                                   FlatAffineValueConstraints *other);
 
   /// Returns true if this constraint system and `other` are in the same
-  /// space, i.e., if they are associated with the same set of identifiers,
+  /// space, i.e., if they are associated with the same set of variables,
   /// appearing in the same order. Returns false otherwise.
-  bool areIdsAlignedWithOther(const FlatAffineValueConstraints &other);
+  bool areVarsAlignedWithOther(const FlatAffineValueConstraints &other);
 
   /// Replaces the contents of this FlatAffineValueConstraints with `other`.
   void clearAndCopyFrom(const IntegerRelation &other) override;
 
-  /// Returns the Value associated with the pos^th identifier. Asserts if
-  /// no Value identifier was associated.
+  /// Returns the Value associated with the pos^th variable. Asserts if
+  /// no Value variable was associated.
   inline Value getValue(unsigned pos) const {
-    assert(pos < getNumDimAndSymbolIds() && "Invalid position");
-    assert(hasValue(pos) && "identifier's Value not set");
+    assert(pos < getNumDimAndSymbolVars() && "Invalid position");
+    assert(hasValue(pos) && "variable's Value not set");
     return values[pos].getValue();
   }
 
-  /// Returns true if the pos^th identifier has an associated Value.
+  /// Returns true if the pos^th variable has an associated Value.
   inline bool hasValue(unsigned pos) const {
-    assert(pos < getNumDimAndSymbolIds() && "Invalid position");
+    assert(pos < getNumDimAndSymbolVars() && "Invalid position");
     return values[pos].hasValue();
   }
 
-  /// Returns true if at least one identifier has an associated Value.
+  /// Returns true if at least one variable has an associated Value.
   bool hasValues() const;
 
-  /// Returns the Values associated with identifiers in range [start, end).
-  /// Asserts if no Value was associated with one of these identifiers.
+  /// Returns the Values associated with variables in range [start, end).
+  /// Asserts if no Value was associated with one of these variables.
   inline void getValues(unsigned start, unsigned end,
                         SmallVectorImpl<Value> *values) const {
-    assert(end <= getNumDimAndSymbolIds() && "invalid end position");
+    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, getNumDimAndSymbolIds(), values);
+    getValues(0, getNumDimAndSymbolVars(), values);
   }
 
   inline ArrayRef<Optional<Value>> getMaybeValues() const {
     return {values.data(), values.size()};
   }
 
   inline ArrayRef<Optional<Value>>
-  getMaybeValues(presburger::IdKind kind) const {
-    assert(kind != IdKind::Local &&
-           "Local identifiers do not have any value attached to them.");
-    return {values.data() + getIdKindOffset(kind), getNumIdKind(kind)};
+  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)};
   }
 
-  /// Sets the Value associated with the pos^th identifier.
+  /// Sets the Value associated with the pos^th variable.
   inline void setValue(unsigned pos, Value val) {
-    assert(pos < getNumDimAndSymbolIds() && "invalid id position");
+    assert(pos < getNumDimAndSymbolVars() && "invalid var position");
     values[pos] = val;
   }
 
-  /// Sets the Values associated with the identifiers in the range [start, end).
-  /// The range must contain only dim and symbol identifiers.
+  /// Sets the Values associated with the variables in the range [start, end).
+  /// The range must contain only dim and symbol variables.
   void setValues(unsigned start, unsigned end, ArrayRef<Value> values) {
-    assert(end <= getNumIds() && "invalid end position");
+    assert(end <= getNumVars() && "invalid end position");
     assert(start <= end && "invalid start position");
     assert(values.size() == end - start &&
-           "value should be provided for each identifier in the range.");
+           "value should be provided for each variable in the range.");
     for (unsigned i = start; i < end; ++i)
       setValue(i, values[i - start]);
   }
 
   /// Merge and align symbols of `this` and `other` such that both get union of
   /// of symbols that are unique. Symbols in `this` and `other` should be
   /// unique. Symbols with Value as `None` are considered to be inequal to all
   /// other symbols.
-  void mergeSymbolIds(FlatAffineValueConstraints &other);
+  void mergeSymbolVars(FlatAffineValueConstraints &other);
 
 protected:
-  using IdKind = presburger::IdKind;
+  using VarKind = presburger::VarKind;
 
-  /// Returns false if the fields corresponding to various identifier counts, or
+  /// Returns false if the fields corresponding to various variable counts, or
   /// equality/inequality buffer sizes aren't consistent; true otherwise. This
   /// is meant to be used within an assert internally.
   bool hasConsistentState() const override;
 
   /// Given an affine map that is aligned with this constraint system:
   /// * Flatten the map.
   /// * Add newly introduced local columns at the beginning of this constraint
   ///   system (local column pos 0).
   /// * Add equalities that define the new local columns to this constraint
   ///   system.
   /// * Return the flattened expressions via `flattenedExprs`.
   ///
   /// Note: This is a shared helper function of `addLowerOrUpperBound` and
   ///       `composeMatchingMap`.
   LogicalResult flattenAlignedMapAndMergeLocals(
       AffineMap map, std::vector<SmallVector<int64_t, 8>> *flattenedExprs);
 
-  /// Eliminates the identifier at the specified position using Fourier-Motzkin
+  /// Eliminates the variable at the specified position using Fourier-Motzkin
   /// variable elimination, but uses Gaussian elimination if there is an
-  /// equality involving that identifier. If the result of the elimination is
+  /// equality involving that variable. If the result of the elimination is
   /// integer exact, `*isResultIntegerExact` is set to true. If `darkShadow` is
   /// set to true, a potential under approximation (subset) of the rational
   /// shadow / exact integer shadow is computed.
   // See implementation comments for more details.
   void fourierMotzkinEliminate(unsigned pos, bool darkShadow = false,
                                bool *isResultIntegerExact = nullptr) override;
 
   /// Prints the number of constraints, dimensions, symbols and locals in the
-  /// FlatAffineConstraints. Also, prints for each identifier whether there is
+  /// FlatAffineConstraints. Also, prints for each variable whether there is
   /// an SSA Value attached to it.
   void printSpace(raw_ostream &os) const override;
 
-  /// Values corresponding to the (column) non-local identifiers of this
-  /// constraint system appearing in the order the identifiers correspond to
-  /// columns. Identifiers that aren't associated with any Value are set to
+  /// Values corresponding to the (column) non-local variables of this
+  /// constraint system appearing in the order the variables correspond to
+  /// columns. Variables that aren't associated with any Value are set to
   /// None.
   SmallVector<Optional<Value>, 8> values;
 };
 
 /// A FlatAffineRelation represents a set of ordered pairs (domain -> range)
-/// where "domain" and "range" are tuples of identifiers. The relation is
+/// where "domain" and "range" are tuples of variables. The relation is
 /// represented as a FlatAffineValueConstraints with separation of dimension
-/// identifiers into domain and  range. The identifiers are stored as:
-/// [domainIds, rangeIds, symbolIds, localIds, constant].
+/// variables into domain and  range. The variables are stored as:
+/// [domainVars, rangeVars, symbolVars, localVars, constant].
 class FlatAffineRelation : public FlatAffineValueConstraints {
 public:
   FlatAffineRelation(unsigned numReservedInequalities,
                      unsigned numReservedEqualities, unsigned numReservedCols,
                      unsigned numDomainDims, unsigned numRangeDims,
                      unsigned numSymbols, unsigned numLocals,
                      ArrayRef<Optional<Value>> valArgs = {})
       : FlatAffineValueConstraints(
FlatAffineRelation(unsigned numDomainDims, unsigned numRangeDims,
                      IntegerPolyhedron &fac)
       : FlatAffineValueConstraints(fac), numDomainDims(numDomainDims),
         numRangeDims(numRangeDims) {}
 
   /// Returns a set corresponding to the domain/range of the affine relation.
   FlatAffineValueConstraints getDomainSet() const;
   FlatAffineValueConstraints getRangeSet() const;
 
-  /// Returns the number of identifiers corresponding to domain/range of
+  /// Returns the number of variables corresponding to domain/range of
   /// relation.
   inline unsigned getNumDomainDims() const { return numDomainDims; }
   inline unsigned getNumRangeDims() const { return numRangeDims; }
 
   /// Given affine relation `other: (domainOther -> rangeOther)`, this operation
   /// takes the composition of `other` on `this: (domainThis -> rangeThis)`.
   /// The resulting relation represents tuples of the form: `domainOther ->
   /// rangeThis`.
   void compose(const FlatAffineRelation &other);
 
   /// Swap domain and range of the relation.
   /// `(domain -> range)` is converted to `(range -> domain)`.
   void inverse();
 
-  /// Insert `num` identifiers of the specified kind after the `pos` identifier
+  /// Insert `num` variables of the specified kind after the `pos` variable
   /// of that kind. The coefficient columns corresponding to the added
-  /// identifiers are initialized to zero.
-  void insertDomainId(unsigned pos, unsigned num = 1);
-  void insertRangeId(unsigned pos, unsigned num = 1);
+  /// variables are initialized to zero.
+  void insertDomainVar(unsigned pos, unsigned num = 1);
+  void insertRangeVar(unsigned pos, unsigned num = 1);
 
-  /// Append `num` identifiers of the specified kind after the last identifier
+  /// Append `num` variables of the specified kind after the last variable
   /// of that kind. The coefficient columns corresponding to the added
-  /// identifiers are initialized to zero.
-  void appendDomainId(unsigned num = 1);
-  void appendRangeId(unsigned num = 1);
+  /// variables are initialized to zero.
+  void appendDomainVar(unsigned num = 1);
+  void appendRangeVar(unsigned num = 1);
 
-  /// Removes identifiers in the column range [idStart, idLimit), and copies any
+  /// Removes variables in the column range [varStart, varLimit), and copies any
   /// remaining valid data into place, updates member variables, and resizes
   /// arrays as needed.
-  void removeIdRange(IdKind kind, unsigned idStart, unsigned idLimit) override;
-  using IntegerRelation::removeIdRange;
+  void removeVarRange(VarKind kind, unsigned varStart,
+                      unsigned varLimit) override;
+  using IntegerRelation::removeVarRange;
 
 protected:
-  // Number of dimension identifers corresponding to domain identifers.
+  // Number of dimension variables corresponding to domain variables.
   unsigned numDomainDims;
 
-  // Number of dimension identifers corresponding to range identifers.
+  // Number of dimension variables corresponding to range variables.
   unsigned numRangeDims;
 };
 
 /// Flattens 'expr' into 'flattenedExpr', which contains the coefficients of the
 /// dimensions, symbols, and additional variables that represent floor divisions
 /// of dimensions, symbols, and in turn other floor divisions.  Returns failure
 /// if 'expr' could not be flattened (i.e., semi-affine is not yet handled).
-/// 'cst' contains constraints that connect newly introduced local identifiers
-/// to existing dimensional and symbolic identifiers. See documentation for
+/// 'cst' contains constraints that connect newly introduced local variables
+/// to existing dimensional and symbolic variables. See documentation for
 /// AffineExprFlattener on how mod's and div's are flattened.
 LogicalResult getFlattenedAffineExpr(AffineExpr expr, unsigned numDims,
                                      unsigned numSymbols,
                                      SmallVectorImpl<int64_t> *flattenedExpr,
                                      FlatAffineValueConstraints *cst = nullptr);
 
 /// Flattens the result expressions of the map to their corresponding flattened
 /// forms and set in 'flattenedExprs'. Returns failure if any expression in the
 /// map could not be flattened (i.e., semi-affine is not yet handled). 'cst'
-/// contains constraints that connect newly introduced local identifiers to
-/// existing dimensional and / symbolic identifiers. See documentation for
+/// contains constraints that connect newly introduced local variables to
+/// existing dimensional and / symbolic variables. See documentation for
 /// AffineExprFlattener on how mod's and div's are flattened. For all affine
 /// expressions that share the same operands (like those of an affine map), this
 /// method should be used instead of repeatedly calling getFlattenedAffineExpr
 /// since local variables added to deal with div's and mod's will be reused
 /// across expressions.
 LogicalResult
 getFlattenedAffineExprs(AffineMap map,
                         std::vector<SmallVector<int64_t, 8>> *flattenedExprs,

mlir/include/mlir/Dialect/Affine/Analysis/Utils.h

struct ComputationSliceState {
   // List of lower bound operands (lbOperands[i] are used by 'lbs[i]').
   std::vector<SmallVector<Value, 4>> lbOperands;
   // List of upper bound operands (ubOperands[i] are used by 'ubs[i]').
   std::vector<SmallVector<Value, 4>> ubOperands;
   // Slice loop nest insertion point in target loop nest.
   Block::iterator insertPoint;
   // Adds to 'cst' with constraints which represent the slice bounds on 'ivs'
   // in 'this'. Specifically, the values in 'ivs' are added to 'cst' as dim
-  // identifiers and the values in 'lb/ubOperands' are added as symbols.
+  // variables and the values in 'lb/ubOperands' are added as symbols.
   // Constraints are added for all loop IV bounds (dim or symbol), and
   // constraints are added for slice bounds in 'lbs'/'ubs'.
   // Returns failure if we cannot add loop bounds because of unsupported cases.
   LogicalResult getAsConstraints(FlatAffineValueConstraints *cst);
 
   /// Adds to 'cst' constraints which represent the original loop bounds on
   /// 'ivs' in 'this'. This corresponds to the original domain of the loop nest
   /// from which the slice is being computed. Returns failure if we cannot add

 // The last field is a 2-d FlatAffineValueConstraints symbolic in %i.
 //
 struct MemRefRegion {
   explicit MemRefRegion(Location loc) : loc(loc) {}
 
   /// Computes the memory region accessed by this memref with the region
   /// represented as constraints symbolic/parametric in 'loopDepth' loops
   /// surrounding opInst. The computed region's 'cst' field has exactly as many
-  /// dimensional identifiers as the rank of the memref, and *potentially*
-  /// additional symbolic identifiers which could include any of the loop IVs
+  /// dimensional variables as the rank of the memref, and *potentially*
+  /// additional symbolic variables which could include any of the loop IVs
   /// surrounding opInst up until 'loopDepth' and another additional Function
   /// symbols involved with the access (for eg., those appear in affine.apply's,
   /// loop bounds, etc.). If 'sliceState' is non-null, operands from
   /// 'sliceState' are added as symbols, and the following constraints are added
   /// to the system:
   /// *) Inequality constraints which represent loop bounds for 'sliceState'
   ///    operands which are loop IVS (these represent the destination loop IVs
   ///    of the slice, and are added as symbols to MemRefRegion's constraint
struct MemRefRegion {
   const FlatAffineValueConstraints *getConstraints() const { return &cst; }
   bool isWrite() const { return write; }
   void setWrite(bool flag) { write = flag; }
 
   /// Returns a constant upper bound on the number of elements in this region if
   /// bounded by a known constant (always possible for static shapes), None
   /// otherwise. Note that the symbols of the region are treated specially,
   /// i.e., the returned bounding constant holds for *any given* value of the
-  /// symbol identifiers. The 'shape' vector is set to the corresponding
+  /// symbol variables. The 'shape' vector is set to the corresponding
   /// dimension-wise bounds major to minor. The number of elements and all the
   /// dimension-wise bounds are guaranteed to be non-negative. We use int64_t
   /// instead of uint64_t since index types can be at most int64_t. `lbs` are
   /// set to the lower bounds for each of the rank dimensions, and lbDivisors
   /// contains the corresponding denominators for floorDivs.
   Optional<int64_t> getConstantBoundingSizeAndShape(
       SmallVectorImpl<int64_t> *shape = nullptr,
       std::vector<SmallVector<int64_t, 4>> *lbs = nullptr,
       SmallVectorImpl<int64_t> *lbDivisors = nullptr) const;
 
-  /// Gets the lower and upper bound map for the dimensional identifier at
+  /// Gets the lower and upper bound map for the dimensional variable at
   /// `pos`.
   void getLowerAndUpperBound(unsigned pos, AffineMap &lbMap,
                              AffineMap &ubMap) const;
 
   /// A wrapper around FlatAffineValueConstraints::getConstantBoundOnDimSize().
   /// 'pos' corresponds to the position of the memref shape's dimension (major
-  /// to minor) which matches 1:1 with the dimensional identifier positions in
+  /// to minor) which matches 1:1 with the dimensional variable positions in
   /// 'cst'.
   Optional<int64_t>
   getConstantBoundOnDimSize(unsigned pos,
                             SmallVectorImpl<int64_t> *lb = nullptr,
                             int64_t *lbFloorDivisor = nullptr) const {
     assert(pos < getRank() && "invalid position");
     return cst.getConstantBoundOnDimSize(pos, lb);
   }
struct MemRefRegion {
   /// Read or write.
   bool write = false;
 
   /// If there is more than one load/store op associated with the region, the
   /// location information would correspond to one of those op's.
   Location loc;
 
   /// Region (data space) of the memref accessed. This set will thus have at
-  /// least as many dimensional identifiers as the shape dimensionality of the
+  /// least as many dimensional variables as the shape dimensionality of the
   /// memref, and these are the leading dimensions of the set appearing in that
   /// order (major to minor / outermost to innermost). There may be additional
-  /// identifiers since getMemRefRegion() is called with a specific loop depth,
+  /// variables since getMemRefRegion() is called with a specific loop depth,
   /// and thus the region is symbolic in the outer surrounding loops at that
   /// depth.
   // TODO: Replace this to exploit HyperRectangularSet.
   FlatAffineValueConstraints cst;
 };
 
 /// Returns the size of memref data in bytes if it's statically shaped, None
 /// otherwise.

mlir/lib/Analysis/Presburger/IntegerRelation.cpp

 //===- IntegerRelation.cpp - MLIR IntegerRelation Class ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // A class to represent an relation over integer tuples. A relation is
 // represented as a constraint system over a space of tuples of integer valued
-// varaiables supporting symbolic identifiers and existential quantification.
+// variables supporting symbolic variables and existential quantification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/IntegerRelation.h"
 #include "mlir/Analysis/Presburger/LinearTransform.h"
 #include "mlir/Analysis/Presburger/PWMAFunction.h"
 #include "mlir/Analysis/Presburger/PresburgerRelation.h"
 #include "mlir/Analysis/Presburger/Simplex.h"
std::unique_ptr<IntegerRelation> IntegerRelation::clone() const {
   return std::make_unique<IntegerRelation>(*this);
 }
 
 std::unique_ptr<IntegerPolyhedron> IntegerPolyhedron::clone() const {
   return std::make_unique<IntegerPolyhedron>(*this);
 }
 
 void IntegerRelation::setSpace(const PresburgerSpace &oSpace) {
-  assert(space.getNumIds() == oSpace.getNumIds() && "invalid space!");
+  assert(space.getNumVars() == oSpace.getNumVars() && "invalid space!");
   space = oSpace;
 }
 
 void IntegerRelation::setSpaceExceptLocals(const PresburgerSpace &oSpace) {
-  assert(oSpace.getNumLocalIds() == 0 && "no locals should be present!");
-  assert(oSpace.getNumIds() <= getNumIds() && "invalid space!");
-  unsigned newNumLocals = getNumIds() - oSpace.getNumIds();
+  assert(oSpace.getNumLocalVars() == 0 && "no locals should be present!");
+  assert(oSpace.getNumVars() <= getNumVars() && "invalid space!");
+  unsigned newNumLocals = getNumVars() - oSpace.getNumVars();
   space = oSpace;
-  space.insertId(IdKind::Local, 0, newNumLocals);
+  space.insertVar(VarKind::Local, 0, newNumLocals);
 }
 
 void IntegerRelation::append(const IntegerRelation &other) {
   assert(space.isEqual(other.getSpace()) && "Spaces must be equal.");
 
   inequalities.reserveRows(inequalities.getNumRows() +
                            other.getNumInequalities());
   equalities.reserveRows(equalities.getNumRows() + other.getNumEqualities());
 
   for (unsigned r = 0, e = other.getNumInequalities(); r < e; r++) {
     addInequality(other.getInequality(r));
   }
   for (unsigned r = 0, e = other.getNumEqualities(); r < e; r++) {
     addEquality(other.getEquality(r));
   }
 }
 
 IntegerRelation IntegerRelation::intersect(IntegerRelation other) const {
   IntegerRelation result = *this;
-  result.mergeLocalIds(other);
+  result.mergeLocalVars(other);
   result.append(other);
   return result;
 }
 
 bool IntegerRelation::isEqual(const IntegerRelation &other) const {
   assert(space.isCompatible(other.getSpace()) && "Spaces must be compatible.");
   return PresburgerRelation(*this).isEqual(PresburgerRelation(other));
 }
 
 bool IntegerRelation::isSubsetOf(const IntegerRelation &other) const {
   assert(space.isCompatible(other.getSpace()) && "Spaces must be compatible.");
   return PresburgerRelation(*this).isSubsetOf(PresburgerRelation(other));
 }
 
 MaybeOptimum<SmallVector<Fraction, 8>>
 IntegerRelation::findRationalLexMin() const {
-  assert(getNumSymbolIds() == 0 && "Symbols are not supported!");
+  assert(getNumSymbolVars() == 0 && "Symbols are not supported!");
   MaybeOptimum<SmallVector<Fraction, 8>> maybeLexMin =
       LexSimplex(*this).findRationalLexMin();
 
   if (!maybeLexMin.isBounded())
     return maybeLexMin;
 
   // The Simplex returns the lexmin over all the variables including locals. But
   // locals are not actually part of the space and should not be returned in the
-  // result. Since the locals are placed last in the list of identifiers, they
+  // result. Since the locals are placed last in the list of variables, they
   // will be minimized last in the lexmin. So simply truncating out the locals
   // from the end of the answer gives the desired lexmin over the dimensions.
-  assert(maybeLexMin->size() == getNumIds() &&
+  assert(maybeLexMin->size() == getNumVars() &&
          "Incorrect number of vars in lexMin!");
-  maybeLexMin->resize(getNumDimAndSymbolIds());
+  maybeLexMin->resize(getNumDimAndSymbolVars());
   return maybeLexMin;
 }
 
 MaybeOptimum<SmallVector<int64_t, 8>>
 IntegerRelation::findIntegerLexMin() const {
-  assert(getNumSymbolIds() == 0 && "Symbols are not supported!");
+  assert(getNumSymbolVars() == 0 && "Symbols are not supported!");
   MaybeOptimum<SmallVector<int64_t, 8>> maybeLexMin =
       LexSimplex(*this).findIntegerLexMin();
 
   if (!maybeLexMin.isBounded())
     return maybeLexMin.getKind();
 
   // The Simplex returns the lexmin over all the variables including locals. But
   // locals are not actually part of the space and should not be returned in the
-  // result. Since the locals are placed last in the list of identifiers, they
+  // result. Since the locals are placed last in the list of variables, they
   // will be minimized last in the lexmin. So simply truncating out the locals
   // from the end of the answer gives the desired lexmin over the dimensions.
-  assert(maybeLexMin->size() == getNumIds() &&
+  assert(maybeLexMin->size() == getNumVars() &&
          "Incorrect number of vars in lexMin!");
-  maybeLexMin->resize(getNumDimAndSymbolIds());
+  maybeLexMin->resize(getNumDimAndSymbolVars());
   return maybeLexMin;
 }
 
 static bool rangeIsZero(ArrayRef<int64_t> range) {
   return llvm::all_of(range, [](int64_t x) { return x == 0; });
 }
 
-void removeConstraintsInvolvingIdRange(IntegerRelation &poly, unsigned begin,
-                                       unsigned count) {
+static void removeConstraintsInvolvingVarRange(IntegerRelation &poly,
+                                               unsigned begin, unsigned count) {
   // We loop until i > 0 and index into i - 1 to avoid sign issues.
   //
   // We iterate backwards so that whether we remove constraint i - 1 or not, the
   // next constraint to be tested is always i - 2.
   for (unsigned i = poly.getNumEqualities(); i > 0; i--)
     if (!rangeIsZero(poly.getEquality(i - 1).slice(begin, count)))
       poly.removeEquality(i - 1);
   for (unsigned i = poly.getNumInequalities(); i > 0; i--)
     if (!rangeIsZero(poly.getInequality(i - 1).slice(begin, count)))
       poly.removeInequality(i - 1);
 }
 
 IntegerRelation::CountsSnapshot IntegerRelation::getCounts() const {
   return {getSpace(), getNumInequalities(), getNumEqualities()};
 }
 
-void IntegerRelation::truncateIdKind(IdKind kind, unsigned num) {
-  unsigned curNum = getNumIdKind(kind);
-  assert(num <= curNum && "Can't truncate to more ids!");
-  removeIdRange(kind, num, curNum);
+void IntegerRelation::truncateVarKind(VarKind kind, unsigned num) {
+  unsigned curNum = getNumVarKind(kind);
+  assert(num <= curNum && "Can't truncate to more vars!");
+  removeVarRange(kind, num, curNum);
 }
 
-void IntegerRelation::truncateIdKind(IdKind kind,
+void IntegerRelation::truncateVarKind(VarKind kind,
                                       const CountsSnapshot &counts) {
-  truncateIdKind(kind, counts.getSpace().getNumIdKind(kind));
+  truncateVarKind(kind, counts.getSpace().getNumVarKind(kind));
 }
 
 void IntegerRelation::truncate(const CountsSnapshot &counts) {
-  truncateIdKind(IdKind::Domain, counts);
-  truncateIdKind(IdKind::Range, counts);
-  truncateIdKind(IdKind::Symbol, counts);
-  truncateIdKind(IdKind::Local, counts);
+  truncateVarKind(VarKind::Domain, counts);
+  truncateVarKind(VarKind::Range, counts);
+  truncateVarKind(VarKind::Symbol, counts);
+  truncateVarKind(VarKind::Local, counts);
   removeInequalityRange(counts.getNumIneqs(), getNumInequalities());
   removeEqualityRange(counts.getNumEqs(), getNumEqualities());
 }
 
 PresburgerSet IntegerPolyhedron::computeReprWithOnlyDivLocals() const {
   // If there are no locals, we're done.
-  if (getNumLocalIds() == 0)
+  if (getNumLocalVars() == 0)
     return PresburgerSet(*this);
 
   // Move all the non-div locals to the end, as the current API to
   // SymbolicLexMin requires these to form a contiguous range.
   //
   // Take a copy so we can perform mutations.
   IntegerPolyhedron copy = *this;
   std::vector<MaybeLocalRepr> reprs;
   copy.getLocalReprs(reprs);
 
   // Iterate through all the locals. The last `numNonDivLocals` are the locals
   // that have been scanned already and do not have division representations.
   unsigned numNonDivLocals = 0;
-  unsigned offset = copy.getIdKindOffset(IdKind::Local);
-  for (unsigned i = 0, e = copy.getNumLocalIds(); i < e - numNonDivLocals;) {
+  unsigned offset = copy.getVarKindOffset(VarKind::Local);
+  for (unsigned i = 0, e = copy.getNumLocalVars(); i < e - numNonDivLocals;) {
     if (!reprs[i]) {
       // Whenever we come across a local that does not have a division
       // representation, we swap it to the `numNonDivLocals`-th last position
       // and increment `numNonDivLocal`s. `reprs` also needs to be swapped.
-      copy.swapId(offset + i, offset + e - numNonDivLocals - 1);
+      copy.swapVar(offset + i, offset + e - numNonDivLocals - 1);
       std::swap(reprs[i], reprs[e - numNonDivLocals - 1]);
       ++numNonDivLocals;
       continue;
     }
     ++i;
   }
 
   // If there are no non-div locals, we're done.
PresburgerSet IntegerPolyhedron::computeReprWithOnlyDivLocals() const {
   // exists but the lexmin is unbounded. We basically want to find the set of
   // values of the "symbols" such that an assignment to the "non-symbols"
   // exists, which is the union of the domain of the returned lexmin function
   // and the returned set of assignments to the "symbols" that makes the lexmin
   // unbounded.
   SymbolicLexMin lexminResult =
       SymbolicLexSimplex(copy, /*symbolOffset*/ 0,
                          IntegerPolyhedron(PresburgerSpace::getSetSpace(
-                             /*numDims=*/copy.getNumIds() - numNonDivLocals)))
+                             /*numDims=*/copy.getNumVars() - numNonDivLocals)))
           .computeSymbolicIntegerLexMin();
   PresburgerSet result =
       lexminResult.lexmin.getDomain().unionSet(lexminResult.unboundedDomain);
 
   // The result set might lie in the wrong space -- all its ids are dims.
   // Set it to the desired space and return.
   PresburgerSpace space = getSpace();
-  space.removeIdRange(IdKind::Local, 0, getNumLocalIds());
+  space.removeVarRange(VarKind::Local, 0, getNumLocalVars());
   result.setSpace(space);
   return result;
 }
 
 SymbolicLexMin IntegerPolyhedron::findSymbolicIntegerLexMin() const {
   // Compute the symbolic lexmin of the dims and locals, with the symbols being
   // the actual symbols of this set.
   SymbolicLexMin result =
       SymbolicLexSimplex(*this, IntegerPolyhedron(PresburgerSpace::getSetSpace(
-                                    /*numDims=*/getNumSymbolIds())))
+                                    /*numDims=*/getNumSymbolVars())))
           .computeSymbolicIntegerLexMin();
 
   // We want to return only the lexmin over the dims, so strip the locals from
   // the computed lexmin.
   result.lexmin.truncateOutput(result.lexmin.getNumOutputs() -
-                               getNumLocalIds());
+                               getNumLocalVars());
   return result;
 }
 
-unsigned IntegerRelation::insertId(IdKind kind, unsigned pos, unsigned num) {
-  assert(pos <= getNumIdKind(kind));
+unsigned IntegerRelation::insertVar(VarKind kind, unsigned pos, unsigned num) {
+  assert(pos <= getNumVarKind(kind));
 
-  unsigned insertPos = space.insertId(kind, pos, num);
+  unsigned insertPos = space.insertVar(kind, pos, num);
   inequalities.insertColumns(insertPos, num);
   equalities.insertColumns(insertPos, num);
   return insertPos;
 }
 
-unsigned IntegerRelation::appendId(IdKind kind, unsigned num) {
-  unsigned pos = getNumIdKind(kind);
-  return insertId(kind, pos, num);
+unsigned IntegerRelation::appendVar(VarKind kind, unsigned num) {
+  unsigned pos = getNumVarKind(kind);
+  return insertVar(kind, pos, num);
 }
 
 void IntegerRelation::addEquality(ArrayRef<int64_t> eq) {
   assert(eq.size() == getNumCols());
   unsigned row = equalities.appendExtraRow();
   for (unsigned i = 0, e = eq.size(); i < e; ++i)
     equalities(row, i) = eq[i];
 }
 
 void IntegerRelation::addInequality(ArrayRef<int64_t> inEq) {
   assert(inEq.size() == getNumCols());
   unsigned row = inequalities.appendExtraRow();
   for (unsigned i = 0, e = inEq.size(); i < e; ++i)
     inequalities(row, i) = inEq[i];
 }
 
-void IntegerRelation::removeId(IdKind kind, unsigned pos) {
-  removeIdRange(kind, pos, pos + 1);
+void IntegerRelation::removeVar(VarKind kind, unsigned pos) {
+  removeVarRange(kind, pos, pos + 1);
 }
 
-void IntegerRelation::removeId(unsigned pos) { removeIdRange(pos, pos + 1); }
+void IntegerRelation::removeVar(unsigned pos) { removeVarRange(pos, pos + 1); }
 
-void IntegerRelation::removeIdRange(IdKind kind, unsigned idStart,
-                                    unsigned idLimit) {
-  assert(idLimit <= getNumIdKind(kind));
+void IntegerRelation::removeVarRange(VarKind kind, unsigned varStart,
+                                     unsigned varLimit) {
+  assert(varLimit <= getNumVarKind(kind));
 
-  if (idStart >= idLimit)
+  if (varStart >= varLimit)
     return;
 
-  // Remove eliminated identifiers from the constraints.
-  unsigned offset = getIdKindOffset(kind);
-  equalities.removeColumns(offset + idStart, idLimit - idStart);
-  inequalities.removeColumns(offset + idStart, idLimit - idStart);
+  // Remove eliminated variables from the constraints.
+  unsigned offset = getVarKindOffset(kind);
+  equalities.removeColumns(offset + varStart, varLimit - varStart);
+  inequalities.removeColumns(offset + varStart, varLimit - varStart);
 
-  // Remove eliminated identifiers from the space.
-  space.removeIdRange(kind, idStart, idLimit);
+  // Remove eliminated variables from the space.
+  space.removeVarRange(kind, varStart, varLimit);
 }
 
-void IntegerRelation::removeIdRange(unsigned idStart, unsigned idLimit) {
-  assert(idLimit <= getNumIds());
+void IntegerRelation::removeVarRange(unsigned varStart, unsigned varLimit) {
+  assert(varLimit <= getNumVars());
 
-  if (idStart >= idLimit)
+  if (varStart >= varLimit)
     return;
 
-  // Helper function to remove ids of the specified kind in the given range
+  // Helper function to remove vars of the specified kind in the given range
   // [start, limit), The range is absolute (i.e. it is not relative to the kind
-  // of identifier). Also updates `limit` to reflect the deleted identifiers.
-  auto removeIdKindInRange = [this](IdKind kind, unsigned &start,
+  // of variable). Also updates `limit` to reflect the deleted variables.
+  auto removeVarKindInRange = [this](VarKind kind, unsigned &start,
                                      unsigned &limit) {
     if (start >= limit)
       return;
 
-    unsigned offset = getIdKindOffset(kind);
-    unsigned num = getNumIdKind(kind);
+    unsigned offset = getVarKindOffset(kind);
+    unsigned num = getNumVarKind(kind);
 
     // Get `start`, `limit` relative to the specified kind.
     unsigned relativeStart =
         start <= offset ? 0 : std::min(num, start - offset);
     unsigned relativeLimit =
         limit <= offset ? 0 : std::min(num, limit - offset);
 
-    // Remove ids of the specified kind in the relative range.
-    removeIdRange(kind, relativeStart, relativeLimit);
+    // Remove vars of the specified kind in the relative range.
+    removeVarRange(kind, relativeStart, relativeLimit);
 
-    // Update `limit` to reflect deleted identifiers.
-    // `start` does not need to be updated because any identifiers that are
+    // Update `limit` to reflect deleted variables.
+    // `start` does not need to be updated because any variables that are
     // deleted are after position `start`.
     limit -= relativeLimit - relativeStart;
   };
 
-  removeIdKindInRange(IdKind::Domain, idStart, idLimit);
-  removeIdKindInRange(IdKind::Range, idStart, idLimit);
-  removeIdKindInRange(IdKind::Symbol, idStart, idLimit);
-  removeIdKindInRange(IdKind::Local, idStart, idLimit);
+  removeVarKindInRange(VarKind::Domain, varStart, varLimit);
+  removeVarKindInRange(VarKind::Range, varStart, varLimit);
+  removeVarKindInRange(VarKind::Symbol, varStart, varLimit);
+  removeVarKindInRange(VarKind::Local, varStart, varLimit);
 }
 
 void IntegerRelation::removeEquality(unsigned pos) {
   equalities.removeRow(pos);
 }
 
 void IntegerRelation::removeInequality(unsigned pos) {
   inequalities.removeRow(pos);
 }
 
 void IntegerRelation::removeEqualityRange(unsigned start, unsigned end) {
   if (start >= end)
     return;
   equalities.removeRows(start, end - start);
 }
 
 void IntegerRelation::removeInequalityRange(unsigned start, unsigned end) {
   if (start >= end)
     return;
   inequalities.removeRows(start, end - start);
 }
 
-void IntegerRelation::swapId(unsigned posA, unsigned posB) {
-  assert(posA < getNumIds() && "invalid position A");
-  assert(posB < getNumIds() && "invalid position B");
+void IntegerRelation::swapVar(unsigned posA, unsigned posB) {
+  assert(posA < getNumVars() && "invalid position A");
+  assert(posB < getNumVars() && "invalid position B");
 
   if (posA == posB)
     return;
 
   inequalities.swapColumns(posA, posB);
   equalities.swapColumns(posA, posB);
 }
 
 void IntegerRelation::clearConstraints() {
   equalities.resizeVertically(0);
   inequalities.resizeVertically(0);
 }
 
-/// Gather all lower and upper bounds of the identifier at `pos`, and
+/// Gather all lower and upper bounds of the variable at `pos`, and
 /// optionally any equalities on it. In addition, the bounds are to be
-/// independent of identifiers in position range [`offset`, `offset` + `num`).
+/// independent of variables in position range [`offset`, `offset` + `num`).
 void IntegerRelation::getLowerAndUpperBoundIndices(
     unsigned pos, SmallVectorImpl<unsigned> *lbIndices,
     SmallVectorImpl<unsigned> *ubIndices, SmallVectorImpl<unsigned> *eqIndices,
     unsigned offset, unsigned num) const {
-  assert(pos < getNumIds() && "invalid position");
+  assert(pos < getNumVars() && "invalid position");
   assert(offset + num < getNumCols() && "invalid range");
 
-  // Checks for a constraint that has a non-zero coeff for the identifiers in
+  // Checks for a constraint that has a non-zero coeff for the variables in
   // the position range [offset, offset + num) while ignoring `pos`.
   auto containsConstraintDependentOnRange = [&](unsigned r, bool isEq) {
     unsigned c, f;
     auto cst = isEq ? getEquality(r) : getInequality(r);
     for (c = offset, f = offset + num; c < f; ++c) {
       if (c == pos)
         continue;
       if (cst[c] != 0)
if (atIneq(r, pos) >= 1) {
       lbIndices->push_back(r);
     } else if (atIneq(r, pos) <= -1) {
       // Upper bound.
       ubIndices->push_back(r);
     }
   }
 
   // An equality is both a lower and upper bound. Record any equalities
-  // involving the pos^th identifier.
+  // involving the pos^th variable.
   if (!eqIndices)
     return;
 
   for (unsigned r = 0, e = getNumEqualities(); r < e; r++) {
     if (atEq(r, pos) == 0)
       continue;
     if (containsConstraintDependentOnRange(r, /*isEq=*/true))
       continue;
     eqIndices->push_back(r);
   }
 }
 
 bool IntegerRelation::hasConsistentState() const {
   if (!inequalities.hasConsistentState())
     return false;
   if (!equalities.hasConsistentState())
     return false;
   return true;
 }
 
 void IntegerRelation::setAndEliminate(unsigned pos, ArrayRef<int64_t> values) {
   if (values.empty())
     return;
-  assert(pos + values.size() <= getNumIds() &&
+  assert(pos + values.size() <= getNumVars() &&
          "invalid position or too many values");
   // Setting x_j = p in sum_i a_i x_i + c is equivalent to adding p*a_j to the
-  // constant term and removing the id x_j. We do this for all the ids
+  // constant term and removing the var x_j. We do this for all the vars
   // pos, pos + 1, ... pos + values.size() - 1.
   unsigned constantColPos = getNumCols() - 1;
   for (unsigned i = 0, numVals = values.size(); i < numVals; ++i)
     inequalities.addToColumn(i + pos, constantColPos, values[i]);
   for (unsigned i = 0, numVals = values.size(); i < numVals; ++i)
     equalities.addToColumn(i + pos, constantColPos, values[i]);
-  removeIdRange(pos, pos + values.size());
+  removeVarRange(pos, pos + values.size());
 }
 
 void IntegerRelation::clearAndCopyFrom(const IntegerRelation &other) {
   *this = other;
 }
 
 // Searches for a constraint with a non-zero coefficient at `colIdx` in
 // equality (isEq=true) or inequality (isEq=false) constraints.
auto check = [&](bool isEq) -> bool {
     }
     return false;
   };
   if (check(/*isEq=*/true))
     return true;
   return check(/*isEq=*/false);
 }
 
-/// Eliminate identifier from constraint at `rowIdx` based on coefficient at
+/// Eliminate variable from constraint at `rowIdx` based on coefficient at
 /// pivotRow, pivotCol. Columns in range [elimColStart, pivotCol) will not be
 /// updated as they have already been eliminated.
 static void eliminateFromConstraint(IntegerRelation *constraints,
                                     unsigned rowIdx, unsigned pivotRow,
                                     unsigned pivotCol, unsigned elimColStart,
                                     bool isEq) {
   // Skip if equality 'rowIdx' if same as 'pivotRow'.
   if (isEq && rowIdx == pivotRow)
if (j >= elimColStart && j < pivotCol)
       continue;
     int64_t v = pivotMultiplier * constraints->atEq(pivotRow, j) +
                 rowMultiplier * at(rowIdx, j);
     isEq ? constraints->atEq(rowIdx, j) = v
          : constraints->atIneq(rowIdx, j) = v;
   }
 }
 
-/// Returns the position of the identifier that has the minimum <number of lower
+/// Returns the position of the variable that has the minimum <number of lower
 /// bounds> times <number of upper bounds> from the specified range of
-/// identifiers [start, end). It is often best to eliminate in the increasing
+/// variables [start, end). It is often best to eliminate in the increasing
 /// order of these counts when doing Fourier-Motzkin elimination since FM adds
 /// that many new constraints.
-static unsigned getBestIdToEliminate(const IntegerRelation &cst, unsigned start,
-                                     unsigned end) {
-  assert(start < cst.getNumIds() && end < cst.getNumIds() + 1);
+static unsigned getBestVarToEliminate(const IntegerRelation &cst,
+                                      unsigned start, unsigned end) {
+  assert(start < cst.getNumVars() && end < cst.getNumVars() + 1);
 
   auto getProductOfNumLowerUpperBounds = [&](unsigned pos) {
     unsigned numLb = 0;
     unsigned numUb = 0;
     for (unsigned r = 0, e = cst.getNumInequalities(); r < e; r++) {
       if (cst.atIneq(r, pos) > 0) {
         ++numLb;
       } else if (cst.atIneq(r, pos) < 0) {
for (unsigned c = start + 1; c < end; c++) {
     if (numLbUbProduct < min) {
       min = numLbUbProduct;
       minLoc = c;
     }
   }
   return minLoc;
 }
 
-// Checks for emptiness of the set by eliminating identifiers successively and
+// Checks for emptiness of the set by eliminating variables successively and
 // using the GCD test (on all equality constraints) and checking for trivially
 // invalid constraints. Returns 'true' if the constraint system is found to be
 // empty; false otherwise.
 bool IntegerRelation::isEmpty() const {
   if (isEmptyByGCDTest() || hasInvalidConstraint())
     return true;
 
   IntegerRelation tmpCst(*this);
 
   // First, eliminate as many local variables as possible using equalities.
   tmpCst.removeRedundantLocalVars();
   if (tmpCst.isEmptyByGCDTest() || tmpCst.hasInvalidConstraint())
     return true;
 
-  // Eliminate as many identifiers as possible using Gaussian elimination.
+  // Eliminate as many variables as possible using Gaussian elimination.
   unsigned currentPos = 0;
-  while (currentPos < tmpCst.getNumIds()) {
-    tmpCst.gaussianEliminateIds(currentPos, tmpCst.getNumIds());
+  while (currentPos < tmpCst.getNumVars()) {
+    tmpCst.gaussianEliminateVars(currentPos, tmpCst.getNumVars());
     ++currentPos;
     // We check emptiness through trivial checks after eliminating each ID to
     // detect emptiness early. Since the checks isEmptyByGCDTest() and
     // hasInvalidConstraint() are linear time and single sweep on the constraint
     // buffer, this appears reasonable - but can optimize in the future.
     if (tmpCst.hasInvalidConstraint() || tmpCst.isEmptyByGCDTest())
       return true;
   }
 
   // Eliminate the remaining using FM.
-  for (unsigned i = 0, e = tmpCst.getNumIds(); i < e; i++) {
+  for (unsigned i = 0, e = tmpCst.getNumVars(); i < e; i++) {
     tmpCst.fourierMotzkinEliminate(
-        getBestIdToEliminate(tmpCst, 0, tmpCst.getNumIds()));
+        getBestVarToEliminate(tmpCst, 0, tmpCst.getNumVars()));
     // Check for a constraint explosion. This rarely happens in practice, but
     // this check exists as a safeguard against improperly constructed
     // constraint systems or artificially created arbitrarily complex systems
     // that aren't the intended use case for IntegerRelation. This is
     // needed since FM has a worst case exponential complexity in theory.
-    if (tmpCst.getNumConstraints() >= kExplosionFactor * getNumIds()) {
+    if (tmpCst.getNumConstraints() >= kExplosionFactor * getNumVars()) {
       LLVM_DEBUG(llvm::dbgs() << "FM constraint explosion detected\n");
       return false;
     }
 
     // FM wouldn't have modified the equalities in any way. So no need to again
     // run GCD test. Check for trivial invalid constraints.
     if (tmpCst.hasInvalidConstraint())
       return true;
Optional<SmallVector<int64_t, 8>> IntegerRelation::findIntegerSample() const {
   const LinearTransform &transform = result.second;
   // 1) Apply T to S to obtain S*T.
   IntegerRelation transformedSet = transform.applyTo(*this);
 
   // 2) Remove the unbounded dimensions and constraints involving them to
   // obtain a bounded set.
   IntegerRelation boundedSet(transformedSet);
   unsigned numBoundedDims = result.first;
-  unsigned numUnboundedDims = getNumIds() - numBoundedDims;
-  removeConstraintsInvolvingIdRange(boundedSet, numBoundedDims,
+  unsigned numUnboundedDims = getNumVars() - numBoundedDims;
+  removeConstraintsInvolvingVarRange(boundedSet, numBoundedDims,
                                      numUnboundedDims);
-  boundedSet.removeIdRange(numBoundedDims, boundedSet.getNumIds());
+  boundedSet.removeVarRange(numBoundedDims, boundedSet.getNumVars());
 
   // 3) Try to obtain a sample from the bounded set.
   Optional<SmallVector<int64_t, 8>> boundedSample =
       Simplex(boundedSet).findIntegerSample();
   if (!boundedSample)
     return {};
   assert(boundedSet.containsPoint(*boundedSample) &&
          "Simplex returned an invalid sample!");
Optional<SmallVector<int64_t, 8>> IntegerRelation::findIntegerSample() const {
   // is minimized when we add 1 to the x_i with negative coefficient a_i and
   // keep the other x_i the same. In the example, we would get x = (3, 1, 1),
   // changing the value of the LHS by -3 + -7 = -10.
   //
   // In general, the value of the LHS can change by at most the sum of the
   // negative a_i, so we accomodate this by shifting the inequality by this
   // amount for the shrunken cone.
   for (unsigned i = 0, e = cone.getNumInequalities(); i < e; ++i) {
-    for (unsigned j = 0; j < cone.getNumIds(); ++j) {
+    for (unsigned j = 0; j < cone.getNumVars(); ++j) {
       int64_t coeff = cone.atIneq(i, j);
       if (coeff < 0)
-        cone.atIneq(i, cone.getNumIds()) += coeff;
+        cone.atIneq(i, cone.getNumVars()) += coeff;
     }
   }
 
   // Obtain an integer sample in the cone by rounding up a rational point from
   // the shrunken cone. Shrinking the cone amounts to shifting its apex
   // "inwards" without changing its "shape"; the shrunken cone is still a
   // full-dimensional cone and is hence non-empty.
   Simplex shrunkenConeSimplex(cone);
bool IntegerRelation::containsPoint(ArrayRef<int64_t> point) const {
   for (unsigned i = 0, e = getNumInequalities(); i < e; ++i) {
     if (valueAt(getInequality(i), point) < 0)
       return false;
   }
   return true;
 }
 
 /// Just substitute the values given and check if an integer sample exists for
-/// the local ids.
+/// the local vars.
 ///
 /// TODO: this could be made more efficient by handling divisions separately.
 /// Instead of finding an integer sample over all the locals, we can first
 /// compute the values of the locals that have division representations and
 /// only use the integer emptiness check for the locals that don't have this.
 /// Handling this correctly requires ordering the divs, though.
 Optional<SmallVector<int64_t, 8>>
 IntegerRelation::containsPointNoLocal(ArrayRef<int64_t> point) const {
-  assert(point.size() == getNumIds() - getNumLocalIds() &&
-         "Point should contain all ids except locals!");
-  assert(getIdKindOffset(IdKind::Local) == getNumIds() - getNumLocalIds() &&
+  assert(point.size() == getNumVars() - getNumLocalVars() &&
+         "Point should contain all vars except locals!");
+  assert(getVarKindOffset(VarKind::Local) == getNumVars() - getNumLocalVars() &&
          "This function depends on locals being stored last!");
   IntegerRelation copy = *this;
   copy.setAndEliminate(0, point);
   return copy.findIntegerSample();
 }
 
 void IntegerRelation::getLocalReprs(std::vector<MaybeLocalRepr> &repr) const {
-  std::vector<SmallVector<int64_t, 8>> dividends(getNumLocalIds());
-  SmallVector<unsigned, 4> denominators(getNumLocalIds());
+  std::vector<SmallVector<int64_t, 8>> dividends(getNumLocalVars());
+  SmallVector<unsigned, 4> denominators(getNumLocalVars());
   getLocalReprs(dividends, denominators, repr);
 }
 
 void IntegerRelation::getLocalReprs(
     std::vector<SmallVector<int64_t, 8>> &dividends,
     SmallVector<unsigned, 4> &denominators) const {
-  std::vector<MaybeLocalRepr> repr(getNumLocalIds());
+  std::vector<MaybeLocalRepr> repr(getNumLocalVars());
   getLocalReprs(dividends, denominators, repr);
 }
 
 void IntegerRelation::getLocalReprs(
     std::vector<SmallVector<int64_t, 8>> &dividends,
     SmallVector<unsigned, 4> &denominators,
     std::vector<MaybeLocalRepr> &repr) const {
 
-  repr.resize(getNumLocalIds());
-  dividends.resize(getNumLocalIds());
-  denominators.resize(getNumLocalIds());
+  repr.resize(getNumLocalVars());
+  dividends.resize(getNumLocalVars());
+  denominators.resize(getNumLocalVars());
 
-  SmallVector<bool, 8> foundRepr(getNumIds(), false);
-  for (unsigned i = 0, e = getNumDimAndSymbolIds(); i < e; ++i)
+  SmallVector<bool, 8> foundRepr(getNumVars(), false);
+  for (unsigned i = 0, e = getNumDimAndSymbolVars(); i < e; ++i)
     foundRepr[i] = true;
 
-  unsigned divOffset = getNumDimAndSymbolIds();
+  unsigned divOffset = getNumDimAndSymbolVars();
   bool changed;
   do {
     // Each time changed is true, at end of this iteration, one or more local
     // vars have been detected as floor divs.
     changed = false;
-    for (unsigned i = 0, e = getNumLocalIds(); i < e; ++i) {
+    for (unsigned i = 0, e = getNumLocalVars(); i < e; ++i) {
       if (!foundRepr[i + divOffset]) {
         MaybeLocalRepr res = computeSingleVarRepr(
             *this, foundRepr, divOffset + i, dividends[i], denominators[i]);
         if (!res)
           continue;
         foundRepr[i + divOffset] = true;
         repr[i] = res;
         changed = true;
       }
     }
   } while (changed);
 
-  // Set 0 denominator for identifiers for which no division representation
+  // Set 0 denominator for variables for which no division representation
   // could be found.
   for (unsigned i = 0, e = repr.size(); i < e; ++i)
     if (!repr[i])
       denominators[i] = 0;
 }
 
 /// Tightens inequalities given that we are dealing with integer spaces. This is
 /// analogous to the GCD test but applied to inequalities. The constant term can
 /// be reduced to the preceding multiple of the GCD of the coefficients, i.e.,
 ///  64*i - 100 >= 0  =>  64*i - 128 >= 0 (since 'i' is an integer). This is a
 /// fast method - linear in the number of coefficients.
 // Example on how this affects practical cases: consider the scenario:
 // 64*i >= 100, j = 64*i; without a tightening, elimination of i would yield
 // j >= 100 instead of the tighter (exact) j >= 128.
 void IntegerRelation::gcdTightenInequalities() {
   unsigned numCols = getNumCols();
   for (unsigned i = 0, e = getNumInequalities(); i < e; ++i) {
     // Normalize the constraint and tighten the constant term by the GCD.
     int64_t gcd = inequalities.normalizeRow(i, getNumCols() - 1);
     if (gcd > 1)
       atIneq(i, numCols - 1) = mlir::floorDiv(atIneq(i, numCols - 1), gcd);
   }
 }
 
-// Eliminates all identifier variables in column range [posStart, posLimit).
+// Eliminates all variable variables in column range [posStart, posLimit).
 // Returns the number of variables eliminated.
-unsigned IntegerRelation::gaussianEliminateIds(unsigned posStart,
+unsigned IntegerRelation::gaussianEliminateVars(unsigned posStart,
                                                 unsigned posLimit) {
-  // Return if identifier positions to eliminate are out of range.
-  assert(posLimit <= getNumIds());
+  // Return if variable positions to eliminate are out of range.
+  assert(posLimit <= getNumVars());
   assert(hasConsistentState());
 
   if (posStart >= posLimit)
     return 0;
 
   gcdTightenInequalities();
 
   unsigned pivotCol = 0;
   for (pivotCol = posStart; pivotCol < posLimit; ++pivotCol) {
     // Find a row which has a non-zero coefficient in column 'j'.
     unsigned pivotRow;
     if (!findConstraintWithNonZeroAt(pivotCol, /*isEq=*/true, &pivotRow)) {
       // No pivot row in equalities with non-zero at 'pivotCol'.
       if (!findConstraintWithNonZeroAt(pivotCol, /*isEq=*/false, &pivotRow)) {
         // If inequalities are also non-zero in 'pivotCol', it can be
         // eliminated.
         continue;
       }
       break;
     }
 
-    // Eliminate identifier at 'pivotCol' from each equality row.
+    // Eliminate variable at 'pivotCol' from each equality row.
     for (unsigned i = 0, e = getNumEqualities(); i < e; ++i) {
       eliminateFromConstraint(this, i, pivotRow, pivotCol, posStart,
                               /*isEq=*/true);
       equalities.normalizeRow(i);
     }
 
-    // Eliminate identifier at 'pivotCol' from each inequality row.
+    // Eliminate variable at 'pivotCol' from each inequality row.
     for (unsigned i = 0, e = getNumInequalities(); i < e; ++i) {
       eliminateFromConstraint(this, i, pivotRow, pivotCol, posStart,
                               /*isEq=*/false);
       inequalities.normalizeRow(i);
     }
     removeEquality(pivotRow);
     gcdTightenInequalities();
   }
   // Update position limit based on number eliminated.
   posLimit = pivotCol;
   // Remove eliminated columns from all constraints.
-  removeIdRange(posStart, posLimit);
+  removeVarRange(posStart, posLimit);
   return posLimit - posStart;
 }
 
 // A more complex check to eliminate redundant inequalities. Uses FourierMotzkin
 // to check if a constraint is redundant.
 void IntegerRelation::removeRedundantInequalities() {
   SmallVector<bool, 32> redun(getNumInequalities(), false);
   // To check if an inequality is redundant, we replace the inequality by its
for (unsigned r = 0, e = getNumEqualities(); r < e; r++) {
     if (!(simplex.isMarkedRedundant(numIneqs + 2 * r) &&
           simplex.isMarkedRedundant(numIneqs + 2 * r + 1)))
       equalities.copyRow(r, pos++);
   }
   equalities.resizeVertically(pos);
 }
 
 Optional<uint64_t> IntegerRelation::computeVolume() const {
-  assert(getNumSymbolIds() == 0 && "Symbols are not yet supported!");
+  assert(getNumSymbolVars() == 0 && "Symbols are not yet supported!");
 
   Simplex simplex(*this);
   // If the polytope is rationally empty, there are certainly no integer
   // points.
   if (simplex.isEmpty())
     return 0;
 
-  // Just find the maximum and minimum integer value of each non-local id
-  // separately, thus finding the number of integer values each such id can
+  // Just find the maximum and minimum integer value of each non-local var
+  // separately, thus finding the number of integer values each such var can
   // take. Multiplying these together gives a valid overapproximation of the
   // number of integer points in the relation. The result this gives is
-  // equivalent to projecting (rationally) the relation onto its non-local ids
+  // equivalent to projecting (rationally) the relation onto its non-local vars
   // and returning the number of integer points in a minimal axis-parallel
   // hyperrectangular overapproximation of that.
   //
   // We also handle the special case where one dimension is unbounded and
   // another dimension can take no integer values. In this case, the volume is
   // zero.
   //
   // If there is no such empty dimension, if any dimension is unbounded we
   // just return the result as unbounded.
   uint64_t count = 1;
-  SmallVector<int64_t, 8> dim(getNumIds() + 1);
-  bool hasUnboundedId = false;
-  for (unsigned i = 0, e = getNumDimAndSymbolIds(); i < e; ++i) {
+  SmallVector<int64_t, 8> dim(getNumVars() + 1);
+  bool hasUnboundedVar = false;
+  for (unsigned i = 0, e = getNumDimAndSymbolVars(); i < e; ++i) {
     dim[i] = 1;
     MaybeOptimum<int64_t> min, max;
     std::tie(min, max) = simplex.computeIntegerBounds(dim);
     dim[i] = 0;
 
     assert((!min.isEmpty() && !max.isEmpty()) &&
            "Polytope should be rationally non-empty!");
 
     // One of the dimensions is unbounded. Note this fact. We will return
     // unbounded if none of the other dimensions makes the volume zero.
     if (min.isUnbounded() || max.isUnbounded()) {
-      hasUnboundedId = true;
+      hasUnboundedVar = true;
       continue;
     }
 
     // In this case there are no valid integer points and the volume is
     // definitely zero.
     if (min.getBoundedOptimum() > max.getBoundedOptimum())
       return 0;
 
     count *= (*max - *min + 1);
   }
 
   if (count == 0)
     return 0;
-  if (hasUnboundedId)
+  if (hasUnboundedVar)
     return {};
   return count;
 }
 
-void IntegerRelation::eliminateRedundantLocalId(unsigned posA, unsigned posB) {
-  assert(posA < getNumLocalIds() && "Invalid local id position");
-  assert(posB < getNumLocalIds() && "Invalid local id position");
+void IntegerRelation::eliminateRedundantLocalVar(unsigned posA, unsigned posB) {
+  assert(posA < getNumLocalVars() && "Invalid local var position");
+  assert(posB < getNumLocalVars() && "Invalid local var position");
 
-  unsigned localOffset = getIdKindOffset(IdKind::Local);
+  unsigned localOffset = getVarKindOffset(VarKind::Local);
   posA += localOffset;
   posB += localOffset;
   inequalities.addToColumn(posB, posA, 1);
   equalities.addToColumn(posB, posA, 1);
-  removeId(posB);
+  removeVar(posB);
 }
 
 /// Adds additional local ids to the sets such that they both have the union
 /// of the local ids in each set, without changing the set of points that
 /// lie in `this` and `other`.
 ///
 /// To detect local ids that always take the same value, each local id is
 /// represented as a floordiv with constant denominator in terms of other ids.
 /// After extracting these divisions, local ids in `other` with the same
 /// division representation as some other local id in any set are considered
 /// duplicate and are merged.
 ///
 /// It is possible that division representation for some local id cannot be
 /// obtained, and thus these local ids are not considered for detecting
 /// duplicates.
-unsigned IntegerRelation::mergeLocalIds(IntegerRelation &other) {
+unsigned IntegerRelation::mergeLocalVars(IntegerRelation &other) {
   IntegerRelation &relA = *this;
   IntegerRelation &relB = other;
 
-  unsigned oldALocals = relA.getNumLocalIds();
+  unsigned oldALocals = relA.getNumLocalVars();
 
   // Merge function that merges the local variables in both sets by treating
-  // them as the same identifier.
+  // them as the same variable.
   auto merge = [&relA, &relB, oldALocals](unsigned i, unsigned j) -> bool {
     // We only merge from local at pos j to local at pos i, where j > i.
     if (i >= j)
       return false;
 
     // If i < oldALocals, we are trying to merge duplicate divs. Since we do not
     // want to merge duplicates in A, we ignore this call.
     if (j < oldALocals)
       return false;
 
     // Merge local at pos j into local at position i.
-    relA.eliminateRedundantLocalId(i, j);
-    relB.eliminateRedundantLocalId(i, j);
+    relA.eliminateRedundantLocalVar(i, j);
+    relB.eliminateRedundantLocalVar(i, j);
     return true;
   };
 
-  presburger::mergeLocalIds(*this, other, merge);
+  presburger::mergeLocalVars(*this, other, merge);
 
   // Since we do not remove duplicate divisions in relA, this is guranteed to be
   // non-negative.
-  return relA.getNumLocalIds() - oldALocals;
+  return relA.getNumLocalVars() - oldALocals;
 }
 
 bool IntegerRelation::hasOnlyDivLocals() const {
   std::vector<MaybeLocalRepr> reprs;
   getLocalReprs(reprs);
   return llvm::all_of(reprs,
                       [](const MaybeLocalRepr &repr) { return bool(repr); });
 }
 
 void IntegerRelation::removeDuplicateDivs() {
   std::vector<SmallVector<int64_t, 8>> divs;
   SmallVector<unsigned, 4> denoms;
 
   getLocalReprs(divs, denoms);
   auto merge = [this](unsigned i, unsigned j) -> bool {
-    eliminateRedundantLocalId(i, j);
+    eliminateRedundantLocalVar(i, j);
     return true;
   };
-  presburger::removeDuplicateDivs(divs, denoms, getIdKindOffset(IdKind::Local),
-                                  merge);
+  presburger::removeDuplicateDivs(divs, denoms,
+                                  getVarKindOffset(VarKind::Local), merge);
 }
 
 /// Removes local variables using equalities. Each equality is checked if it
 /// can be reduced to the form: `e = affine-expr`, where `e` is a local
 /// variable and `affine-expr` is an affine expression not containing `e`.
 /// If an equality satisfies this form, the local variable is replaced in
 /// each constraint and then removed. The equality used to replace this local
 /// variable is also removed.
 void IntegerRelation::removeRedundantLocalVars() {
   // Normalize the equality constraints to reduce coefficients of local
   // variables to 1 wherever possible.
   for (unsigned i = 0, e = getNumEqualities(); i < e; ++i)
     equalities.normalizeRow(i);
 
   while (true) {
     unsigned i, e, j, f;
     for (i = 0, e = getNumEqualities(); i < e; ++i) {
       // Find a local variable to eliminate using ith equality.
-      for (j = getNumDimAndSymbolIds(), f = getNumIds(); j < f; ++j)
+      for (j = getNumDimAndSymbolVars(), f = getNumVars(); j < f; ++j)
         if (std::abs(atEq(i, j)) == 1)
           break;
 
       // Local variable can be eliminated using ith equality.
       if (j < f)
         break;
     }
 
for (unsigned k = 0, t = getNumEqualities(); k < t; ++k) {
       }
     }
 
     // Use the ith equality to simplify inequalities.
     for (unsigned k = 0, t = getNumInequalities(); k < t; ++k)
       eliminateFromConstraint(this, k, i, j, j, /*isEq=*/false);
 
     // Remove the ith equality and the found local variable.
-    removeId(j);
+    removeVar(j);
     removeEquality(i);
   }
 }
 
-void IntegerRelation::convertIdKind(IdKind srcKind, unsigned idStart,
-                                    unsigned idLimit, IdKind dstKind,
+void IntegerRelation::covertVarKind(VarKind srcKind, unsigned idStart,
+                                    unsigned idLimit, VarKind dstKind,
                                     unsigned pos) {
-  assert(idLimit <= getNumIdKind(srcKind) && "Invalid id range");
+  assert(idLimit <= getNumVarKind(srcKind) && "Invalid id range");
 
   if (idStart >= idLimit)
     return;
 
   // Append new local variables corresponding to the dimensions to be converted.
   unsigned convertCount = idLimit - idStart;
-  unsigned newIdsBegin = insertId(dstKind, pos, convertCount);
+  unsigned newVarsBegin = insertVar(dstKind, pos, convertCount);
 
   // Swap the new local variables with dimensions.
   //
   // Essentially, this moves the information corresponding to the specified ids
   // of kind `srcKind` to the `convertCount` newly created ids of kind
   // `dstKind`. In particular, this moves the columns in the constraint
   // matrices, and zeros out the initially occupied columns (because the newly
   // created ids we're swapping with were zero-initialized).
-  unsigned offset = getIdKindOffset(srcKind);
+  unsigned offset = getVarKindOffset(srcKind);
   for (unsigned i = 0; i < convertCount; ++i)
-    swapId(offset + idStart + i, newIdsBegin + i);
+    swapVar(offset + idStart + i, newVarsBegin + i);
 
   // Complete the move by deleting the initially occupied columns.
-  removeIdRange(srcKind, idStart, idLimit);
+  removeVarRange(srcKind, idStart, idLimit);
 }
 
 void IntegerRelation::addBound(BoundType type, unsigned pos, int64_t value) {
   assert(pos < getNumCols());
   if (type == BoundType::EQ) {
     unsigned row = equalities.appendExtraRow();
     equalities(row, pos) = 1;
     equalities(row, getNumCols() - 1) = -value;
void IntegerRelation::addBound(BoundType type, ArrayRef<int64_t> expr,
   assert(expr.size() == getNumCols());
   unsigned row = inequalities.appendExtraRow();
   for (unsigned i = 0, e = expr.size(); i < e; ++i)
     inequalities(row, i) = type == BoundType::LB ? expr[i] : -expr[i];
   inequalities(inequalities.getNumRows() - 1, getNumCols() - 1) +=
       type == BoundType::LB ? -value : value;
 }
 
-/// Adds a new local identifier as the floordiv of an affine function of other
-/// identifiers, the coefficients of which are provided in 'dividend' and with
+/// Adds a new local variable as the floordiv of an affine function of other
+/// variables, the coefficients of which are provided in 'dividend' and with
 /// respect to a positive constant 'divisor'. Two constraints are added to the
 /// system to capture equivalence with the floordiv.
 ///      q = expr floordiv c    <=>   c*q <= expr <= c*q + c - 1.
 void IntegerRelation::addLocalFloorDiv(ArrayRef<int64_t> dividend,
                                        int64_t divisor) {
   assert(dividend.size() == getNumCols() && "incorrect dividend size");
   assert(divisor > 0 && "positive divisor expected");
 
-  appendId(IdKind::Local);
+  appendVar(VarKind::Local);
 
-  // Add two constraints for this new identifier 'q'.
+  // Add two constraints for this new variable 'q'.
   SmallVector<int64_t, 8> bound(dividend.size() + 1);
 
   // dividend - q * divisor >= 0
   std::copy(dividend.begin(), dividend.begin() + dividend.size() - 1,
             bound.begin());
   bound.back() = dividend.back();
-  bound[getNumIds() - 1] = -divisor;
+  bound[getNumVars() - 1] = -divisor;
   addInequality(bound);
 
   // -dividend +qdivisor * q + divisor - 1 >= 0
   std::transform(bound.begin(), bound.end(), bound.begin(),
                  std::negate<int64_t>());
   bound[bound.size() - 1] += divisor - 1;
   addInequality(bound);
 }
 
-/// Finds an equality that equates the specified identifier to a constant.
+/// Finds an equality that equates the specified variable to a constant.
 /// Returns the position of the equality row. If 'symbolic' is set to true,
 /// symbols are also treated like a constant, i.e., an affine function of the
 /// symbols is also treated like a constant. Returns -1 if such an equality
 /// could not be found.
 static int findEqualityToConstant(const IntegerRelation &cst, unsigned pos,
                                   bool symbolic = false) {
-  assert(pos < cst.getNumIds() && "invalid position");
+  assert(pos < cst.getNumVars() && "invalid position");
   for (unsigned r = 0, e = cst.getNumEqualities(); r < e; r++) {
     int64_t v = cst.atEq(r, pos);
     if (v * v != 1)
       continue;
     unsigned c;
-    unsigned f = symbolic ? cst.getNumDimIds() : cst.getNumIds();
+    unsigned f = symbolic ? cst.getNumDimVars() : cst.getNumVars();
     // This checks for zeros in all positions other than 'pos' in [0, f)
     for (c = 0; c < f; c++) {
       if (c == pos)
         continue;
       if (cst.atEq(r, c) != 0) {
-        // Dependent on another identifier.
+        // Dependent on another variable.
         break;
       }
     }
     if (c == f)
-      // Equality is free of other identifiers.
+      // Equality is free of other variables.
       return r;
   }
   return -1;
 }
 
-LogicalResult IntegerRelation::constantFoldId(unsigned pos) {
-  assert(pos < getNumIds() && "invalid position");
+LogicalResult IntegerRelation::constantFoldVar(unsigned pos) {
+  assert(pos < getNumVars() && "invalid position");
   int rowIdx;
   if ((rowIdx = findEqualityToConstant(*this, pos)) == -1)
     return failure();
 
   // atEq(rowIdx, pos) is either -1 or 1.
   assert(atEq(rowIdx, pos) * atEq(rowIdx, pos) == 1);
   int64_t constVal = -atEq(rowIdx, getNumCols() - 1) / atEq(rowIdx, pos);
   setAndEliminate(pos, constVal);
   return success();
 }
 
-void IntegerRelation::constantFoldIdRange(unsigned pos, unsigned num) {
+void IntegerRelation::constantFoldVarRange(unsigned pos, unsigned num) {
   for (unsigned s = pos, t = pos, e = pos + num; s < e; s++) {
-    if (failed(constantFoldId(t)))
+    if (failed(constantFoldVar(t)))
       t++;
   }
 }
 
 /// Returns a non-negative constant bound on the extent (upper bound - lower
-/// bound) of the specified identifier if it is found to be a constant; returns
-/// None if it's not a constant. This methods treats symbolic identifiers
+/// bound) of the specified variable if it is found to be a constant; returns
+/// None if it's not a constant. This methods treats symbolic variables
 /// specially, i.e., it looks for constant differences between affine
-/// expressions involving only the symbolic identifiers. See comments at
+/// expressions involving only the symbolic variables. See comments at
 /// function definition for example. 'lb', if provided, is set to the lower
 /// bound associated with the constant difference. Note that 'lb' is purely
-/// symbolic and thus will contain the coefficients of the symbolic identifiers
+/// symbolic and thus will contain the coefficients of the symbolic variables
 /// and the constant coefficient.
 //  Egs: 0 <= i <= 15, return 16.
 //       s0 + 2 <= i <= s0 + 17, returns 16. (s0 has to be a symbol)
 //       s0 + s1 + 16 <= d0 <= s0 + s1 + 31, returns 16.
 //       s0 - 7 <= 8*j <= s0 returns 1 with lb = s0, lbDivisor = 8 (since lb =
 //       ceil(s0 - 7 / 8) = floor(s0 / 8)).
 Optional<int64_t> IntegerRelation::getConstantBoundOnDimSize(
     unsigned pos, SmallVectorImpl<int64_t> *lb, int64_t *boundFloorDivisor,
     SmallVectorImpl<int64_t> *ub, unsigned *minLbPos,
     unsigned *minUbPos) const {
-  assert(pos < getNumDimIds() && "Invalid identifier position");
+  assert(pos < getNumDimVars() && "Invalid variable position");
 
-  // Find an equality for 'pos'^th identifier that equates it to some function
-  // of the symbolic identifiers (+ constant).
+  // Find an equality for 'pos'^th variable that equates it to some function
+  // of the symbolic variables (+ constant).
   int eqPos = findEqualityToConstant(*this, pos, /*symbolic=*/true);
   if (eqPos != -1) {
     auto eq = getEquality(eqPos);
     // If the equality involves a local var, punt for now.
     // TODO: this can be handled in the future by using the explicit
     // representation of the local vars.
-    if (!std::all_of(eq.begin() + getNumDimAndSymbolIds(), eq.end() - 1,
+    if (!std::all_of(eq.begin() + getNumDimAndSymbolVars(), eq.end() - 1,
                      [](int64_t coeff) { return coeff == 0; }))
       return None;
 
-    // This identifier can only take a single value.
+    // This variable can only take a single value.
     if (lb) {
       // Set lb to that symbolic value.
-      lb->resize(getNumSymbolIds() + 1);
+      lb->resize(getNumSymbolVars() + 1);
       if (ub)
-        ub->resize(getNumSymbolIds() + 1);
-      for (unsigned c = 0, f = getNumSymbolIds() + 1; c < f; c++) {
+        ub->resize(getNumSymbolVars() + 1);
+      for (unsigned c = 0, f = getNumSymbolVars() + 1; c < f; c++) {
         int64_t v = atEq(eqPos, pos);
         // atEq(eqRow, pos) is either -1 or 1.
         assert(v * v == 1);
-        (*lb)[c] = v < 0 ? atEq(eqPos, getNumDimIds() + c) / -v
-                         : -atEq(eqPos, getNumDimIds() + c) / v;
+        (*lb)[c] = v < 0 ? atEq(eqPos, getNumDimVars() + c) / -v
+                         : -atEq(eqPos, getNumDimVars() + c) / v;
         // Since this is an equality, ub = lb.
         if (ub)
           (*ub)[c] = (*lb)[c];
       }
       assert(boundFloorDivisor &&
              "both lb and divisor or none should be provided");
       *boundFloorDivisor = 1;
     }
     if (minLbPos)
       *minLbPos = eqPos;
     if (minUbPos)
       *minUbPos = eqPos;
     return 1;
   }
 
-  // Check if the identifier appears at all in any of the inequalities.
+  // Check if the variable appears at all in any of the inequalities.
   unsigned r, e;
   for (r = 0, e = getNumInequalities(); r < e; r++) {
     if (atIneq(r, pos) != 0)
       break;
   }
   if (r == e)
     // If it doesn't, there isn't a bound on it.
     return None;
 
   // Positions of constraints that are lower/upper bounds on the variable.
   SmallVector<unsigned, 4> lbIndices, ubIndices;
 
   // Gather all symbolic lower bounds and upper bounds of the variable, i.e.,
-  // the bounds can only involve symbolic (and local) identifiers. Since the
+  // the bounds can only involve symbolic (and local) variables. Since the
   // canonical form c_1*x_1 + c_2*x_2 + ... + c_0 >= 0, a constraint is a lower
   // bound for x_i if c_i >= 1, and an upper bound if c_i <= -1.
   getLowerAndUpperBoundIndices(pos, &lbIndices, &ubIndices,
                                /*eqIndices=*/nullptr, /*offset=*/0,
-                               /*num=*/getNumDimIds());
+                               /*num=*/getNumDimVars());
 
   Optional<int64_t> minDiff = None;
   unsigned minLbPosition = 0, minUbPosition = 0;
   for (auto ubPos : ubIndices) {
     for (auto lbPos : lbIndices) {
       // Look for a lower bound and an upper bound that only differ by a
       // constant, i.e., pairs of the form  0 <= c_pos - f(c_i's) <= diffConst.
       // For example, if ii is the pos^th variable, we are looking for
for (auto lbPos : lbIndices) {
         minDiff = diff;
         minLbPosition = lbPos;
         minUbPosition = ubPos;
       }
     }
   }
   if (lb && minDiff) {
     // Set lb to the symbolic lower bound.
-    lb->resize(getNumSymbolIds() + 1);
+    lb->resize(getNumSymbolVars() + 1);
     if (ub)
-      ub->resize(getNumSymbolIds() + 1);
+      ub->resize(getNumSymbolVars() + 1);
     // The lower bound is the ceildiv of the lb constraint over the coefficient
     // of the variable at 'pos'. We express the ceildiv equivalently as a floor
     // for uniformity. For eg., if the lower bound constraint was: 32*d0 - N +
     // 31 >= 0, the lower bound for d0 is ceil(N - 31, 32), i.e., floor(N, 32).
     *boundFloorDivisor = atIneq(minLbPosition, pos);
     assert(*boundFloorDivisor == -atIneq(minUbPosition, pos));
-    for (unsigned c = 0, e = getNumSymbolIds() + 1; c < e; c++) {
-      (*lb)[c] = -atIneq(minLbPosition, getNumDimIds() + c);
+    for (unsigned c = 0, e = getNumSymbolVars() + 1; c < e; c++) {
+      (*lb)[c] = -atIneq(minLbPosition, getNumDimVars() + c);
     }
     if (ub) {
-      for (unsigned c = 0, e = getNumSymbolIds() + 1; c < e; c++)
-        (*ub)[c] = atIneq(minUbPosition, getNumDimIds() + c);
+      for (unsigned c = 0, e = getNumSymbolVars() + 1; c < e; c++)
+        (*ub)[c] = atIneq(minUbPosition, getNumDimVars() + c);
     }
     // The lower bound leads to a ceildiv while the upper bound is a floordiv
     // whenever the coefficient at pos != 1. ceildiv (val / d) = floordiv (val +
     // d - 1 / d); hence, the addition of 'atIneq(minLbPosition, pos) - 1' to
     // the constant term for the lower bound.
-    (*lb)[getNumSymbolIds()] += atIneq(minLbPosition, pos) - 1;
+    (*lb)[getNumSymbolVars()] += atIneq(minLbPosition, pos) - 1;
   }
   if (minLbPos)
     *minLbPos = minLbPosition;
   if (minUbPos)
     *minUbPos = minUbPosition;
   return minDiff;
 }
 
 template <bool isLower>
 Optional<int64_t>
 IntegerRelation::computeConstantLowerOrUpperBound(unsigned pos) {
-  assert(pos < getNumIds() && "invalid position");
+  assert(pos < getNumVars() && "invalid position");
   // Project to 'pos'.
   projectOut(0, pos);
-  projectOut(1, getNumIds() - 1);
-  // Check if there's an equality equating the '0'^th identifier to a constant.
+  projectOut(1, getNumVars() - 1);
+  // Check if there's an equality equating the '0'^th variable to a constant.
   int eqRowIdx = findEqualityToConstant(*this, 0, /*symbolic=*/false);
   if (eqRowIdx != -1)
     // atEq(rowIdx, 0) is either -1 or 1.
     return -atEq(eqRowIdx, getNumCols() - 1) / atEq(eqRowIdx, 0);
 
-  // Check if the identifier appears at all in any of the inequalities.
+  // Check if the variable appears at all in any of the inequalities.
   unsigned r, e;
   for (r = 0, e = getNumInequalities(); r < e; r++) {
     if (atIneq(r, 0) != 0)
       break;
   }
   if (r == e)
     // If it doesn't, there isn't a bound on it.
     return None;
void IntegerRelation::removeTrivialRedundancy() {
 
   // TODO: consider doing this for equalities as well, but probably not worth
   // the savings.
 }
 
 #undef DEBUG_TYPE
 #define DEBUG_TYPE "fm"
 
-/// Eliminates identifier at the specified position using Fourier-Motzkin
+/// Eliminates variable at the specified position using Fourier-Motzkin
 /// variable elimination. This technique is exact for rational spaces but
 /// conservative (in "rare" cases) for integer spaces. The operation corresponds
 /// to a projection operation yielding the (convex) set of integer points
 /// contained in the rational shadow of the set. An emptiness test that relies
 /// on this method will guarantee emptiness, i.e., it disproves the existence of
 /// a solution if it says it's empty.
 /// If a non-null isResultIntegerExact is passed, it is set to true if the
 /// result is also integer exact. If it's set to false, the obtained solution

 ///
 /// darkShadow = false, isResultIntegerExact = nullptr are default values.
 // TODO: a slight modification to yield dark shadow version of FM (tightened),
 // which can prove the existence of a solution if there is one.
 void IntegerRelation::fourierMotzkinEliminate(unsigned pos, bool darkShadow,
                                               bool *isResultIntegerExact) {
   LLVM_DEBUG(llvm::dbgs() << "FM input (eliminate pos " << pos << "):\n");
   LLVM_DEBUG(dump());
-  assert(pos < getNumIds() && "invalid position");
+  assert(pos < getNumVars() && "invalid position");
   assert(hasConsistentState());
 
-  // Check if this identifier can be eliminated through a substitution.
+  // Check if this variable can be eliminated through a substitution.
   for (unsigned r = 0, e = getNumEqualities(); r < e; r++) {
     if (atEq(r, pos) != 0) {
       // Use Gaussian elimination here (since we have an equality).
-      LogicalResult ret = gaussianEliminateId(pos);
+      LogicalResult ret = gaussianEliminateVar(pos);
       (void)ret;
       assert(succeeded(ret) && "Gaussian elimination guaranteed to succeed");
       LLVM_DEBUG(llvm::dbgs() << "FM output (through Gaussian elimination):\n");
       LLVM_DEBUG(dump());
       return;
     }
   }
 
   // A fast linear time tightening.
   gcdTightenInequalities();
 
-  // Check if the identifier appears at all in any of the inequalities.
+  // Check if the variable appears at all in any of the inequalities.
   if (isColZero(pos)) {
     // If it doesn't appear, just remove the column and return.
     // TODO: refactor removeColumns to use it from here.
-    removeId(pos);
+    removeVar(pos);
     LLVM_DEBUG(llvm::dbgs() << "FM output:\n");
     LLVM_DEBUG(dump());
     return;
   }
 
   // Positions of constraints that are lower bounds on the variable.
   SmallVector<unsigned, 4> lbIndices;
   // Positions of constraints that are lower bounds on the variable.
   SmallVector<unsigned, 4> ubIndices;
   // Positions of constraints that do not involve the variable.
   std::vector<unsigned> nbIndices;
   nbIndices.reserve(getNumInequalities());
 
   // Gather all lower bounds and upper bounds of the variable. Since the
   // canonical form c_1*x_1 + c_2*x_2 + ... + c_0 >= 0, a constraint is a lower
   // bound for x_i if c_i >= 1, and an upper bound if c_i <= -1.
   for (unsigned r = 0, e = getNumInequalities(); r < e; r++) {
     if (atIneq(r, pos) == 0) {
-      // Id does not appear in bound.
+      // Var does not appear in bound.
       nbIndices.push_back(r);
     } else if (atIneq(r, pos) >= 1) {
       // Lower bound.
       lbIndices.push_back(r);
     } else {
       // Upper bound.
       ubIndices.push_back(r);
     }
   }
 
   PresburgerSpace newSpace = getSpace();
-  IdKind idKindRemove = newSpace.getIdKindAt(pos);
-  unsigned relativePos = pos - newSpace.getIdKindOffset(idKindRemove);
-  newSpace.removeIdRange(idKindRemove, relativePos, relativePos + 1);
+  VarKind idKindRemove = newSpace.getVarKindAt(pos);
+  unsigned relativePos = pos - newSpace.getVarKindOffset(idKindRemove);
+  newSpace.removeVarRange(idKindRemove, relativePos, relativePos + 1);
 
-  /// Create the new system which has one identifier less.
+  /// Create the new system which has one variable less.
   IntegerRelation newRel(lbIndices.size() * ubIndices.size() + nbIndices.size(),
                          getNumEqualities(), getNumCols() - 1, newSpace);
 
   // This will be used to check if the elimination was integer exact.
   unsigned lcmProducts = 1;
 
   // Let x be the variable we are eliminating.
   // For each lower bound, lb <= c_l*x, and each upper bound c_u*x <= ub, (note

 void IntegerRelation::projectOut(unsigned pos, unsigned num) {
   if (num == 0)
     return;
 
   // 'pos' can be at most getNumCols() - 2 if num > 0.
   assert((getNumCols() < 2 || pos <= getNumCols() - 2) && "invalid position");
   assert(pos + num < getNumCols() && "invalid range");
 
-  // Eliminate as many identifiers as possible using Gaussian elimination.
+  // Eliminate as many variables as possible using Gaussian elimination.
   unsigned currentPos = pos;
   unsigned numToEliminate = num;
   unsigned numGaussianEliminated = 0;
 
-  while (currentPos < getNumIds()) {
+  while (currentPos < getNumVars()) {
     unsigned curNumEliminated =
-        gaussianEliminateIds(currentPos, currentPos + numToEliminate);
+        gaussianEliminateVars(currentPos, currentPos + numToEliminate);
     ++currentPos;
     numToEliminate -= curNumEliminated + 1;
     numGaussianEliminated += curNumEliminated;
   }
 
   // Eliminate the remaining using Fourier-Motzkin.
   for (unsigned i = 0; i < num - numGaussianEliminated; i++) {
     unsigned numToEliminate = num - numGaussianEliminated - i;
     fourierMotzkinEliminate(
-        getBestIdToEliminate(*this, pos, pos + numToEliminate));
+        getBestVarToEliminate(*this, pos, pos + numToEliminate));
   }
 
   // Fast/trivial simplifications.
   gcdTightenInequalities();
   // Normalize constraints after tightening since the latter impacts this, but
   // not the other way round.
   normalizeConstraintsByGCD();
 }
 
 namespace {
 
 enum BoundCmpResult { Greater, Less, Equal, Unknown };
 
 /// Compares two affine bounds whose coefficients are provided in 'first' and
 /// 'second'. The last coefficient is the constant term.
 static BoundCmpResult compareBounds(ArrayRef<int64_t> a, ArrayRef<int64_t> b) {
   assert(a.size() == b.size());
 
-  // For the bounds to be comparable, their corresponding identifier
+  // For the bounds to be comparable, their corresponding variable
   // coefficients should be equal; the constant terms are then compared to
   // determine less/greater/equal.
 
   if (!std::equal(a.begin(), a.end() - 1, b.begin()))
     return Unknown;
 
   if (a.back() == b.back())
     return Equal;
static void getCommonConstraints(const IntegerRelation &a,
   }
 }
 
 // Computes the bounding box with respect to 'other' by finding the min of the
 // lower bounds and the max of the upper bounds along each of the dimensions.
 LogicalResult
 IntegerRelation::unionBoundingBox(const IntegerRelation &otherCst) {
   assert(space.isEqual(otherCst.getSpace()) && "Spaces should match.");
-  assert(getNumLocalIds() == 0 && "local ids not supported yet here");
+  assert(getNumLocalVars() == 0 && "local ids not supported yet here");
 
   // Get the constraints common to both systems; these will be added as is to
   // the union.
   IntegerRelation commonCst(PresburgerSpace::getRelationSpace());
   getCommonConstraints(*this, otherCst, commonCst);
 
   std::vector<SmallVector<int64_t, 8>> boundingLbs;
   std::vector<SmallVector<int64_t, 8>> boundingUbs;
-  boundingLbs.reserve(2 * getNumDimIds());
-  boundingUbs.reserve(2 * getNumDimIds());
+  boundingLbs.reserve(2 * getNumDimVars());
+  boundingUbs.reserve(2 * getNumDimVars());
 
   // To hold lower and upper bounds for each dimension.
   SmallVector<int64_t, 4> lb, otherLb, ub, otherUb;
   // To compute min of lower bounds and max of upper bounds for each dimension.
-  SmallVector<int64_t, 4> minLb(getNumSymbolIds() + 1);
-  SmallVector<int64_t, 4> maxUb(getNumSymbolIds() + 1);
+  SmallVector<int64_t, 4> minLb(getNumSymbolVars() + 1);
+  SmallVector<int64_t, 4> maxUb(getNumSymbolVars() + 1);
   // To compute final new lower and upper bounds for the union.
   SmallVector<int64_t, 8> newLb(getNumCols()), newUb(getNumCols());
 
   int64_t lbFloorDivisor, otherLbFloorDivisor;
-  for (unsigned d = 0, e = getNumDimIds(); d < e; ++d) {
+  for (unsigned d = 0, e = getNumDimVars(); d < e; ++d) {
     auto extent = getConstantBoundOnDimSize(d, &lb, &lbFloorDivisor, &ub);
     if (!extent.hasValue())
       // TODO: symbolic extents when necessary.
       // TODO: handle union if a dimension is unbounded.
       return failure();
 
     auto otherExtent = otherCst.getConstantBoundOnDimSize(
         d, &otherLb, &otherLbFloorDivisor, &otherUb);
for (unsigned d = 0, e = getNumDimVars(); d < e; ++d) {
     std::fill(newLb.begin(), newLb.end(), 0);
     std::fill(newUb.begin(), newUb.end(), 0);
 
     // The divisor for lb, ub, otherLb, otherUb at this point is lbDivisor,
     // and so it's the divisor for newLb and newUb as well.
     newLb[d] = lbFloorDivisor;
     newUb[d] = -lbFloorDivisor;
     // Copy over the symbolic part + constant term.
-    std::copy(minLb.begin(), minLb.end(), newLb.begin() + getNumDimIds());
-    std::transform(newLb.begin() + getNumDimIds(), newLb.end(),
-                   newLb.begin() + getNumDimIds(), std::negate<int64_t>());
-    std::copy(maxUb.begin(), maxUb.end(), newUb.begin() + getNumDimIds());
+    std::copy(minLb.begin(), minLb.end(), newLb.begin() + getNumDimVars());
+    std::transform(newLb.begin() + getNumDimVars(), newLb.end(),
+                   newLb.begin() + getNumDimVars(), std::negate<int64_t>());
+    std::copy(maxUb.begin(), maxUb.end(), newUb.begin() + getNumDimVars());
 
     boundingLbs.push_back(newLb);
     boundingUbs.push_back(newUb);
   }
 
   // Clear all constraints and add the lower/upper bounds for the bounding box.
   clearConstraints();
-  for (unsigned d = 0, e = getNumDimIds(); d < e; ++d) {
+  for (unsigned d = 0, e = getNumDimVars(); d < e; ++d) {
     addInequality(boundingLbs[d]);
     addInequality(boundingUbs[d]);
   }
 
   // Add the constraints that were common to both systems.
   append(commonCst);
   removeTrivialRedundancy();
 
   // TODO: copy over pure symbolic constraints from this and 'other' over to the
   // union (since the above are just the union along dimensions); we shouldn't
   // be discarding any other constraints on the symbols.
 
   return success();
 }
 
 bool IntegerRelation::isColZero(unsigned pos) const {
   unsigned rowPos;
   return !findConstraintWithNonZeroAt(pos, /*isEq=*/false, &rowPos) &&
          !findConstraintWithNonZeroAt(pos, /*isEq=*/true, &rowPos);
 }
 
 /// Find positions of inequalities and equalities that do not have a coefficient
-/// for [pos, pos + num) identifiers.
+/// for [pos, pos + num) variables.
 static void getIndependentConstraints(const IntegerRelation &cst, unsigned pos,
                                       unsigned num,
                                       SmallVectorImpl<unsigned> &nbIneqIndices,
                                       SmallVectorImpl<unsigned> &nbEqIndices) {
-  assert(pos < cst.getNumIds() && "invalid start position");
-  assert(pos + num <= cst.getNumIds() && "invalid limit");
+  assert(pos < cst.getNumVars() && "invalid start position");
+  assert(pos + num <= cst.getNumVars() && "invalid limit");
 
   for (unsigned r = 0, e = cst.getNumInequalities(); r < e; r++) {
     // The bounds are to be independent of [offset, offset + num) columns.
     unsigned c;
     for (c = pos; c < pos + num; ++c) {
       if (cst.atIneq(r, c) != 0)
         break;
     }
for (c = pos; c < pos + num; ++c) {
         break;
     }
     if (c == pos + num)
       nbEqIndices.push_back(r);
   }
 }
 
 void IntegerRelation::removeIndependentConstraints(unsigned pos, unsigned num) {
-  assert(pos + num <= getNumIds() && "invalid range");
+  assert(pos + num <= getNumVars() && "invalid range");
 
-  // Remove constraints that are independent of these identifiers.
+  // Remove constraints that are independent of these variables.
   SmallVector<unsigned, 4> nbIneqIndices, nbEqIndices;
   getIndependentConstraints(*this, /*pos=*/0, num, nbIneqIndices, nbEqIndices);
 
   // Iterate in reverse so that indices don't have to be updated.
   // TODO: This method can be made more efficient (because removal of each
   // inequality leads to much shifting/copying in the underlying buffer).
   for (auto nbIndex : llvm::reverse(nbIneqIndices))
     removeInequality(nbIndex);
   for (auto nbIndex : llvm::reverse(nbEqIndices))
     removeEquality(nbIndex);
 }
 
 IntegerPolyhedron IntegerRelation::getDomainSet() const {
   IntegerRelation copyRel = *this;
 
   // Convert Range variables to Local variables.
-  copyRel.convertIdKind(IdKind::Range, 0, getNumIdKind(IdKind::Range),
-                        IdKind::Local);
+  copyRel.convertVarKind(VarKind::Range, 0, getNumVarKind(VarKind::Range),
+                         VarKind::Local);
 
   // Convert Domain variables to SetDim(Range) variables.
-  copyRel.convertIdKind(IdKind::Domain, 0, getNumIdKind(IdKind::Domain),
-                        IdKind::SetDim);
+  copyRel.convertVarKind(VarKind::Domain, 0, getNumVarKind(VarKind::Domain),
+                         VarKind::SetDim);
 
   return IntegerPolyhedron(std::move(copyRel));
 }
 
 IntegerPolyhedron IntegerRelation::getRangeSet() const {
   IntegerRelation copyRel = *this;
 
   // Convert Domain variables to Local variables.
-  copyRel.convertIdKind(IdKind::Domain, 0, getNumIdKind(IdKind::Domain),
-                        IdKind::Local);
+  copyRel.convertVarKind(VarKind::Domain, 0, getNumVarKind(VarKind::Domain),
+                         VarKind::Local);
 
   // We do not need to do anything to Range variables since they are already in
   // SetDim position.
 
   return IntegerPolyhedron(std::move(copyRel));
 }
 
 void IntegerRelation::intersectDomain(const IntegerPolyhedron &poly) {
   assert(getDomainSet().getSpace().isCompatible(poly.getSpace()) &&
          "Domain set is not compatible with poly");
 
   // Treating the poly as a relation, convert it from `0 -> R` to `R -> 0`.
   IntegerRelation rel = poly;
   rel.inverse();
 
   // Append dummy range variables to make the spaces compatible.
-  rel.appendId(IdKind::Range, getNumRangeIds());
+  rel.appendVar(VarKind::Range, getNumRangeVars());
 
   // Intersect in place.
-  mergeLocalIds(rel);
+  mergeLocalVars(rel);
   append(rel);
 }
 
 void IntegerRelation::intersectRange(const IntegerPolyhedron &poly) {
   assert(getRangeSet().getSpace().isCompatible(poly.getSpace()) &&
          "Range set is not compatible with poly");
 
   IntegerRelation rel = poly;
 
   // Append dummy domain variables to make the spaces compatible.
-  rel.appendId(IdKind::Domain, getNumDomainIds());
+  rel.appendVar(VarKind::Domain, getNumDomainVars());
 
-  mergeLocalIds(rel);
+  mergeLocalVars(rel);
   append(rel);
 }
 
 void IntegerRelation::inverse() {
-  unsigned numRangeIds = getNumIdKind(IdKind::Range);
-  convertIdKind(IdKind::Domain, 0, getIdKindEnd(IdKind::Domain), IdKind::Range);
-  convertIdKind(IdKind::Range, 0, numRangeIds, IdKind::Domain);
+  unsigned numRangeVars = getNumVarKind(VarKind::Range);
+  convertVarKind(VarKind::Domain, 0, getVarKindEnd(VarKind::Domain),
+                 VarKind::Range);
+  convertVarKind(VarKind::Range, 0, numRangeVars, VarKind::Domain);
 }
 
 void IntegerRelation::compose(const IntegerRelation &rel) {
   assert(getRangeSet().getSpace().isCompatible(rel.getDomainSet().getSpace()) &&
          "Range of `this` should be compatible with Domain of `rel`");
 
   IntegerRelation copyRel = rel;
 
   // Let relation `this` be R1: A -> B, and `rel` be R2: B -> C.
   // We convert R1 to A -> (B X C), and R2 to B X C then intersect the range of
   // R1 with R2. After this, we get R1: A -> C, by projecting out B.
   // TODO: Using nested spaces here would help, since we could directly
   // intersect the range with another relation.
-  unsigned numBIds = getNumRangeIds();
+  unsigned numBVars = getNumRangeVars();
 
   // Convert R1 from A -> B to A -> (B X C).
-  appendId(IdKind::Range, copyRel.getNumRangeIds());
+  appendVar(VarKind::Range, copyRel.getNumRangeVars());
 
   // Convert R2 to B X C.
-  copyRel.convertIdKind(IdKind::Domain, 0, numBIds, IdKind::Range, 0);
+  copyRel.covertVarKind(VarKind::Domain, 0, numBVars, VarKind::Range, 0);
 
   // Intersect R2 to range of R1.
   intersectRange(IntegerPolyhedron(copyRel));
 
   // Project out B in R1.
-  convertIdKind(IdKind::Range, 0, numBIds, IdKind::Local);
+  convertVarKind(VarKind::Range, 0, numBVars, VarKind::Local);
 }
 
 void IntegerRelation::applyDomain(const IntegerRelation &rel) {
   inverse();
   compose(rel);
   inverse();
 }
 
for (unsigned i = 0, e = getNumInequalities(); i < e; ++i) {
     }
     os << ">= 0\n";
   }
   os << '\n';
 }
 
 void IntegerRelation::dump() const { print(llvm::errs()); }
 
-unsigned IntegerPolyhedron::insertId(IdKind kind, unsigned pos, unsigned num) {
-  assert((kind != IdKind::Domain || num == 0) &&
+unsigned IntegerPolyhedron::insertVar(VarKind kind, unsigned pos,
+                                      unsigned num) {
+  assert((kind != VarKind::Domain || num == 0) &&
          "Domain has to be zero in a set");
-  return IntegerRelation::insertId(kind, pos, num);
-}
+  return IntegerRelation::insertVar(kind, pos, num);
+}
 No newline at end of file

mlir/lib/Analysis/Presburger/PWMAFunction.cpp

PresburgerSet PWMAFunction::getDomain() const {
   PresburgerSet domain = PresburgerSet::getEmpty(getSpace());
   for (const MultiAffineFunction &piece : pieces)
     domain.unionInPlace(piece.getDomain());
   return domain;
 }
 
 Optional<SmallVector<int64_t, 8>>
 MultiAffineFunction::valueAt(ArrayRef<int64_t> point) const {
-  assert(point.size() == domainSet.getNumDimAndSymbolIds() &&
+  assert(point.size() == domainSet.getNumDimAndSymbolVars() &&
          "Point has incorrect dimensionality!");
 
   Optional<SmallVector<int64_t, 8>> maybeLocalValues =
       getDomain().containsPointNoLocal(point);
   if (!maybeLocalValues)
     return {};
 
   // The point lies in the domain, so we need to compute the output value.
   SmallVector<int64_t, 8> pointHomogenous{llvm::to_vector(point)};
   // The given point didn't include the values of locals which the output is a
   // function of; we have computed one possible set of values and use them
-  // here. The function is not allowed to have local ids that take more than
+  // here. The function is not allowed to have local vars that take more than
   // one possible value.
   pointHomogenous.append(*maybeLocalValues);
   // The matrix `output` has an affine expression in the ith row, corresponding
   // to the expression for the ith value in the output vector. The last column
   // of the matrix contains the constant term. Let v be the input point with
   // a 1 appended at the end. We can see that output * v gives the desired
   // output vector.
   pointHomogenous.emplace_back(1);

 void MultiAffineFunction::dump() const { print(llvm::errs()); }
 
 bool MultiAffineFunction::isEqual(const MultiAffineFunction &other) const {
   return getDomainSpace().isCompatible(other.getDomainSpace()) &&
          getDomain().isEqual(other.getDomain()) &&
          isEqualWhereDomainsOverlap(other);
 }
 
-unsigned MultiAffineFunction::insertId(IdKind kind, unsigned pos,
+unsigned MultiAffineFunction::insertVar(VarKind kind, unsigned pos,
                                         unsigned num) {
-  assert(kind != IdKind::Domain && "Domain has to be zero in a set");
-  unsigned absolutePos = domainSet.getIdKindOffset(kind) + pos;
+  assert(kind != VarKind::Domain && "Domain has to be zero in a set");
+  unsigned absolutePos = domainSet.getVarKindOffset(kind) + pos;
   output.insertColumns(absolutePos, num);
-  return domainSet.insertId(kind, pos, num);
+  return domainSet.insertVar(kind, pos, num);
 }
 
-void MultiAffineFunction::removeIdRange(IdKind kind, unsigned idStart,
-                                        unsigned idLimit) {
-  output.removeColumns(idStart + domainSet.getIdKindOffset(kind),
-                       idLimit - idStart);
-  domainSet.removeIdRange(kind, idStart, idLimit);
+void MultiAffineFunction::removeVarRange(VarKind kind, unsigned varStart,
+                                         unsigned varLimit) {
+  output.removeColumns(varStart + domainSet.getVarKindOffset(kind),
+                       varLimit - varStart);
+  domainSet.removeVarRange(kind, varStart, varLimit);
 }
 
 void MultiAffineFunction::truncateOutput(unsigned count) {
   assert(count <= output.getNumRows());
   output.resizeVertically(count);
 }
 
 void PWMAFunction::truncateOutput(unsigned count) {
   assert(count <= numOutputs);
   for (MultiAffineFunction &piece : pieces)
     piece.truncateOutput(count);
   numOutputs = count;
 }
 
-void MultiAffineFunction::mergeLocalIds(MultiAffineFunction &other) {
-  // Merge output local ids of both functions without using division
-  // information i.e. append local ids of `other` to `this` and insert
-  // local ids of `this` to `other` at the start of it's local ids.
-  output.insertColumns(domainSet.getIdKindEnd(IdKind::Local),
-                       other.domainSet.getNumLocalIds());
-  other.output.insertColumns(other.domainSet.getIdKindOffset(IdKind::Local),
-                             domainSet.getNumLocalIds());
+void MultiAffineFunction::mergeLocalVars(MultiAffineFunction &other) {
+  // Merge output local vars of both functions without using division
+  // information i.e. append local vars of `other` to `this` and insert
+  // local vars of `this` to `other` at the start of it's local vars.
+  output.insertColumns(domainSet.getVarKindEnd(VarKind::Local),
+                       other.domainSet.getNumLocalVars());
+  other.output.insertColumns(other.domainSet.getVarKindOffset(VarKind::Local),
+                             domainSet.getNumLocalVars());
 
   auto merge = [this, &other](unsigned i, unsigned j) -> bool {
     // Merge local at position j into local at position i in function domain.
-    domainSet.eliminateRedundantLocalId(i, j);
-    other.domainSet.eliminateRedundantLocalId(i, j);
+    domainSet.eliminateRedundantLocalVar(i, j);
+    other.domainSet.eliminateRedundantLocalVar(i, j);
 
-    unsigned localOffset = domainSet.getIdKindOffset(IdKind::Local);
+    unsigned localOffset = domainSet.getVarKindOffset(VarKind::Local);
 
     // Merge local at position j into local at position i in output domain.
     output.addToColumn(localOffset + j, localOffset + i, 1);
     output.removeColumn(localOffset + j);
     other.output.addToColumn(localOffset + j, localOffset + i, 1);
     other.output.removeColumn(localOffset + j);
 
     return true;
   };
 
-  presburger::mergeLocalIds(domainSet, other.domainSet, merge);
+  presburger::mergeLocalVars(domainSet, other.domainSet, merge);
 }
 
 bool MultiAffineFunction::isEqualWhereDomainsOverlap(
     MultiAffineFunction other) const {
   if (!getDomainSpace().isCompatible(other.getDomainSpace()))
     return false;
 
   // `commonFunc` has the same output as `this`.
   MultiAffineFunction commonFunc = *this;
-  // After this merge, `commonFunc` and `other` have the same local ids; they
+  // After this merge, `commonFunc` and `other` have the same local vars; they
   // are merged.
-  commonFunc.mergeLocalIds(other);
+  commonFunc.mergeLocalVars(other);
   // After this, the domain of `commonFunc` will be the intersection of the
   // domains of `this` and `other`.
   commonFunc.domainSet.append(other.domainSet);
 
   // `commonDomainMatching` contains the subset of the common domain
   // where the outputs of `this` and `other` match.
   //
   // We want to add constraints equating the outputs of `this` and `other`.
-  // However, `this` may have difference local ids from `other`, whereas we
+  // However, `this` may have difference local vars from `other`, whereas we
   // need both to have the same locals. Accordingly, we use `commonFunc.output`
   // in place of `this->output`, since `commonFunc` has the same output but also
   // has its locals merged.
   IntegerPolyhedron commonDomainMatching = commonFunc.getDomain();
   for (unsigned row = 0, e = getNumOutputs(); row < e; ++row)
     commonDomainMatching.addEquality(
         subtract(commonFunc.output.getRow(row), other.output.getRow(row)));
 

mlir/lib/Analysis/Presburger/PresburgerRelation.cpp

 using namespace presburger;
 
 PresburgerRelation::PresburgerRelation(const IntegerRelation &disjunct)
     : space(disjunct.getSpaceWithoutLocals()) {
   unionInPlace(disjunct);
 }
 
 void PresburgerRelation::setSpace(const PresburgerSpace &oSpace) {
-  assert(space.getNumLocalIds() == 0 && "no locals should be present");
+  assert(space.getNumLocalVars() == 0 && "no locals should be present");
   space = oSpace;
   for (IntegerRelation &disjunct : disjuncts)
     disjunct.setSpaceExceptLocals(space);
 }
 
 unsigned PresburgerRelation::getNumDisjuncts() const {
   return disjuncts.size();
 }

 ///
 static PresburgerRelation getSetDifference(IntegerRelation b,
                                            const PresburgerRelation &s) {
   assert(b.getSpace().isCompatible(s.getSpace()) && "Spaces should match");
   if (b.isEmptyByGCDTest())
     return PresburgerRelation::getEmpty(b.getSpaceWithoutLocals());
 
   // Remove duplicate divs up front here to avoid existing
-  // divs disappearing in the call to mergeLocalIds below.
+  // divs disappearing in the call to mergeLocalVars below.
   b.removeDuplicateDivs();
 
   PresburgerRelation result =
       PresburgerRelation::getEmpty(b.getSpaceWithoutLocals());
   Simplex simplex(b);
 
   // This algorithm is more naturally expressed recursively, but we implement
   // it iteratively here to avoid issues with stack sizes.
if (level - 1 >= s.getNumDisjuncts()) {
       level = frames.size();
       continue;
     }
 
     if (level > frames.size()) {
       // No frame for this level yet, so we have just recursed into this level.
       IntegerRelation sI = s.getDisjunct(level - 1);
       // Remove the duplicate divs up front to avoid them possibly disappearing
-      // in the call to mergeLocalIds below.
+      // in the call to mergeLocalVars below.
       sI.removeDuplicateDivs();
 
       // Below, we append some additional constraints and ids to b. We want to
       // rollback b to its initial state before returning, which we will do by
       // removing all constraints beyond the original number of inequalities
       // and equalities, so we store these counts first.
       IntegerRelation::CountsSnapshot initBCounts = b.getCounts();
       // Similarly, we also want to rollback simplex to its original state.
       unsigned initialSnapshot = simplex.getSnapshot();
 
       // Find out which inequalities of sI correspond to division inequalities
       // for the local variables of sI.
-      std::vector<MaybeLocalRepr> repr(sI.getNumLocalIds());
+      std::vector<MaybeLocalRepr> repr(sI.getNumLocalVars());
       sI.getLocalReprs(repr);
 
       // Add sI's locals to b, after b's locals. Only those locals of sI which
       // do not already exist in b will be added. (i.e., duplicate divisions
       // will not be added.) Also add b's locals to sI, in such a way that both
       // have the same locals in the same order in the end.
-      b.mergeLocalIds(sI);
+      b.mergeLocalVars(sI);
 
       // Mark which inequalities of sI are division inequalities and add all
       // such inequalities to b.
       llvm::SmallBitVector canIgnoreIneq(sI.getNumInequalities() +
                                          2 * sI.getNumEqualities());
       for (MaybeLocalRepr &maybeRepr : repr) {
         assert(
             maybeRepr &&
if (level > frames.size()) {
           unsigned offset = sI.getNumInequalities();
           canIgnoreIneq[offset + 2 * idx] = true;
           canIgnoreIneq[offset + 2 * idx + 1] = true;
         }
       }
 
       unsigned offset = simplex.getNumConstraints();
       unsigned numLocalsAdded =
-          b.getNumLocalIds() - initBCounts.getSpace().getNumLocalIds();
+          b.getNumLocalVars() - initBCounts.getSpace().getNumLocalVars();
       simplex.appendVariable(numLocalsAdded);
 
       unsigned snapshotBeforeIntersect = simplex.getSnapshot();
       simplex.intersectIntegerRelation(sI);
 
       if (simplex.isEmpty()) {
         // b /\ s_i is empty, so b \ s_i = b. We move directly to i + 1.
         // We are ignoring level i completely, so we restore the state
if (Optional<SmallVector<int64_t, 8>> opt = disjunct.findIntegerSample()) {
       sample = std::move(*opt);
       return true;
     }
   }
   return false;
 }
 
 Optional<uint64_t> PresburgerRelation::computeVolume() const {
-  assert(getNumSymbolIds() == 0 && "Symbols are not yet supported!");
+  assert(getNumSymbolVars() == 0 && "Symbols are not yet supported!");
   // The sum of the volumes of the disjuncts is a valid overapproximation of the
   // volume of their union, even if they overlap.
   uint64_t result = 0;
   for (const IntegerRelation &disjunct : disjuncts) {
     Optional<uint64_t> volume = disjunct.computeVolume();
     if (!volume)
       return {};
     result += *volume;

 
 LogicalResult SetCoalescer::coalescePair(unsigned i, unsigned j) {
 
   IntegerRelation &a = disjuncts[i];
   IntegerRelation &b = disjuncts[j];
   /// Handling of local ids is not yet implemented, so these cases are
   /// skipped.
   /// TODO: implement local id support.
-  if (a.getNumLocalIds() != 0 || b.getNumLocalIds() != 0)
+  if (a.getNumLocalVars() != 0 || b.getNumLocalVars() != 0)
     return failure();
   Simplex &simpA = simplices[i];
   Simplex &simpB = simplices[j];
 
   // Organize all inequalities and equalities of `a` according to their type
   // for `b` into `redundantIneqsA` and `cuttingIneqsA` (and vice versa for
   // all inequalities of `b` according to their type in `a`). If a separate
   // inequality is encountered during typing, the two IntegerRelations

mlir/lib/Analysis/Presburger/PresburgerSpace.cpp

 //===- PresburgerSpace.cpp - MLIR PresburgerSpace Class -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/PresburgerSpace.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace mlir;
 using namespace presburger;
 
-unsigned PresburgerSpace::getNumIdKind(IdKind kind) const {
-  if (kind == IdKind::Domain)
-    return getNumDomainIds();
-  if (kind == IdKind::Range)
-    return getNumRangeIds();
-  if (kind == IdKind::Symbol)
-    return getNumSymbolIds();
-  if (kind == IdKind::Local)
+unsigned PresburgerSpace::getNumVarKind(VarKind kind) const {
+  if (kind == VarKind::Domain)
+    return getNumDomainVars();
+  if (kind == VarKind::Range)
+    return getNumRangeVars();
+  if (kind == VarKind::Symbol)
+    return getNumSymbolVars();
+  if (kind == VarKind::Local)
     return numLocals;
-  llvm_unreachable("IdKind does not exist!");
+  llvm_unreachable("VarKind does not exist!");
 }
 
-unsigned PresburgerSpace::getIdKindOffset(IdKind kind) const {
-  if (kind == IdKind::Domain)
+unsigned PresburgerSpace::getVarKindOffset(VarKind kind) const {
+  if (kind == VarKind::Domain)
     return 0;
-  if (kind == IdKind::Range)
-    return getNumDomainIds();
-  if (kind == IdKind::Symbol)
-    return getNumDimIds();
-  if (kind == IdKind::Local)
-    return getNumDimAndSymbolIds();
-  llvm_unreachable("IdKind does not exist!");
-}
-
-unsigned PresburgerSpace::getIdKindEnd(IdKind kind) const {
-  return getIdKindOffset(kind) + getNumIdKind(kind);
-}
-
-unsigned PresburgerSpace::getIdKindOverlap(IdKind kind, unsigned idStart,
-                                           unsigned idLimit) const {
-  unsigned idRangeStart = getIdKindOffset(kind);
-  unsigned idRangeEnd = getIdKindEnd(kind);
-
-  // Compute number of elements in intersection of the ranges [idStart, idLimit)
-  // and [idRangeStart, idRangeEnd).
-  unsigned overlapStart = std::max(idStart, idRangeStart);
-  unsigned overlapEnd = std::min(idLimit, idRangeEnd);
+  if (kind == VarKind::Range)
+    return getNumDomainVars();
+  if (kind == VarKind::Symbol)
+    return getNumDimVars();
+  if (kind == VarKind::Local)
+    return getNumDimAndSymbolVars();
+  llvm_unreachable("VarKind does not exist!");
+}
+
+unsigned PresburgerSpace::getVarKindEnd(VarKind kind) const {
+  return getVarKindOffset(kind) + getNumVarKind(kind);
+}
+
+unsigned PresburgerSpace::getVarKindOverlap(VarKind kind, unsigned varStart,
+                                            unsigned varLimit) const {
+  unsigned varRangeStart = getVarKindOffset(kind);
+  unsigned varRangeEnd = getVarKindEnd(kind);
+
+  // Compute number of elements in intersection of the ranges [varStart,
+  // varLimit) and [varRangeStart, varRangeEnd).
+  unsigned overlapStart = std::max(varStart, varRangeStart);
+  unsigned overlapEnd = std::min(varLimit, varRangeEnd);
 
   if (overlapStart > overlapEnd)
     return 0;
   return overlapEnd - overlapStart;
 }
 
-IdKind PresburgerSpace::getIdKindAt(unsigned pos) const {
-  assert(pos < getNumIds() && "`pos` should represent a valid id position");
-  if (pos < getIdKindEnd(IdKind::Domain))
-    return IdKind::Domain;
-  if (pos < getIdKindEnd(IdKind::Range))
-    return IdKind::Range;
-  if (pos < getIdKindEnd(IdKind::Symbol))
-    return IdKind::Symbol;
-  if (pos < getIdKindEnd(IdKind::Local))
-    return IdKind::Local;
-  llvm_unreachable("`pos` should represent a valid id position");
+VarKind PresburgerSpace::getVarKindAt(unsigned pos) const {
+  assert(pos < getNumVars() && "`pos` should represent a valid var position");
+  if (pos < getVarKindEnd(VarKind::Domain))
+    return VarKind::Domain;
+  if (pos < getVarKindEnd(VarKind::Range))
+    return VarKind::Range;
+  if (pos < getVarKindEnd(VarKind::Symbol))
+    return VarKind::Symbol;
+  if (pos < getVarKindEnd(VarKind::Local))
+    return VarKind::Local;
+  llvm_unreachable("`pos` should represent a valid var position");
 }
 
-unsigned PresburgerSpace::insertId(IdKind kind, unsigned pos, unsigned num) {
-  assert(pos <= getNumIdKind(kind));
+unsigned PresburgerSpace::insertVar(VarKind kind, unsigned pos, unsigned num) {
+  assert(pos <= getNumVarKind(kind));
 
-  unsigned absolutePos = getIdKindOffset(kind) + pos;
+  unsigned absolutePos = getVarKindOffset(kind) + pos;
 
-  if (kind == IdKind::Domain)
+  if (kind == VarKind::Domain)
     numDomain += num;
-  else if (kind == IdKind::Range)
+  else if (kind == VarKind::Range)
     numRange += num;
-  else if (kind == IdKind::Symbol)
+  else if (kind == VarKind::Symbol)
     numSymbols += num;
   else
     numLocals += num;
 
   // Insert NULL attachments if `usingAttachments` and variables inserted are
   // not locals.
-  if (usingAttachments && kind != IdKind::Local)
+  if (usingAttachments && kind != VarKind::Local)
     attachments.insert(attachments.begin() + absolutePos, num, nullptr);
 
   return absolutePos;
 }
 
-void PresburgerSpace::removeIdRange(IdKind kind, unsigned idStart,
-                                    unsigned idLimit) {
-  assert(idLimit <= getNumIdKind(kind) && "invalid id limit");
+void PresburgerSpace::removeVarRange(VarKind kind, unsigned varStart,
+                                     unsigned varLimit) {
+  assert(varLimit <= getNumVarKind(kind) && "invalid var limit");
 
-  if (idStart >= idLimit)
+  if (varStart >= varLimit)
     return;
 
-  unsigned numIdsEliminated = idLimit - idStart;
-  if (kind == IdKind::Domain)
-    numDomain -= numIdsEliminated;
-  else if (kind == IdKind::Range)
-    numRange -= numIdsEliminated;
-  else if (kind == IdKind::Symbol)
-    numSymbols -= numIdsEliminated;
+  unsigned numVarsEliminated = varLimit - varStart;
+  if (kind == VarKind::Domain)
+    numDomain -= numVarsEliminated;
+  else if (kind == VarKind::Range)
+    numRange -= numVarsEliminated;
+  else if (kind == VarKind::Symbol)
+    numSymbols -= numVarsEliminated;
   else
-    numLocals -= numIdsEliminated;
+    numLocals -= numVarsEliminated;
 
   // Remove attachments if `usingAttachments` and variables removed are not
   // locals.
-  if (usingAttachments && kind != IdKind::Local)
-    attachments.erase(attachments.begin() + getIdKindOffset(kind) + idStart,
-                      attachments.begin() + getIdKindOffset(kind) + idLimit);
+  if (usingAttachments && kind != VarKind::Local)
+    attachments.erase(attachments.begin() + getVarKindOffset(kind) + varStart,
+                      attachments.begin() + getVarKindOffset(kind) + varLimit);
 }
 
-void PresburgerSpace::swapId(IdKind kindA, IdKind kindB, unsigned posA,
+void PresburgerSpace::swapVar(VarKind kindA, VarKind kindB, unsigned posA,
                               unsigned posB) {
 
   if (!usingAttachments)
     return;
 
-  if (kindA == IdKind::Local && kindB == IdKind::Local)
+  if (kindA == VarKind::Local && kindB == VarKind::Local)
     return;
 
-  if (kindA == IdKind::Local) {
+  if (kindA == VarKind::Local) {
     atAttachment(kindB, posB) = nullptr;
     return;
   }
 
-  if (kindB == IdKind::Local) {
+  if (kindB == VarKind::Local) {
     atAttachment(kindA, posA) = nullptr;
     return;
   }
 
   std::swap(atAttachment(kindA, posA), atAttachment(kindB, posB));
 }
 
 bool PresburgerSpace::isCompatible(const PresburgerSpace &other) const {
-  return getNumDomainIds() == other.getNumDomainIds() &&
-         getNumRangeIds() == other.getNumRangeIds() &&
-         getNumSymbolIds() == other.getNumSymbolIds();
+  return getNumDomainVars() == other.getNumDomainVars() &&
+         getNumRangeVars() == other.getNumRangeVars() &&
+         getNumSymbolVars() == other.getNumSymbolVars();
 }
 
 bool PresburgerSpace::isEqual(const PresburgerSpace &other) const {
-  return isCompatible(other) && getNumLocalIds() == other.getNumLocalIds();
+  return isCompatible(other) && getNumLocalVars() == other.getNumLocalVars();
 }
 
 bool PresburgerSpace::isAligned(const PresburgerSpace &other) const {
   assert(isUsingAttachments() && other.isUsingAttachments() &&
          "Both spaces should be using attachments to check for "
          "alignment.");
   return isCompatible(other) && attachments == other.attachments;
 }
 
 bool PresburgerSpace::isAligned(const PresburgerSpace &other,
-                                IdKind kind) const {
+                                VarKind kind) const {
   assert(isUsingAttachments() && other.isUsingAttachments() &&
          "Both spaces should be using attachments to check for "
          "alignment.");
 
   ArrayRef<void *> kindAttachments =
       makeArrayRef(attachments)
-          .slice(getIdKindOffset(kind), getNumIdKind(kind));
+          .slice(getVarKindOffset(kind), getNumVarKind(kind));
   ArrayRef<void *> otherKindAttachments =
       makeArrayRef(other.attachments)
-          .slice(other.getIdKindOffset(kind), other.getNumIdKind(kind));
+          .slice(other.getVarKindOffset(kind), other.getNumVarKind(kind));
   return kindAttachments == otherKindAttachments;
 }
 
-void PresburgerSpace::setDimSymbolSeparation(unsigned newSymbolCount) {
-  assert(newSymbolCount <= getNumDimAndSymbolIds() &&
+void PresburgerSpace::setVarSymbolSeperation(unsigned newSymbolCount) {
+  assert(newSymbolCount <= getNumDimAndSymbolVars() &&
          "invalid separation position");
   numRange = numRange + numSymbols - newSymbolCount;
   numSymbols = newSymbolCount;
   // We do not need to change `attachments` since the ordering of
   // `attachments` remains same.
 }
 
 void PresburgerSpace::print(llvm::raw_ostream &os) const {
-  os << "Domain: " << getNumDomainIds() << ", "
-     << "Range: " << getNumRangeIds() << ", "
-     << "Symbols: " << getNumSymbolIds() << ", "
-     << "Locals: " << getNumLocalIds() << "\n";
+  os << "Domain: " << getNumDomainVars() << ", "
+     << "Range: " << getNumRangeVars() << ", "
+     << "Symbols: " << getNumSymbolVars() << ", "
+     << "Locals: " << getNumLocalVars() << "\n";
 
   if (usingAttachments) {
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
     os << "TypeID of attachments: " << attachmentType.getAsOpaquePointer()
        << "\n";
 #endif
 
     os << "(";
     for (void *attachment : attachments)
       os << attachment << " ";
     os << ")\n";
   }
 }
 
 void PresburgerSpace::dump() const { print(llvm::errs()); }

mlir/lib/Analysis/Presburger/Simplex.cpp

LogicalResult SymbolicLexSimplex::addSymbolicCut(unsigned row) {
   tableau(cutRow, 3 + nSymbol - 1) = d;                 // q*d.
 
   for (unsigned col = 3 + nSymbol, e = getNumColumns(); col < e; ++col)
     tableau(cutRow, col) = mod(tableau(row, col), d); // (b_i%d)y_i.
   return moveRowUnknownToColumn(cutRow);
 }
 
 void SymbolicLexSimplex::recordOutput(SymbolicLexMin &result) const {
-  Matrix output(0, domainPoly.getNumIds() + 1);
+  Matrix output(0, domainPoly.getNumVars() + 1);
   output.reserveRows(result.lexmin.getNumOutputs());
   for (const Unknown &u : var) {
     if (u.isSymbol)
       continue;
 
     if (u.orientation == Orientation::Column) {
       // M + u has a sample value of zero so u has a sample value of -M, i.e,
       // unbounded.
for (unsigned i = 0; i < count; ++i) {
     colUnknown.push_back(var.size() - 1);
   }
   tableau.resizeHorizontally(getNumColumns() + count);
   undoLog.insert(undoLog.end(), count, UndoLogEntry::RemoveLastVariable);
 }
 
 /// Add all the constraints from the given IntegerRelation.
 void SimplexBase::intersectIntegerRelation(const IntegerRelation &rel) {
-  assert(rel.getNumIds() == getNumVariables() &&
+  assert(rel.getNumVars() == getNumVariables() &&
          "IntegerRelation must have same dimensionality as simplex");
   for (unsigned i = 0, e = rel.getNumInequalities(); i < e; ++i)
     addInequality(rel.getInequality(i));
   for (unsigned i = 0, e = rel.getNumEqualities(); i < e; ++i)
     addEquality(rel.getEquality(i));
 }
 
 MaybeOptimum<Fraction> Simplex::computeRowOptimum(Direction direction,

mlir/lib/Analysis/Presburger/Utils.cpp

static void normalizeDivisionByGCD(SmallVectorImpl<int64_t> &dividend,
   }
 
   // Normalize the dividend and the denominator.
   std::transform(dividend.begin(), dividend.end(), dividend.begin(),
                  [gcd](int64_t &n) { return floorDiv(n, gcd); });
   divisor /= gcd;
 }
 
-/// Check if the pos^th identifier can be represented as a division using upper
+/// Check if the pos^th variable can be represented as a division using upper
 /// bound inequality at position `ubIneq` and lower bound inequality at position
 /// `lbIneq`.
 ///
-/// Let `id` be the pos^th identifier, then `id` is equivalent to
+/// Let `var` be the pos^th variable, then `var` is equivalent to
 /// `expr floordiv divisor` if there are constraints of the form:
-///      0 <= expr - divisor * id <= divisor - 1
+///      0 <= expr - divisor * var <= divisor - 1
 /// Rearranging, we have:
-///       divisor * id - expr + (divisor - 1) >= 0  <-- Lower bound for 'id'
-///      -divisor * id + expr                 >= 0  <-- Upper bound for 'id'
+///       divisor * var - expr + (divisor - 1) >= 0  <-- Lower bound for 'var'
+///      -divisor * var + expr                 >= 0  <-- Upper bound for 'var'
 ///
 /// For example:
 ///     32*k >= 16*i + j - 31                 <-- Lower bound for 'k'
 ///     32*k  <= 16*i + j                     <-- Upper bound for 'k'
 ///     expr = 16*i + j, divisor = 32
 ///     k = ( 16*i + j ) floordiv 32
 ///
 ///     4q >= i + j - 2                       <-- Lower bound for 'q'
 ///     4q <= i + j + 1                       <-- Upper bound for 'q'
 ///     expr = i + j + 1, divisor = 4
 ///     q = (i + j + 1) floordiv 4
 //
 /// This function also supports detecting divisions from bounds that are
 /// strictly tighter than the division bounds described above, since tighter
 /// bounds imply the division bounds. For example:
 ///     4q - i - j + 2 >= 0                       <-- Lower bound for 'q'
 ///    -4q + i + j     >= 0                       <-- Tight upper bound for 'q'
 ///
 /// To extract floor divisions with tighter bounds, we assume that that the
 /// constraints are of the form:
-///     c <= expr - divisior * id <= divisor - 1, where 0 <= c <= divisor - 1
+///     c <= expr - divisior * var <= divisor - 1, where 0 <= c <= divisor - 1
 /// Rearranging, we have:
-///     divisor * id - expr + (divisor - 1) >= 0  <-- Lower bound for 'id'
-///    -divisor * id + expr - c             >= 0  <-- Upper bound for 'id'
+///     divisor * var - expr + (divisor - 1) >= 0  <-- Lower bound for 'var'
+///    -divisor * var + expr - c             >= 0  <-- Upper bound for 'var'
 ///
 /// If successful, `expr` is set to dividend of the division and `divisor` is
 /// set to the denominator of the division. The final division expression is
 /// normalized by GCD.
 static LogicalResult getDivRepr(const IntegerRelation &cst, unsigned pos,
                                 unsigned ubIneq, unsigned lbIneq,
                                 SmallVector<int64_t, 8> &expr,
                                 unsigned &divisor) {
 
-  assert(pos <= cst.getNumIds() && "Invalid identifier position");
+  assert(pos <= cst.getNumVars() && "Invalid variable position");
   assert(ubIneq <= cst.getNumInequalities() &&
          "Invalid upper bound inequality position");
   assert(lbIneq <= cst.getNumInequalities() &&
          "Invalid upper bound inequality position");
 
   // Extract divisor from the lower bound.
   divisor = cst.atIneq(lbIneq, pos);
 
   // First, check if the constraints are opposite of each other except the
   // constant term.
   unsigned i = 0, e = 0;
-  for (i = 0, e = cst.getNumIds(); i < e; ++i)
+  for (i = 0, e = cst.getNumVars(); i < e; ++i)
     if (cst.atIneq(ubIneq, i) != -cst.atIneq(lbIneq, i))
       break;
 
   if (i < e)
     return failure();
 
   // Then, check if the constant term is of the proper form.
   // Due to the form of the upper/lower bound inequalities, the sum of their
   // constants is `divisor - 1 - c`. From this, we can extract c:
   int64_t constantSum = cst.atIneq(lbIneq, cst.getNumCols() - 1) +
                         cst.atIneq(ubIneq, cst.getNumCols() - 1);
   int64_t c = divisor - 1 - constantSum;
 
   // Check if `c` satisfies the condition `0 <= c <= divisor - 1`. This also
   // implictly checks that `divisor` is positive.
   if (c < 0 || c > divisor - 1)
     return failure();
 
   // The inequality pair can be used to extract the division.
   // Set `expr` to the dividend of the division except the constant term, which
   // is set below.
   expr.resize(cst.getNumCols(), 0);
-  for (i = 0, e = cst.getNumIds(); i < e; ++i)
+  for (i = 0, e = cst.getNumVars(); i < e; ++i)
     if (i != pos)
       expr[i] = cst.atIneq(ubIneq, i);
 
   // From the upper bound inequality's form, its constant term is equal to the
   // constant term of `expr`, minus `c`. From this,
   // constant term of `expr` = constant term of upper bound + `c`.
   expr.back() = cst.atIneq(ubIneq, cst.getNumCols() - 1) + c;
   normalizeDivisionByGCD(expr, divisor);
 
   return success();
 }
 
-/// Check if the pos^th identifier can be represented as a division using
+/// Check if the pos^th variable can be represented as a division using
 /// equality at position `eqInd`.
 ///
 /// For example:
 ///     32*k == 16*i + j - 31                 <-- `eqInd` for 'k'
 ///     expr = 16*i + j - 31, divisor = 32
 ///     k = (16*i + j - 31) floordiv 32
 ///
 /// If successful, `expr` is set to dividend of the division and `divisor` is
 /// set to the denominator of the division. The final division expression is
 /// normalized by GCD.
 static LogicalResult getDivRepr(const IntegerRelation &cst, unsigned pos,
                                 unsigned eqInd, SmallVector<int64_t, 8> &expr,
                                 unsigned &divisor) {
 
-  assert(pos <= cst.getNumIds() && "Invalid identifier position");
+  assert(pos <= cst.getNumVars() && "Invalid variable position");
   assert(eqInd <= cst.getNumEqualities() && "Invalid equality position");
 
   // Extract divisor, the divisor can be negative and hence its sign information
   // is stored in `signDiv` to reverse the sign of dividend's coefficients.
   // Equality must involve the pos-th variable and hence `tempDiv` != 0.
   int64_t tempDiv = cst.atEq(eqInd, pos);
   if (tempDiv == 0)
     return failure();
   int64_t signDiv = tempDiv < 0 ? -1 : 1;
 
   // The divisor is always a positive integer.
   divisor = tempDiv * signDiv;
 
   expr.resize(cst.getNumCols(), 0);
-  for (unsigned i = 0, e = cst.getNumIds(); i < e; ++i)
+  for (unsigned i = 0, e = cst.getNumVars(); i < e; ++i)
     if (i != pos)
       expr[i] = -signDiv * cst.atEq(eqInd, i);
 
   expr.back() = -signDiv * cst.atEq(eqInd, cst.getNumCols() - 1);
   normalizeDivisionByGCD(expr, divisor);
 
   return success();
 }
 
 // Returns `false` if the constraints depends on a variable for which an
 // explicit representation has not been found yet, otherwise returns `true`.
 static bool checkExplicitRepresentation(const IntegerRelation &cst,
                                         ArrayRef<bool> foundRepr,
                                         ArrayRef<int64_t> dividend,
                                         unsigned pos) {
   // Exit to avoid circular dependencies between divisions.
-  for (unsigned c = 0, e = cst.getNumIds(); c < e; ++c) {
+  for (unsigned c = 0, e = cst.getNumVars(); c < e; ++c) {
     if (c == pos)
       continue;
 
     if (!foundRepr[c] && dividend[c] != 0) {
       // Expression can't be constructed as it depends on a yet unknown
-      // identifier.
+      // variable.
       //
-      // TODO: Visit/compute the identifiers in an order so that this doesn't
+      // TODO: Visit/compute the variables in an order so that this doesn't
       // happen. More complex but much more efficient.
       return false;
     }
   }
 
   return true;
 }
 
-/// Check if the pos^th identifier can be expressed as a floordiv of an affine
-/// function of other identifiers (where the divisor is a positive constant).
-/// `foundRepr` contains a boolean for each identifier indicating if the
-/// explicit representation for that identifier has already been computed.
+/// Check if the pos^th variable can be expressed as a floordiv of an affine
+/// function of other variables (where the divisor is a positive constant).
+/// `foundRepr` contains a boolean for each variable indicating if the
+/// explicit representation for that variable has already been computed.
 /// Returns the `MaybeLocalRepr` struct which contains the indices of the
 /// constraints that can be expressed as a floordiv of an affine function. If
 /// the representation could be computed, `dividend` and `denominator` are set.
 /// If the representation could not be computed, the kind attribute in
 /// `MaybeLocalRepr` is set to None.
 MaybeLocalRepr presburger::computeSingleVarRepr(
     const IntegerRelation &cst, ArrayRef<bool> foundRepr, unsigned pos,
     SmallVector<int64_t, 8> &dividend, unsigned &divisor) {
-  assert(pos < cst.getNumIds() && "invalid position");
-  assert(foundRepr.size() == cst.getNumIds() &&
+  assert(pos < cst.getNumVars() && "invalid position");
+  assert(foundRepr.size() == cst.getNumVars() &&
          "Size of foundRepr does not match total number of variables");
 
   SmallVector<unsigned, 4> lbIndices, ubIndices, eqIndices;
   cst.getLowerAndUpperBoundIndices(pos, &lbIndices, &ubIndices, &eqIndices);
   MaybeLocalRepr repr{};
 
   for (unsigned ubPos : ubIndices) {
     for (unsigned lbPos : lbIndices) {
void presburger::removeDuplicateDivs(
     std::vector<SmallVector<int64_t, 8>> &divs,
     SmallVectorImpl<unsigned> &denoms, unsigned localOffset,
     llvm::function_ref<bool(unsigned i, unsigned j)> merge) {
 
   // Find and merge duplicate divisions.
   // TODO: Add division normalization to support divisions that differ by
   // a constant.
   // TODO: Add division ordering such that a division representation for local
-  // identifier at position `i` only depends on local identifiers at position <
+  // variable at position `i` only depends on local variables at position <
   // `i`. This would make sure that all divisions depending on other local
   // variables that can be merged, are merged.
   for (unsigned i = 0; i < divs.size(); ++i) {
-    // Check if a division representation exists for the `i^th` local id.
+    // Check if a division representation exists for the `i^th` local var.
     if (denoms[i] == 0)
       continue;
     // Check if a division exists which is a duplicate of the division at `i`.
     for (unsigned j = i + 1; j < divs.size(); ++j) {
-      // Check if a division representation exists for the `j^th` local id.
+      // Check if a division representation exists for the `j^th` local var.
       if (denoms[j] == 0)
         continue;
       // Check if the denominators match.
       if (denoms[i] != denoms[j])
         continue;
       // Check if the representations are equal.
       if (divs[i] != divs[j])
         continue;
for (unsigned j = i + 1; j < divs.size(); ++j) {
       divs.erase(divs.begin() + j);
       denoms.erase(denoms.begin() + j);
       // Since `j` can never be zero, we do not need to worry about overflows.
       --j;
     }
   }
 }
 
-void presburger::mergeLocalIds(
+void presburger::mergeLocalVars(
     IntegerRelation &relA, IntegerRelation &relB,
     llvm::function_ref<bool(unsigned i, unsigned j)> merge) {
   assert(relA.getSpace().isCompatible(relB.getSpace()) &&
          "Spaces should be compatible.");
 
-  // Merge local ids of relA and relB without using division information,
-  // i.e. append local ids of `relB` to `relA` and insert local ids of `relA`
-  // to `relB` at start of its local ids.
-  unsigned initLocals = relA.getNumLocalIds();
-  relA.insertId(IdKind::Local, relA.getNumLocalIds(), relB.getNumLocalIds());
-  relB.insertId(IdKind::Local, 0, initLocals);
+  // Merge local vars of relA and relB without using division information,
+  // i.e. append local vars of `relB` to `relA` and insert local vars of `relA`
+  // to `relB` at start of its local vars.
+  unsigned initLocals = relA.getNumLocalVars();
+  relA.insertVar(VarKind::Local, relA.getNumLocalVars(),
+                 relB.getNumLocalVars());
+  relB.insertVar(VarKind::Local, 0, initLocals);
 
   // Get division representations from each rel.
   std::vector<SmallVector<int64_t, 8>> divsA, divsB;
   SmallVector<unsigned, 4> denomsA, denomsB;
   relA.getLocalReprs(divsA, denomsA);
   relB.getLocalReprs(divsB, denomsB);
 
   // Copy division information for relB into `divsA` and `denomsA`, so that
   // these have the combined division information of both rels. Since newly
   // added local variables in relA and relB have no constraints, they will not
   // have any division representation.
   std::copy(divsB.begin() + initLocals, divsB.end(),
             divsA.begin() + initLocals);
   std::copy(denomsB.begin() + initLocals, denomsB.end(),
             denomsA.begin() + initLocals);
 
   // Merge all divisions by removing duplicate divisions.
-  unsigned localOffset = relA.getIdKindOffset(IdKind::Local);
+  unsigned localOffset = relA.getVarKindOffset(VarKind::Local);
   presburger::removeDuplicateDivs(divsA, denomsA, localOffset, merge);
 }
 
 int64_t presburger::gcdRange(ArrayRef<int64_t> range) {
   int64_t gcd = 0;
   for (int64_t elem : range) {
     gcd = llvm::GreatestCommonDivisor64(gcd, std::abs(elem));
     if (gcd == 1)

mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp

 // Returns the number of outer loop common to 'src/dstDomain'.
 // Loops common to 'src/dst' domains are added to 'commonLoops' if non-null.
 static unsigned
 getNumCommonLoops(const FlatAffineValueConstraints &srcDomain,
                   const FlatAffineValueConstraints &dstDomain,
                   SmallVectorImpl<AffineForOp> *commonLoops = nullptr) {
   // Find the number of common loops shared by src and dst accesses.
   unsigned minNumLoops =
-      std::min(srcDomain.getNumDimIds(), dstDomain.getNumDimIds());
+      std::min(srcDomain.getNumDimVars(), dstDomain.getNumDimVars());
   unsigned numCommonLoops = 0;
   for (unsigned i = 0; i < minNumLoops; ++i) {
     if (!isForInductionVar(srcDomain.getValue(i)) ||
         !isForInductionVar(dstDomain.getValue(i)) ||
         srcDomain.getValue(i) != dstDomain.getValue(i))
       break;
     if (commonLoops != nullptr)
       commonLoops->push_back(getForInductionVarOwner(srcDomain.getValue(i)));

 // *) If 'loopDepth == 3' then two constraints are added: i == i' and j == j'
 static void
 addOrderingConstraints(const FlatAffineValueConstraints &srcDomain,
                        const FlatAffineValueConstraints &dstDomain,
                        unsigned loopDepth,
                        FlatAffineValueConstraints *dependenceDomain) {
   unsigned numCols = dependenceDomain->getNumCols();
   SmallVector<int64_t, 4> eq(numCols);
-  unsigned numSrcDims = srcDomain.getNumDimIds();
+  unsigned numSrcDims = srcDomain.getNumDimVars();
   unsigned numCommonLoops = getNumCommonLoops(srcDomain, dstDomain);
   unsigned numCommonLoopConstraints = std::min(numCommonLoops, loopDepth);
   for (unsigned i = 0; i < numCommonLoopConstraints; ++i) {
     std::fill(eq.begin(), eq.end(), 0);
     eq[i] = -1;
     eq[i + numSrcDims] = 1;
     if (i == loopDepth - 1) {
       eq[numCols - 1] = -1;
static void computeDirectionVector(
     SmallVector<DependenceComponent, 2> *dependenceComponents) {
   // Find the number of common loops shared by src and dst accesses.
   SmallVector<AffineForOp, 4> commonLoops;
   unsigned numCommonLoops =
       getNumCommonLoops(srcDomain, dstDomain, &commonLoops);
   if (numCommonLoops == 0)
     return;
   // Compute direction vectors for requested loop depth.
-  unsigned numIdsToEliminate = dependenceDomain->getNumIds();
+  unsigned numIdsToEliminate = dependenceDomain->getNumVars();
   // Add new variables to 'dependenceDomain' to represent the direction
   // constraints for each shared loop.
-  dependenceDomain->insertDimId(/*pos=*/0, /*num=*/numCommonLoops);
+  dependenceDomain->insertDimVar(/*pos=*/0, /*num=*/numCommonLoops);
 
   // Add equality constraints for each common loop, setting newly introduced
   // variable at column 'j' to the 'dst' IV minus the 'src IV.
   SmallVector<int64_t, 4> eq;
   eq.resize(dependenceDomain->getNumCols());
-  unsigned numSrcDims = srcDomain.getNumDimIds();
+  unsigned numSrcDims = srcDomain.getNumDimVars();
   // Constraint variables format:
   // [num-common-loops][num-src-dim-ids][num-dst-dim-ids][num-symbols][constant]
   for (unsigned j = 0; j < numCommonLoops; ++j) {
     std::fill(eq.begin(), eq.end(), 0);
     eq[j] = 1;
     eq[j + numCommonLoops] = 1;
     eq[j + numCommonLoops + numSrcDims] = -1;
     dependenceDomain->addEquality(eq);
if (failed(getRelationFromMap(accessValueMap, rel)))
     return failure();
 
   FlatAffineRelation domainRel(rel.getNumDomainDims(), /*numRangeDims=*/0,
                                domain);
 
   // Merge and align domain ids of `ret` and ids of `domain`. Since the domain
   // of the access map is a subset of the domain of access, the domain ids of
   // `ret` are guranteed to be a subset of ids of `domain`.
-  for (unsigned i = 0, e = domain.getNumDimIds(); i < e; ++i) {
+  for (unsigned i = 0, e = domain.getNumDimVars(); i < e; ++i) {
     unsigned loc;
-    if (rel.findId(domain.getValue(i), &loc)) {
-      rel.swapId(i, loc);
+    if (rel.findVar(domain.getValue(i), &loc)) {
+      rel.swapVar(i, loc);
     } else {
-      rel.insertDomainId(i);
+      rel.insertDomainVar(i);
       rel.setValue(i, domain.getValue(i));
     }
   }
 
   // Append domain constraints to `rel`.
-  domainRel.appendRangeId(rel.getNumRangeDims());
-  domainRel.mergeSymbolIds(rel);
-  domainRel.mergeLocalIds(rel);
+  domainRel.appendRangeVar(rel.getNumRangeDims());
+  domainRel.mergeSymbolVars(rel);
+  domainRel.mergeLocalVars(rel);
   rel.append(domainRel);
 
   return success();
 }
 
 // Populates 'accessMap' with composition of AffineApplyOps reachable from
 // indices of MemRefAccess.
 void MemRefAccess::getAccessMap(AffineValueMap *accessMap) const {

mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp

public:
   // inequalities.
   IntegerPolyhedron localVarCst;
 
   AffineExprFlattener(unsigned nDims, unsigned nSymbols)
       : SimpleAffineExprFlattener(nDims, nSymbols),
         localVarCst(PresburgerSpace::getSetSpace(nDims, nSymbols)) {}
 
 private:
-  // Add a local identifier (needed to flatten a mod, floordiv, ceildiv expr).
-  // The local identifier added is always a floordiv of a pure add/mul affine
-  // function of other identifiers, coefficients of which are specified in
+  // Add a local variable (needed to flatten a mod, floordiv, ceildiv expr).
+  // The local variable added is always a floordiv of a pure add/mul affine
+  // function of other variables, coefficients of which are specified in
   // `dividend' and with respect to the positive constant `divisor'. localExpr
   // is the simplified tree expression (AffineExpr) corresponding to the
   // quantifier.
   void addLocalFloorDivId(ArrayRef<int64_t> dividend, int64_t divisor,
                           AffineExpr localExpr) override {
     SimpleAffineExprFlattener::addLocalFloorDivId(dividend, divisor, localExpr);
     // Update localVarCst.
     localVarCst.addLocalFloorDiv(dividend, divisor);
getFlattenedAffineExprs(ArrayRef<AffineExpr> exprs, unsigned numDims,
                         FlatAffineValueConstraints *localVarCst) {
   if (exprs.empty()) {
     localVarCst->reset(numDims, numSymbols);
     return success();
   }
 
   AffineExprFlattener flattener(numDims, numSymbols);
   // Use the same flattener to simplify each expression successively. This way
-  // local identifiers / expressions are shared.
+  // local variables / expressions are shared.
   for (auto expr : exprs) {
     if (!expr.isPureAffine())
       return failure();
 
     flattener.walkPostOrder(expr);
   }
 
   assert(flattener.operandExprStack.size() == exprs.size());

 FlatAffineValueConstraints::FlatAffineValueConstraints(IntegerSet set)
     : IntegerPolyhedron(set.getNumInequalities(), set.getNumEqualities(),
                         set.getNumDims() + set.getNumSymbols() + 1,
                         PresburgerSpace::getSetSpace(set.getNumDims(),
                                                      set.getNumSymbols(),
                                                      /*numLocals=*/0)) {
 
   // Resize values.
-  values.resize(getNumDimAndSymbolIds(), None);
+  values.resize(getNumDimAndSymbolVars(), None);
 
   // Flatten expressions and add them to the constraint system.
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   FlatAffineValueConstraints localVarCst;
   if (failed(getFlattenedAffineExprs(set, &flatExprs, &localVarCst))) {
     assert(false && "flattening unimplemented for semi-affine integer sets");
     return;
   }
   assert(flatExprs.size() == set.getNumConstraints());
-  insertId(IdKind::Local, getNumIdKind(IdKind::Local),
-           /*num=*/localVarCst.getNumLocalIds());
+  insertVar(VarKind::Local, getNumVarKind(VarKind::Local),
+            /*num=*/localVarCst.getNumLocalVars());
 
   for (unsigned i = 0, e = flatExprs.size(); i < e; ++i) {
     const auto &flatExpr = flatExprs[i];
     assert(flatExpr.size() == getNumCols());
     if (set.getEqFlags()[i]) {
       addEquality(flatExpr);
     } else {
       addInequality(flatExpr);
     }
   }
-  // Add the other constraints involving local id's from flattening.
+  // 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 DimId.
+// All dimensions as set as VarKind::SetDim.
 FlatAffineValueConstraints
 FlatAffineValueConstraints::getHyperrectangular(ValueRange ivs, ValueRange lbs,
                                                 ValueRange ubs) {
   FlatAffineValueConstraints 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.appendDimId(ivs);
-  unsigned lbsStart = res.appendDimId(lbs);
-  unsigned ubsStart = res.appendDimId(ubs);
+  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 FlatAffineValueConstraints creation error");

 void FlatAffineValueConstraints::reset(unsigned newNumDims,
                                        unsigned newNumSymbols,
                                        unsigned newNumLocals,
                                        ArrayRef<Value> valArgs) {
   reset(0, 0, newNumDims + newNumSymbols + newNumLocals + 1, newNumDims,
         newNumSymbols, newNumLocals, valArgs);
 }
 
-unsigned FlatAffineValueConstraints::appendDimId(ValueRange vals) {
-  unsigned pos = getNumDimIds();
-  insertId(IdKind::SetDim, pos, vals);
+unsigned FlatAffineValueConstraints::appendDimVar(ValueRange vals) {
+  unsigned pos = getNumDimVars();
+  insertVar(VarKind::SetDim, pos, vals);
   return pos;
 }
 
-unsigned FlatAffineValueConstraints::appendSymbolId(ValueRange vals) {
-  unsigned pos = getNumSymbolIds();
-  insertId(IdKind::Symbol, pos, vals);
+unsigned FlatAffineValueConstraints::appendSymbolVar(ValueRange vals) {
+  unsigned pos = getNumSymbolVars();
+  insertVar(VarKind::Symbol, pos, vals);
   return pos;
 }
 
-unsigned FlatAffineValueConstraints::insertDimId(unsigned pos,
+unsigned FlatAffineValueConstraints::insertDimVar(unsigned pos,
                                                   ValueRange vals) {
-  return insertId(IdKind::SetDim, pos, vals);
+  return insertVar(VarKind::SetDim, pos, vals);
 }
 
-unsigned FlatAffineValueConstraints::insertSymbolId(unsigned pos,
+unsigned FlatAffineValueConstraints::insertSymbolVar(unsigned pos,
                                                      ValueRange vals) {
-  return insertId(IdKind::Symbol, pos, vals);
+  return insertVar(VarKind::Symbol, pos, vals);
 }
 
-unsigned FlatAffineValueConstraints::insertId(IdKind kind, unsigned pos,
+unsigned FlatAffineValueConstraints::insertVar(VarKind kind, unsigned pos,
                                                unsigned num) {
-  unsigned absolutePos = IntegerPolyhedron::insertId(kind, pos, num);
+  unsigned absolutePos = IntegerPolyhedron::insertVar(kind, pos, num);
 
-  if (kind != IdKind::Local) {
+  if (kind != VarKind::Local) {
     values.insert(values.begin() + absolutePos, num, None);
-    assert(values.size() == getNumDimAndSymbolIds());
+    assert(values.size() == getNumDimAndSymbolVars());
   }
 
   return absolutePos;
 }
 
-unsigned FlatAffineValueConstraints::insertId(IdKind kind, unsigned pos,
+unsigned FlatAffineValueConstraints::insertVar(VarKind kind, unsigned pos,
                                                ValueRange vals) {
   assert(!vals.empty() && "expected ValueRange with Values.");
-  assert(kind != IdKind::Local &&
-         "values cannot be attached to local identifiers.");
+  assert(kind != VarKind::Local &&
+         "values cannot be attached to local variables.");
   unsigned num = vals.size();
-  unsigned absolutePos = IntegerPolyhedron::insertId(kind, pos, num);
+  unsigned absolutePos = IntegerPolyhedron::insertVar(kind, pos, num);
 
   // If a Value is provided, insert it; otherwise use None.
   for (unsigned i = 0; i < num; ++i)
     values.insert(values.begin() + absolutePos + i,
                   vals[i] ? Optional<Value>(vals[i]) : None);
 
-  assert(values.size() == getNumDimAndSymbolIds());
+  assert(values.size() == getNumDimAndSymbolVars());
   return absolutePos;
 }
 
 bool FlatAffineValueConstraints::hasValues() const {
-  return llvm::find_if(values, [](Optional<Value> id) {
-           return id.hasValue();
+  return llvm::find_if(values, [](Optional<Value> var) {
+           return var.hasValue();
          }) != values.end();
 }
 
 /// Checks if two constraint systems are in the same space, i.e., if they are
-/// associated with the same set of identifiers, appearing in the same order.
-static bool areIdsAligned(const FlatAffineValueConstraints &a,
+/// associated with the same set of variables, appearing in the same order.
+static bool areVarsAligned(const FlatAffineValueConstraints &a,
                            const FlatAffineValueConstraints &b) {
-  return a.getNumDimIds() == b.getNumDimIds() &&
-         a.getNumSymbolIds() == b.getNumSymbolIds() &&
-         a.getNumIds() == b.getNumIds() &&
+  return a.getNumDimVars() == b.getNumDimVars() &&
+         a.getNumSymbolVars() == b.getNumSymbolVars() &&
+         a.getNumVars() == b.getNumVars() &&
          a.getMaybeValues().equals(b.getMaybeValues());
 }
 
-/// Calls areIdsAligned to check if two constraint systems have the same set
-/// of identifiers in the same order.
-bool FlatAffineValueConstraints::areIdsAlignedWithOther(
+/// Calls areVarsAligned to check if two constraint systems have the same set
+/// of variables in the same order.
+bool FlatAffineValueConstraints::areVarsAlignedWithOther(
     const FlatAffineValueConstraints &other) {
-  return areIdsAligned(*this, other);
+  return areVarsAligned(*this, other);
 }
 
-/// Checks if the SSA values associated with `cst`'s identifiers in range
+/// Checks if the SSA values associated with `cst`'s variables in range
 /// [start, end) are unique.
-static bool LLVM_ATTRIBUTE_UNUSED areIdsUnique(
+static bool LLVM_ATTRIBUTE_UNUSED areVarsUnique(
     const FlatAffineValueConstraints &cst, unsigned start, unsigned end) {
 
-  assert(start <= cst.getNumDimAndSymbolIds() &&
+  assert(start <= cst.getNumDimAndSymbolVars() &&
          "Start position out of bounds");
-  assert(end <= cst.getNumDimAndSymbolIds() && "End position out of bounds");
+  assert(end <= cst.getNumDimAndSymbolVars() && "End position out of bounds");
 
   if (start >= end)
     return true;
 
-  SmallPtrSet<Value, 8> uniqueIds;
+  SmallPtrSet<Value, 8> uniqueVars;
   ArrayRef<Optional<Value>> maybeValues =
       cst.getMaybeValues().slice(start, end - start);
   for (Optional<Value> val : maybeValues) {
-    if (val && !uniqueIds.insert(*val).second)
+    if (val && !uniqueVars.insert(*val).second)
       return false;
   }
   return true;
 }
 
-/// Checks if the SSA values associated with `cst`'s identifiers are unique.
+/// Checks if the SSA values associated with `cst`'s variables are unique.
 static bool LLVM_ATTRIBUTE_UNUSED
-areIdsUnique(const FlatAffineValueConstraints &cst) {
-  return areIdsUnique(cst, 0, cst.getNumDimAndSymbolIds());
+areVarsUnique(const FlatAffineValueConstraints &cst) {
+  return areVarsUnique(cst, 0, cst.getNumDimAndSymbolVars());
 }
 
-/// Checks if the SSA values associated with `cst`'s identifiers of kind `kind`
+/// Checks if the SSA values associated with `cst`'s variables of kind `kind`
 /// are unique.
 static bool LLVM_ATTRIBUTE_UNUSED
-areIdsUnique(const FlatAffineValueConstraints &cst, IdKind kind) {
+areVarsUnique(const FlatAffineValueConstraints &cst, VarKind kind) {
 
-  if (kind == IdKind::SetDim)
-    return areIdsUnique(cst, 0, cst.getNumDimIds());
-  if (kind == IdKind::Symbol)
-    return areIdsUnique(cst, cst.getNumDimIds(), cst.getNumDimAndSymbolIds());
-  llvm_unreachable("Unexpected IdKind");
+  if (kind == VarKind::SetDim)
+    return areVarsUnique(cst, 0, cst.getNumDimVars());
+  if (kind == VarKind::Symbol)
+    return areVarsUnique(cst, cst.getNumDimVars(),
+                         cst.getNumDimAndSymbolVars());
+  llvm_unreachable("Unexpected VarKind");
 }
 
-/// Merge and align the identifiers of A and B starting at 'offset', so that
-/// both constraint systems get the union of the contained identifiers that is
+/// Merge and align the variables of A and B starting at 'offset', so that
+/// both constraint systems get the union of the contained variables that is
 /// dimension-wise and symbol-wise unique; both constraint systems are updated
-/// so that they have the union of all identifiers, with A's original
-/// identifiers appearing first followed by any of B's identifiers that didn't
-/// appear in A. Local identifiers in B that have the same division
-/// representation as local identifiers in A are merged into one.
+/// so that they have the union of all variables, with A's original
+/// variables appearing first followed by any of B's variables that didn't
+/// appear in A. Local variables in B that have the same division
+/// representation as local variables in A are merged into one.
 //  E.g.: Input: A has ((%i, %j) [%M, %N]) and B has (%k, %j) [%P, %N, %M])
 //        Output: both A, B have (%i, %j, %k) [%M, %N, %P]
-static void mergeAndAlignIds(unsigned offset, FlatAffineValueConstraints *a,
+static void mergeAndAlignVars(unsigned offset, FlatAffineValueConstraints *a,
                               FlatAffineValueConstraints *b) {
-  assert(offset <= a->getNumDimIds() && offset <= b->getNumDimIds());
-  // A merge/align isn't meaningful if a cst's ids aren't distinct.
-  assert(areIdsUnique(*a) && "A's values aren't unique");
-  assert(areIdsUnique(*b) && "B's values aren't unique");
+  assert(offset <= a->getNumDimVars() && offset <= b->getNumDimVars());
+  // A merge/align isn't meaningful if a cst's vars aren't distinct.
+  assert(areVarsUnique(*a) && "A's values aren't unique");
+  assert(areVarsUnique(*b) && "B's values aren't unique");
 
   assert(std::all_of(a->getMaybeValues().begin() + offset,
                      a->getMaybeValues().end(),
-                     [](Optional<Value> id) { return id.hasValue(); }));
+                     [](Optional<Value> var) { return var.hasValue(); }));
 
   assert(std::all_of(b->getMaybeValues().begin() + offset,
                      b->getMaybeValues().end(),
-                     [](Optional<Value> id) { return id.hasValue(); }));
+                     [](Optional<Value> var) { return var.hasValue(); }));
 
   SmallVector<Value, 4> aDimValues;
-  a->getValues(offset, a->getNumDimIds(), &aDimValues);
+  a->getValues(offset, a->getNumDimVars(), &aDimValues);
 
   {
     // Merge dims from A into B.
     unsigned d = offset;
     for (auto aDimValue : aDimValues) {
       unsigned loc;
-      if (b->findId(aDimValue, &loc)) {
+      if (b->findVar(aDimValue, &loc)) {
         assert(loc >= offset && "A's dim appears in B's aligned range");
-        assert(loc < b->getNumDimIds() &&
+        assert(loc < b->getNumDimVars() &&
                "A's dim appears in B's non-dim position");
-        b->swapId(d, loc);
+        b->swapVar(d, loc);
       } else {
-        b->insertDimId(d, aDimValue);
+        b->insertDimVar(d, aDimValue);
       }
       d++;
     }
     // Dimensions that are in B, but not in A, are added at the end.
-    for (unsigned t = a->getNumDimIds(), e = b->getNumDimIds(); t < e; t++) {
-      a->appendDimId(b->getValue(t));
+    for (unsigned t = a->getNumDimVars(), e = b->getNumDimVars(); t < e; t++) {
+      a->appendDimVar(b->getValue(t));
     }
-    assert(a->getNumDimIds() == b->getNumDimIds() &&
+    assert(a->getNumDimVars() == b->getNumDimVars() &&
            "expected same number of dims");
   }
 
   // Merge and align symbols of A and B
-  a->mergeSymbolIds(*b);
-  // Merge and align local ids of A and B
-  a->mergeLocalIds(*b);
+  a->mergeSymbolVars(*b);
+  // Merge and align locals of A and B
+  a->mergeLocalVars(*b);
 
-  assert(areIdsAligned(*a, *b) && "IDs expected to be aligned");
+  assert(areVarsAligned(*a, *b) && "IDs expected to be aligned");
 }
 
-// Call 'mergeAndAlignIds' to align constraint systems of 'this' and 'other'.
-void FlatAffineValueConstraints::mergeAndAlignIdsWithOther(
+// Call 'mergeAndAlignVars' to align constraint systems of 'this' and 'other'.
+void FlatAffineValueConstraints::mergeAndAlignVarsWithOther(
     unsigned offset, FlatAffineValueConstraints *other) {
-  mergeAndAlignIds(offset, this, other);
+  mergeAndAlignVars(offset, this, other);
 }
 
 LogicalResult
 FlatAffineValueConstraints::composeMap(const AffineValueMap *vMap) {
   return composeMatchingMap(
       computeAlignedMap(vMap->getAffineMap(), vMap->getOperands()));
 }
 
 // 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 FlatAffineValueConstraints::composeMatchingMap(AffineMap other) {
-  assert(other.getNumDims() == getNumDimIds() && "dim mismatch");
-  assert(other.getNumSymbols() == getNumSymbolIds() && "symbol mismatch");
+  assert(other.getNumDims() == getNumDimVars() && "dim mismatch");
+  assert(other.getNumSymbols() == getNumSymbolVars() && "symbol mismatch");
 
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   if (failed(flattenAlignedMapAndMergeLocals(other, &flatExprs)))
     return failure();
   assert(flatExprs.size() == other.getNumResults());
 
   // Add dimensions corresponding to the map's results.
-  insertDimId(/*pos=*/0, /*num=*/other.getNumResults());
+  insertDimVar(/*pos=*/0, /*num=*/other.getNumResults());
 
   // We add one equality for each result connecting the result dim of the map to
-  // the other identifiers.
+  // the other variables.
   // E.g.: if the expression is 16*i0 + i1, and this is the r^th
   // iteration/result of the value map, we are adding the equality:
   // d_r - 16*i0 - i1 = 0. Similarly, when flattening (i0 + 1, i0 + 8*i2), we
   // add two equalities: d_0 - i0 - 1 == 0, d1 - i0 - 8*i2 == 0.
   for (unsigned r = 0, e = flatExprs.size(); r < e; r++) {
     const auto &flatExpr = flatExprs[r];
     assert(flatExpr.size() >= other.getNumInputs() + 1);
 
     SmallVector<int64_t, 8> eqToAdd(getNumCols(), 0);
     // Set the coefficient for this result to one.
     eqToAdd[r] = 1;
 
     // Dims and symbols.
     for (unsigned i = 0, f = other.getNumInputs(); i < f; i++) {
       // Negate `eq[r]` since the newly added dimension will be set to this one.
       eqToAdd[e + i] = -flatExpr[i];
     }
     // Local columns of `eq` are at the beginning.
-    unsigned j = getNumDimIds() + getNumSymbolIds();
+    unsigned j = getNumDimVars() + getNumSymbolVars();
     unsigned end = flatExpr.size() - 1;
     for (unsigned i = other.getNumInputs(); i < end; i++, j++) {
       eqToAdd[j] = -flatExpr[i];
     }
 
     // Constant term.
     eqToAdd[getNumCols() - 1] = -flatExpr[flatExpr.size() - 1];
 
     // Add the equality connecting the result of the map to this constraint set.
     addEquality(eqToAdd);
   }
 
   return success();
 }
 
 // Turn a symbol into a dimension.
-static void turnSymbolIntoDim(FlatAffineValueConstraints *cst, Value id) {
+static void turnSymbolIntoDim(FlatAffineValueConstraints *cst, Value value) {
   unsigned pos;
-  if (cst->findId(id, &pos) && pos >= cst->getNumDimIds() &&
-      pos < cst->getNumDimAndSymbolIds()) {
-    cst->swapId(pos, cst->getNumDimIds());
-    cst->setDimSymbolSeparation(cst->getNumSymbolIds() - 1);
+  if (cst->findVar(value, &pos) && pos >= cst->getNumDimVars() &&
+      pos < cst->getNumDimAndSymbolVars()) {
+    cst->swapVar(pos, cst->getNumDimVars());
+    cst->setDimSymbolSeparation(cst->getNumSymbolVars() - 1);
   }
 }
 
 /// Merge and align symbols of `this` and `other` such that both get union of
 /// of symbols that are unique. Symbols in `this` and `other` should be
 /// unique. Symbols with Value as `None` are considered to be inequal to all
 /// other symbols.
-void FlatAffineValueConstraints::mergeSymbolIds(
+void FlatAffineValueConstraints::mergeSymbolVars(
     FlatAffineValueConstraints &other) {
 
-  assert(areIdsUnique(*this, IdKind::Symbol) && "Symbol ids are not unique");
-  assert(areIdsUnique(other, IdKind::Symbol) && "Symbol ids are not unique");
+  assert(areVarsUnique(*this, VarKind::Symbol) && "Symbol vars are not unique");
+  assert(areVarsUnique(other, VarKind::Symbol) && "Symbol vars are not unique");
 
   SmallVector<Value, 4> aSymValues;
-  getValues(getNumDimIds(), getNumDimAndSymbolIds(), &aSymValues);
+  getValues(getNumDimVars(), getNumDimAndSymbolVars(), &aSymValues);
 
   // Merge symbols: merge symbols into `other` first from `this`.
-  unsigned s = other.getNumDimIds();
+  unsigned s = other.getNumDimVars();
   for (Value aSymValue : aSymValues) {
     unsigned loc;
-    // If the id is a symbol in `other`, then align it, otherwise assume that
+    // If the var is a symbol in `other`, then align it, otherwise assume that
     // it is a new symbol
-    if (other.findId(aSymValue, &loc) && loc >= other.getNumDimIds() &&
-        loc < other.getNumDimAndSymbolIds())
-      other.swapId(s, loc);
+    if (other.findVar(aSymValue, &loc) && loc >= other.getNumDimVars() &&
+        loc < other.getNumDimAndSymbolVars())
+      other.swapVar(s, loc);
     else
-      other.insertSymbolId(s - other.getNumDimIds(), aSymValue);
+      other.insertSymbolVar(s - other.getNumDimVars(), aSymValue);
     s++;
   }
 
   // Symbols that are in other, but not in this, are added at the end.
-  for (unsigned t = other.getNumDimIds() + getNumSymbolIds(),
-                e = other.getNumDimAndSymbolIds();
+  for (unsigned t = other.getNumDimVars() + getNumSymbolVars(),
+                e = other.getNumDimAndSymbolVars();
        t < e; t++)
-    insertSymbolId(getNumSymbolIds(), other.getValue(t));
+    insertSymbolVar(getNumSymbolVars(), other.getValue(t));
 
-  assert(getNumSymbolIds() == other.getNumSymbolIds() &&
+  assert(getNumSymbolVars() == other.getNumSymbolVars() &&
          "expected same number of symbols");
-  assert(areIdsUnique(*this, IdKind::Symbol) && "Symbol ids are not unique");
-  assert(areIdsUnique(other, IdKind::Symbol) && "Symbol ids are not unique");
+  assert(areVarsUnique(*this, VarKind::Symbol) && "Symbol vars are not unique");
+  assert(areVarsUnique(other, VarKind::Symbol) && "Symbol vars are not unique");
 }
 
-// Changes all symbol identifiers which are loop IVs to dim identifiers.
+// Changes all symbol variables which are loop IVs to dim variables.
 void FlatAffineValueConstraints::convertLoopIVSymbolsToDims() {
   // Gather all symbols which are loop IVs.
   SmallVector<Value, 4> loopIVs;
-  for (unsigned i = getNumDimIds(), e = getNumDimAndSymbolIds(); i < e; i++) {
+  for (unsigned i = getNumDimVars(), e = getNumDimAndSymbolVars(); i < e; i++) {
     if (hasValue(i) && getForInductionVarOwner(getValue(i)))
       loopIVs.push_back(getValue(i));
   }
-  // Turn each symbol in 'loopIVs' into a dim identifier.
+  // Turn each symbol in 'loopIVs' into a dim variable.
   for (auto iv : loopIVs) {
     turnSymbolIntoDim(this, iv);
   }
 }
 
 void FlatAffineValueConstraints::addInductionVarOrTerminalSymbol(Value val) {
-  if (containsId(val))
+  if (containsVar(val))
     return;
 
   // Caller is expected to fully compose map/operands if necessary.
   assert((isTopLevelValue(val) || isForInductionVar(val)) &&
          "non-terminal symbol / loop IV expected");
   // Outer loop IVs could be used in forOp's bounds.
   if (auto loop = getForInductionVarOwner(val)) {
-    appendDimId(val);
+    appendDimVar(val);
     if (failed(this->addAffineForOpDomain(loop)))
       LLVM_DEBUG(
           loop.emitWarning("failed to add domain info to constraint system"));
     return;
   }
   // Add top level symbol.
-  appendSymbolId(val);
+  appendSymbolVar(val);
   // Check if the symbol is a constant.
   if (auto constOp = val.getDefiningOp<arith::ConstantIndexOp>())
     addBound(BoundType::EQ, val, constOp.value());
 }
 
 LogicalResult
 FlatAffineValueConstraints::addAffineForOpDomain(AffineForOp forOp) {
   unsigned pos;
   // Pre-condition for this method.
-  if (!findId(forOp.getInductionVar(), &pos)) {
+  if (!findVar(forOp.getInductionVar(), &pos)) {
     assert(false && "Value not found");
     return failure();
   }
 
   int64_t step = forOp.getStep();
   if (step != 1) {
     if (!forOp.hasConstantLowerBound())
       LLVM_DEBUG(forOp.emitWarning("domain conservatively approximated"));
return addBound(BoundType::UB, pos, forOp.getUpperBoundMap(),
                   forOp.getUpperBoundOperands());
 }
 
 LogicalResult
 FlatAffineValueConstraints::addDomainFromSliceMaps(ArrayRef<AffineMap> lbMaps,
                                                    ArrayRef<AffineMap> ubMaps,
                                                    ArrayRef<Value> operands) {
   assert(lbMaps.size() == ubMaps.size());
-  assert(lbMaps.size() <= getNumDimIds());
+  assert(lbMaps.size() <= getNumDimVars());
 
   for (unsigned i = 0, e = lbMaps.size(); i < e; ++i) {
     AffineMap lbMap = lbMaps[i];
     AffineMap ubMap = ubMaps[i];
     assert(!lbMap || lbMap.getNumInputs() == operands.size());
     assert(!ubMap || ubMap.getNumInputs() == operands.size());
 
     // Check if this slice is just an equality along this dimension. If so,
if (lbMap && ubMap && lbMap.getNumResults() == 1 &&
         return failure();
 
       if (failed(addAffineForOpDomain(loop)))
         return failure();
       continue;
     }
 
     // This slice refers to a loop that doesn't exist in the IR yet. Add its
-    // bounds to the system assuming its dimension identifier position is the
+    // bounds to the system assuming its dimension variable position is the
     // same as the position of the loop in the loop nest.
     if (lbMap && failed(addBound(BoundType::LB, i, lbMap, operands)))
       return failure();
     if (ubMap && failed(addBound(BoundType::UB, i, ubMap, operands)))
       return failure();
   }
   return success();
 }
 
 void FlatAffineValueConstraints::addAffineIfOpDomain(AffineIfOp ifOp) {
   // Create the base constraints from the integer set attached to ifOp.
   FlatAffineValueConstraints cst(ifOp.getIntegerSet());
 
-  // Bind ids in the constraints to ifOp operands.
+  // Bind vars in the constraints to ifOp operands.
   SmallVector<Value, 4> operands = ifOp.getOperands();
-  cst.setValues(0, cst.getNumDimAndSymbolIds(), operands);
+  cst.setValues(0, cst.getNumDimAndSymbolVars(), operands);
 
   // Merge the constraints from ifOp to the current domain. We need first merge
   // and align the IDs from both constraints, and then append the constraints
   // from the ifOp into the current one.
-  mergeAndAlignIdsWithOther(0, &cst);
+  mergeAndAlignVarsWithOther(0, &cst);
   append(cst);
 }
 
 bool FlatAffineValueConstraints::hasConsistentState() const {
   return IntegerPolyhedron::hasConsistentState() &&
-         values.size() == getNumDimAndSymbolIds();
+         values.size() == getNumDimAndSymbolVars();
 }
 
-void FlatAffineValueConstraints::removeIdRange(IdKind kind, unsigned idStart,
-                                               unsigned idLimit) {
-  IntegerPolyhedron::removeIdRange(kind, idStart, idLimit);
-  unsigned offset = getIdKindOffset(kind);
+void FlatAffineValueConstraints::removeVarRange(VarKind kind, unsigned varStart,
+                                                unsigned varLimit) {
+  IntegerPolyhedron::removeVarRange(kind, varStart, varLimit);
+  unsigned offset = getVarKindOffset(kind);
 
-  if (kind != IdKind::Local) {
-    values.erase(values.begin() + idStart + offset,
-                 values.begin() + idLimit + offset);
+  if (kind != VarKind::Local) {
+    values.erase(values.begin() + varStart + offset,
+                 values.begin() + varLimit + offset);
   }
 }
 
-// Determine whether the identifier at 'pos' (say id_r) can be expressed as
-// modulo of another known identifier (say id_n) w.r.t a constant. For example,
+// Determine whether the variable at 'pos' (say var_r) can be expressed as
+// modulo of another known variable (say var_n) w.r.t a constant. For example,
 // if the following constraints hold true:
 // ```
-// 0 <= id_r <= divisor - 1
-// id_n - (divisor * q_expr) = id_r
+// 0 <= var_r <= divisor - 1
+// var_n - (divisor * q_expr) = var_r
 // ```
-// where `id_n` is a known identifier (called dividend), and `q_expr` is an
-// `AffineExpr` (called the quotient expression), `id_r` can be written as:
+// where `var_n` is a known variable (called dividend), and `q_expr` is an
+// `AffineExpr` (called the quotient expression), `var_r` can be written as:
 //
-// `id_r = id_n mod divisor`.
+// `var_r = var_n mod divisor`.
 //
 // Additionally, in a special case of the above constaints where `q_expr` is an
-// identifier itself that is not yet known (say `id_q`), it can be written as a
+// variable itself that is not yet known (say `var_q`), it can be written as a
 // floordiv in the following way:
 //
-// `id_q = id_n floordiv divisor`.
+// `var_q = var_n floordiv divisor`.
 //
 // Returns true if the above mod or floordiv are detected, updating 'memo' with
 // these new expressions. Returns false otherwise.
 static bool detectAsMod(const FlatAffineValueConstraints &cst, unsigned pos,
                         int64_t lbConst, int64_t ubConst,
                         SmallVectorImpl<AffineExpr> &memo,
                         MLIRContext *context) {
-  assert(pos < cst.getNumIds() && "invalid position");
+  assert(pos < cst.getNumVars() && "invalid position");
 
-  // Check if a divisor satisfying the condition `0 <= id_r <= divisor - 1` can
+  // Check if a divisor satisfying the condition `0 <= var_r <= divisor - 1` can
   // be determined.
   if (lbConst != 0 || ubConst < 1)
     return false;
   int64_t divisor = ubConst + 1;
 
   // Check for the aforementioned conditions in each equality.
   for (unsigned curEquality = 0, numEqualities = cst.getNumEqualities();
        curEquality < numEqualities; curEquality++) {
     int64_t coefficientAtPos = cst.atEq(curEquality, pos);
-    // If current equality does not involve `id_r`, continue to the next
+    // If current equality does not involve `var_r`, continue to the next
     // equality.
     if (coefficientAtPos == 0)
       continue;
 
     // Constant term should be 0 in this equality.
     if (cst.atEq(curEquality, cst.getNumCols() - 1) != 0)
       continue;
 
     // Traverse through the equality and construct the dividend expression
-    // `dividendExpr`, to contain all the identifiers which are known and are
+    // `dividendExpr`, to contain all the variables which are known and are
     // not divisible by `(coefficientAtPos * divisor)`. Hope here is that the
-    // `dividendExpr` gets simplified into a single identifier `id_n` discussed
+    // `dividendExpr` gets simplified into a single variable `var_n` discussed
     // above.
     auto dividendExpr = getAffineConstantExpr(0, context);
 
     // Track the terms that go into quotient expression, later used to detect
     // additional floordiv.
     unsigned quotientCount = 0;
     int quotientPosition = -1;
     int quotientSign = 1;
 
     // Consider each term in the current equality.
-    unsigned curId, e;
-    for (curId = 0, e = cst.getNumDimAndSymbolIds(); curId < e; ++curId) {
-      // Ignore id_r.
-      if (curId == pos)
+    unsigned curVar, e;
+    for (curVar = 0, e = cst.getNumDimAndSymbolVars(); curVar < e; ++curVar) {
+      // Ignore var_r.
+      if (curVar == pos)
         continue;
-      int64_t coefficientOfCurId = cst.atEq(curEquality, curId);
-      // Ignore ids that do not contribute to the current equality.
-      if (coefficientOfCurId == 0)
+      int64_t coefficientOfCurVar = cst.atEq(curEquality, curVar);
+      // Ignore vars that do not contribute to the current equality.
+      if (coefficientOfCurVar == 0)
         continue;
-      // Check if the current id goes into the quotient expression.
-      if (coefficientOfCurId % (divisor * coefficientAtPos) == 0) {
+      // Check if the current var goes into the quotient expression.
+      if (coefficientOfCurVar % (divisor * coefficientAtPos) == 0) {
         quotientCount++;
-        quotientPosition = curId;
-        quotientSign = (coefficientOfCurId * coefficientAtPos) > 0 ? 1 : -1;
+        quotientPosition = curVar;
+        quotientSign = (coefficientOfCurVar * coefficientAtPos) > 0 ? 1 : -1;
         continue;
       }
-      // Identifiers that are part of dividendExpr should be known.
-      if (!memo[curId])
+      // Variables that are part of dividendExpr should be known.
+      if (!memo[curVar])
         break;
-      // Append the current identifier to the dividend expression.
-      dividendExpr = dividendExpr + memo[curId] * coefficientOfCurId;
+      // Append the current variable to the dividend expression.
+      dividendExpr = dividendExpr + memo[curVar] * coefficientOfCurVar;
     }
 
-    // Can't construct expression as it depends on a yet uncomputed id.
-    if (curId < e)
+    // Can't construct expression as it depends on a yet uncomputed var.
+    if (curVar < e)
       continue;
 
-    // Express `id_r` in terms of the other ids collected so far.
+    // Express `var_r` in terms of the other vars collected so far.
     if (coefficientAtPos > 0)
       dividendExpr = (-dividendExpr).floorDiv(coefficientAtPos);
     else
       dividendExpr = dividendExpr.floorDiv(-coefficientAtPos);
 
     // Simplify the expression.
-    dividendExpr = simplifyAffineExpr(dividendExpr, cst.getNumDimIds(),
-                                      cst.getNumSymbolIds());
-    // Only if the final dividend expression is just a single id (which we call
-    // `id_n`), we can proceed.
+    dividendExpr = simplifyAffineExpr(dividendExpr, cst.getNumDimVars(),
+                                      cst.getNumSymbolVars());
+    // Only if the final dividend expression is just a single var (which we call
+    // `var_n`), we can proceed.
     // TODO: Handle AffineSymbolExpr as well. There is no reason to restrict it
     // to dims themselves.
     auto dimExpr = dividendExpr.dyn_cast<AffineDimExpr>();
     if (!dimExpr)
       continue;
 
-    // Express `id_r` as `id_n % divisor` and store the expression in `memo`.
+    // Express `var_r` as `var_n % divisor` and store the expression in `memo`.
     if (quotientCount >= 1) {
       auto ub = cst.getConstantBound(FlatAffineValueConstraints::BoundType::UB,
                                      dimExpr.getPosition());
-      // If `id_n` has an upperbound that is less than the divisor, mod can be
+      // If `var_n` has an upperbound that is less than the divisor, mod can be
       // eliminated altogether.
       if (ub && *ub < divisor)
         memo[pos] = dimExpr;
       else
         memo[pos] = dimExpr % divisor;
-      // If a unique quotient `id_q` was seen, it can be expressed as
-      // `id_n floordiv divisor`.
+      // If a unique quotient `var_q` was seen, it can be expressed as
+      // `var_n floordiv divisor`.
       if (quotientCount == 1 && !memo[quotientPosition])
         memo[quotientPosition] = dimExpr.floorDiv(divisor) * quotientSign;
 
       return true;
     }
   }
   return false;
 }
 
-/// Check if the pos^th identifier can be expressed as a floordiv of an affine
-/// function of other identifiers (where the divisor is a positive constant)
+/// Check if the pos^th variable can be expressed as a floordiv of an affine
+/// function of other variables (where the divisor is a positive constant)
 /// given the initial set of expressions in `exprs`. If it can be, the
 /// corresponding position in `exprs` is set as the detected affine expr. For
 /// eg: 4q <= i + j <= 4q + 3   <=>   q = (i + j) floordiv 4. An equality can
 /// also yield a floordiv: eg.  4q = i + j <=> q = (i + j) floordiv 4. 32q + 28
 /// <= i <= 32q + 31 => q = i floordiv 32.
 static bool detectAsFloorDiv(const FlatAffineValueConstraints &cst,
                              unsigned pos, MLIRContext *context,
                              SmallVectorImpl<AffineExpr> &exprs) {
-  assert(pos < cst.getNumIds() && "invalid position");
+  assert(pos < cst.getNumVars() && "invalid position");
 
   // Get upper-lower bound pair for this variable.
-  SmallVector<bool, 8> foundRepr(cst.getNumIds(), false);
-  for (unsigned i = 0, e = cst.getNumIds(); i < e; ++i)
+  SmallVector<bool, 8> foundRepr(cst.getNumVars(), false);
+  for (unsigned i = 0, e = cst.getNumVars(); i < e; ++i)
     if (exprs[i])
       foundRepr[i] = true;
 
   SmallVector<int64_t, 8> dividend;
   unsigned divisor;
   auto ulPair = computeSingleVarRepr(cst, foundRepr, pos, dividend, divisor);
 
   // No upper-lower bound pair found for this var.
   if (ulPair.kind == ReprKind::None || ulPair.kind == ReprKind::Equality)
     return false;
 
   // Construct the dividend expression.
   auto dividendExpr = getAffineConstantExpr(dividend.back(), context);
-  for (unsigned c = 0, f = cst.getNumIds(); c < f; c++)
+  for (unsigned c = 0, f = cst.getNumVars(); c < f; c++)
     if (dividend[c] != 0)
       dividendExpr = dividendExpr + dividend[c] * exprs[c];
 
   // Successfully detected the floordiv.
   exprs[pos] = dividendExpr.floorDiv(divisor);
   return true;
 }
 
 std::pair<AffineMap, AffineMap>
 FlatAffineValueConstraints::getLowerAndUpperBound(
     unsigned pos, unsigned offset, unsigned num, unsigned symStartPos,
     ArrayRef<AffineExpr> localExprs, MLIRContext *context) const {
-  assert(pos + offset < getNumDimIds() && "invalid dim start pos");
+  assert(pos + offset < getNumDimVars() && "invalid dim start pos");
   assert(symStartPos >= (pos + offset) && "invalid sym start pos");
-  assert(getNumLocalIds() == localExprs.size() &&
+  assert(getNumLocalVars() == localExprs.size() &&
          "incorrect local exprs count");
 
   SmallVector<unsigned, 4> lbIndices, ubIndices, eqIndices;
   getLowerAndUpperBoundIndices(pos + offset, &lbIndices, &ubIndices, &eqIndices,
                                offset, num);
 
   /// Add to 'b' from 'a' in set [0, offset) U [offset + num, symbStartPos).
   auto addCoeffs = [&](ArrayRef<int64_t> a, SmallVectorImpl<int64_t> &b) {
     b.clear();
     for (unsigned i = 0, e = a.size(); i < e; ++i) {
       if (i < offset || i >= offset + num)
         b.push_back(a[i]);
     }
   };
 
   SmallVector<int64_t, 8> lb, ub;
   SmallVector<AffineExpr, 4> lbExprs;
   unsigned dimCount = symStartPos - num;
-  unsigned symCount = getNumDimAndSymbolIds() - symStartPos;
+  unsigned symCount = getNumDimAndSymbolVars() - symStartPos;
   lbExprs.reserve(lbIndices.size() + eqIndices.size());
   // Lower bound expressions.
   for (auto idx : lbIndices) {
     auto ineq = getInequality(idx);
     // Extract the lower bound (in terms of other coeff's + const), i.e., if
     // i - j + 1 >= 0 is the constraint, 'pos' is for i the lower bound is j
     // - 1.
     addCoeffs(ineq, lb);
FlatAffineValueConstraints::getLowerAndUpperBound(
 
   auto lbMap = AffineMap::get(dimCount, symCount, lbExprs, context);
   auto ubMap = AffineMap::get(dimCount, symCount, ubExprs, context);
 
   return {lbMap, ubMap};
 }
 
 /// Computes the lower and upper bounds of the first 'num' dimensional
-/// identifiers (starting at 'offset') as affine maps of the remaining
-/// identifiers (dimensional and symbolic identifiers). Local identifiers are
-/// themselves explicitly computed as affine functions of other identifiers in
+/// variables (starting at 'offset') as affine maps of the remaining
+/// variables (dimensional and symbolic variables). Local variables are
+/// themselves explicitly computed as affine functions of other variables in
 /// this process if needed.
 void FlatAffineValueConstraints::getSliceBounds(
     unsigned offset, unsigned num, MLIRContext *context,
     SmallVectorImpl<AffineMap> *lbMaps, SmallVectorImpl<AffineMap> *ubMaps,
     bool getClosedUB) {
-  assert(num < getNumDimIds() && "invalid range");
+  assert(num < getNumDimVars() && "invalid range");
 
   // Basic simplification.
   normalizeConstraintsByGCD();
 
   LLVM_DEBUG(llvm::dbgs() << "getSliceBounds for first " << num
-                          << " identifiers\n");
+                          << " variables\n");
   LLVM_DEBUG(dump());
 
-  // Record computed/detected identifiers.
-  SmallVector<AffineExpr, 8> memo(getNumIds());
-  // Initialize dimensional and symbolic identifiers.
-  for (unsigned i = 0, e = getNumDimIds(); i < e; i++) {
+  // Record computed/detected variables.
+  SmallVector<AffineExpr, 8> memo(getNumVars());
+  // Initialize dimensional and symbolic variables.
+  for (unsigned i = 0, e = getNumDimVars(); i < e; i++) {
     if (i < offset)
       memo[i] = getAffineDimExpr(i, context);
     else if (i >= offset + num)
       memo[i] = getAffineDimExpr(i - num, context);
   }
-  for (unsigned i = getNumDimIds(), e = getNumDimAndSymbolIds(); i < e; i++)
-    memo[i] = getAffineSymbolExpr(i - getNumDimIds(), context);
+  for (unsigned i = getNumDimVars(), e = getNumDimAndSymbolVars(); i < e; i++)
+    memo[i] = getAffineSymbolExpr(i - getNumDimVars(), context);
 
   bool changed;
   do {
     changed = false;
-    // Identify yet unknown identifiers as constants or mod's / floordiv's of
-    // other identifiers if possible.
-    for (unsigned pos = 0; pos < getNumIds(); pos++) {
+    // Identify yet unknown variables as constants or mod's / floordiv's of
+    // other variables if possible.
+    for (unsigned pos = 0; pos < getNumVars(); pos++) {
       if (memo[pos])
         continue;
 
       auto lbConst = getConstantBound(BoundType::LB, pos);
       auto ubConst = getConstantBound(BoundType::UB, pos);
       if (lbConst.hasValue() && ubConst.hasValue()) {
         // Detect equality to a constant.
         if (lbConst.getValue() == ubConst.getValue()) {
           memo[pos] = getAffineConstantExpr(lbConst.getValue(), context);
           changed = true;
           continue;
         }
 
-        // Detect an identifier as modulo of another identifier w.r.t a
+        // Detect an variable as modulo of another variable w.r.t a
         // constant.
         if (detectAsMod(*this, pos, lbConst.getValue(), ubConst.getValue(),
                         memo, context)) {
           changed = true;
           continue;
         }
       }
 
-      // Detect an identifier as a floordiv of an affine function of other
-      // identifiers (divisor is a positive constant).
+      // Detect an variable as a floordiv of an affine function of other
+      // variables (divisor is a positive constant).
       if (detectAsFloorDiv(*this, pos, context, memo)) {
         changed = true;
         continue;
       }
 
-      // Detect an identifier as an expression of other identifiers.
+      // Detect an variable as an expression of other variables.
       unsigned idx;
       if (!findConstraintWithNonZeroAt(pos, /*isEq=*/true, &idx)) {
         continue;
       }
 
-      // Build AffineExpr solving for identifier 'pos' in terms of all others.
+      // Build AffineExpr solving for variable 'pos' in terms of all others.
       auto expr = getAffineConstantExpr(0, context);
       unsigned j, e;
-      for (j = 0, e = getNumIds(); j < e; ++j) {
+      for (j = 0, e = getNumVars(); j < e; ++j) {
         if (j == pos)
           continue;
         int64_t c = atEq(idx, j);
         if (c == 0)
           continue;
         // If any of the involved IDs hasn't been found yet, we can't proceed.
         if (!memo[j])
           break;
         expr = expr + memo[j] * c;
       }
       if (j < e)
         // Can't construct expression as it depends on a yet uncomputed
-        // identifier.
+        // variable.
         continue;
 
       // Add constant term to AffineExpr.
-      expr = expr + atEq(idx, getNumIds());
+      expr = expr + atEq(idx, getNumVars());
       int64_t vPos = atEq(idx, pos);
       assert(vPos != 0 && "expected non-zero here");
       if (vPos > 0)
         expr = (-expr).floorDiv(vPos);
       else
         // vPos < 0.
         expr = expr.floorDiv(-vPos);
       // Successfully constructed expression.
       memo[pos] = expr;
       changed = true;
     }
     // This loop is guaranteed to reach a fixed point - since once an
-    // identifier's explicit form is computed (in memo[pos]), it's not updated
+    // variable's explicit form is computed (in memo[pos]), it's not updated
     // again.
   } while (changed);
 
   int64_t ubAdjustment = getClosedUB ? 0 : 1;
 
-  // Set the lower and upper bound maps for all the identifiers that were
+  // Set the lower and upper bound maps for all the variables that were
   // computed as affine expressions of the rest as the "detected expr" and
   // "detected expr + 1" respectively; set the undetected ones to null.
   Optional<FlatAffineValueConstraints> tmpClone;
   for (unsigned pos = 0; pos < num; pos++) {
-    unsigned numMapDims = getNumDimIds() - num;
-    unsigned numMapSymbols = getNumSymbolIds();
+    unsigned numMapDims = getNumDimVars() - num;
+    unsigned numMapSymbols = getNumSymbolVars();
     AffineExpr expr = memo[pos + offset];
     if (expr)
       expr = simplifyAffineExpr(expr, numMapDims, numMapSymbols);
 
     AffineMap &lbMap = (*lbMaps)[pos];
     AffineMap &ubMap = (*ubMaps)[pos];
 
     if (expr) {
       lbMap = AffineMap::get(numMapDims, numMapSymbols, expr);
       ubMap = AffineMap::get(numMapDims, numMapSymbols, expr + ubAdjustment);
     } else {
-      // TODO: Whenever there are local identifiers in the dependence
+      // TODO: Whenever there are local variables in the dependence
       // constraints, we'll conservatively over-approximate, since we don't
       // always explicitly compute them above (in the while loop).
-      if (getNumLocalIds() == 0) {
+      if (getNumLocalVars() == 0) {
         // Work on a copy so that we don't update this constraint system.
         if (!tmpClone) {
           tmpClone.emplace(FlatAffineValueConstraints(*this));
           // Removing redundant inequalities is necessary so that we don't get
           // redundant loop bounds.
           tmpClone->removeRedundantInequalities();
         }
         std::tie(lbMap, ubMap) = tmpClone->getLowerAndUpperBound(
-            pos, offset, num, getNumDimIds(), /*localExprs=*/{}, context);
+            pos, offset, num, getNumDimVars(), /*localExprs=*/{}, context);
       }
 
       // If the above fails, we'll just use the constant lower bound and the
       // constant upper bound (if they exist) as the slice bounds.
       // TODO: being conservative for the moment in cases that
       // lead to multiple bounds - until getConstDifference in LoopFusion.cpp is
       // fixed (b/126426796).
       if (!lbMap || lbMap.getNumResults() > 1) {
LogicalResult FlatAffineValueConstraints::flattenAlignedMapAndMergeLocals(
   FlatAffineValueConstraints localCst;
   if (failed(getFlattenedAffineExprs(map, flattenedExprs, &localCst))) {
     LLVM_DEBUG(llvm::dbgs()
                << "composition unimplemented for semi-affine maps\n");
     return failure();
   }
 
   // Add localCst information.
-  if (localCst.getNumLocalIds() > 0) {
-    unsigned numLocalIds = getNumLocalIds();
+  if (localCst.getNumLocalVars() > 0) {
+    unsigned numLocalVars = getNumLocalVars();
     // Insert local dims of localCst at the beginning.
-    insertLocalId(/*pos=*/0, /*num=*/localCst.getNumLocalIds());
+    insertLocalVar(/*pos=*/0, /*num=*/localCst.getNumLocalVars());
     // Insert local dims of `this` at the end of localCst.
-    localCst.appendLocalId(/*num=*/numLocalIds);
+    localCst.appendLocalVar(/*num=*/numLocalVars);
     // Dimensions of localCst and this constraint set match. Append localCst to
     // this constraint set.
     append(localCst);
   }
 
   return success();
 }
 
 LogicalResult FlatAffineValueConstraints::addBound(BoundType type, unsigned pos,
                                                    AffineMap boundMap,
                                                    bool isClosedBound) {
-  assert(boundMap.getNumDims() == getNumDimIds() && "dim mismatch");
-  assert(boundMap.getNumSymbols() == getNumSymbolIds() && "symbol mismatch");
-  assert(pos < getNumDimAndSymbolIds() && "invalid position");
+  assert(boundMap.getNumDims() == getNumDimVars() && "dim mismatch");
+  assert(boundMap.getNumSymbols() == getNumSymbolVars() && "symbol mismatch");
+  assert(pos < getNumDimAndSymbolVars() && "invalid position");
   assert((type != BoundType::EQ || isClosedBound) &&
          "EQ bound must be closed.");
 
   // Equality follows the logic of lower bound except that we add an equality
   // instead of an inequality.
   assert((type != BoundType::EQ || boundMap.getNumResults() == 1) &&
          "single result expected");
   bool lower = type == BoundType::LB || type == BoundType::EQ;
for (const auto &flatExpr : flatExprs) {
     }
     // Invalid bound: pos appears in `boundMap`.
     // TODO: This should be an assertion. Fix `addDomainFromSliceMaps` and/or
     // its callers to prevent invalid bounds from being added.
     if (ineq[pos] != 0)
       continue;
     ineq[pos] = lower ? 1 : -1;
     // Local columns of `ineq` are at the beginning.
-    unsigned j = getNumDimIds() + getNumSymbolIds();
+    unsigned j = getNumDimVars() + getNumSymbolVars();
     unsigned end = flatExpr.size() - 1;
     for (unsigned i = boundMap.getNumInputs(); i < end; i++, j++) {
       ineq[j] = lower ? -flatExpr[i] : flatExpr[i];
     }
     // Make the bound closed in if flatExpr is open. The inequality is always
     // created in the upper bound form, so the adjustment is -1.
     int64_t boundAdjustment = (isClosedBound || type == BoundType::EQ) ? 0 : -1;
     // Constant term.
FlatAffineValueConstraints::computeAlignedMap(AffineMap map,
   SmallVector<Value> dims, syms;
 #ifndef NDEBUG
   SmallVector<Value> newSyms;
   SmallVector<Value> *newSymsPtr = &newSyms;
 #else
   SmallVector<Value> *newSymsPtr = nullptr;
 #endif // NDEBUG
 
-  dims.reserve(getNumDimIds());
-  syms.reserve(getNumSymbolIds());
-  for (unsigned i = getIdKindOffset(IdKind::SetDim),
-                e = getIdKindEnd(IdKind::SetDim);
+  dims.reserve(getNumDimVars());
+  syms.reserve(getNumSymbolVars());
+  for (unsigned i = getVarKindOffset(VarKind::SetDim),
+                e = getVarKindEnd(VarKind::SetDim);
        i < e; ++i)
     dims.push_back(values[i] ? *values[i] : Value());
-  for (unsigned i = getIdKindOffset(IdKind::Symbol),
-                e = getIdKindEnd(IdKind::Symbol);
+  for (unsigned i = getVarKindOffset(VarKind::Symbol),
+                e = getVarKindEnd(VarKind::Symbol);
        i < e; ++i)
     syms.push_back(values[i] ? *values[i] : Value());
 
   AffineMap alignedMap =
       alignAffineMapWithValues(map, operands, dims, syms, newSymsPtr);
   // All symbols are already part of this FlatAffineConstraints.
   assert(syms.size() == newSymsPtr->size() && "unexpected new/missing symbols");
   assert(std::equal(syms.begin(), syms.end(), newSymsPtr->begin()) &&

 LogicalResult FlatAffineValueConstraints::addSliceBounds(
     ArrayRef<Value> values, ArrayRef<AffineMap> lbMaps,
     ArrayRef<AffineMap> ubMaps, ArrayRef<Value> operands) {
   assert(values.size() == lbMaps.size());
   assert(lbMaps.size() == ubMaps.size());
 
   for (unsigned i = 0, e = lbMaps.size(); i < e; ++i) {
     unsigned pos;
-    if (!findId(values[i], &pos))
+    if (!findVar(values[i], &pos))
       continue;
 
     AffineMap lbMap = lbMaps[i];
     AffineMap ubMap = ubMaps[i];
     assert(!lbMap || lbMap.getNumInputs() == operands.size());
     assert(!ubMap || ubMap.getNumInputs() == operands.size());
 
     // Check if this slice is just an equality along this dimension.
if (lbMap && lbMap.getNumResults() != 0 && ubMap &&
       auto loop = getForInductionVarOwner(values[i]);
       if (failed(this->addAffineForOpDomain(loop)))
         return failure();
     }
   }
   return success();
 }
 
-bool FlatAffineValueConstraints::findId(Value val, unsigned *pos) const {
+bool FlatAffineValueConstraints::findVar(Value val, unsigned *pos) const {
   unsigned i = 0;
-  for (const auto &mayBeId : values) {
-    if (mayBeId && *mayBeId == val) {
+  for (const auto &mayBeVar : values) {
+    if (mayBeVar && *mayBeVar == val) {
       *pos = i;
       return true;
     }
     i++;
   }
   return false;
 }
 
-bool FlatAffineValueConstraints::containsId(Value val) const {
-  return llvm::any_of(values, [&](const Optional<Value> &mayBeId) {
-    return mayBeId && *mayBeId == val;
+bool FlatAffineValueConstraints::containsVar(Value val) const {
+  return llvm::any_of(values, [&](const Optional<Value> &mayBeVar) {
+    return mayBeVar && *mayBeVar == val;
   });
 }
 
-void FlatAffineValueConstraints::swapId(unsigned posA, unsigned posB) {
-  IntegerPolyhedron::swapId(posA, posB);
+void FlatAffineValueConstraints::swapVar(unsigned posA, unsigned posB) {
+  IntegerPolyhedron::swapVar(posA, posB);
 
-  if (getIdKindAt(posA) == IdKind::Local && getIdKindAt(posB) == IdKind::Local)
+  if (getVarKindAt(posA) == VarKind::Local &&
+      getVarKindAt(posB) == VarKind::Local)
     return;
 
-  // Treat value of a local identifer as None.
-  if (getIdKindAt(posA) == IdKind::Local)
+  // Treat value of a local variable as None.
+  if (getVarKindAt(posA) == VarKind::Local)
     values[posB] = None;
-  else if (getIdKindAt(posB) == IdKind::Local)
+  else if (getVarKindAt(posB) == VarKind::Local)
     values[posA] = None;
   else
     std::swap(values[posA], values[posB]);
 }
 
 void FlatAffineValueConstraints::addBound(BoundType type, Value val,
                                           int64_t value) {
   unsigned pos;
-  if (!findId(val, &pos))
+  if (!findVar(val, &pos))
     // This is a pre-condition for this method.
-    assert(0 && "id not found");
+    assert(0 && "var not found");
   addBound(type, pos, value);
 }
 
 void FlatAffineValueConstraints::printSpace(raw_ostream &os) const {
   IntegerPolyhedron::printSpace(os);
   os << "(";
-  for (unsigned i = 0, e = getNumDimAndSymbolIds(); i < e; i++) {
+  for (unsigned i = 0, e = getNumDimAndSymbolVars(); i < e; i++) {
     if (hasValue(i))
       os << "Value ";
     else
       os << "None ";
   }
-  for (unsigned i = getIdKindOffset(IdKind::Local),
-                e = getIdKindEnd(IdKind::Local);
+  for (unsigned i = getVarKindOffset(VarKind::Local),
+                e = getVarKindEnd(VarKind::Local);
        i < e; ++i)
     os << "Local ";
   os << " const)\n";
 }
 
 void FlatAffineValueConstraints::clearAndCopyFrom(
     const IntegerRelation &other) {
 
   if (auto *otherValueSet =
           dyn_cast<const FlatAffineValueConstraints>(&other)) {
     *this = *otherValueSet;
   } else {
     *static_cast<IntegerRelation *>(this) = other;
     values.clear();
-    values.resize(getNumDimAndSymbolIds(), None);
+    values.resize(getNumDimAndSymbolVars(), None);
   }
 }
 
 void FlatAffineValueConstraints::fourierMotzkinEliminate(
     unsigned pos, bool darkShadow, bool *isResultIntegerExact) {
   SmallVector<Optional<Value>, 8> newVals = values;
-  if (getIdKindAt(pos) != IdKind::Local)
+  if (getVarKindAt(pos) != VarKind::Local)
     newVals.erase(newVals.begin() + pos);
   // Note: Base implementation discards all associated Values.
   IntegerPolyhedron::fourierMotzkinEliminate(pos, darkShadow,
                                              isResultIntegerExact);
   values = newVals;
-  assert(values.size() == getNumDimAndSymbolIds());
+  assert(values.size() == getNumDimAndSymbolVars());
 }
 
 void FlatAffineValueConstraints::projectOut(Value val) {
   unsigned pos;
-  bool ret = findId(val, &pos);
+  bool ret = findVar(val, &pos);
   assert(ret);
   (void)ret;
   fourierMotzkinEliminate(pos);
 }
 
 LogicalResult FlatAffineValueConstraints::unionBoundingBox(
     const FlatAffineValueConstraints &otherCst) {
-  assert(otherCst.getNumDimIds() == getNumDimIds() && "dims mismatch");
+  assert(otherCst.getNumDimVars() == getNumDimVars() && "dims mismatch");
   assert(otherCst.getMaybeValues()
-             .slice(0, getNumDimIds())
-             .equals(getMaybeValues().slice(0, getNumDimIds())) &&
+             .slice(0, getNumDimVars())
+             .equals(getMaybeValues().slice(0, getNumDimVars())) &&
          "dim values mismatch");
-  assert(otherCst.getNumLocalIds() == 0 && "local ids not supported here");
-  assert(getNumLocalIds() == 0 && "local ids not supported yet here");
+  assert(otherCst.getNumLocalVars() == 0 && "local vars not supported here");
+  assert(getNumLocalVars() == 0 && "local vars not supported yet here");
 
   // Align `other` to this.
-  if (!areIdsAligned(*this, otherCst)) {
+  if (!areVarsAligned(*this, otherCst)) {
     FlatAffineValueConstraints otherCopy(otherCst);
-    mergeAndAlignIds(/*offset=*/getNumDimIds(), this, &otherCopy);
+    mergeAndAlignVars(/*offset=*/getNumDimVars(), this, &otherCopy);
     return IntegerPolyhedron::unionBoundingBox(otherCopy);
   }
 
   return IntegerPolyhedron::unionBoundingBox(otherCst);
 }
 
 /// Compute an explicit representation for local vars. For all systems coming
 /// from MLIR integer sets, maps, or expressions where local vars were
 /// introduced to model floordivs and mods, this always succeeds.
 static LogicalResult computeLocalVars(const FlatAffineValueConstraints &cst,
                                       SmallVectorImpl<AffineExpr> &memo,
                                       MLIRContext *context) {
-  unsigned numDims = cst.getNumDimIds();
-  unsigned numSyms = cst.getNumSymbolIds();
+  unsigned numDims = cst.getNumDimVars();
+  unsigned numSyms = cst.getNumSymbolVars();
 
-  // Initialize dimensional and symbolic identifiers.
+  // Initialize dimensional and symbolic variables.
   for (unsigned i = 0; i < numDims; i++)
     memo[i] = getAffineDimExpr(i, context);
   for (unsigned i = numDims, e = numDims + numSyms; i < e; i++)
     memo[i] = getAffineSymbolExpr(i - numDims, context);
 
   bool changed;
   do {
     // Each time `changed` is true at the end of this iteration, one or more
     // local vars would have been detected as floordivs and set in memo; so the
     // number of null entries in memo[...] strictly reduces; so this converges.
     changed = false;
-    for (unsigned i = 0, e = cst.getNumLocalIds(); i < e; ++i)
+    for (unsigned i = 0, e = cst.getNumLocalVars(); i < e; ++i)
       if (!memo[numDims + numSyms + i] &&
           detectAsFloorDiv(cst, /*pos=*/numDims + numSyms + i, context, memo))
         changed = true;
   } while (changed);
 
   ArrayRef<AffineExpr> localExprs =
-      ArrayRef<AffineExpr>(memo).take_back(cst.getNumLocalIds());
+      ArrayRef<AffineExpr>(memo).take_back(cst.getNumLocalVars());
   return success(
       llvm::all_of(localExprs, [](AffineExpr expr) { return expr; }));
 }
 
 void FlatAffineValueConstraints::getIneqAsAffineValueMap(
     unsigned pos, unsigned ineqPos, AffineValueMap &vmap,
     MLIRContext *context) const {
-  unsigned numDims = getNumDimIds();
-  unsigned numSyms = getNumSymbolIds();
+  unsigned numDims = getNumDimVars();
+  unsigned numSyms = getNumSymbolVars();
 
   assert(pos < numDims && "invalid position");
   assert(ineqPos < getNumInequalities() && "invalid inequality position");
 
   // Get expressions for local vars.
-  SmallVector<AffineExpr, 8> memo(getNumIds(), AffineExpr());
+  SmallVector<AffineExpr, 8> memo(getNumVars(), AffineExpr());
   if (failed(computeLocalVars(*this, memo, context)))
     assert(false &&
            "one or more local exprs do not have an explicit representation");
-  auto localExprs = ArrayRef<AffineExpr>(memo).take_back(getNumLocalIds());
+  auto localExprs = ArrayRef<AffineExpr>(memo).take_back(getNumLocalVars());
 
   // Compute the AffineExpr lower/upper bound for this inequality.
   ArrayRef<int64_t> inequality = getInequality(ineqPos);
   SmallVector<int64_t, 8> bound;
   bound.reserve(getNumCols() - 1);
   // Everything other than the coefficient at `pos`.
   bound.append(inequality.begin(), inequality.begin() + pos);
   bound.append(inequality.begin() + pos + 1, inequality.end());
void FlatAffineValueConstraints::getIneqAsAffineValueMap(
   // Convert to AffineExpr (tree) form.
   auto boundExpr = getAffineExprFromFlatForm(bound, numDims - 1, numSyms,
                                              localExprs, context);
 
   // Get the values to bind to this affine expr (all dims and symbols).
   SmallVector<Value, 4> operands;
   getValues(0, pos, &operands);
   SmallVector<Value, 4> trailingOperands;
-  getValues(pos + 1, getNumDimAndSymbolIds(), &trailingOperands);
+  getValues(pos + 1, getNumDimAndSymbolVars(), &trailingOperands);
   operands.append(trailingOperands.begin(), trailingOperands.end());
   vmap.reset(AffineMap::get(numDims - 1, numSyms, boundExpr), operands);
 }
 
 IntegerSet
 FlatAffineValueConstraints::getAsIntegerSet(MLIRContext *context) const {
   if (getNumConstraints() == 0)
     // Return universal set (always true): 0 == 0.
-    return IntegerSet::get(getNumDimIds(), getNumSymbolIds(),
+    return IntegerSet::get(getNumDimVars(), getNumSymbolVars(),
                            getAffineConstantExpr(/*constant=*/0, context),
                            /*eqFlags=*/true);
 
   // Construct local references.
-  SmallVector<AffineExpr, 8> memo(getNumIds(), AffineExpr());
+  SmallVector<AffineExpr, 8> memo(getNumVars(), AffineExpr());
 
   if (failed(computeLocalVars(*this, memo, context))) {
     // Check if the local variables without an explicit representation have
     // zero coefficients everywhere.
     SmallVector<unsigned> noLocalRepVars;
-    unsigned numDimsSymbols = getNumDimAndSymbolIds();
-    for (unsigned i = numDimsSymbols, e = getNumIds(); i < e; ++i) {
+    unsigned numDimsSymbols = getNumDimAndSymbolVars();
+    for (unsigned i = numDimsSymbols, e = getNumVars(); i < e; ++i) {
       if (!memo[i] && !isColZero(/*pos=*/i))
         noLocalRepVars.push_back(i - numDimsSymbols);
     }
     if (!noLocalRepVars.empty()) {
       LLVM_DEBUG({
         llvm::dbgs() << "local variables at position(s) ";
         llvm::interleaveComma(noLocalRepVars, llvm::dbgs());
         llvm::dbgs() << " do not have an explicit representation in:\n";
         this->dump();
       });
       return IntegerSet();
     }
   }
 
   ArrayRef<AffineExpr> localExprs =
-      ArrayRef<AffineExpr>(memo).take_back(getNumLocalIds());
+      ArrayRef<AffineExpr>(memo).take_back(getNumLocalVars());
 
   // Construct the IntegerSet from the equalities/inequalities.
-  unsigned numDims = getNumDimIds();
-  unsigned numSyms = getNumSymbolIds();
+  unsigned numDims = getNumDimVars();
+  unsigned numSyms = getNumSymbolVars();
 
   SmallVector<bool, 16> eqFlags(getNumConstraints());
   std::fill(eqFlags.begin(), eqFlags.begin() + getNumEqualities(), true);
   std::fill(eqFlags.begin() + getNumEqualities(), eqFlags.end(), false);
 
   SmallVector<AffineExpr, 8> exprs;
   exprs.reserve(getNumConstraints());
 
AffineMap mlir::alignAffineMapWithValues(AffineMap map, ValueRange operands,
 
   return map.replaceDimsAndSymbols(dimReplacements, symReplacements,
                                    dims.size(), numSymbols);
 }
 
 FlatAffineValueConstraints FlatAffineRelation::getDomainSet() const {
   FlatAffineValueConstraints domain = *this;
   // Convert all range variables to local variables.
-  domain.convertToLocal(IdKind::SetDim, getNumDomainDims(),
+  domain.convertToLocal(VarKind::SetDim, getNumDomainDims(),
                         getNumDomainDims() + getNumRangeDims());
   return domain;
 }
 
 FlatAffineValueConstraints FlatAffineRelation::getRangeSet() const {
   FlatAffineValueConstraints range = *this;
   // Convert all domain variables to local variables.
-  range.convertToLocal(IdKind::SetDim, 0, getNumDomainDims());
+  range.convertToLocal(VarKind::SetDim, 0, getNumDomainDims());
   return range;
 }
 
 void FlatAffineRelation::compose(const FlatAffineRelation &other) {
   assert(getNumDomainDims() == other.getNumRangeDims() &&
          "Domain of this and range of other do not match");
   assert(std::equal(values.begin(), values.begin() + getNumDomainDims(),
                     other.values.begin() + other.getNumDomainDims()) &&
          "Domain of this and range of other do not match");
 
   FlatAffineRelation rel = other;
 
   // Convert `rel` from
   //    [otherDomain] -> [otherRange]
   // to
   //    [otherDomain] -> [otherRange thisRange]
   // and `this` from
   //    [thisDomain] -> [thisRange]
   // to
   //    [otherDomain thisDomain] -> [thisRange].
   unsigned removeDims = rel.getNumRangeDims();
-  insertDomainId(0, rel.getNumDomainDims());
-  rel.appendRangeId(getNumRangeDims());
+  insertDomainVar(0, rel.getNumDomainDims());
+  rel.appendRangeVar(getNumRangeDims());
 
-  // Merge symbol and local identifiers.
-  mergeSymbolIds(rel);
-  mergeLocalIds(rel);
+  // Merge symbol and local variables.
+  mergeSymbolVars(rel);
+  mergeLocalVars(rel);
 
   // Convert `rel` from [otherDomain] -> [otherRange thisRange] to
-  // [otherDomain] -> [thisRange] by converting first otherRange range ids
-  // to local ids.
-  rel.convertToLocal(IdKind::SetDim, rel.getNumDomainDims(),
+  // [otherDomain] -> [thisRange] by converting first otherRange range vars
+  // to local vars.
+  rel.convertToLocal(VarKind::SetDim, rel.getNumDomainDims(),
                      rel.getNumDomainDims() + removeDims);
   // Convert `this` from [otherDomain thisDomain] -> [thisRange] to
-  // [otherDomain] -> [thisRange] by converting last thisDomain domain ids
-  // to local ids.
-  convertToLocal(IdKind::SetDim, getNumDomainDims() - removeDims,
+  // [otherDomain] -> [thisRange] by converting last thisDomain domain vars
+  // to local vars.
+  convertToLocal(VarKind::SetDim, getNumDomainDims() - removeDims,
                  getNumDomainDims());
 
-  auto thisMaybeValues = getMaybeValues(IdKind::SetDim);
-  auto relMaybeValues = rel.getMaybeValues(IdKind::SetDim);
+  auto thisMaybeValues = getMaybeValues(VarKind::SetDim);
+  auto relMaybeValues = rel.getMaybeValues(VarKind::SetDim);
 
   // Add and match domain of `rel` to domain of `this`.
   for (unsigned i = 0, e = rel.getNumDomainDims(); i < e; ++i)
     if (relMaybeValues[i].hasValue())
       setValue(i, relMaybeValues[i].getValue());
   // Add and match range of `this` to range of `rel`.
   for (unsigned i = 0, e = getNumRangeDims(); i < e; ++i) {
     unsigned rangeIdx = rel.getNumDomainDims() + i;
     if (thisMaybeValues[rangeIdx].hasValue())
       rel.setValue(rangeIdx, thisMaybeValues[rangeIdx].getValue());
   }
 
   // Append `this` to `rel` and simplify constraints.
   rel.append(*this);
   rel.removeRedundantLocalVars();
 
   *this = rel;
 }
 
 void FlatAffineRelation::inverse() {
   unsigned oldDomain = getNumDomainDims();
   unsigned oldRange = getNumRangeDims();
-  // Add new range ids.
-  appendRangeId(oldDomain);
-  // Swap new ids with domain.
+  // Add new range vars.
+  appendRangeVar(oldDomain);
+  // Swap new vars with domain.
   for (unsigned i = 0; i < oldDomain; ++i)
-    swapId(i, oldDomain + oldRange + i);
+    swapVar(i, oldDomain + oldRange + i);
   // Remove the swapped domain.
-  removeIdRange(0, oldDomain);
+  removeVarRange(0, oldDomain);
   // Set domain and range as inverse.
   numDomainDims = oldRange;
   numRangeDims = oldDomain;
 }
 
-void FlatAffineRelation::insertDomainId(unsigned pos, unsigned num) {
+void FlatAffineRelation::insertDomainVar(unsigned pos, unsigned num) {
   assert(pos <= getNumDomainDims() &&
-         "Id cannot be inserted at invalid position");
-  insertDimId(pos, num);
+         "Var cannot be inserted at invalid position");
+  insertDimVar(pos, num);
   numDomainDims += num;
 }
 
-void FlatAffineRelation::insertRangeId(unsigned pos, unsigned num) {
+void FlatAffineRelation::insertRangeVar(unsigned pos, unsigned num) {
   assert(pos <= getNumRangeDims() &&
-         "Id cannot be inserted at invalid position");
-  insertDimId(getNumDomainDims() + pos, num);
+         "Var cannot be inserted at invalid position");
+  insertDimVar(getNumDomainDims() + pos, num);
   numRangeDims += num;
 }
 
-void FlatAffineRelation::appendDomainId(unsigned num) {
-  insertDimId(getNumDomainDims(), num);
+void FlatAffineRelation::appendDomainVar(unsigned num) {
+  insertDimVar(getNumDomainDims(), num);
   numDomainDims += num;
 }
 
-void FlatAffineRelation::appendRangeId(unsigned num) {
-  insertDimId(getNumDimIds(), num);
+void FlatAffineRelation::appendRangeVar(unsigned num) {
+  insertDimVar(getNumDimVars(), num);
   numRangeDims += num;
 }
 
-void FlatAffineRelation::removeIdRange(IdKind kind, unsigned idStart,
-                                       unsigned idLimit) {
-  assert(idLimit <= getNumIdKind(kind));
-  if (idStart >= idLimit)
+void FlatAffineRelation::removeVarRange(VarKind kind, unsigned varStart,
+                                        unsigned varLimit) {
+  assert(varLimit <= getNumVarKind(kind));
+  if (varStart >= varLimit)
     return;
 
-  FlatAffineValueConstraints::removeIdRange(kind, idStart, idLimit);
+  FlatAffineValueConstraints::removeVarRange(kind, varStart, varLimit);
 
   // If kind is not SetDim, domain and range don't need to be updated.
-  if (kind != IdKind::SetDim)
+  if (kind != VarKind::SetDim)
     return;
 
-  // Compute number of domain and range identifiers to remove. This is done by
-  // intersecting the range of domain/range ids with range of ids to remove.
-  unsigned intersectDomainLHS = std::min(idLimit, getNumDomainDims());
-  unsigned intersectDomainRHS = idStart;
-  unsigned intersectRangeLHS = std::min(idLimit, getNumDimIds());
-  unsigned intersectRangeRHS = std::max(idStart, getNumDomainDims());
+  // Compute number of domain and range variables to remove. This is done by
+  // intersecting the range of domain/range vars with range of vars to remove.
+  unsigned intersectDomainLHS = std::min(varLimit, getNumDomainDims());
+  unsigned intersectDomainRHS = varStart;
+  unsigned intersectRangeLHS = std::min(varLimit, getNumDimVars());
+  unsigned intersectRangeRHS = std::max(varStart, getNumDomainDims());
 
   if (intersectDomainLHS > intersectDomainRHS)
     numDomainDims -= intersectDomainLHS - intersectDomainRHS;
   if (intersectRangeLHS > intersectRangeRHS)
     numRangeDims -= intersectRangeLHS - intersectRangeRHS;
 }
 
 LogicalResult mlir::getRelationFromMap(AffineMap &map,
                                        FlatAffineRelation &rel) {
   // Get flattened affine expressions.
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   FlatAffineValueConstraints localVarCst;
   if (failed(getFlattenedAffineExprs(map, &flatExprs, &localVarCst)))
     return failure();
 
-  unsigned oldDimNum = localVarCst.getNumDimIds();
+  unsigned oldDimNum = localVarCst.getNumDimVars();
   unsigned oldCols = localVarCst.getNumCols();
-  unsigned numRangeIds = map.getNumResults();
-  unsigned numDomainIds = map.getNumDims();
+  unsigned numRangeVars = map.getNumResults();
+  unsigned numDomainVars = map.getNumDims();
 
   // Add range as the new expressions.
-  localVarCst.appendDimId(numRangeIds);
+  localVarCst.appendDimVar(numRangeVars);
 
   // Add equalities between source and range.
   SmallVector<int64_t, 8> eq(localVarCst.getNumCols());
   for (unsigned i = 0, e = map.getNumResults(); i < e; ++i) {
     // Zero fill.
     std::fill(eq.begin(), eq.end(), 0);
     // Fill equality.
     for (unsigned j = 0, f = oldDimNum; j < f; ++j)
       eq[j] = flatExprs[i][j];
     for (unsigned j = oldDimNum, f = oldCols; j < f; ++j)
-      eq[j + numRangeIds] = flatExprs[i][j];
+      eq[j + numRangeVars] = flatExprs[i][j];
     // Set this dimension to -1 to equate lhs and rhs and add equality.
-    eq[numDomainIds + i] = -1;
+    eq[numDomainVars + i] = -1;
     localVarCst.addEquality(eq);
   }
 
   // Create relation and return success.
-  rel = FlatAffineRelation(numDomainIds, numRangeIds, localVarCst);
+  rel = FlatAffineRelation(numDomainVars, numRangeVars, localVarCst);
   return success();
 }
 
 LogicalResult mlir::getRelationFromMap(const AffineValueMap &map,
                                        FlatAffineRelation &rel) {
 
   AffineMap affineMap = map.getAffineMap();
   if (failed(getRelationFromMap(affineMap, rel)))
     return failure();
 
   // Set symbol values for domain dimensions and symbols.
   for (unsigned i = 0, e = rel.getNumDomainDims(); i < e; ++i)
     rel.setValue(i, map.getOperand(i));
-  for (unsigned i = rel.getNumDimIds(), e = rel.getNumDimAndSymbolIds(); i < e;
-       ++i)
+  for (unsigned i = rel.getNumDimVars(), e = rel.getNumDimAndSymbolVars();
+       i < e; ++i)
     rel.setValue(i, map.getOperand(i - rel.getNumRangeDims()));
 
   return success();
 }

mlir/lib/Dialect/Affine/Analysis/Utils.cpp

ComputationSliceState::getSourceAsConstraints(FlatAffineValueConstraints &cst) {
   }
   return success();
 }
 
 // Populates 'cst' with FlatAffineValueConstraints which represent slice bounds.
 LogicalResult
 ComputationSliceState::getAsConstraints(FlatAffineValueConstraints *cst) {
   assert(!lbOperands.empty());
-  // Adds src 'ivs' as dimension identifiers in 'cst'.
+  // Adds src 'ivs' as dimension variables in 'cst'.
   unsigned numDims = ivs.size();
   // Adds operands (dst ivs and symbols) as symbols in 'cst'.
   unsigned numSymbols = lbOperands[0].size();
 
   SmallVector<Value, 4> values(ivs);
   // Append 'ivs' then 'operands' to 'values'.
   values.append(lbOperands[0].begin(), lbOperands[0].end());
   cst->reset(numDims, numSymbols, 0, values);
 
   // Add loop bound constraints for values which are loop IVs of the destination
   // of fusion and equality constraints for symbols which are constants.
   for (unsigned i = numDims, end = values.size(); i < end; ++i) {
     Value value = values[i];
-    assert(cst->containsId(value) && "value expected to be present");
+    assert(cst->containsVar(value) && "value expected to be present");
     if (isValidSymbol(value)) {
       // Check if the symbol is a constant.
       if (auto cOp = value.getDefiningOp<arith::ConstantIndexOp>())
         cst->addBound(FlatAffineValueConstraints::EQ, value, cOp.value());
     } else if (auto loop = getForInductionVarOwner(value)) {
       if (failed(cst->addAffineForOpDomain(loop)))
         return failure();
     }
Optional<bool> ComputationSliceState::isSliceValid() {
   FlatAffineValueConstraints srcConstraints;
   // TODO: Store the source's domain to avoid computation at each depth.
   if (failed(getSourceAsConstraints(srcConstraints))) {
     LLVM_DEBUG(llvm::dbgs() << "Unable to compute source's domain\n");
     return llvm::None;
   }
   // As the set difference utility currently cannot handle symbols in its
   // operands, validity of the slice cannot be determined.
-  if (srcConstraints.getNumSymbolIds() > 0) {
+  if (srcConstraints.getNumSymbolVars() > 0) {
     LLVM_DEBUG(llvm::dbgs() << "Cannot handle symbols in source domain\n");
     return llvm::None;
   }
-  // TODO: Handle local ids in the source domains while using the 'projectOut'
+  // TODO: Handle local vars in the source domains while using the 'projectOut'
   // utility below. Currently, aligning is not done assuming that there will be
-  // no local ids in the source domain.
-  if (srcConstraints.getNumLocalIds() != 0) {
+  // no local vars in the source domain.
+  if (srcConstraints.getNumLocalVars() != 0) {
     LLVM_DEBUG(llvm::dbgs() << "Cannot handle locals in source domain\n");
     return llvm::None;
   }
 
   // Create constraints for the slice loop nest that would be created if the
   // fusion succeeds.
   FlatAffineValueConstraints sliceConstraints;
   if (failed(getAsConstraints(&sliceConstraints))) {
     LLVM_DEBUG(llvm::dbgs() << "Unable to compute slice's domain\n");
     return llvm::None;
   }
 
   // Projecting out every dimension other than the 'ivs' to express slice's
   // domain completely in terms of source's IVs.
   sliceConstraints.projectOut(ivs.size(),
-                              sliceConstraints.getNumIds() - ivs.size());
+                              sliceConstraints.getNumVars() - ivs.size());
 
   LLVM_DEBUG(llvm::dbgs() << "Domain of the source of the slice:\n");
   LLVM_DEBUG(srcConstraints.dump());
   LLVM_DEBUG(llvm::dbgs() << "Domain of the slice if this fusion succeeds "
                              "(expressed in terms of its source's IVs):\n");
   LLVM_DEBUG(sliceConstraints.dump());
 
   // TODO: Store 'srcSet' to avoid recalculating for each depth.
Optional<bool> ComputationSliceState::isMaximal() const {
 
   FlatAffineValueConstraints sliceConstraints;
   sliceConstraints.reset(/*numDims=*/consumerIVs.size(), /*numSymbols=*/0,
                          /*numLocals=*/0, consumerIVs);
 
   if (failed(sliceConstraints.addDomainFromSliceMaps(lbs, ubs, lbOperands[0])))
     return llvm::None;
 
-  if (srcConstraints.getNumDimIds() != sliceConstraints.getNumDimIds())
+  if (srcConstraints.getNumDimVars() != sliceConstraints.getNumDimVars())
     // Constraint dims are different. The integer set difference can't be
     // computed so we don't know if the slice is maximal.
     return llvm::None;
 
   // Compute the difference between the src loop nest and the slice integer
   // sets.
   PresburgerSet srcSet(srcConstraints);
   PresburgerSet sliceSet(sliceConstraints);
   PresburgerSet diffSet = srcSet.subtract(sliceSet);
   return diffSet.isIntegerEmpty();
 }
 
 unsigned MemRefRegion::getRank() const {
   return memref.getType().cast<MemRefType>().getRank();
 }
 
 Optional<int64_t> MemRefRegion::getConstantBoundingSizeAndShape(
     SmallVectorImpl<int64_t> *shape, std::vector<SmallVector<int64_t, 4>> *lbs,
     SmallVectorImpl<int64_t> *lbDivisors) const {
   auto memRefType = memref.getType().cast<MemRefType>();
   unsigned rank = memRefType.getRank();
   if (shape)
     shape->reserve(rank);
 
-  assert(rank == cst.getNumDimIds() && "inconsistent memref region");
+  assert(rank == cst.getNumDimVars() && "inconsistent memref region");
 
   // Use a copy of the region constraints that has upper/lower bounds for each
   // memref dimension with static size added to guard against potential
   // over-approximation from projection or union bounding box. We may not add
   // this on the region itself since they might just be redundant constraints
   // that will need non-trivials means to eliminate.
   FlatAffineValueConstraints cstWithShapeBounds(cst);
   for (unsigned r = 0; r < rank; r++) {
for (unsigned d = 0; d < rank; d++) {
     } else {
       // If no constant bound is found, then it can always be bound by the
       // memref's dim size if the latter has a constant size along this dim.
       auto dimSize = memRefType.getDimSize(d);
       if (dimSize == -1)
         return None;
       diffConstant = dimSize;
       // Lower bound becomes 0.
-      lb.resize(cstWithShapeBounds.getNumSymbolIds() + 1, 0);
+      lb.resize(cstWithShapeBounds.getNumSymbolVars() + 1, 0);
       lbDivisor = 1;
     }
     numElements *= diffConstant;
     if (lbs) {
       lbs->push_back(lb);
       assert(lbDivisors && "both lbs and lbDivisor or none");
       lbDivisors->push_back(lbDivisor);
     }
     if (shape) {
       shape->push_back(diffConstant);
     }
   }
   return numElements;
 }
 
 void MemRefRegion::getLowerAndUpperBound(unsigned pos, AffineMap &lbMap,
                                          AffineMap &ubMap) const {
-  assert(pos < cst.getNumDimIds() && "invalid position");
+  assert(pos < cst.getNumDimVars() && "invalid position");
   auto memRefType = memref.getType().cast<MemRefType>();
   unsigned rank = memRefType.getRank();
 
-  assert(rank == cst.getNumDimIds() && "inconsistent memref region");
+  assert(rank == cst.getNumDimVars() && "inconsistent memref region");
 
   auto boundPairs = cst.getLowerAndUpperBound(
-      pos, /*offset=*/0, /*num=*/rank, cst.getNumDimAndSymbolIds(),
+      pos, /*offset=*/0, /*num=*/rank, cst.getNumDimAndSymbolVars(),
       /*localExprs=*/{}, memRefType.getContext());
   lbMap = boundPairs.first;
   ubMap = boundPairs.second;
   assert(lbMap && "lower bound for a region must exist");
   assert(ubMap && "upper bound for a region must exist");
-  assert(lbMap.getNumInputs() == cst.getNumDimAndSymbolIds() - rank);
-  assert(ubMap.getNumInputs() == cst.getNumDimAndSymbolIds() - rank);
+  assert(lbMap.getNumInputs() == cst.getNumDimAndSymbolVars() - rank);
+  assert(ubMap.getNumInputs() == cst.getNumDimAndSymbolVars() - rank);
 }
 
 LogicalResult MemRefRegion::unionBoundingBox(const MemRefRegion &other) {
   assert(memref == other.memref);
   return cst.unionBoundingBox(*other.getConstraints());
 }
 
 /// Computes the memory region accessed by this memref with the region
LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
 
   // Add access function equalities to connect loop IVs to data dimensions.
   if (failed(cst.composeMap(&accessValueMap))) {
     op->emitError("getMemRefRegion: compose affine map failed");
     LLVM_DEBUG(accessValueMap.getAffineMap().dump());
     return failure();
   }
 
-  // Set all identifiers appearing after the first 'rank' identifiers as
-  // symbolic identifiers - so that the ones corresponding to the memref
-  // dimensions are the dimensional identifiers for the memref region.
-  cst.setDimSymbolSeparation(cst.getNumDimAndSymbolIds() - rank);
+  // Set all variables appearing after the first 'rank' variables as
+  // symbolic variables - so that the ones corresponding to the memref
+  // dimensions are the dimensional variables for the memref region.
+  cst.setDimSymbolSeparation(cst.getNumDimAndSymbolVars() - rank);
 
   // Eliminate any loop IVs other than the outermost 'loopDepth' IVs, on which
   // this memref region is symbolic.
   SmallVector<AffineForOp, 4> enclosingIVs;
   getLoopIVs(*op, &enclosingIVs);
   assert(loopDepth <= enclosingIVs.size() && "invalid loop depth");
   enclosingIVs.resize(loopDepth);
-  SmallVector<Value, 4> ids;
-  cst.getValues(cst.getNumDimIds(), cst.getNumDimAndSymbolIds(), &ids);
-  for (auto id : ids) {
+  SmallVector<Value, 4> vars;
+  cst.getValues(cst.getNumDimVars(), cst.getNumDimAndSymbolVars(), &vars);
+  for (auto var : vars) {
     AffineForOp iv;
-    if ((iv = getForInductionVarOwner(id)) &&
+    if ((iv = getForInductionVarOwner(var)) &&
         !llvm::is_contained(enclosingIVs, iv)) {
-      cst.projectOut(id);
+      cst.projectOut(var);
     }
   }
 
   // Project out any local variables (these would have been added for any
   // mod/divs).
-  cst.projectOut(cst.getNumDimAndSymbolIds(), cst.getNumLocalIds());
+  cst.projectOut(cst.getNumDimAndSymbolVars(), cst.getNumLocalVars());
 
-  // Constant fold any symbolic identifiers.
-  cst.constantFoldIdRange(/*pos=*/cst.getNumDimIds(),
-                          /*num=*/cst.getNumSymbolIds());
+  // Constant fold any symbolic variables.
+  cst.constantFoldVarRange(/*pos=*/cst.getNumDimVars(),
+                           /*num=*/cst.getNumSymbolVars());
 
-  assert(cst.getNumDimIds() == rank && "unexpected MemRefRegion format");
+  assert(cst.getNumDimVars() == rank && "unexpected MemRefRegion format");
 
   // Add upper/lower bounds for each memref dimension with static size
   // to guard against potential over-approximation from projection.
   // TODO: Support dynamic memref dimensions.
   if (addMemRefDimBounds) {
     auto memRefType = memref.getType().cast<MemRefType>();
     for (unsigned r = 0; r < rank; r++) {
       cst.addBound(FlatAffineValueConstraints::LB, /*pos=*/r, /*value=*/0);
for (auto &op : *block) {
     return nullptr;
   }
   return nullptr;
 }
 
 // Adds loop IV bounds to 'cst' for loop IVs not found in 'ivs'.
 static LogicalResult addMissingLoopIVBounds(SmallPtrSet<Value, 8> &ivs,
                                             FlatAffineValueConstraints *cst) {
-  for (unsigned i = 0, e = cst->getNumDimIds(); i < e; ++i) {
+  for (unsigned i = 0, e = cst->getNumDimVars(); i < e; ++i) {
     auto value = cst->getValue(i);
     if (ivs.count(value) == 0) {
       assert(isForInductionVar(value));
       auto loop = getForInductionVarOwner(value);
       if (failed(cst->addAffineForOpDomain(loop)))
         return failure();
     }
   }

 SliceComputationResult
 mlir::computeSliceUnion(ArrayRef<Operation *> opsA, ArrayRef<Operation *> opsB,
                         unsigned loopDepth, unsigned numCommonLoops,
                         bool isBackwardSlice,
                         ComputationSliceState *sliceUnion) {
   // Compute the union of slice bounds between all pairs in 'opsA' and
   // 'opsB' in 'sliceUnionCst'.
   FlatAffineValueConstraints sliceUnionCst;
-  assert(sliceUnionCst.getNumDimAndSymbolIds() == 0);
+  assert(sliceUnionCst.getNumDimAndSymbolVars() == 0);
   std::vector<std::pair<Operation *, Operation *>> dependentOpPairs;
   for (auto *i : opsA) {
     MemRefAccess srcAccess(i);
     for (auto *j : opsB) {
       MemRefAccess dstAccess(j);
       if (srcAccess.memref != dstAccess.memref)
         continue;
       // Check if 'loopDepth' exceeds nesting depth of src/dst ops.
for (auto *j : opsB) {
         continue;
       dependentOpPairs.emplace_back(i, j);
 
       // Compute slice bounds for 'srcAccess' and 'dstAccess'.
       ComputationSliceState tmpSliceState;
       mlir::getComputationSliceState(i, j, &dependenceConstraints, loopDepth,
                                      isBackwardSlice, &tmpSliceState);
 
-      if (sliceUnionCst.getNumDimAndSymbolIds() == 0) {
+      if (sliceUnionCst.getNumDimAndSymbolVars() == 0) {
         // Initialize 'sliceUnionCst' with the bounds computed in previous step.
         if (failed(tmpSliceState.getAsConstraints(&sliceUnionCst))) {
           LLVM_DEBUG(llvm::dbgs()
                      << "Unable to compute slice bound constraints\n");
           return SliceComputationResult::GenericFailure;
         }
-        assert(sliceUnionCst.getNumDimAndSymbolIds() > 0);
+        assert(sliceUnionCst.getNumDimAndSymbolVars() > 0);
         continue;
       }
 
       // Compute constraints for 'tmpSliceState' in 'tmpSliceCst'.
       FlatAffineValueConstraints tmpSliceCst;
       if (failed(tmpSliceState.getAsConstraints(&tmpSliceCst))) {
         LLVM_DEBUG(llvm::dbgs()
                    << "Unable to compute slice bound constraints\n");
         return SliceComputationResult::GenericFailure;
       }
 
       // Align coordinate spaces of 'sliceUnionCst' and 'tmpSliceCst' if needed.
-      if (!sliceUnionCst.areIdsAlignedWithOther(tmpSliceCst)) {
+      if (!sliceUnionCst.areVarsAlignedWithOther(tmpSliceCst)) {
 
-        // Pre-constraint id alignment: record loop IVs used in each constraint
+        // Pre-constraint var alignment: record loop IVs used in each constraint
         // system.
         SmallPtrSet<Value, 8> sliceUnionIVs;
-        for (unsigned k = 0, l = sliceUnionCst.getNumDimIds(); k < l; ++k)
+        for (unsigned k = 0, l = sliceUnionCst.getNumDimVars(); k < l; ++k)
           sliceUnionIVs.insert(sliceUnionCst.getValue(k));
         SmallPtrSet<Value, 8> tmpSliceIVs;
-        for (unsigned k = 0, l = tmpSliceCst.getNumDimIds(); k < l; ++k)
+        for (unsigned k = 0, l = tmpSliceCst.getNumDimVars(); k < l; ++k)
           tmpSliceIVs.insert(tmpSliceCst.getValue(k));
 
-        sliceUnionCst.mergeAndAlignIdsWithOther(/*offset=*/0, &tmpSliceCst);
+        sliceUnionCst.mergeAndAlignVarsWithOther(/*offset=*/0, &tmpSliceCst);
 
-        // Post-constraint id alignment: add loop IV bounds missing after
-        // id alignment to constraint systems. This can occur if one constraint
+        // Post-constraint var alignment: add loop IV bounds missing after
+        // var alignment to constraint systems. This can occur if one constraint
         // system uses an loop IV that is not used by the other. The call
         // to unionBoundingBox below expects constraints for each Loop IV, even
         // if they are the unsliced full loop bounds added here.
         if (failed(addMissingLoopIVBounds(sliceUnionIVs, &sliceUnionCst)))
           return SliceComputationResult::GenericFailure;
         if (failed(addMissingLoopIVBounds(tmpSliceIVs, &tmpSliceCst)))
           return SliceComputationResult::GenericFailure;
       }
       // Compute union bounding box of 'sliceUnionCst' and 'tmpSliceCst'.
-      if (sliceUnionCst.getNumLocalIds() > 0 ||
-          tmpSliceCst.getNumLocalIds() > 0 ||
+      if (sliceUnionCst.getNumLocalVars() > 0 ||
+          tmpSliceCst.getNumLocalVars() > 0 ||
           failed(sliceUnionCst.unionBoundingBox(tmpSliceCst))) {
         LLVM_DEBUG(llvm::dbgs()
                    << "Unable to compute union bounding box of slice bounds\n");
         return SliceComputationResult::GenericFailure;
       }
     }
   }
 
   // Empty union.
-  if (sliceUnionCst.getNumDimAndSymbolIds() == 0)
+  if (sliceUnionCst.getNumDimAndSymbolVars() == 0)
     return SliceComputationResult::GenericFailure;
 
   // Gather loops surrounding ops from loop nest where slice will be inserted.
   SmallVector<Operation *, 4> ops;
   for (auto &dep : dependentOpPairs) {
     ops.push_back(isBackwardSlice ? dep.second : dep.first);
   }
   SmallVector<AffineForOp, 4> surroundingLoops;
   unsigned innermostCommonLoopDepth =
       getInnermostCommonLoopDepth(ops, &surroundingLoops);
   if (loopDepth > innermostCommonLoopDepth) {
     LLVM_DEBUG(llvm::dbgs() << "Exceeds max loop depth\n");
     return SliceComputationResult::GenericFailure;
   }
 
   // Store 'numSliceLoopIVs' before converting dst loop IVs to dims.
-  unsigned numSliceLoopIVs = sliceUnionCst.getNumDimIds();
+  unsigned numSliceLoopIVs = sliceUnionCst.getNumDimVars();
 
-  // Convert any dst loop IVs which are symbol identifiers to dim identifiers.
+  // Convert any dst loop IVs which are symbol variables to dim variables.
   sliceUnionCst.convertLoopIVSymbolsToDims();
   sliceUnion->clearBounds();
   sliceUnion->lbs.resize(numSliceLoopIVs, AffineMap());
   sliceUnion->ubs.resize(numSliceLoopIVs, AffineMap());
 
   // Get slice bounds from slice union constraints 'sliceUnionCst'.
   sliceUnionCst.getSliceBounds(/*offset=*/0, numSliceLoopIVs,
                                opsA[0]->getContext(), &sliceUnion->lbs,
                                &sliceUnion->ubs);
 
   // Add slice bound operands of union.
   SmallVector<Value, 4> sliceBoundOperands;
   sliceUnionCst.getValues(numSliceLoopIVs,
-                          sliceUnionCst.getNumDimAndSymbolIds(),
+                          sliceUnionCst.getNumDimAndSymbolVars(),
                           &sliceBoundOperands);
 
   // Copy src loop IVs from 'sliceUnionCst' to 'sliceUnion'.
   sliceUnion->ivs.clear();
   sliceUnionCst.getValues(0, numSliceLoopIVs, &sliceUnion->ivs);
 
   // Set loop nest insertion point to block start at 'loopDepth'.
   sliceUnion->insertPoint =
void mlir::getComputationSliceState(
 
   // Get bounds for slice IVs in terms of other IVs, symbols, and constants.
   dependenceConstraints->getSliceBounds(offset, numSliceLoopIVs,
                                         depSourceOp->getContext(),
                                         &sliceState->lbs, &sliceState->ubs);
 
   // Set up bound operands for the slice's lower and upper bounds.
   SmallVector<Value, 4> sliceBoundOperands;
-  unsigned numDimsAndSymbols = dependenceConstraints->getNumDimAndSymbolIds();
+  unsigned numDimsAndSymbols = dependenceConstraints->getNumDimAndSymbolVars();
   for (unsigned i = 0; i < numDimsAndSymbols; ++i) {
     if (i < offset || i >= offset + numSliceLoopIVs) {
       sliceBoundOperands.push_back(dependenceConstraints->getValue(i));
     }
   }
 
   // Give each bound its own copy of 'sliceBoundOperands' for subsequent
   // canonicalization.

mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp

Optional<int64_t> numElements =
       region.getConstantBoundingSizeAndShape(&newShape, &lbs, &lbDivisors);
   assert(numElements && "non-constant number of elts in local buffer");
 
   const FlatAffineValueConstraints *cst = region.getConstraints();
   // 'outerIVs' holds the values that this memory region is symbolic/parametric
   // on; this would correspond to loop IVs surrounding the level at which the
   // slice is being materialized.
   SmallVector<Value, 8> outerIVs;
-  cst->getValues(rank, cst->getNumIds(), &outerIVs);
+  cst->getValues(rank, cst->getNumVars(), &outerIVs);
 
   // Build 'rank' AffineExprs from MemRefRegion 'lbs'
   SmallVector<AffineExpr, 4> offsets;
   offsets.reserve(rank);
   for (unsigned d = 0; d < rank; ++d) {
     assert(lbs[d].size() == cst->getNumCols() - rank && "incorrect bound size");
 
     AffineExpr offset = top.getAffineConstantExpr(0);

mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp

 static void
 findHighestBlockForPlacement(const MemRefRegion &region, Block &block,
                              Block::iterator &begin, Block::iterator &end,
                              Block **copyPlacementBlock,
                              Block::iterator *copyInPlacementStart,
                              Block::iterator *copyOutPlacementStart) {
   const auto *cst = region.getConstraints();
   SmallVector<Value, 4> symbols;
-  cst->getValues(cst->getNumDimIds(), cst->getNumDimAndSymbolIds(), &symbols);
+  cst->getValues(cst->getNumDimVars(), cst->getNumDimAndSymbolVars(), &symbols);
 
   SmallVector<AffineForOp, 4> enclosingFors;
   getLoopIVs(*block.begin(), &enclosingFors);
   // Walk up loop parents till we find an IV on which this region is
   // symbolic/variant.
   auto it = enclosingFors.rbegin();
   for (auto e = enclosingFors.rend(); it != e; ++it) {
     // TODO: also need to be checking this for regions symbols that
static LogicalResult generateCopy(
   for (unsigned i = 0; i < rank; ++i)
     region.getLowerAndUpperBound(i, lbMaps[i], ubMaps[i]);
 
   const FlatAffineValueConstraints *cst = region.getConstraints();
   // 'regionSymbols' hold values that this memory region is symbolic/parametric
   // on; these typically include loop IVs surrounding the level at which the
   // copy generation is being done or other valid symbols in MLIR.
   SmallVector<Value, 8> regionSymbols;
-  cst->getValues(rank, cst->getNumIds(), &regionSymbols);
+  cst->getValues(rank, cst->getNumVars(), &regionSymbols);
 
   // Construct the index expressions for the fast memory buffer. The index
   // expression for a particular dimension of the fast buffer is obtained by
   // subtracting out the lower bound on the original memref's data region
   // along the corresponding dimension.
 
   // Index start offsets for faster memory buffer relative to the original.
   SmallVector<AffineExpr, 4> fastBufOffsets;
if (auto caf = offset.dyn_cast<AffineConstantExpr>()) {
       } else {
         memIndices.push_back(
             top.create<arith::ConstantIndexOp>(loc, indexVal).getResult());
       }
     } else {
       // The coordinate for the start location is just the lower bound along the
       // corresponding dimension on the memory region (stored in 'offset').
       auto map = AffineMap::get(
-          cst->getNumDimIds() + cst->getNumSymbolIds() - rank, 0, offset);
+          cst->getNumDimVars() + cst->getNumSymbolVars() - rank, 0, offset);
       memIndices.push_back(b.create<AffineApplyOp>(loc, map, regionSymbols));
     }
     // The fast buffer is copied into at location zero; addressing is relative.
     bufIndices.push_back(zeroIndex);
 
     // Record the offsets since they are needed to remap the memory accesses of
     // the original memref further below.
     fastBufOffsets.push_back(offset);
static AffineIfOp createSeparationCondition(MutableArrayRef<AffineForOp> loops,
   // lower bound (and upper bound) corresponding to the full tile should be
   // larger (and resp. smaller) than any other lower (or upper bound).
   SmallVector<int64_t, 8> fullTileLb, fullTileUb;
   for (auto loop : loops) {
     (void)loop;
     // TODO: Non-unit stride is not an issue to generalize to.
     assert(loop.getStep() == 1 && "point loop step expected to be one");
     // Mark everything symbols for the purpose of finding a constant diff pair.
-    cst.setDimSymbolSeparation(/*newSymbolCount=*/cst.getNumDimAndSymbolIds() -
+    cst.setDimSymbolSeparation(/*newSymbolCount=*/cst.getNumDimAndSymbolVars() -
                                1);
     unsigned fullTileLbPos, fullTileUbPos;
     if (!cst.getConstantBoundOnDimSize(0, /*lb=*/nullptr,
                                        /*boundFloorDivisor=*/nullptr,
                                        /*ub=*/nullptr, &fullTileLbPos,
                                        &fullTileUbPos)) {
       LLVM_DEBUG(llvm::dbgs() << "Can't get constant diff pair for a loop\n");
       return nullptr;
for (auto lbIndex : lbIndices)
       for (unsigned i = 0, e = cst.getNumCols(); i < e; ++i)
         cst.atIneq(lbIndex, i) = fullTileLb[i] - cst.atIneq(lbIndex, i);
 
     // Full tile upper bound should be <= any other upper bound.
     for (auto ubIndex : ubIndices)
       for (unsigned i = 0, e = cst.getNumCols(); i < e; ++i)
         cst.atIneq(ubIndex, i) -= fullTileUb[i];
 
-    cst.removeId(0);
+    cst.removeVar(0);
   }
 
   // The previous step leads to all zeros for the full tile lb and ub position
   // itself; remove those and any other duplicates / trivial redundancies.
   cst.removeTrivialRedundancy();
 
   // Turn everything into dims conservatively since we earlier turned all
   // trailing ids past point loop IV into symbols. Some of these could be outer
   // loop IVs; we'll canonicalize anyway.
   cst.setDimSymbolSeparation(0);
 
   IntegerSet ifCondSet = cst.getAsIntegerSet(context);
   // ifCondSet can be null if cst was empty -- this can happen if all loops
   // in the nest have constant trip counts.
   if (!ifCondSet)
     return nullptr;
 
   SmallVector<Value, 4> setOperands;
-  cst.getValues(0, cst.getNumDimAndSymbolIds(), &setOperands);
+  cst.getValues(0, cst.getNumDimAndSymbolVars(), &setOperands);
   canonicalizeSetAndOperands(&ifCondSet, &setOperands);
   return b.create<AffineIfOp>(loops[0].getLoc(), ifCondSet, setOperands,
                               /*withElseRegion=*/true);
 }
 
 /// Create the full tile loop nest (along with its body).
 static LogicalResult
 createFullTiles(MutableArrayRef<AffineForOp> inputNest,
if (loop.getStep() != 1) {
       LLVM_DEBUG(llvm::dbgs()
                  << "[tile separation] non-unit stride not implemented\n");
       return failure();
     }
     SmallVector<Operation *, 1> loopOp{loop.getOperation()};
     (void)getIndexSet(loopOp, &cst);
     // We will mark everything other than this loop IV as symbol for getting a
     // pair of <lb, ub> with a constant difference.
-    cst.setDimSymbolSeparation(cst.getNumDimAndSymbolIds() - 1);
+    cst.setDimSymbolSeparation(cst.getNumDimAndSymbolVars() - 1);
     unsigned lbPos, ubPos;
     if (!cst.getConstantBoundOnDimSize(/*pos=*/0, /*lb=*/nullptr,
                                        /*lbDivisor=*/nullptr, /*ub=*/nullptr,
                                        &lbPos, &ubPos) ||
         lbPos == ubPos) {
       LLVM_DEBUG(llvm::dbgs() << "[tile separation] Can't get constant diff / "
                                  "equalities not yet handled\n");
       return failure();

mlir/lib/Dialect/Affine/Utils/Utils.cpp

MemRefType mlir::normalizeMemRefType(MemRefType memrefType, OpBuilder b,
   }
   // We compose this map with the original index (logical) space to derive
   // the upper bounds for the new index space.
   unsigned newRank = layoutMap.getNumResults();
   if (failed(fac.composeMatchingMap(layoutMap)))
     return memrefType;
   // TODO: Handle semi-affine maps.
   // Project out the old data dimensions.
-  fac.projectOut(newRank, fac.getNumIds() - newRank - fac.getNumLocalIds());
+  fac.projectOut(newRank, fac.getNumVars() - newRank - fac.getNumLocalVars());
   SmallVector<int64_t, 4> newShape(newRank);
   for (unsigned d = 0; d < newRank; ++d) {
     // Check if each dimension of normalized memrefType is dynamic.
     bool isDynDim = isNormalizedMemRefDynamicDim(
         d, layoutMap, memrefTypeDynDims, b.getContext());
     if (isDynDim) {
       newShape[d] = -1;
     } else {

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

void getUpperBoundForIndex(Value value, AffineMap &boundMap,
   });
   backwardSlice.insert(definingOp);
 
   // Setup a system of affine constraints that describe the index computation.
   FlatAffineValueConstraints constraints;
 
   // Helper to find or create an identifier for the given value.
   auto findOrCreateId = [&](Value value) {
-    if (!constraints.containsId(value)) {
-      constraints.appendDimId(value);
+    if (!constraints.containsVar(value)) {
+      constraints.appendDimVar(value);
       return true;
     }
     unsigned pos;
-    constraints.findId(value, &pos);
-    return pos < constraints.getNumDimIds();
+    constraints.findVar(value, &pos);
+    return pos < constraints.getNumDimVars();
   };
   // Helper to get the position for the given value.
   auto getPosition = [&](Value value) {
     unsigned pos;
-    bool exists = constraints.findId(value, &pos);
+    bool exists = constraints.findVar(value, &pos);
     (void)exists;
     assert(exists && "expect to find the identifier");
     return pos;
   };
 
   // Add the affine operations in `backwardSlice` to the constraints.
   for (Operation *op : llvm::reverse(backwardSlice)) {
     // Add an identifier for all op results and operands.

mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp

 /// `operands` are the SSA Value operands used with the affine map.
 /// Note: This function adds a new symbol column to the `constraints` for each
 /// dimension/symbol that exists in the affine map but not in `constraints`.
 static LogicalResult alignAndAddBound(FlatAffineValueConstraints &constraints,
                                       IntegerPolyhedron::BoundType type,
                                       unsigned pos, AffineMap map,
                                       ValueRange operands) {
   SmallVector<Value> dims, syms, newSyms;
-  unpackOptionalValues(constraints.getMaybeValues(IdKind::SetDim), dims);
-  unpackOptionalValues(constraints.getMaybeValues(IdKind::Symbol), syms);
+  unpackOptionalValues(constraints.getMaybeValues(VarKind::SetDim), dims);
+  unpackOptionalValues(constraints.getMaybeValues(VarKind::Symbol), syms);
 
   AffineMap alignedMap =
       alignAffineMapWithValues(map, operands, dims, syms, &newSyms);
   for (unsigned i = syms.size(); i < newSyms.size(); ++i)
-    constraints.appendSymbolId(newSyms[i]);
+    constraints.appendSymbolVar(newSyms[i]);
   return constraints.addBound(type, pos, alignedMap);
 }
 
 /// Add `val` to each result of `map`.
 static AffineMap addConstToResults(AffineMap map, int64_t val) {
   SmallVector<AffineExpr> newResults;
   for (AffineExpr r : map.getResults())
     newResults.push_back(r + val);

 static LogicalResult
 canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
                      ValueRange operands, bool isMin,
                      FlatAffineValueConstraints constraints) {
   RewriterBase::InsertionGuard guard(rewriter);
   unsigned numResults = map.getNumResults();
 
   // Add a few extra dimensions.
-  unsigned dimOp = constraints.appendDimId();      // `op`
-  unsigned dimOpBound = constraints.appendDimId(); // `op` lower/upper bound
-  unsigned resultDimStart = constraints.appendDimId(/*num=*/numResults);
+  unsigned dimOp = constraints.appendDimVar();      // `op`
+  unsigned dimOpBound = constraints.appendDimVar(); // `op` lower/upper bound
+  unsigned resultDimStart = constraints.appendDimVar(/*num=*/numResults);
 
   // Add an inequality for each result expr_i of map:
   // isMin: op <= expr_i, !isMin: op >= expr_i
   auto boundType = isMin ? IntegerPolyhedron::UB : IntegerPolyhedron::LB;
   // Upper bounds are exclusive, so add 1. (`affine.min` ops are inclusive.)
   AffineMap mapLbUb = isMin ? addConstToResults(map, 1) : map;
   if (failed(
           alignAndAddBound(constraints, boundType, dimOp, mapLbUb, operands)))
canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
   }
 
   // Lower and upper bound of `op` are equal. Replace `minOp` with its bound.
   AffineMap newMap = alignedBoundMap;
   SmallVector<Value> newOperands;
   unpackOptionalValues(constraints.getMaybeValues(), newOperands);
   // If dims/symbols have known constant values, use those in order to simplify
   // the affine map further.
-  for (int64_t i = 0, e = constraints.getNumIds(); i < e; ++i) {
+  for (int64_t i = 0, e = constraints.getNumVars(); i < e; ++i) {
     // Skip unused operands and operands that are already constants.
     if (!newOperands[i] || getConstantIntValue(newOperands[i]))
       continue;
     if (auto bound = constraints.getConstantBound(IntegerPolyhedron::EQ, i))
       newOperands[i] =
           rewriter.create<arith::ConstantIndexOp>(op->getLoc(), *bound);
   }
   mlir::canonicalizeMapAndOperands(&newMap, &newOperands);
   rewriter.setInsertionPoint(op);
   rewriter.replaceOpWithNewOp<AffineApplyOp>(op, newMap, newOperands);
   return success();
 }
 
 static LogicalResult
 addLoopRangeConstraints(FlatAffineValueConstraints &constraints, Value iv,
                         OpFoldResult lb, OpFoldResult ub, OpFoldResult step,
                         RewriterBase &rewriter) {
   // IntegerPolyhedron does not support semi-affine expressions.
   // Therefore, only constant step values are supported.
   auto stepInt = getConstantIntValue(step);
   if (!stepInt)
     return failure();
 
-  unsigned dimIv = constraints.appendDimId(iv);
+  unsigned dimIv = constraints.appendDimVar(iv);
   auto lbv = lb.dyn_cast<Value>();
   unsigned dimLb =
-      lbv ? constraints.appendDimId(lbv) : constraints.appendDimId(/*num=*/1);
+      lbv ? constraints.appendDimVar(lbv) : constraints.appendDimVar(/*num=*/1);
   auto ubv = ub.dyn_cast<Value>();
   unsigned dimUb =
-      ubv ? constraints.appendDimId(ubv) : constraints.appendDimId(/*num=*/1);
+      ubv ? constraints.appendDimVar(ubv) : constraints.appendDimVar(/*num=*/1);
 
   // If loop lower/upper bounds are constant: Add EQ constraint.
   Optional<int64_t> lbInt = getConstantIntValue(lb);
   Optional<int64_t> ubInt = getConstantIntValue(ub);
   if (lbInt)
     constraints.addBound(IntegerPolyhedron::EQ, dimLb, *lbInt);
   if (ubInt)
     constraints.addBound(IntegerPolyhedron::EQ, dimUb, *ubInt);
if (lbInt && ubInt && (*lbInt + *stepInt >= *ubInt)) {
     // iv < lb + step * ((ub - lb - 1) floorDiv step) + 1
     AffineExpr exprLb = lbInt ? rewriter.getAffineConstantExpr(*lbInt)
                               : rewriter.getAffineDimExpr(dimLb);
     AffineExpr exprUb = ubInt ? rewriter.getAffineConstantExpr(*ubInt)
                               : rewriter.getAffineDimExpr(dimUb);
     ivUb = exprLb + 1 + (*stepInt * ((exprUb - exprLb - 1).floorDiv(*stepInt)));
   }
   auto map = AffineMap::get(
-      /*dimCount=*/constraints.getNumDimIds(),
-      /*symbolCount=*/constraints.getNumSymbolIds(), /*result=*/ivUb);
+      /*dimCount=*/constraints.getNumDimVars(),
+      /*symbolCount=*/constraints.getNumSymbolVars(), /*result=*/ivUb);
 
   return constraints.addBound(IntegerPolyhedron::UB, dimIv, map);
 }
 
 /// Canonicalize min/max operations in the context of for loops with a known
 /// range. Call `canonicalizeMinMaxOp` and add the following constraints to
 /// the constraint system (along with the missing dimensions):
 ///

 /// `insideLoop` must be true for min/max ops inside the loop and false for
 /// affine.min ops inside the partial iteration. For an explanation of the other
 /// parameters, see comment of `canonicalizeMinMaxOpInLoop`.
 LogicalResult scf::rewritePeeledMinMaxOp(RewriterBase &rewriter, Operation *op,
                                          AffineMap map, ValueRange operands,
                                          bool isMin, Value iv, Value ub,
                                          Value step, bool insideLoop) {
   FlatAffineValueConstraints constraints;
-  constraints.appendDimId({iv, ub, step});
+  constraints.appendDimVar({iv, ub, step});
   if (auto constUb = getConstantIntValue(ub))
     constraints.addBound(IntegerPolyhedron::EQ, 1, *constUb);
   if (auto constStep = getConstantIntValue(step))
     constraints.addBound(IntegerPolyhedron::EQ, 2, *constStep);
 
   // Add loop peeling invariant. This is the main piece of knowledge that
   // enables AffineMinOp simplification.
   if (insideLoop) {

mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp

TEST(IntegerPolyhedronTest, clearConstraints) {
   EXPECT_EQ(set.atIneq(0, 0), 1);
   EXPECT_EQ(set.atIneq(0, 1), 0);
 }
 
 TEST(IntegerPolyhedronTest, removeIdRange) {
   IntegerPolyhedron set(PresburgerSpace::getSetSpace(3, 2, 1));
 
   set.addInequality({10, 11, 12, 20, 21, 30, 40});
-  set.removeId(IdKind::Symbol, 1);
+  set.removeVar(VarKind::Symbol, 1);
   EXPECT_THAT(set.getInequality(0),
               testing::ElementsAre(10, 11, 12, 20, 30, 40));
 
-  set.removeIdRange(IdKind::SetDim, 0, 2);
+  set.removeVarRange(VarKind::SetDim, 0, 2);
   EXPECT_THAT(set.getInequality(0), testing::ElementsAre(12, 20, 30, 40));
 
-  set.removeIdRange(IdKind::Local, 1, 1);
+  set.removeVarRange(VarKind::Local, 1, 1);
   EXPECT_THAT(set.getInequality(0), testing::ElementsAre(12, 20, 30, 40));
 
-  set.removeIdRange(IdKind::Local, 0, 1);
+  set.removeVarRange(VarKind::Local, 0, 1);
   EXPECT_THAT(set.getInequality(0), testing::ElementsAre(12, 20, 40));
 }
 
 TEST(IntegerPolyhedronTest, FindSampleTest) {
   // Bounded sets with only inequalities.
   // 0 <= 7x <= 5
   checkSample(true, parsePoly("(x) : (7 * x >= 0, -7 * x + 5 >= 0)"));
 
TEST(IntegerPolyhedronTest, computeLocalReprTightUpperBound) {
     // Check if the divisions can be computed even with a tighter upper bound.
     checkDivisionRepresentation(poly, divisions, denoms);
   }
 
   {
     IntegerPolyhedron poly =
         parsePoly("(i, j, q) : (4*q - i - j + 2 >= 0, -4*q + i + j >= 0)");
     // Convert `q` to a local variable.
-    poly.convertToLocal(IdKind::SetDim, 2, 3);
+    poly.convertToLocal(VarKind::SetDim, 2, 3);
 
     std::vector<SmallVector<int64_t, 8>> divisions = {{1, 1, 0, 1}};
     SmallVector<unsigned, 8> denoms = {4};
 
     // Check if the divisions can be computed even with a tighter upper bound.
     checkDivisionRepresentation(poly, divisions, denoms);
   }
 }
 
 TEST(IntegerPolyhedronTest, computeLocalReprFromEquality) {
   {
     IntegerPolyhedron poly = parsePoly("(i, j, q) : (-4*q + i + j == 0)");
     // Convert `q` to a local variable.
-    poly.convertToLocal(IdKind::SetDim, 2, 3);
+    poly.convertToLocal(VarKind::SetDim, 2, 3);
 
     std::vector<SmallVector<int64_t, 8>> divisions = {{1, 1, 0, 0}};
     SmallVector<unsigned, 8> denoms = {4};
 
     checkDivisionRepresentation(poly, divisions, denoms);
   }
   {
     IntegerPolyhedron poly = parsePoly("(i, j, q) : (4*q - i - j == 0)");
     // Convert `q` to a local variable.
-    poly.convertToLocal(IdKind::SetDim, 2, 3);
+    poly.convertToLocal(VarKind::SetDim, 2, 3);
 
     std::vector<SmallVector<int64_t, 8>> divisions = {{1, 1, 0, 0}};
     SmallVector<unsigned, 8> denoms = {4};
 
     checkDivisionRepresentation(poly, divisions, denoms);
   }
   {
     IntegerPolyhedron poly = parsePoly("(i, j, q) : (3*q + i + j - 2 == 0)");
     // Convert `q` to a local variable.
-    poly.convertToLocal(IdKind::SetDim, 2, 3);
+    poly.convertToLocal(VarKind::SetDim, 2, 3);
 
     std::vector<SmallVector<int64_t, 8>> divisions = {{-1, -1, 0, 2}};
     SmallVector<unsigned, 8> denoms = {3};
 
     checkDivisionRepresentation(poly, divisions, denoms);
   }
 }
 
 TEST(IntegerPolyhedronTest, computeLocalReprFromEqualityAndInequality) {
   {
     IntegerPolyhedron poly =
         parsePoly("(i, j, q, k) : (-3*k + i + j == 0, 4*q - "
                   "i - j + 2 >= 0, -4*q + i + j >= 0)");
     // Convert `q` and `k` to local variables.
-    poly.convertToLocal(IdKind::SetDim, 2, 4);
+    poly.convertToLocal(VarKind::SetDim, 2, 4);
 
     std::vector<SmallVector<int64_t, 8>> divisions = {{1, 1, 0, 0, 1},
                                                       {1, 1, 0, 0, 0}};
     SmallVector<unsigned, 8> denoms = {4, 3};
 
     checkDivisionRepresentation(poly, divisions, denoms);
   }
 }
 
 TEST(IntegerPolyhedronTest, computeLocalReprNoRepr) {
   IntegerPolyhedron poly =
       parsePoly("(x, q) : (x - 3 * q >= 0, -x + 3 * q + 3 >= 0)");
   // Convert q to a local variable.
-  poly.convertToLocal(IdKind::SetDim, 1, 2);
+  poly.convertToLocal(VarKind::SetDim, 1, 2);
 
   std::vector<SmallVector<int64_t, 8>> divisions = {{0, 0, 0}};
   SmallVector<unsigned, 8> denoms = {0};
 
   // Check that no division is computed.
   checkDivisionRepresentation(poly, divisions, denoms);
 }
 
 TEST(IntegerPolyhedronTest, computeLocalReprNegConstNormalize) {
   IntegerPolyhedron poly =
       parsePoly("(x, q) : (-1 - 3*x - 6 * q >= 0, 6 + 3*x + 6*q >= 0)");
   // Convert q to a local variable.
-  poly.convertToLocal(IdKind::SetDim, 1, 2);
+  poly.convertToLocal(VarKind::SetDim, 1, 2);
 
   // q = floor((-1/3 - x)/2)
   //   = floor((1/3) + (-1 - x)/2)
   //   = floor((-1 - x)/2).
   std::vector<SmallVector<int64_t, 8>> divisions = {{-1, 0, -1}};
   SmallVector<unsigned, 8> denoms = {2};
   checkDivisionRepresentation(poly, divisions, denoms);
 }
TEST(IntegerPolyhedronTest, mergeDivisionsSimple) {
     poly1.addLocalFloorDiv({1, 0, 0}, 2); // y = [x / 2].
     poly1.addEquality({1, 0, -3, 0});     // x = 3y.
     poly1.addInequality({1, 1, 0, 1});    // x + z + 1 >= 0.
 
     // (x) : (exists y = [x / 2], z : x = 5y).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 0}, 2); // y = [x / 2].
     poly2.addEquality({1, -5, 0});     // x = 5y.
-    poly2.appendId(IdKind::Local);     // Add local id z.
+    poly2.appendVar(VarKind::Local);   // Add local id z.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 1 division should be matched + 2 unmatched local ids.
-    EXPECT_EQ(poly1.getNumLocalIds(), 3u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 3u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 3u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 3u);
   }
 
   {
     // (x) : (exists z = [x / 5], y = [x / 2] : x = 3y).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
     poly1.addLocalFloorDiv({1, 0}, 5);    // z = [x / 5].
     poly1.addLocalFloorDiv({1, 0, 0}, 2); // y = [x / 2].
     poly1.addEquality({1, 0, -3, 0});     // x = 3y.
 
     // (x) : (exists y = [x / 2], z = [x / 5]: x = 5z).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 0}, 2);    // y = [x / 2].
     poly2.addLocalFloorDiv({1, 0, 0}, 5); // z = [x / 5].
     poly2.addEquality({1, 0, -5, 0});     // x = 5z.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 2 divisions should be matched.
-    EXPECT_EQ(poly1.getNumLocalIds(), 2u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 2u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 2u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 2u);
   }
 
   {
     // Division Normalization test.
     // (x) : (exists z, y  = [x / 2] : x = 3y and x + z + 1 >= 0).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1, 0, 1));
     // This division would be normalized.
     poly1.addLocalFloorDiv({3, 0, 0}, 6); // y = [3x / 6] -> [x/2].
     poly1.addEquality({1, 0, -3, 0});     // x = 3z.
     poly1.addInequality({1, 1, 0, 1});    // x + y + 1 >= 0.
 
     // (x) : (exists y = [x / 2], z : x = 5y).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 0}, 2); // y = [x / 2].
     poly2.addEquality({1, -5, 0});     // x = 5y.
-    poly2.appendId(IdKind::Local);     // Add local id z.
+    poly2.appendVar(VarKind::Local);   // Add local id z.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // One division should be matched + 2 unmatched local ids.
-    EXPECT_EQ(poly1.getNumLocalIds(), 3u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 3u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 3u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 3u);
   }
 }
 
 TEST(IntegerPolyhedronTest, mergeDivisionsNestedDivsions) {
   {
     // (x) : (exists y = [x / 2], z = [x + y / 3]: y + z >= x).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
     poly1.addLocalFloorDiv({1, 0}, 2);    // y = [x / 2].
     poly1.addLocalFloorDiv({1, 1, 0}, 3); // z = [x + y / 3].
     poly1.addInequality({-1, 1, 1, 0});   // y + z >= x.
 
     // (x) : (exists y = [x / 2], z = [x + y / 3]: y + z <= x).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 0}, 2);    // y = [x / 2].
     poly2.addLocalFloorDiv({1, 1, 0}, 3); // z = [x + y / 3].
     poly2.addInequality({1, -1, -1, 0});  // y + z <= x.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 2 divisions should be matched.
-    EXPECT_EQ(poly1.getNumLocalIds(), 2u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 2u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 2u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 2u);
   }
 
   {
     // (x) : (exists y = [x / 2], z = [x + y / 3], w = [z + 1 / 5]: y + z >= x).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
     poly1.addLocalFloorDiv({1, 0}, 2);       // y = [x / 2].
     poly1.addLocalFloorDiv({1, 1, 0}, 3);    // z = [x + y / 3].
     poly1.addLocalFloorDiv({0, 0, 1, 1}, 5); // w = [z + 1 / 5].
     poly1.addInequality({-1, 1, 1, 0, 0});   // y + z >= x.
 
     // (x) : (exists y = [x / 2], z = [x + y / 3], w = [z + 1 / 5]: y + z <= x).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 0}, 2);       // y = [x / 2].
     poly2.addLocalFloorDiv({1, 1, 0}, 3);    // z = [x + y / 3].
     poly2.addLocalFloorDiv({0, 0, 1, 1}, 5); // w = [z + 1 / 5].
     poly2.addInequality({1, -1, -1, 0, 0});  // y + z <= x.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 3 divisions should be matched.
-    EXPECT_EQ(poly1.getNumLocalIds(), 3u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 3u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 3u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 3u);
   }
   {
     // (x) : (exists y = [x / 2], z = [x + y / 3]: y + z >= x).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
     poly1.addLocalFloorDiv({2, 0}, 4);    // y = [2x / 4] -> [x / 2].
     poly1.addLocalFloorDiv({1, 1, 0}, 3); // z = [x + y / 3].
     poly1.addInequality({-1, 1, 1, 0});   // y + z >= x.
 
     // (x) : (exists y = [x / 2], z = [x + y / 3]: y + z <= x).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 0}, 2); // y = [x / 2].
     // This division would be normalized.
     poly2.addLocalFloorDiv({3, 3, 0}, 9); // z = [3x + 3y / 9] -> [x + y / 3].
     poly2.addInequality({1, -1, -1, 0});  // y + z <= x.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 2 divisions should be matched.
-    EXPECT_EQ(poly1.getNumLocalIds(), 2u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 2u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 2u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 2u);
   }
 }
 
 TEST(IntegerPolyhedronTest, mergeDivisionsConstants) {
   {
     // (x) : (exists y = [x + 1 / 3], z = [x + 2 / 3]: y + z >= x).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
     poly1.addLocalFloorDiv({1, 1}, 2);    // y = [x + 1 / 2].
     poly1.addLocalFloorDiv({1, 0, 2}, 3); // z = [x + 2 / 3].
     poly1.addInequality({-1, 1, 1, 0});   // y + z >= x.
 
     // (x) : (exists y = [x + 1 / 3], z = [x + 2 / 3]: y + z <= x).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     poly2.addLocalFloorDiv({1, 1}, 2);    // y = [x + 1 / 2].
     poly2.addLocalFloorDiv({1, 0, 2}, 3); // z = [x + 2 / 3].
     poly2.addInequality({1, -1, -1, 0});  // y + z <= x.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 2 divisions should be matched.
-    EXPECT_EQ(poly1.getNumLocalIds(), 2u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 2u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 2u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 2u);
   }
   {
     // (x) : (exists y = [x + 1 / 3], z = [x + 2 / 3]: y + z >= x).
     IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
     poly1.addLocalFloorDiv({1, 1}, 2); // y = [x + 1 / 2].
     // Normalization test.
     poly1.addLocalFloorDiv({3, 0, 6}, 9); // z = [3x + 6 / 9] -> [x + 2 / 3].
     poly1.addInequality({-1, 1, 1, 0});   // y + z >= x.
 
     // (x) : (exists y = [x + 1 / 3], z = [x + 2 / 3]: y + z <= x).
     IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
     // Normalization test.
     poly2.addLocalFloorDiv({2, 2}, 4);    // y = [2x + 2 / 4] -> [x + 1 / 2].
     poly2.addLocalFloorDiv({1, 0, 2}, 3); // z = [x + 2 / 3].
     poly2.addInequality({1, -1, -1, 0});  // y + z <= x.
 
-    poly1.mergeLocalIds(poly2);
+    poly1.mergeLocalVars(poly2);
 
     // Local space should be same.
-    EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+    EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
     // 2 divisions should be matched.
-    EXPECT_EQ(poly1.getNumLocalIds(), 2u);
-    EXPECT_EQ(poly2.getNumLocalIds(), 2u);
+    EXPECT_EQ(poly1.getNumLocalVars(), 2u);
+    EXPECT_EQ(poly2.getNumLocalVars(), 2u);
   }
 }
 
 TEST(IntegerPolyhedronTest, mergeDivisionsDuplicateInSameSet) {
   // (x) : (exists y = [x + 1 / 3], z = [x + 1 / 3]: y + z >= x).
   IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
   poly1.addLocalFloorDiv({1, 1}, 3);    // y = [x + 1 / 2].
   poly1.addLocalFloorDiv({1, 0, 1}, 3); // z = [x + 1 / 3].
   poly1.addInequality({-1, 1, 1, 0});   // y + z >= x.
 
   // (x) : (exists y = [x + 1 / 3], z = [x + 2 / 3]: y + z <= x).
   IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
   poly2.addLocalFloorDiv({1, 1}, 3);    // y = [x + 1 / 3].
   poly2.addLocalFloorDiv({1, 0, 2}, 3); // z = [x + 2 / 3].
   poly2.addInequality({1, -1, -1, 0});  // y + z <= x.
 
-  poly1.mergeLocalIds(poly2);
+  poly1.mergeLocalVars(poly2);
 
   // Local space should be same.
-  EXPECT_EQ(poly1.getNumLocalIds(), poly2.getNumLocalIds());
+  EXPECT_EQ(poly1.getNumLocalVars(), poly2.getNumLocalVars());
 
   // 1 divisions should be matched.
-  EXPECT_EQ(poly1.getNumLocalIds(), 3u);
-  EXPECT_EQ(poly2.getNumLocalIds(), 3u);
+  EXPECT_EQ(poly1.getNumLocalVars(), 3u);
+  EXPECT_EQ(poly2.getNumLocalVars(), 3u);
 }
 
 TEST(IntegerPolyhedronTest, negativeDividends) {
   // (x) : (exists y = [-x + 1 / 2], z = [-x - 2 / 3]: y + z >= x).
   IntegerPolyhedron poly1(PresburgerSpace::getSetSpace(1));
   poly1.addLocalFloorDiv({-1, 1}, 2); // y = [x + 1 / 2].
   // Normalization test with negative dividends
   poly1.addLocalFloorDiv({-3, 0, -6}, 9); // z = [3x + 6 / 9] -> [x + 2 / 3].
   poly1.addInequality({-1, 1, 1, 0});     // y + z >= x.
 
   // (x) : (exists y = [x + 1 / 3], z = [x + 2 / 3]: y + z <= x).
   IntegerPolyhedron poly2(PresburgerSpace::getSetSpace(1));
   // Normalization test.
   poly2.addLocalFloorDiv({-2, 2}, 4);     // y = [-2x + 2 / 4] -> [-x + 1 / 2].
   poly2.addLocalFloorDiv({-1, 0, -2}, 3); // z = [-x - 2 / 3].
   poly2.addInequality({1, -1, -1, 0});    // y + z <= x.
 
-  poly1.mergeLocalIds(poly2);
+  poly1.mergeLocalVars(poly2);
 
   // Merging triggers normalization.
   std::vector<SmallVector<int64_t, 8>> divisions = {{-1, 0, 0, 1},
                                                     {-1, 0, 0, -2}};
   SmallVector<unsigned, 8> denoms = {2, 3};
   checkDivisionRepresentation(poly1, divisions, denoms);
 }
 

 
 void expectSymbolicIntegerLexMin(
     StringRef polyStr,
     ArrayRef<std::pair<StringRef, SmallVector<SmallVector<int64_t, 8>, 8>>>
         expectedLexminRepr,
     ArrayRef<StringRef> expectedUnboundedDomainRepr) {
   IntegerPolyhedron poly = parsePoly(polyStr);
 
-  ASSERT_NE(poly.getNumDimIds(), 0u);
-  ASSERT_NE(poly.getNumSymbolIds(), 0u);
+  ASSERT_NE(poly.getNumDimVars(), 0u);
+  ASSERT_NE(poly.getNumSymbolVars(), 0u);
 
   PWMAFunction expectedLexmin =
-      parsePWMAF(/*numInputs=*/poly.getNumSymbolIds(),
-                 /*numOutputs=*/poly.getNumDimIds(), expectedLexminRepr);
+      parsePWMAF(/*numInputs=*/poly.getNumSymbolVars(),
+                 /*numOutputs=*/poly.getNumDimVars(), expectedLexminRepr);
 
   PresburgerSet expectedUnboundedDomain = parsePresburgerSetFromPolyStrings(
-      poly.getNumSymbolIds(), expectedUnboundedDomainRepr);
+      poly.getNumSymbolVars(), expectedUnboundedDomainRepr);
 
   SymbolicLexMin result = poly.findSymbolicIntegerLexMin();
 
   EXPECT_TRUE(result.lexmin.isEqual(expectedLexmin));
   if (!result.lexmin.isEqual(expectedLexmin)) {
     llvm::errs() << "got:\n";
     result.lexmin.dump();
     llvm::errs() << "expected:\n";

mlir/unittests/Analysis/Presburger/IntegerRelationTest.cpp

 #include <gtest/gtest.h>
 
 using namespace mlir;
 using namespace presburger;
 
 static IntegerRelation parseRelationFromSet(StringRef set, unsigned numDomain) {
   IntegerRelation rel = parsePoly(set);
 
-  rel.convertIdKind(IdKind::SetDim, 0, numDomain, IdKind::Domain);
+  rel.convertVarKind(VarKind::SetDim, 0, numDomain, VarKind::Domain);
 
   return rel;
 }
 
 TEST(IntegerRelationTest, getDomainAndRangeSet) {
   IntegerRelation rel = parseRelationFromSet(
       "(x, xr)[N] : (xr - x - 10 == 0, xr >= 0, N - xr >= 0)", 1);
 

mlir/unittests/Analysis/Presburger/PresburgerSetTest.cpp

expectComputedVolumeIsValidOverapprox(unbounded.unionSet(diamond),
                                         /*resultBound=*/{});
 }
 
 // The last `numToProject` dims will be projected out, i.e., converted to
 // locals.
 void testComputeReprAtPoints(IntegerPolyhedron poly,
                              ArrayRef<SmallVector<int64_t, 4>> points,
                              unsigned numToProject) {
-  poly.convertIdKind(IdKind::SetDim, poly.getNumDimIds() - numToProject,
-                     poly.getNumDimIds(), IdKind::Local);
+  poly.convertVarKind(VarKind::SetDim, poly.getNumDimVars() - numToProject,
+                      poly.getNumDimVars(), VarKind::Local);
   PresburgerSet repr = poly.computeReprWithOnlyDivLocals();
   EXPECT_TRUE(repr.hasOnlyDivLocals());
   EXPECT_TRUE(repr.getSpace().isCompatible(poly.getSpace()));
   for (const SmallVector<int64_t, 4> &point : points) {
     EXPECT_EQ(poly.containsPointNoLocal(point).hasValue(),
               repr.containsPoint(point));
   }
 }
 
 void testComputeRepr(IntegerPolyhedron poly, const PresburgerSet &expected,
                      unsigned numToProject) {
-  poly.convertIdKind(IdKind::SetDim, poly.getNumDimIds() - numToProject,
-                     poly.getNumDimIds(), IdKind::Local);
+  poly.convertVarKind(VarKind::SetDim, poly.getNumDimVars() - numToProject,
+                      poly.getNumDimVars(), VarKind::Local);
   PresburgerSet repr = poly.computeReprWithOnlyDivLocals();
   EXPECT_TRUE(repr.hasOnlyDivLocals());
   EXPECT_TRUE(repr.getSpace().isCompatible(poly.getSpace()));
   EXPECT_TRUE(repr.isEqual(expected));
 }
 
 TEST(SetTest, computeReprWithOnlyDivLocals) {
   testComputeReprAtPoints(parsePoly("(x, y) : (x - 2*y == 0)"),

mlir/unittests/Analysis/Presburger/PresburgerSpaceTest.cpp

 
 using namespace mlir;
 using namespace presburger;
 
 TEST(PresburgerSpaceTest, insertId) {
   PresburgerSpace space = PresburgerSpace::getRelationSpace(2, 2, 1);
 
   // Try inserting 2 domain ids.
-  space.insertId(IdKind::Domain, 0, 2);
-  EXPECT_EQ(space.getNumDomainIds(), 4u);
+  space.insertVar(VarKind::Domain, 0, 2);
+  EXPECT_EQ(space.getNumDomainVars(), 4u);
 
   // Try inserting 1 range ids.
-  space.insertId(IdKind::Range, 0, 1);
-  EXPECT_EQ(space.getNumRangeIds(), 3u);
+  space.insertVar(VarKind::Range, 0, 1);
+  EXPECT_EQ(space.getNumRangeVars(), 3u);
 }
 
 TEST(PresburgerSpaceTest, insertIdSet) {
   PresburgerSpace space = PresburgerSpace::getSetSpace(2, 1);
 
   // Try inserting 2 dimension ids. The space should have 4 range ids since
   // spaces which do not distinguish between domain, range are implemented like
   // this.
-  space.insertId(IdKind::SetDim, 0, 2);
-  EXPECT_EQ(space.getNumRangeIds(), 4u);
+  space.insertVar(VarKind::SetDim, 0, 2);
+  EXPECT_EQ(space.getNumRangeVars(), 4u);
 }
 
 TEST(PresburgerSpaceTest, removeIdRange) {
   PresburgerSpace space = PresburgerSpace::getRelationSpace(2, 1, 3);
 
   // Remove 1 domain identifier.
-  space.removeIdRange(IdKind::Domain, 0, 1);
-  EXPECT_EQ(space.getNumDomainIds(), 1u);
+  space.removeVarRange(VarKind::Domain, 0, 1);
+  EXPECT_EQ(space.getNumDomainVars(), 1u);
 
   // Remove 1 symbol and 1 range identifier.
-  space.removeIdRange(IdKind::Symbol, 0, 1);
-  space.removeIdRange(IdKind::Range, 0, 1);
-  EXPECT_EQ(space.getNumDomainIds(), 1u);
-  EXPECT_EQ(space.getNumRangeIds(), 0u);
-  EXPECT_EQ(space.getNumSymbolIds(), 2u);
+  space.removeVarRange(VarKind::Symbol, 0, 1);
+  space.removeVarRange(VarKind::Range, 0, 1);
+  EXPECT_EQ(space.getNumDomainVars(), 1u);
+  EXPECT_EQ(space.getNumRangeVars(), 0u);
+  EXPECT_EQ(space.getNumSymbolVars(), 2u);
 }
 
 TEST(PresburgerSpaceTest, insertIdAttachment) {
   PresburgerSpace space = PresburgerSpace::getRelationSpace(2, 2, 1, 0);
   space.resetAttachments<int *>();
 
   // Attach attachment to domain ids.
   int attachments[2] = {0, 1};
-  space.setAttachment<int *>(IdKind::Domain, 0, &attachments[0]);
-  space.setAttachment<int *>(IdKind::Domain, 1, &attachments[1]);
+  space.setAttachment<int *>(VarKind::Domain, 0, &attachments[0]);
+  space.setAttachment<int *>(VarKind::Domain, 1, &attachments[1]);
 
   // Try inserting 2 domain ids.
-  space.insertId(IdKind::Domain, 0, 2);
-  EXPECT_EQ(space.getNumDomainIds(), 4u);
+  space.insertVar(VarKind::Domain, 0, 2);
+  EXPECT_EQ(space.getNumDomainVars(), 4u);
 
   // Try inserting 1 range ids.
-  space.insertId(IdKind::Range, 0, 1);
-  EXPECT_EQ(space.getNumRangeIds(), 3u);
+  space.insertVar(VarKind::Range, 0, 1);
+  EXPECT_EQ(space.getNumRangeVars(), 3u);
 
   // Check if the attachments for the old ids are still attached properly.
-  EXPECT_EQ(*space.getAttachment<int *>(IdKind::Domain, 2), attachments[0]);
-  EXPECT_EQ(*space.getAttachment<int *>(IdKind::Domain, 3), attachments[1]);
+  EXPECT_EQ(*space.getAttachment<int *>(VarKind::Domain, 2), attachments[0]);
+  EXPECT_EQ(*space.getAttachment<int *>(VarKind::Domain, 3), attachments[1]);
 }
 
 TEST(PresburgerSpaceTest, removeIdRangeAttachment) {
   PresburgerSpace space = PresburgerSpace::getRelationSpace(2, 1, 3, 0);
   space.resetAttachments<int *>();
 
   int attachments[6] = {0, 1, 2, 3, 4, 5};
 
   // Attach attachments to domain identifiers.
-  space.setAttachment<int *>(IdKind::Domain, 0, &attachments[0]);
-  space.setAttachment<int *>(IdKind::Domain, 1, &attachments[1]);
+  space.setAttachment<int *>(VarKind::Domain, 0, &attachments[0]);
+  space.setAttachment<int *>(VarKind::Domain, 1, &attachments[1]);
 
   // Attach attachments to range identifiers.
-  space.setAttachment<int *>(IdKind::Range, 0, &attachments[2]);
+  space.setAttachment<int *>(VarKind::Range, 0, &attachments[2]);
 
   // Attach attachments to symbol identifiers.
-  space.setAttachment<int *>(IdKind::Symbol, 0, &attachments[3]);
-  space.setAttachment<int *>(IdKind::Symbol, 1, &attachments[4]);
-  space.setAttachment<int *>(IdKind::Symbol, 2, &attachments[5]);
+  space.setAttachment<int *>(VarKind::Symbol, 0, &attachments[3]);
+  space.setAttachment<int *>(VarKind::Symbol, 1, &attachments[4]);
+  space.setAttachment<int *>(VarKind::Symbol, 2, &attachments[5]);
 
   // Remove 1 domain identifier.
-  space.removeIdRange(IdKind::Domain, 0, 1);
-  EXPECT_EQ(space.getNumDomainIds(), 1u);
+  space.removeVarRange(VarKind::Domain, 0, 1);
+  EXPECT_EQ(space.getNumDomainVars(), 1u);
 
   // Remove 1 symbol and 1 range identifier.
-  space.removeIdRange(IdKind::Symbol, 0, 1);
-  space.removeIdRange(IdKind::Range, 0, 1);
-  EXPECT_EQ(space.getNumDomainIds(), 1u);
-  EXPECT_EQ(space.getNumRangeIds(), 0u);
-  EXPECT_EQ(space.getNumSymbolIds(), 2u);
+  space.removeVarRange(VarKind::Symbol, 0, 1);
+  space.removeVarRange(VarKind::Range, 0, 1);
+  EXPECT_EQ(space.getNumDomainVars(), 1u);
+  EXPECT_EQ(space.getNumRangeVars(), 0u);
+  EXPECT_EQ(space.getNumSymbolVars(), 2u);
 
   // Check if domain attachments are attached properly.
-  EXPECT_EQ(*space.getAttachment<int *>(IdKind::Domain, 0), attachments[1]);
+  EXPECT_EQ(*space.getAttachment<int *>(VarKind::Domain, 0), attachments[1]);
 
   // Check if symbol attachments are attached properly.
-  EXPECT_EQ(*space.getAttachment<int *>(IdKind::Range, 0), attachments[4]);
-  EXPECT_EQ(*space.getAttachment<int *>(IdKind::Range, 1), attachments[5]);
+  EXPECT_EQ(*space.getAttachment<int *>(VarKind::Range, 0), attachments[4]);
+  EXPECT_EQ(*space.getAttachment<int *>(VarKind::Range, 1), attachments[5]);
 }

mlir/unittests/Analysis/Presburger/Utils.h

inline PWMAFunction parsePWMAF(
 
   PWMAFunction result(
       PresburgerSpace::getSetSpace(numInputs - numSymbols, numSymbols),
       numOutputs);
   for (const auto &pair : data) {
     IntegerPolyhedron domain = parsePoly(pair.first);
 
     result.addPiece(
-        domain, makeMatrix(numOutputs, domain.getNumIds() + 1, pair.second));
+        domain, makeMatrix(numOutputs, domain.getNumVars() + 1, pair.second));
   }
   return result;
 }
 
 /// lhs and rhs represent non-negative integers or positive infinity. The
 /// infinity case corresponds to when the Optional is empty.
 inline bool infinityOrUInt64LE(Optional<uint64_t> lhs, Optional<uint64_t> rhs) {
   // No constraint.