[mlir][sparse] Adjusting error message wording, to better match new field names

[wrengr]

Summary

This is a followup to D150330, split out because it's not purely mechanical.

Depends On D150330

[wrengr]

git-clang-format

[wrengr]

rebase

[wrengr]

Fixing test/Dialect/SparseTensor/GPU/gpu_matvec_lib.mlir

[wrengr]

I've moved that test fix to D150822, and will rebase this differential once that lands

[wrengr]

rebased over D150822

[wrengr]

rebased over D150830

[wrengr]

rebase

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

while (succeeded(parser.parseOptionalKeyword(&attrName))) {
     // FIXME: using `operator==` below duplicates the string comparison
     // cost of the `is_contained` check above. Should instead use some
     // "find" function that returns the index into `keys` so that we can
     // dispatch on that instead.
     if (attrName == "lvlTypes") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr));
       auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr);
-      ERROR_IF(!arrayAttr, "expected an array for dimension level types")
+      ERROR_IF(!arrayAttr, "expected an array for lvlTypes")
       for (auto i : arrayAttr) {
         auto strAttr = llvm::dyn_cast<StringAttr>(i);
-        ERROR_IF(!strAttr, "expected a string value in dimension level types")
+        ERROR_IF(!strAttr, "expected a string value in lvlTypes")
         auto strVal = strAttr.getValue();
         if (auto optDLT = parseDLT(strVal)) {
           lvlTypes.push_back(optDLT.value());
         } else {
-          parser.emitError(parser.getNameLoc(),
-                           "unexpected dimension level type: ")
+          parser.emitError(parser.getNameLoc(), "unexpected level-type: ")
               << strVal;
           return {};
         }
       }
     } else if (attrName == "dimOrdering") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
       auto affineAttr = llvm::dyn_cast<AffineMapAttr>(attr);
if (!acceptBitWidth(crdWidth))
     return emitError() << "unexpected coordinate bitwidth: " << crdWidth;
   // Before we can check that the level-rank is consistent/coherent
   // across all fields, we need to define it.  The source-of-truth for
   // the `getLvlRank` method is the length of the level-types array,
   // since it must always be provided and have full rank; therefore we
   // use that same source-of-truth here.
   const Level lvlRank = lvlTypes.size();
   if (lvlRank == 0)
-    return emitError() << "expected a non-empty array for level types";
+    return emitError() << "expected a non-empty array for lvlTypes";
   if (dimOrdering) {
     if (!dimOrdering.isPermutation())
       return emitError()
              << "expected a permutation affine map for dimension ordering";
     if (dimOrdering.getNumResults() != lvlRank)
-      return emitError() << "unexpected mismatch in ordering and dimension "
-                            "level types size";
+      return emitError()
+             << "level-rank mismatch between dimOrdering and lvlTypes";
   }
   if (higherOrdering) {
     if (higherOrdering.getNumDims() >= higherOrdering.getNumResults())
       return emitError() << "unexpected higher ordering mapping from "
                          << higherOrdering.getNumDims() << " to "
                          << higherOrdering.getNumResults();
     if (higherOrdering.getNumResults() != lvlRank)
-      return emitError() << "unexpected mismatch in higher ordering and "
-                            "dimension level types size";
+      return emitError()
+             << "level-rank mismatch between higherOrdering and lvlTypes";
   }
   if (!dimSlices.empty() && dimSlices.size() != lvlRank) {
-    return emitError() << "unexpected mismatch in dimension slices and "
-                          "dimension level type size";
+    return emitError() << "level-rank mismatch between dimSlices and lvlTypes";
   }
   return success();
 }
 
 #define RETURN_FAILURE_IF_FAILED(X)                                            \
   if (failed(X)) {                                                             \
     return failure();                                                          \
   }
if (dimRank == 0)
     return emitError() << "expected non-scalar sparse tensor";
   if (const auto higherOrdering = getHigherOrdering()) {
     if (higherOrdering.getNumDims() != dimRank)
       return emitError() << "expected an affine map with " << dimRank
                          << " dimensions for higher ordering";
     // TODO: verification of higher ordering contents
   } else if (dimRank != getLvlRank()) {
     return emitError() << "expected an array of size " << dimRank
-                       << " for dimension level types";
+                       << " for lvlTypes";
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Convenience Methods.
 //===----------------------------------------------------------------------===//
 

mlir/test/Dialect/SparseTensor/invalid_encoding.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
-// expected-error@+1 {{expected a non-empty array for level types}}
+// expected-error@+1 {{expected a non-empty array for lvlTypes}}
 #a = #sparse_tensor.encoding<{lvlTypes = []}>
 func.func private @scalar(%arg0: tensor<f64, #a>) -> ()
 
 // -----
 
 #a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
-func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> () // expected-error {{expected an array of size 1 for dimension level types}}
+func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> () // expected-error {{expected an array of size 1 for lvlTypes}}
 
 // -----
 
-#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimOrdering = affine_map<(i) -> (i)>}> // expected-error {{unexpected mismatch in ordering and dimension level types size}}
+#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimOrdering = affine_map<(i) -> (i)>}> // expected-error {{level-rank mismatch between dimOrdering and lvlTypes}}
 func.func private @tensor_sizes_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
-#a = #sparse_tensor.encoding<{lvlTypes = [1]}> // expected-error {{expected a string value in dimension level types}}
+#a = #sparse_tensor.encoding<{lvlTypes = [1]}> // expected-error {{expected a string value in lvlTypes}}
 func.func private @tensor_type_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
-#a = #sparse_tensor.encoding<{lvlTypes = ["strange"]}> // expected-error {{unexpected dimension level type: strange}}
+#a = #sparse_tensor.encoding<{lvlTypes = ["strange"]}> // expected-error {{unexpected level-type: strange}}
 func.func private @tensor_value_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
 #a = #sparse_tensor.encoding<{dimOrdering = "wrong"}> // expected-error {{expected an affine map for dimension ordering}}
 func.func private @tensor_dimorder_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----