[mlir][sparse] refined doc of sparse tensor ops

[aartbik]

removed empty line at end

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

def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
     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
     `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
-    lowers into a call into a support library to obtain access to the
-    pointers array.
+    lowers into code that extracts the pointers array from the sparse storage
+    scheme (either by calling a support library or through direct code).
 
     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)";
   let hasVerifier = 1;
 }
 
 def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
     Arguments<(ins AnySparseTensor:$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
     `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
-    lowers into a call into a support library to obtain access to the
-    indices array.
+    lowers into code that extracts the indices array from the sparse storage
+    scheme (either by calling a support library or through direct code).
 
     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)";
   let hasVerifier = 1;
 }
 
 def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
     Arguments<(ins AnySparseTensor:$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 `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
-    lowers into a call into a support library to obtain access to the
-    values array.
+    lowers into code that extracts the values array from the sparse storage
+    scheme (either by calling a support library or through direct code).
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.values %0 : tensor<64x64xf64, #CSR> to memref<?xf64>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
def SparseTensor_ConcatenateOp : SparseTensor_Op<"concatenate", []>,
   let assemblyFormat = "$inputs attr-dict `:` type($inputs) `to` type($result)";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 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.
+// "sparsification" on one hand and a support library or actual code generation
+// on the other hand. The semantics of these operations may be refined over time
+// as our sparse abstractions evolve.
 //===----------------------------------------------------------------------===//
 
 def SparseTensor_LexInsertOp : SparseTensor_Op<"lex_insert", []>,
     Arguments<(ins AnySparseTensor:$tensor,
                StridedMemRefRankOf<[Index], [1]>:$indices,
                AnyType:$value)> {
   string summary = "Inserts a value into given sparse tensor in lexicographical index order";
   string description = [{
let description = [{
      %0 = sparse_tensor.storage_set %arg0, %arg1 at 0 : tuple<memref<?xf64>, memref<?xf64>, f64>, memref<?xf64> to tuple<memref<?xf64>, memref<?xf64>, f64>
      ```
    }];
 
   let assemblyFormat = " $storage attr-dict `[`$idx`]``,` $value `:` type($storage) `,` type($value) `to` type($result)";
   let hasVerifier = 1;
 }
 
-
 #endif // SPARSETENSOR_OPS