[mlir][sparse] fixed bug in verification

[aartbik]

Summary

The order of testing in two sparse tensor ops was incorrect,
which could cause an invalid cast (crashing the compiler instead
of reporting the error). This revision fixes that bug.

[gussmith23]

Great catch!

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

 
 static LogicalResult verify(NewOp op) {
   if (!getSparseTensorEncoding(op.getResult().getType()))
     return op.emitError("expected a sparse tensor result");
   return success();
 }
 
 static LogicalResult verify(ToPointersOp op) {
+  if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
     if (failed(isInBounds(op.dim(), op.tensor())))
       return op.emitError("requested pointers dimension out of bounds");
-  if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
     if (failed(isMatchingWidth(op.result(), e.getPointerBitWidth())))
       return op.emitError("unexpected type for pointers");
     return success();
   }
   return op.emitError("expected a sparse tensor to get pointers");
 }
 
 static LogicalResult verify(ToIndicesOp op) {
+  if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
     if (failed(isInBounds(op.dim(), op.tensor())))
       return op.emitError("requested indices dimension out of bounds");
-  if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
     if (failed(isMatchingWidth(op.result(), e.getIndexBitWidth())))
       return op.emitError("unexpected type for indices");
     return success();
   }
   return op.emitError("expected a sparse tensor to get indices");
 }
 
 static LogicalResult verify(ToValuesOp op) {

mlir/test/Dialect/SparseTensor/invalid.mlir

func @invalid_pointers_dense(%arg0: tensor<128xf64>) -> memref<?xindex> {
   %c = constant 0 : index
   // expected-error@+1 {{expected a sparse tensor to get pointers}}
   %0 = sparse_tensor.pointers %arg0, %c : tensor<128xf64> to memref<?xindex>
   return %0 : memref<?xindex>
 }
 
 // -----
 
+func @invalid_pointers_unranked(%arg0: tensor<*xf64>) -> memref<?xindex> {
+  %c = constant 0 : index
+  // expected-error@+1 {{expected a sparse tensor to get pointers}}
+  %0 = sparse_tensor.pointers %arg0, %c : tensor<*xf64> to memref<?xindex>
+  return %0 : memref<?xindex>
+}
+
+// -----
+
 #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"], pointerBitWidth=32}>
 
 func @mismatch_pointers_types(%arg0: tensor<128xf64, #SparseVector>) -> memref<?xindex> {
   %c = constant 0 : index
   // expected-error@+1 {{unexpected type for pointers}}
   %0 = sparse_tensor.pointers %arg0, %c : tensor<128xf64, #SparseVector> to memref<?xindex>
   return %0 : memref<?xindex>
 }
func @invalid_indices_dense(%arg0: tensor<10x10xi32>) -> memref<?xindex> {
   %c = constant 1 : index
   // expected-error@+1 {{expected a sparse tensor to get indices}}
   %0 = sparse_tensor.indices %arg0, %c : tensor<10x10xi32> to memref<?xindex>
   return %0 : memref<?xindex>
 }
 
 // -----
 
+func @invalid_indices_unranked(%arg0: tensor<*xf64>) -> memref<?xindex> {
+  %c = constant 0 : index
+  // expected-error@+1 {{expected a sparse tensor to get indices}}
+  %0 = sparse_tensor.indices %arg0, %c : tensor<*xf64> to memref<?xindex>
+  return %0 : memref<?xindex>
+}
+
+// -----
+
 #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
 
 func @mismatch_indices_types(%arg0: tensor<?xf64, #SparseVector>) -> memref<?xi32> {
   %c = constant 0 : index
   // expected-error@+1 {{unexpected type for indices}}
   %0 = sparse_tensor.indices %arg0, %c : tensor<?xf64, #SparseVector> to memref<?xi32>
   return %0 : memref<?xi32>
 }