[mlir] Fix inconsistency with SparseElementsAttr indices type

[jfurtek]

Summary

This diff fixes the inconsistency between the parameters of the
SparseElementsAttr type and the arguments to the custom builder.

The previous implementation used assert() calls in the builder to ensure
that the indices argument (of type DenseElementsAttr) had an underlying
integer type. This diff changes the builder to use the DenseIntElementsAttr
type for the argument, instead of DenseElementsAttr, making the requirement
on the argument explicit to code that creates the SparseElementsAttr
attribute.

(This was uncovered during a separate effort to add attribute/type parameter
verification, but these changes are independent.)

[rriddle]

mlir/lib/Parser/AttributeParser.cpp

961

cast already asserts that it succeeds (i.e. it never returns nullptr), dyn_cast is the one that is failable.

[jfurtek]

• Remove redundant assert on attribute cast<>()

[jfurtek]

Abandoning - these (trivial) changes have been folded in to the diff below, making this diff redundant.

https://reviews.llvm.org/D126428

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     ```
   }];
 
   let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
                         "DenseIntElementsAttr":$indices,
                         "DenseElementsAttr":$values);
   let builders = [
     AttrBuilderWithInferredContext<(ins "ShapedType":$type,
-                                        "DenseElementsAttr":$indices,
+                                        "DenseIntElementsAttr":$indices,
                                         "DenseElementsAttr":$values), [{
       assert(indices.getType().getElementType().isInteger(64) &&
              "expected sparse indices to be 64-bit integer values");
       assert((type.isa<RankedTensorType, VectorType>()) &&
              "type must be ranked tensor or vector");
       assert(type.hasStaticShape() && "type must have static shape");
-      return $_get(type.getContext(), type,
-                   indices.cast<DenseIntElementsAttr>(), values);
+      return $_get(type.getContext(), type, indices, values);
     }]>,
   ];
   let extraClassDeclaration = [{
     /// The set of data types that can be iterated by this attribute.
     // FIXME: Realistically, SparseElementsAttr could use ElementsAttr for the
     // value storage. This would mean dispatching to `values` when accessing
     // values. For now, we just add the types that can be iterated by
     // DenseElementsAttr.

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

bool mlirAttributeIsASparseElements(MlirAttribute attr) {
   return unwrap(attr).isa<SparseElementsAttr>();
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                           MlirAttribute denseIndices,
                                           MlirAttribute denseValues) {
   return wrap(
       SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
-                              unwrap(denseIndices).cast<DenseElementsAttr>(),
+                              unwrap(denseIndices).cast<DenseIntElementsAttr>(),
                               unwrap(denseValues).cast<DenseElementsAttr>()));
 }
 
 MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SparseElementsAttr>().getIndices());
 }
 
 MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SparseElementsAttr>().getValues());
 }

mlir/lib/Parser/AttributeParser.cpp

if (!type)
       return nullptr;
 
     // Construct the sparse elements attr using zero element indice/value
     // attributes.
     ShapedType indicesType =
         RankedTensorType::get({0, type.getRank()}, indiceEltType);
     ShapedType valuesType = RankedTensorType::get({0}, type.getElementType());
     return getChecked<SparseElementsAttr>(
-        loc, type, DenseElementsAttr::get(indicesType, ArrayRef<Attribute>()),
+        loc, type,
+        DenseIntElementsAttr::get(indicesType, ArrayRef<Attribute>()),
         DenseElementsAttr::get(valuesType, ArrayRef<Attribute>()));
   }
 
   /// Parse the indices. We don't allow hex values here as we may need to use
   /// the inferred shape.
   auto indicesLoc = getToken().getLoc();
   TensorLiteralParser indiceParser(*this);
   if (indiceParser.parse(/*allowHex=*/false))
Attribute Parser::parseSparseElementsAttr(Type attrType) {
   // indice and thus one for the first dimension.
   ShapedType indicesType;
   if (indiceParser.getShape().empty()) {
     indicesType = RankedTensorType::get({1, type.getRank()}, indiceEltType);
   } else {
     // Otherwise, set the shape to the one parsed by the literal parser.
     indicesType = RankedTensorType::get(indiceParser.getShape(), indiceEltType);
   }
-  auto indices = indiceParser.getAttr(indicesLoc, indicesType);
+  auto indices = indiceParser.getAttr(indicesLoc, indicesType)
+                     .cast<DenseIntElementsAttr>();
 
   // If the values are a splat, set the shape explicitly based on the number of
   // indices. The number of indices is encoded in the first dimension of the
   // indice shape type.
   auto valuesEltType = type.getElementType();
   ShapedType valuesType =
       valuesParser.getShape().empty()
           ? RankedTensorType::get({indicesType.getDimSize(0)}, valuesEltType)
           : RankedTensorType::get(valuesParser.getShape(), valuesEltType);
   auto values = valuesParser.getAttr(valuesLoc, valuesType);
 
   // Build the sparse elements attribute by the indices and values.
   return getChecked<SparseElementsAttr>(loc, type, indices, values);
 }