[MLIR] Tidy up documentation for `Shape_JoinOp`, `Shape_ReduceOp`, and `Shape_ConstSizeOp`

[frgossen]

Summary

Fix places that refer to shape.type instead of shape.shape.

Depends On D80277

[herhut]

Thanks for cleaning this up!

[jpienaar]

Thanks

[frgossen]

@silvas, can I land this?

[frgossen]

Rebase

[frgossen]

Rebase

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

def Shape_ConstShapeOp : Shape_Op<"const_shape", [ConstantLike, NoSideEffect]> {
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let hasFolder = 1;
 }
 
 def Shape_ConstSizeOp : Shape_Op<"const_size",
     [ConstantLike,
      NoSideEffect,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
-  let summary = "Creates a constant of !shape.size type.";
+  let summary = "Creates a constant of type `shape.size`";
   let description = [{
-    Creates a !shape.size type representing the constant size given by `value`.
+    Creates a `shape.size` type representing the constant size given by `value`.
 
     ```mlir
     %x = shape.const_size 10
     ```
   }];
 
   let arguments = (ins IndexAttr:$value);
   let results = (outs Shape_SizeType:$result);
def Shape_GetExtentOp : Shape_Op<"get_extent",
   ];
 
   let hasFolder = 1;
 }
 
 def Shape_JoinOp : Shape_Op<"join", []> {
   let summary = "Returns the least general shape.size of its operands";
   let description = [{
-    An operation that computes the least general shape of input operands. This
-    effectively asserts that corresponding static dimensions are equal. The
-    behavior is to match each element of the `shape.type` and propagate the most
-    restrictive information, returning an invalid shape if there are
+    An operation that computes the least general shape of input operands.
+    This effectively asserts that corresponding static dimensions are equal.
+    The behavior is to match each element of the `shape.shape` and propagate the
+    most restrictive information, returning an invalid shape if there are
     contradictory requirements. E.g., using pseudo code
 
     ```
     shape.join([*], [*]) -> [*]
     shape.join([*], [1, ?]) -> [1, ?]
     shape.join([1, 2], [1, ?]) -> [1, 2]
     shape.join([*], [1, 2]) -> [1, 2]
     shape.join([], []) -> []
     shape.join([], [*]) -> []
     shape.join([], [?, ?]) -> [invalid]
     shape.join([1, ?], [2, ?, ?]) -> [invalid]
     ```
 
     `shape.join` also allows specifying an optional error string, that may be
     used to return an error to the user upon mismatch of dimensions.
 
     ```mlir
-    %c = shape.join %a, %b, error="<reason>" : !shape.type
+    %c = shape.join %a, %b, error="<reason>" : !shape.shape
     ```
   }];
 
   let arguments = (ins Shape_ShapeOrSizeType:$arg0, Shape_ShapeOrSizeType:$arg1,
                    OptionalAttr<StrAttr>:$error);
   let results = (outs Shape_ShapeOrSizeType:$result);
 }
 
let description = [{
     }
     ```
 
     Where fn is provided by the user and the result of the reduce op is the
     last computed output of the reduce function. As an example, computing the
     number of elements
 
     ```mlir
-    func @shape_num_elements(%shape : !shape.type) -> !shape.size {
+    func @shape_num_elements(%shape : !shape.shape) -> !shape.size {
       %0 = "shape.constant_dim"() {value = 1 : i32} : () -> !shape.size
       %1 = "shape.reduce"(%shape, %0) ( {
         ^bb0(%index: i32, %dim: !shape.size, %lci: !shape.size):
           %acc = "shape.mul"(%lci, %dim) :
             (!shape.size, !shape.size) -> !shape.size
           shape.yield %acc : !shape.size
-        }) : (!shape.type, !shape.size) -> (!shape.size)
+        }) : (!shape.shape, !shape.size) -> (!shape.size)
       return %1 : !shape.size
     }
     ```
 
     If the shape is unranked, then the results of the op is also unranked.
   }];
 
   let arguments = (ins Shape_ShapeType:$shape, Variadic<AnyType>:$args);