[mlir][SCF][bufferize] Small simplification and more comments

mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp

struct ParallelInsertSliceOpInterface
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }
 
   LogicalResult resolveConflicts(Operation *op, RewriterBase &rewriter,
                                  const AnalysisState &state) const {
+    // RaW conflicts are resolved as part of ForeachThreadOp.
     return success();
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     OpBuilder::InsertionGuard g(rewriter);
     auto insertOp = cast<ParallelInsertSliceOp>(op);
     auto performConcurrentlyOp = cast<PerformConcurrentlyOp>(op->getParentOp());
     auto foreachThreadOp =
         cast<ForeachThreadOp>(performConcurrentlyOp->getParentOp());
 
-    // If the op bufferizes out-of-place, allocate the copy before the
-    // ForeachThreadOp.
-    rewriter.setInsertionPoint(foreachThreadOp);
+    // Get destination buffer.
     FailureOr<Value> destBuffer =
         getBuffer(rewriter, insertOp.getDest(), options);
     if (failed(destBuffer))
       return failure();
 
     // Bufferize the ParallelInsertSliceOp outside of the PerformConcurrentlyOp.
     rewriter.setInsertionPoint(performConcurrentlyOp);
     FailureOr<Value> srcBuffer =
         getBuffer(rewriter, insertOp.getSource(), options);
     if (failed(srcBuffer))
       return failure();
     Value subview = rewriter.create<memref::SubViewOp>(
         insertOp.getLoc(), *destBuffer, insertOp.getMixedOffsets(),
         insertOp.getMixedSizes(), insertOp.getMixedStrides());
     // This memcpy will fold away if everything bufferizes in-place.
     if (failed(options.createMemCpy(rewriter, insertOp.getLoc(), *srcBuffer,
                                     subview)))
       return failure();
     rewriter.eraseOp(op);
 
     // Replace all uses of ForeachThreadOp (just the corresponding result).
     rewriter.setInsertionPointAfter(foreachThreadOp);
     Value toTensorOp =
         rewriter.create<ToTensorOp>(foreachThreadOp.getLoc(), *destBuffer);
+    // PerformConcurrentlyOp can have multiple ParallelInserSliceOps. Find the
+    // index of `op` within yielding ops.
     unsigned resultNum = 0;
     for (Operation &nextOp : performConcurrentlyOp.yieldingOps()) {
       if (&nextOp == op)
         break;
       resultNum++;
     }
     assert(resultNum < foreachThreadOp->getNumResults() &&
            "ParallelInsertSliceOp not found in PerformConcurrentlyOp");