[MLIR] remove dead affine.applys while generating pointwise copies

[bondhugula]

Summary

This makes no impact on the test cases because affine-data-copy-generate
runs whole function canonicalization at its end; however, the latter
will be removed in a pending revision. It is thus useful to clean up
these affine.applys right here, and eventually, not even generate
these (when the right API to compose by construction is in place).

mlir/lib/Transforms/Utils/LoopUtils.cpp

generatePointWiseCopy(Location loc, Value memref, Value fastMemRef,
   unsigned rank = memref.getType().cast<MemRefType>().getRank();
   assert(lbMaps.size() == rank && "wrong number of lb maps");
   assert(ubMaps.size() == rank && "wrong number of ub maps");
 
   SmallVector<Value, 4> memIndices;
   SmallVector<AffineExpr, 4> fastBufExprs;
   SmallVector<Value, 4> fastBufMapOperands;
   AffineForOp copyNestRoot;
+  SmallVector<AffineApplyOp, 4> mayBeDeadApplys;
   for (unsigned d = 0; d < rank; ++d) {
     auto forOp = createCanonicalizedAffineForOp(b, loc, lbOperands, lbMaps[d],
                                                 ubOperands, ubMaps[d]);
     if (d == 0)
       copyNestRoot = forOp;
 
     b = forOp.getBodyBuilder();
 
     auto fastBufOffsetMap =
         AffineMap::get(lbOperands.size(), 0, {fastBufOffsets[d]});
     auto offset = b.create<AffineApplyOp>(loc, fastBufOffsetMap, lbOperands);
 
     // Construct the subscript for the fast memref being copied into/from:
     // x - offset_x.
     fastBufExprs.push_back(b.getAffineDimExpr(2 * d + 1) -
                            b.getAffineDimExpr(2 * d));
     fastBufMapOperands.push_back(offset);
     fastBufMapOperands.push_back(forOp.getInductionVar());
+    mayBeDeadApplys.push_back(offset);
 
     // Subscript for the slow memref being copied.
     memIndices.push_back(forOp.getInductionVar());
   }
 
   auto fastBufMap = AffineMap::get(2 * rank, /*symbolCount=*/0, fastBufExprs);
   fullyComposeAffineMapAndOperands(&fastBufMap, &fastBufMapOperands);
   fastBufMap = simplifyAffineMap(fastBufMap);
   canonicalizeMapAndOperands(&fastBufMap, &fastBufMapOperands);
 
+  // Drop any dead affine.applys.
+  for (auto applyOp : mayBeDeadApplys)
+    if (applyOp.use_empty())
+      applyOp.erase();
+
   if (!isCopyOut) {
     // Copy in.
     auto load = b.create<AffineLoadOp>(loc, memref, memIndices);
     b.create<AffineStoreOp>(loc, load, fastMemRef, fastBufMap,
                             fastBufMapOperands);
     return copyNestRoot;
   }
 
static AffineIfOp createSeparationCondition(MutableArrayRef<AffineForOp> loops,
   // Remove constraints that are independent of these loop IVs.
   cst.removeIndependentConstraints(/*pos=*/0, /*num=*/loops.size());
 
   // Construct the constraint set representing the guard for full tiles. The
   // 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;
+    (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() -
                                1);
     unsigned fullTileLbPos, fullTileUbPos;
     if (!cst.getConstantBoundOnDimSize(0, /*lb=*/nullptr,
                                        /*lbFloorDivisor=*/nullptr,