[MLIR][Bufferization] Improve documentation of introduction and `summary`s

[rikhuijzer]

Summary

This patch suggests to add a sentence in the introduction which clarifies
the aim of the dialect in one sentence. I hope that I understood it correctly.

For the summary fields, I have scrolled through the Bufferization page
(https://mlir.llvm.org/docs/Bufferization) and added missing summaries
or standardized existing ones to make the summaries easier to read.

[aartbik]

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

211

this is not just for sparse storage format

(seems a copy and past from when we merged dense/sparse tensor bufferization ops)

[springerm]

looks good with Aart's comment addressed

[rikhuijzer]

Update outdated sentence

Thanks both Aart Bik and Matthias Springer for reviewing this patch.

If you agree with the patch after this change, feel free to commit since
I do not have permissions for that.

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationBase.td

 include "mlir/IR/OpBase.td"
 
 def Bufferization_Dialect : Dialect {
   let name = "bufferization";
   let cppNamespace = "::mlir::bufferization";
   let description = [{
     Bufferization in MLIR is the process of converting the `tensor` type to the
     `memref` type.
-    The `bufferization` dialect is intended to collect operations/interfaces
-    specific to the bufferization passes.
+    Simply put, bufferization is the process of converting computations on the
+    mathematical tensor construct to computations on physical memory buffers.
+    The `bufferization` dialect contains operations/interfaces specific to the
+    bufferization passes.
 
-    Overview of the bufferization infrastructure and important conceptual
+    An overview of the bufferization infrastructure and important conceptual
     details related to using the MLIR dialect conversion infrastructure can be
     found in [bufferization](/docs/Bufferization/) and [buffer
     deallocation](/docs/BufferDeallocationInternals/).
   }];
   let dependentDialects = [
     "affine::AffineDialect", "memref::MemRefDialect", "tensor::TensorDialect"
   ];
 

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

 
 //===----------------------------------------------------------------------===//
 // AllocTensorOp
 //===----------------------------------------------------------------------===//
 
 def Bufferization_AllocTensorOp : Bufferization_Op<"alloc_tensor",
     [AttrSizedOperandSegments, BufferizableOpInterface,
      DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>]> {
-  let summary = "buffer allocation in tensor land";
+  let summary = "allocate buffer for a tensor";
 
   let description = [{
     `bufferization.alloc_tensor` materializes an uninitialized tensor with a
     given shape (dynamic or static). It always bufferizes to a new buffer
     allocation of the given shape. The optional `copy` operand specifies the
     contents of the tensors. If no `copy` operand is specified, reading from the
     result of an `alloc_tensor` op yields an undefined value.
 
def Bufferization_CloneOp : Bufferization_Op<"clone", [
     DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
     DeclareOpInterfaceMethods<AllocationOpInterface, ["buildDealloc", "buildClone"]>
   ]> {
   let builders = [
     OpBuilder<(ins "Value":$value), [{
       return build($_builder, $_state, value.getType(), value);
     }]>];
 
+  let summary = "clone a memref";
   let description = [{
     Clones the data in the input view into an implicitly defined output view.
 
     Usage:
 
     ```mlir
     %arg1 = bufferization.clone %arg0 : memref<?xf32> to memref<?xf32>
     ```

 }
 
 //===----------------------------------------------------------------------===//
 // DeallocTensorOp
 //===----------------------------------------------------------------------===//
 
 def Bufferization_DeallocTensorOp : Bufferization_Op<"dealloc_tensor",
     [BufferizableOpInterface]> {
-  string summary = "Releases underlying sparse storage format of given tensor";
+  string summary = "release underlying storage format of given tensor";
   string description = [{
     `bufferization.dealloc_tensor` is a buffer deallocation in tensor land. This
     op can be used for manual buffer deallocation. Some bufferizations (such as
     One-Shot Bufferize) take care of buffer deallocation, in which case this op
     is usually not needed. Details can be found in the documentation of the
     respective bufferization passes.
 
     In case of a dense tensor, this op lowers to a `memref.dealloc` op during

 def Bufferization_ToTensorOp : Bufferization_Op<"to_tensor", [
     BufferizableOpInterface,
     SameOperandsAndResultShape,
     SameOperandsAndResultElementType,
     TypesMatchWith<"result type matches tensor equivalent of 'memref'",
                    "memref", "result",
                    "memref::getTensorTypeFromMemRefType($_self)">
   ]> {
-  let summary = "memref to tensor operation";
+  let summary = "create a tensor from a `memref`";
   let description = [{
     An operation that creates a tensor from a `memref`. The result value is a
     tensor whose shape and element type match the memref operand.
 
     The opposite of this op is `to_memref`. Together, these two ops are
     useful for source/target materializations when doing type conversions
     involving tensors and memrefs.
 
def Bufferization_ToMemrefOp : Bufferization_Op<"to_memref", [
     BufferizableOpInterface,
     SameOperandsAndResultShape,
     SameOperandsAndResultElementType,
     Pure,
     TypesMatchWith<"type of 'tensor' is the tensor equivalent of 'memref'",
                    "memref", "tensor",
                    "memref::getTensorTypeFromMemRefType($_self)">
   ]> {
-  let summary = "tensor to memref cast operation";
+  let summary = "cast a tensor to memref";
   let description = [{
     An operation that returns the future buffer of a `tensor`.
 
     ```mlir
     // Result type is memref<4x?xf32, #layout, 0>
     %m = bufferization.to_memref %t : memref<4x?xf32, #layout, 0>
     ```