[MLIR][NFC] Fix clang tidy warnings in misc utilities

[bondhugula]

Summary

Fix clang tidy warnings in misc utilities - missing const or a star in
declaration.

[rriddle]

mlir/lib/Transforms/LoopFusion.cpp

366

I've been slightly apprehensive in the past about using * for the iterators, because I feel it exposes internal implementation details of the range.

[bondhugula]

mlir/lib/Transforms/LoopFusion.cpp

366

Okay, I can roll the iterator ones back.

[bondhugula]

Don't use * for the iterators.

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

void AffineDataCopyGeneration::runOnFunction() {
   copyNests.clear();
 
   for (auto &block : f)
     runOnBlock(&block, copyNests);
 
   // Promote any single iteration loops in the copy nests and collect
   // load/stores to simplify.
   SmallVector<Operation *, 4> copyOps;
-  for (auto nest : copyNests)
+  for (Operation *nest : copyNests)
     // With a post order walk, the erasure of loops does not affect
     // continuation of the walk or the collection of load/store ops.
     nest->walk([&](Operation *op) {
       if (auto forOp = dyn_cast<AffineForOp>(op))
         promoteIfSingleIteration(forOp);
       else if (isa<AffineLoadOp, AffineStoreOp>(op))
         copyOps.push_back(op);
     });
 
   // Promoting single iteration loops could lead to simplification of
   // contained load's/store's, and the latter could anyway also be
   // canonicalized.
   OwningRewritePatternList patterns;
   AffineLoadOp::getCanonicalizationPatterns(patterns, &getContext());
   AffineStoreOp::getCanonicalizationPatterns(patterns, &getContext());
-  for (auto op : copyOps)
+  for (Operation *op : copyOps)
     applyOpPatternsAndFold(op, std::move(patterns));
 }

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

 
 /// Returns the outermost affine.for/parallel op that the `ifOp` is invariant
 /// on. The `ifOp` could be hoisted and placed right before such an operation.
 /// This method assumes that the ifOp has been canonicalized (to be correct and
 /// effective).
 static Operation *getOutermostInvariantForOp(AffineIfOp ifOp) {
   // Walk up the parents past all for op that this conditional is invariant on.
   auto ifOperands = ifOp.getOperands();
-  auto res = ifOp.getOperation();
+  auto *res = ifOp.getOperation();
   while (!isa<FuncOp>(res->getParentOp())) {
     auto *parentOp = res->getParentOp();
     if (auto forOp = dyn_cast<AffineForOp>(parentOp)) {
       if (llvm::is_contained(ifOperands, forOp.getInductionVar()))
         break;
     } else if (auto parallelOp = dyn_cast<AffineParallelOp>(parentOp)) {
       for (auto iv : parallelOp.getIVs())
         if (llvm::is_contained(ifOperands, iv))

mlir/lib/Transforms/LoopFusion.cpp

public:
   void removeEdge(unsigned srcId, unsigned dstId, Value value) {
     assert(inEdges.count(dstId) > 0);
     assert(outEdges.count(srcId) > 0);
     if (value.getType().isa<MemRefType>()) {
       assert(memrefEdgeCount.count(value) > 0);
       memrefEdgeCount[value]--;
     }
     // Remove 'srcId' from 'inEdges[dstId]'.
     for (auto it = inEdges[dstId].begin(); it != inEdges[dstId].end(); ++it) {
       if ((*it).id == srcId && (*it).value == value) {
         inEdges[dstId].erase(it);
         break;
       }
     }
     // Remove 'dstId' from 'outEdges[srcId]'.
     for (auto it = outEdges[srcId].begin(); it != outEdges[srcId].end(); ++it) {
       if ((*it).id == dstId && (*it).value == value) {
void forEachMemRefOutputEdge(unsigned id,
     if (outEdges.count(id) > 0)
       forEachMemRefEdge(outEdges[id], callback);
   }
 
   // Calls 'callback' for each edge in 'edges' which carries a memref
   // dependence.
   void forEachMemRefEdge(ArrayRef<Edge> edges,
                          const std::function<void(Edge)> &callback) {
-    for (auto &edge : edges) {
+    for (const auto &edge : edges) {
       // Skip if 'edge' is not a memref dependence edge.
       if (!edge.value.getType().isa<MemRefType>())
         continue;
       assert(nodes.count(edge.id) > 0);
       // Skip if 'edge.id' is not a loop nest.
       if (!isa<AffineForOp>(getNode(edge.id)->op))
         continue;
       // Visit current input edge 'edge'.
       callback(edge);
     }
   }
 
   void print(raw_ostream &os) const {
     os << "\nMemRefDependenceGraph\n";
     os << "\nNodes:\n";
-    for (auto &idAndNode : nodes) {
+    for (const auto &idAndNode : nodes) {
       os << "Node: " << idAndNode.first << "\n";
       auto it = inEdges.find(idAndNode.first);
       if (it != inEdges.end()) {
         for (const auto &e : it->second)
           os << "  InEdge: " << e.id << " " << e.value << "\n";
       }
       it = outEdges.find(idAndNode.first);
       if (it != outEdges.end()) {

mlir/lib/Transforms/Utils/LoopFusionUtils.cpp

opX->walk([&](Operation *op) {
       if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op)) {
         if (isDependentLoadOrStoreOp(op, values)) {
           lastDepOp = opX;
           return WalkResult::interrupt();
         }
         return WalkResult::advance();
       }
       for (auto value : op->getResults()) {
-        for (auto user : value.getUsers()) {
+        for (Operation *user : value.getUsers()) {
           SmallVector<AffineForOp, 4> loops;
           // Check if any loop in loop nest surrounding 'user' is 'opB'.
           getLoopIVs(*user, &loops);
           if (llvm::is_contained(loops, cast<AffineForOp>(opB))) {
             lastDepOp = opX;
             return WalkResult::interrupt();
           }
         }

mlir/lib/Transforms/Utils/LoopUtils.cpp

 }
 
 // Traverse the interTile and intraTile loops and try to hoist ops such that
 // bands of perfectly nested loops are isolated.
 // Return failure if either perfect interTile or perfect intraTile bands cannot
 // be formed.
 static LogicalResult tryIsolateBands(const TileLoops &tileLoops) {
   LogicalResult status = success();
-  auto &interTile = tileLoops.first;
-  auto &intraTile = tileLoops.second;
+  const Loops &interTile = tileLoops.first;
+  const Loops &intraTile = tileLoops.second;
   auto size = interTile.size();
   assert(size == intraTile.size());
   if (size <= 1)
     return success();
   for (unsigned s = 1; s < size; ++s)
     status = succeeded(status) ? hoistOpsBetween(intraTile[0], intraTile[s])
                                : failure();
   for (unsigned s = 1; s < size; ++s)
block->walk(begin, end, [&](Operation *opInst) {
     // region in the other list if one exists (write in case of read and vice
     // versa) since there is a single bounding box for a memref across all reads
     // and writes that happen on it.
 
     // Attempts to update; returns true if 'region' exists in targetRegions.
     auto updateRegion =
         [&](const SmallMapVector<Value, std::unique_ptr<MemRefRegion>, 4>
                 &targetRegions) {
-          auto it = targetRegions.find(region->memref);
+          const auto it = targetRegions.find(region->memref);
           if (it == targetRegions.end())
             return false;
 
           // Perform a union with the existing region.
           if (failed(it->second->unionBoundingBox(*region))) {
             LLVM_DEBUG(llvm::dbgs()
                        << "Memory region bounding box failed; "
                           "over-approximating to the entire memref\n");