[MLIR] AffineStructures: resolve clang-tidy warnings [NFC]

[grosser]

I feel that this change can be reviewed post-commit following this policy: https://llvm.org/docs/CodeReview.html#can-code-be-reviewed-after-it-is-committed.
In the unlikely case that this purely mechanical case causes concerns, we can easily revert it and start a full patch review.

[arjunp]

Okay, I've pushed the changes directly.

mlir/include/mlir/Analysis/AffineStructures.h

private:
 
   /// Eliminates identifier 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
   /// 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,
+  void fourierMotzkinEliminate(unsigned pos, bool darkShadow = false,
                                bool *isResultIntegerExact = nullptr);
 
   /// Tightens inequalities given that we are dealing with integer spaces. This
   /// is similar 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).
-  void GCDTightenInequalities();
+  void gcdTightenInequalities();
 
   /// Normalized each constraints by the GCD of its coefficients.
   void normalizeConstraintsByGCD();
 
   /// Removes identifiers in the column range [idStart, idLimit), and copies any
   /// remaining valid data into place, updates member variables, and resizes
   /// arrays as needed.
   void removeIdRange(unsigned idStart, unsigned idLimit);

mlir/lib/Analysis/AffineStructures.cpp

if (id)
     ids.insert(ids.begin() + absolutePos, id);
   else
     ids.insert(ids.begin() + absolutePos, None);
   assert(ids.size() == getNumIds());
 }
 
 /// 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 FlatAffineConstraints &A,
-                          const FlatAffineConstraints &B) {
-  return A.getNumDimIds() == B.getNumDimIds() &&
-         A.getNumSymbolIds() == B.getNumSymbolIds() &&
-         A.getNumIds() == B.getNumIds() && A.getIds().equals(B.getIds());
+static bool areIdsAligned(const FlatAffineConstraints &a,
+                          const FlatAffineConstraints &b) {
+  return a.getNumDimIds() == b.getNumDimIds() &&
+         a.getNumSymbolIds() == b.getNumSymbolIds() &&
+         a.getNumIds() == b.getNumIds() && a.getIds().equals(b.getIds());
 }
 
 /// Calls areIdsAligned to check if two constraint systems have the same set
 /// of identifiers in the same order.
 bool FlatAffineConstraints::areIdsAlignedWithOther(
     const FlatAffineConstraints &other) {
   return areIdsAligned(*this, other);
 }

 /// 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 of each system are by design separate/local
 /// and are placed one after other (A's followed by B's).
 //  Eg: 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, FlatAffineConstraints *A,
-                             FlatAffineConstraints *B) {
-  assert(offset <= A->getNumDimIds() && offset <= B->getNumDimIds());
+static void mergeAndAlignIds(unsigned offset, FlatAffineConstraints *a,
+                             FlatAffineConstraints *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 id values aren't unique");
-  assert(areIdsUnique(*B) && "B's id values aren't unique");
+  assert(areIdsUnique(*a) && "A's id values aren't unique");
+  assert(areIdsUnique(*b) && "B's id values aren't unique");
 
-  assert(std::all_of(A->getIds().begin() + offset,
-                     A->getIds().begin() + A->getNumDimAndSymbolIds(),
+  assert(std::all_of(a->getIds().begin() + offset,
+                     a->getIds().begin() + a->getNumDimAndSymbolIds(),
                      [](Optional<Value> id) { return id.hasValue(); }));
 
-  assert(std::all_of(B->getIds().begin() + offset,
-                     B->getIds().begin() + B->getNumDimAndSymbolIds(),
+  assert(std::all_of(b->getIds().begin() + offset,
+                     b->getIds().begin() + b->getNumDimAndSymbolIds(),
                      [](Optional<Value> id) { return id.hasValue(); }));
 
   // Place local id's of A after local id's of B.
-  for (unsigned l = 0, e = A->getNumLocalIds(); l < e; l++) {
-    B->addLocalId(0);
+  for (unsigned l = 0, e = a->getNumLocalIds(); l < e; l++) {
+    b->addLocalId(0);
   }
-  for (unsigned t = 0, e = B->getNumLocalIds() - A->getNumLocalIds(); t < e;
+  for (unsigned t = 0, e = b->getNumLocalIds() - a->getNumLocalIds(); t < e;
        t++) {
-    A->addLocalId(A->getNumLocalIds());
+    a->addLocalId(a->getNumLocalIds());
   }
 
   SmallVector<Value, 4> aDimValues, aSymValues;
-  A->getIdValues(offset, A->getNumDimIds(), &aDimValues);
-  A->getIdValues(A->getNumDimIds(), A->getNumDimAndSymbolIds(), &aSymValues);
+  a->getIdValues(offset, a->getNumDimIds(), &aDimValues);
+  a->getIdValues(a->getNumDimIds(), a->getNumDimAndSymbolIds(), &aSymValues);
   {
     // Merge dims from A into B.
     unsigned d = offset;
     for (auto aDimValue : aDimValues) {
       unsigned loc;
-      if (B->findId(aDimValue, &loc)) {
+      if (b->findId(aDimValue, &loc)) {
         assert(loc >= offset && "A's dim appears in B's aligned range");
-        assert(loc < B->getNumDimIds() &&
+        assert(loc < b->getNumDimIds() &&
                "A's dim appears in B's non-dim position");
-        B->swapId(d, loc);
+        b->swapId(d, loc);
       } else {
-        B->addDimId(d);
-        B->setIdValue(d, aDimValue);
+        b->addDimId(d);
+        b->setIdValue(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->addDimId(A->getNumDimIds());
-      A->setIdValue(A->getNumDimIds() - 1, B->getIdValue(t));
+    for (unsigned t = a->getNumDimIds(), e = b->getNumDimIds(); t < e; t++) {
+      a->addDimId(a->getNumDimIds());
+      a->setIdValue(a->getNumDimIds() - 1, b->getIdValue(t));
     }
   }
   {
     // Merge symbols: merge A's symbols into B first.
-    unsigned s = B->getNumDimIds();
+    unsigned s = b->getNumDimIds();
     for (auto aSymValue : aSymValues) {
       unsigned loc;
-      if (B->findId(aSymValue, &loc)) {
-        assert(loc >= B->getNumDimIds() && loc < B->getNumDimAndSymbolIds() &&
+      if (b->findId(aSymValue, &loc)) {
+        assert(loc >= b->getNumDimIds() && loc < b->getNumDimAndSymbolIds() &&
                "A's symbol appears in B's non-symbol position");
-        B->swapId(s, loc);
+        b->swapId(s, loc);
       } else {
-        B->addSymbolId(s - B->getNumDimIds());
-        B->setIdValue(s, aSymValue);
+        b->addSymbolId(s - b->getNumDimIds());
+        b->setIdValue(s, aSymValue);
       }
       s++;
     }
     // Symbols that are in B, but not in A, are added at the end.
-    for (unsigned t = A->getNumDimAndSymbolIds(),
-                  e = B->getNumDimAndSymbolIds();
+    for (unsigned t = a->getNumDimAndSymbolIds(),
+                  e = b->getNumDimAndSymbolIds();
          t < e; t++) {
-      A->addSymbolId(A->getNumSymbolIds());
-      A->setIdValue(A->getNumDimAndSymbolIds() - 1, B->getIdValue(t));
+      a->addSymbolId(a->getNumSymbolIds());
+      a->setIdValue(a->getNumDimAndSymbolIds() - 1, b->getIdValue(t));
     }
   }
-  assert(areIdsAligned(*A, *B) && "IDs expected to be aligned");
+  assert(areIdsAligned(*a, *b) && "IDs expected to be aligned");
 }
 
 // Call 'mergeAndAlignIds' to align constraint systems of 'this' and 'other'.
 void FlatAffineConstraints::mergeAndAlignIdsWithOther(
     unsigned offset, FlatAffineConstraints *other) {
   mergeAndAlignIds(offset, this, other);
 }
 
while (currentPos < tmpCst.getNumIds()) {
     // 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++) {
-    tmpCst.FourierMotzkinEliminate(
+    tmpCst.fourierMotzkinEliminate(
         getBestIdToEliminate(tmpCst, 0, tmpCst.getNumIds()));
     // 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 FlatAffineConstraints. This is
     // needed since FM has a worst case exponential complexity in theory.
     if (tmpCst.getNumConstraints() >= kExplosionFactor * getNumIds()) {
       LLVM_DEBUG(llvm::dbgs() << "FM constraint explosion detected\n");

 /// 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 FlatAffineConstraints::GCDTightenInequalities() {
+void FlatAffineConstraints::gcdTightenInequalities() {
   unsigned numCols = getNumCols();
   for (unsigned i = 0, e = getNumInequalities(); i < e; ++i) {
     uint64_t gcd = std::abs(atIneq(i, 0));
     for (unsigned j = 1; j < numCols - 1; ++j) {
       gcd = llvm::GreatestCommonDivisor64(gcd, std::abs(atIneq(i, j)));
     }
     if (gcd > 0 && gcd != 1) {
       int64_t gcdI = static_cast<int64_t>(gcd);
unsigned FlatAffineConstraints::gaussianEliminateIds(unsigned posStart,
                                                      unsigned posLimit) {
   // Return if identifier positions to eliminate are out of range.
   assert(posLimit <= numIds);
   assert(hasConsistentState());
 
   if (posStart >= posLimit)
     return 0;
 
-  GCDTightenInequalities();
+  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(*this, pivotCol, /*isEq=*/true,
                                      &pivotRow)) {
       // No pivot row in equalities with non-zero at 'pivotCol'.
for (pivotCol = posStart; pivotCol < posLimit; ++pivotCol) {
 
     // Eliminate identifier at 'pivotCol' from each inequality row.
     for (unsigned i = 0, e = getNumInequalities(); i < e; ++i) {
       eliminateFromConstraint(this, i, pivotRow, pivotCol, posStart,
                               /*isEq=*/false);
       normalizeConstraintByGCD</*isEq=*/false>(this, i);
     }
     removeEquality(pivotRow);
-    GCDTightenInequalities();
+    gcdTightenInequalities();
   }
   // Update position limit based on number eliminated.
   posLimit = pivotCol;
   // Remove eliminated columns from all constraints.
   removeIdRange(posStart, posLimit);
   return posLimit - posStart;
 }
 
if (!redun[r])
       copyRow(r, pos++);
   }
   inequalities.resizeVertically(pos);
 }
 
 // A more complex check to eliminate redundant inequalities and equalities. Uses
 // Simplex to check if a constraint is redundant.
 void FlatAffineConstraints::removeRedundantConstraints() {
-  // First, we run GCDTightenInequalities. This allows us to catch some
+  // First, we run gcdTightenInequalities. This allows us to catch some
   // constraints which are not redundant when considering rational solutions
   // but are redundant in terms of integer solutions.
-  GCDTightenInequalities();
+  gcdTightenInequalities();
   Simplex simplex(*this);
   simplex.detectRedundant();
 
   auto copyInequality = [&](unsigned src, unsigned dest) {
     if (src == dest)
       return;
     for (unsigned c = 0, e = getNumCols(); c < e; c++)
       atIneq(dest, c) = atIneq(src, c);

 
 /// 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.
 //  Uses a DenseSet to hash and detect duplicates followed by a linear scan to
 //  remove duplicates in place.
 void FlatAffineConstraints::removeTrivialRedundancy() {
-  GCDTightenInequalities();
+  gcdTightenInequalities();
   normalizeConstraintsByGCD();
 
   // A map used to detect redundancy stemming from constraints that only differ
   // in their constant term. The value stored is <row position, const term>
   // for a given row.
   SmallDenseMap<ArrayRef<int64_t>, std::pair<unsigned, int64_t>>
       rowsWithoutConstTerm;
   // To unique rows.

 /// rational shadow / integer light shadow:  1 <= j <= 6
 /// dark shadow:                             3 <= j <= 6
 /// exact integer shadow:                    j = 1 \union  3 <= j <= 6
 /// holes/splinters:                         j = 2
 ///
 /// 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 FlatAffineConstraints::FourierMotzkinEliminate(
+void FlatAffineConstraints::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(hasConsistentState());
 
   // Check if this identifier 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);
       (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();
+  gcdTightenInequalities();
 
   // Check if the identifier 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 == getNumInequalities()) {
for (unsigned l = 0, e = getNumCols(); l < e; l++) {
         continue;
       eq.push_back(atEq(r, l));
     }
     newFac.addEquality(eq);
   }
 
   // GCD tightening and normalization allows detection of more trivially
   // redundant constraints.
-  newFac.GCDTightenInequalities();
+  newFac.gcdTightenInequalities();
   newFac.normalizeConstraintsByGCD();
   newFac.removeTrivialRedundancy();
   clearAndCopyFrom(newFac);
   LLVM_DEBUG(llvm::dbgs() << "FM output:\n");
   LLVM_DEBUG(dump());
 }
 
 #undef DEBUG_TYPE
while (currentPos < getNumIds()) {
     ++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(
+    fourierMotzkinEliminate(
         getBestIdToEliminate(*this, pos, pos + numToEliminate));
   }
 
   // Fast/trivial simplifications.
-  GCDTightenInequalities();
+  gcdTightenInequalities();
   // Normalize constraints after tightening since the latter impacts this, but
   // not the other way round.
   normalizeConstraintsByGCD();
 }
 
 void FlatAffineConstraints::projectOut(Value id) {
   unsigned pos;
   bool ret = findId(id, &pos);
   assert(ret);
   (void)ret;
-  FourierMotzkinEliminate(pos);
+  fourierMotzkinEliminate(pos);
 }
 
 void FlatAffineConstraints::clearConstraints() {
   equalities.resizeVertically(0);
   inequalities.resizeVertically(0);
 }
 
 namespace {
static BoundCmpResult compareBounds(ArrayRef<int64_t> a, ArrayRef<int64_t> b) {
   if (a.back() == b.back())
     return Equal;
 
   return a.back() < b.back() ? Less : Greater;
 }
 } // namespace
 
 // Returns constraints that are common to both A & B.
-static void getCommonConstraints(const FlatAffineConstraints &A,
-                                 const FlatAffineConstraints &B,
-                                 FlatAffineConstraints &C) {
-  C.reset(A.getNumDimIds(), A.getNumSymbolIds(), A.getNumLocalIds());
-  // A naive O(n^2) check should be enough here given the input sizes.
-  for (unsigned r = 0, e = A.getNumInequalities(); r < e; ++r) {
-    for (unsigned s = 0, f = B.getNumInequalities(); s < f; ++s) {
-      if (A.getInequality(r) == B.getInequality(s)) {
-        C.addInequality(A.getInequality(r));
+static void getCommonConstraints(const FlatAffineConstraints &a,
+                                 const FlatAffineConstraints &b,
+                                 FlatAffineConstraints &c) {
+  c.reset(a.getNumDimIds(), a.getNumSymbolIds(), a.getNumLocalIds());
+  // a naive O(n^2) check should be enough here given the input sizes.
+  for (unsigned r = 0, e = a.getNumInequalities(); r < e; ++r) {
+    for (unsigned s = 0, f = b.getNumInequalities(); s < f; ++s) {
+      if (a.getInequality(r) == b.getInequality(s)) {
+        c.addInequality(a.getInequality(r));
         break;
       }
     }
   }
-  for (unsigned r = 0, e = A.getNumEqualities(); r < e; ++r) {
-    for (unsigned s = 0, f = B.getNumEqualities(); s < f; ++s) {
-      if (A.getEquality(r) == B.getEquality(s)) {
-        C.addEquality(A.getEquality(r));
+  for (unsigned r = 0, e = a.getNumEqualities(); r < e; ++r) {
+    for (unsigned s = 0, f = b.getNumEqualities(); s < f; ++s) {
+      if (a.getEquality(r) == b.getEquality(s)) {
+        c.addEquality(a.getEquality(r));
         break;
       }
     }
   }
 }
 
 // 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.