[mlir][sparse] some leftover cleanup from migration to bufferization dialect

[pifon2a]

Thank you!

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

 
 def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor, Index:$dim)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts pointers array at given dimension from a tensor";
   let description = [{
     Returns the pointers array of the sparse storage format at the
     given dimension for the given sparse tensor. This is similar to the
-    `memref.buffer_cast` operation in the sense that it provides a bridge
+    `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
-    `memref.buffer_cast` operation, however, this sparse operation actually
+    `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into a call into a support library to obtain access to the
     pointers array.
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.pointers %0, %c1
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
       " `to` type($result)";
 }
 
 def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor, Index:$dim)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts indices array at given dimension from a tensor";
   let description = [{
     Returns the indices array of the sparse storage format at the
     given dimension for the given sparse tensor. This is similar to the
-    `memref.buffer_cast` operation in the sense that it provides a bridge
+    `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
-    `memref.buffer_cast` operation, however, this sparse operation actually
+    `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into a call into a support library to obtain access to the
     indices array.
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.indices %0, %c1
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
       " `to` type($result)";
 }
 
 def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts numerical values array from a tensor";
   let description = [{
     Returns the values array of the sparse storage format for the given
     sparse tensor, independent of the actual dimension. This is similar to
-    the `memref.buffer_cast` operation in the sense that it provides a bridge
+    the `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
-    `memref.buffer_cast` operation, however, this sparse operation actually
+    `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into a call into a support library to obtain access to the
     values array.
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.values %0 : tensor<64x64xf64, #CSR> to memref<?xf64>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Management Operations. These operations are "impure" in the
 // sense that they do not properly operate on SSA values. Instead, the behavior
 // is solely defined by side-effects. These operations provide a bridge between
 // the code generator and the support library. The semantics of these operations
 // may be refined over time as our sparse abstractions evolve.
 //===----------------------------------------------------------------------===//
 
 def SparseTensor_LexInsertOp : SparseTensor_Op<"lex_insert", []>,
     Arguments<(ins AnyTensor:$tensor,
                StridedMemRefRankOf<[Index], [1]>:$indices,
-         AnyType:$value)> {
+               AnyType:$value)> {
   string summary = "Inserts a value into given sparse tensor in lexicograph index order";
   string description = [{
     Inserts the given value at given indices into the underlying sparse
     storage format of the given tensor with the given indices. This
     operation can only be applied when a tensor materializes unintialized
     with an `init` operation, the insertions occur in strict lexicographic
     index order, and the final tensor is constructed with a `tensor`
     operation that has the `hasInserts` attribute set.

 
 def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
     Arguments<(ins AnyTensor:$tensor, UnitAttr:$hasInserts)>,
     Results<(outs AnyTensor:$result)> {
   let summary =
     "Rematerializes tensor from underlying sparse storage format";
   let description = [{
     Rematerializes a tensor from the underlying sparse storage format of the
-    given tensor. This is similar to the `memref.load` operation in the sense
-    that it provides a bridge between a bufferized world view and a tensor
-    world view. Unlike the `memref.load` operation, however, this sparse
-    operation is used only temporarily to maintain a correctly typed
-    intermediate representation during progressive bufferization.
+    given tensor. This is similar to the `bufferization.to_tensor` operation
+    in the sense that it provides a bridge between a bufferized world view
+    and a tensor world view. Unlike the `bufferization.to_tensor` operation,
+    however, this sparse operation is used only temporarily to maintain a
+    correctly typed intermediate representation during progressive
+    bufferization.
 
     The `hasInserts` attribute denote whether insertions to the underlying
     sparse storage format may have occurred, in which case the underlying
     sparse storage format needs to be finalized. Otherwise, the operation
     simply folds away.
 
     Note that this operation is "impure" in the sense that its behavior
     is solely defined by side-effects and not SSA values. The semantics