[mlir][sparse] Adding nodiscard annotations to `isWF`/`isValid` predicates

[wrengr]

Summary

Depends On D156001

mlir/lib/Dialect/SparseTensor/IR/Detail/DimLvlMap.h

public:
   std::optional<int64_t> tryGetConstantValue() const;
   bool hasConstantValue(int64_t val) const;
   DimLvlExpr getLHS() const;
   DimLvlExpr getRHS() const;
   std::tuple<DimLvlExpr, AffineExprKind, DimLvlExpr> unpackBinop() const;
 
   /// Checks whether the variables bound/used by this spec are valid
   /// with respect to the given ranks.
-  bool isValid(Ranks const &ranks) const;
+  [[nodiscard]] bool isValid(Ranks const &ranks) const;
 
   void print(llvm::raw_ostream &os) const;
   void print(AsmPrinter &printer) const;
   void dump() const;
 
 protected:
   // Variant of `mlir::AsmPrinter::Impl::BindingStrength`
   enum class BindingStrength : bool { Weak = false, Strong = true };
public:
   constexpr bool canElideExpr() const { return elideExpr; }
   void setElideExpr(bool b) { elideExpr = b; }
   constexpr SparseTensorDimSliceAttr getSlice() const { return slice; }
 
   /// Checks whether the variables bound/used by this spec are valid with
   /// respect to the given ranks.  Note that null `DimExpr` is considered
   /// to be vacuously valid, and therefore calling `setExpr` invalidates
   /// the result of this predicate.
-  bool isValid(Ranks const &ranks) const;
+  [[nodiscard]] bool isValid(Ranks const &ranks) const;
 
   // TODO(wrengr): Use it or loose it.
   bool isFunctionOf(Var var) const;
   bool isFunctionOf(VarSet const &vars) const;
   void getFreeVars(VarSet &vars) const;
 
   void print(llvm::raw_ostream &os, bool wantElision = true) const;
   void print(AsmPrinter &printer, bool wantElision = true) const;
public:
   constexpr LvlExpr getExpr() const { return expr; }
   constexpr DimLevelType getType() const { return type; }
 
   /// Checks whether the variables bound/used by this spec are valid
   /// with respect to the given ranks.
   //
   // NOTE: Once we introduce "counting expressions" this will need
   // a more sophisticated implementation than `DimSpec::isValid` does.
-  bool isValid(Ranks const &ranks) const;
+  [[nodiscard]] bool isValid(Ranks const &ranks) const;
 
   // TODO(wrengr): Use it or loose it.
   bool isFunctionOf(Var var) const;
   bool isFunctionOf(VarSet const &vars) const;
   void getFreeVars(VarSet &vars) const;
 
   void print(llvm::raw_ostream &os, bool wantElision = true) const;
   void print(AsmPrinter &printer, bool wantElision = true) const;
   void dump() const;
 };
 // Although this class is more than just a newtype/wrapper, we do want
 // to ensure that storing them into `SmallVector` is efficient.
 static_assert(IsZeroCostAbstraction<LvlSpec>);
 
 //===----------------------------------------------------------------------===//
 class DimLvlMap final {
   // TODO(wrengr): Need to define getters
   unsigned symRank;
   SmallVector<DimSpec> dimSpecs;
   SmallVector<LvlSpec> lvlSpecs;
 
   // Checks for integrity of variable-binding structure.
   // This is already called by the ctor.
-  bool isWF() const;
+  [[nodiscard]] bool isWF() const;
 
 public:
   DimLvlMap(unsigned symRank, ArrayRef<DimSpec> dimSpecs,
             ArrayRef<LvlSpec> lvlSpecs);
 
   unsigned getSymRank() const { return symRank; }
   unsigned getDimRank() const { return dimSpecs.size(); }
   unsigned getLvlRank() const { return lvlSpecs.size(); }

mlir/lib/Dialect/SparseTensor/IR/Detail/Var.h

 ///
 /// NOTE: The numerical values used to represent this enum should be
 /// treated as an implementation detail, not as part of the API.  In the
 /// API below we use the canonical ordering `{Symbol,Dimension,Level}` even
 /// though that does not agree with the numerical ordering of the numerical
 /// representation.
 enum class VarKind { Symbol = 1, Dimension = 0, Level = 2 };
 
-constexpr bool isWF(VarKind vk) {
+[[nodiscard]] constexpr bool isWF(VarKind vk) {
   const auto vk_ = to_underlying(vk);
   return 0 <= vk_ && vk_ <= 2;
 }
 
 /// Swaps `Dimension` and `Level`, but leaves `Symbol` the same.
 constexpr VarKind flipVarKind(VarKind vk) {
   return VarKind{2 - to_underlying(vk)};
 }
private:
   static constexpr Num kMaxNum =
       static_cast<Num>(std::numeric_limits<Storage>::max() >> 3);
 
 public:
   /// Checks whether the number would be accepted by `Var(VarKind,Var::Num)`.
   //
   // This must be public for `VarInfo` to use it (whereas we don't want
   // to expose the `impl` field via friendship).
-  static constexpr bool isWF_Num(Num n) { return n <= kMaxNum; }
+  [[nodiscard]] static constexpr bool isWF_Num(Num n) { return n <= kMaxNum; }
 
 protected:
   /// The underlying implementation of `Var`.  Note that this must be kept
   /// distinct from `Var` itself, since we want to ensure that the RTTI
   /// methods will select the `U(Var::Impl)` ctor rather than selecting
   /// the `U(Var::Num)` ctor.
   class Impl final {
     Storage data;
Ranks(VarKindArray<unsigned> const &ranks)
       : Ranks(ranks[VarKind::Symbol], ranks[VarKind::Dimension],
               ranks[VarKind::Level]) {}
 
   constexpr unsigned getRank(VarKind vk) const { return impl[to_index(vk)]; }
   constexpr unsigned getSymRank() const { return getRank(VarKind::Symbol); }
   constexpr unsigned getDimRank() const { return getRank(VarKind::Dimension); }
   constexpr unsigned getLvlRank() const { return getRank(VarKind::Level); }
 
-  constexpr bool isValid(Var var) const {
+  [[nodiscard]] constexpr bool isValid(Var var) const {
     return var.getNum() < getRank(var.getKind());
   }
-  bool isValid(DimLvlExpr expr) const;
+  [[nodiscard]] bool isValid(DimLvlExpr expr) const;
 };
 static_assert(IsZeroCostAbstraction<Ranks>);
 
 //===----------------------------------------------------------------------===//
 /// Efficient representation of a set of `Var`.
 ///
 /// NOTE: For the `contains`/`occursIn` methods: if variables occurring in
 /// the method parameter are OOB for the `VarSet`, then these methods will