Use index for shape.to_extent_tensor

[silvas]

Summary

Also,

• add IndexTensor to OpBase.td
• fix typo in the op name. It was mistakenly to_tensor instead of to_extent_tensor.

[rriddle]

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

184

This seems to hint at a lack of coverage/usage in general.

[silvas]

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

184

That's exactly why I'm pushing for the TCF/TCP/npcomp stuff. Otherwise we'll always be in this awkward dance where we are incrementally adding random stuff here based on out-of-tree usage.

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

let description = [{
     resulting shape equals the number of elements in the tensor, and the
     extents match the values of the elements.
   }];
 
   let arguments = (ins I32Tensor:$input);
   let results = (outs Shape_ShapeType:$result);
 }
 
-def Shape_ToExtentTensorOp : Shape_Op<"to_tensor", []> {
+def Shape_ToExtentTensorOp : Shape_Op<"to_extent_tensor", []> {
   let summary = "Creates a dimension tensor from a shape";
   // TODO: Think more about the error situation. Perhaps factor out the
   // error detection into a separate op so downstream consumers can control
   // their error behavior. Then this op would assume that the input has
   // been properly checked to not be an error (and could thus be a
   // NoSideEffect op).
   let description = [{
     Converts a shape to a 1D integral tensor of extents. The number of elements
     in the tensor equals the rank of the shape, and the elements equal the
     extents of the shape.
 
     If the shape represents an error, then this op currently aborts the program.
   }];
 
   let arguments = (ins Shape_ShapeType:$input);
-  let results = (outs I32Tensor:$result);
+  let results = (outs IndexTensor:$result);
 }
 
 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

mlir/include/mlir/IR/OpBase.td

 
 def AnyStaticShapeTensor : StaticShapeTensorOf<[AnyType]>;
 
 def I1Tensor   : TensorOf<[I1]>;
 def I8Tensor   : TensorOf<[I8]>;
 def I16Tensor  : TensorOf<[I16]>;
 def I32Tensor  : TensorOf<[I32]>;
 def I64Tensor  : TensorOf<[I64]>;
+def IndexTensor: TensorOf<[Index]>;
 
 def BF16Tensor : TensorOf<[BF16]>;
 def F16Tensor  : TensorOf<[F16]>;
 def F32Tensor  : TensorOf<[F32]>;
 def F64Tensor  : TensorOf<[F64]>;
 
 // Ranked tensor type with one of the specified types and ranks.
 class TensorRankOf<list<Type> allowedTypes, list<int> ranks> :