[mlir][sparse] remove redundant template parameter (NFC)

[Peiming]

Summary

The template parameter is no longer needed after MutSparseTensorDescriptor
is implemented as a subclass of SparseTensorDescriptorImpl. The only purpose
for it was to enable SFINAE.

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorStorageLayout.h

public:
 
   // Undef value for dimension sizes, all zero value for memory sizes.
   static Value getInitValue(OpBuilder &builder, Location loc,
                             RankedTensorType rtp);
 
   /*implicit*/ operator Value() { return specifier; }
 
   Value getSpecifierField(OpBuilder &builder, Location loc,
-                          StorageSpecifierKind kind, Optional<unsigned> dim);
+                          StorageSpecifierKind kind,
+                          std::optional<unsigned> dim);
 
   void setSpecifierField(OpBuilder &builder, Location loc, Value v,
-                         StorageSpecifierKind kind, Optional<unsigned> dim);
+                         StorageSpecifierKind kind,
+                         std::optional<unsigned> dim);
 
-  Type getFieldType(StorageSpecifierKind kind, Optional<unsigned> dim) {
+  Type getFieldType(StorageSpecifierKind kind, std::optional<unsigned> dim) {
     return specifier.getType().getFieldType(kind, dim);
   }
 
 private:
   TypedValue<StorageSpecifierType> specifier;
 };
 
 /// A helper class around an array of values that corresponding to a sparse
void sanityCheck() {
     // We should make sure the class is trivially copyable (and should be small
     // enough) such that we can pass it by value.
     static_assert(
         std::is_trivially_copyable_v<SparseTensorDescriptorImpl<mut>>);
   }
 
 public:
   unsigned getMemRefFieldIndex(SparseTensorFieldKind kind,
-                               Optional<unsigned> dim) const {
+                               std::optional<unsigned> dim) const {
     // Delegates to storage layout.
     StorageLayout<mut> layout(getSparseTensorEncoding(rType));
     return layout.getMemRefFieldIndex(kind, dim);
   }
 
   unsigned getPtrMemRefIndex(unsigned ptrDim) const {
     return getMemRefFieldIndex(SparseTensorFieldKind::PtrMemRef, ptrDim);
   }
public:
   unsigned getNumFields() const { return fields.size(); }
 
   ///
   /// Getters: get the value for required field.
   ///
 
   Value getSpecifierField(OpBuilder &builder, Location loc,
                           StorageSpecifierKind kind,
-                          Optional<unsigned> dim) const {
+                          std::optional<unsigned> dim) const {
     SparseTensorSpecifier md(fields.back());
     return md.getSpecifierField(builder, loc, kind, dim);
   }
 
   Value getDimSize(OpBuilder &builder, Location loc, unsigned dim) const {
     return getSpecifierField(builder, loc, StorageSpecifierKind::DimSize, dim);
   }
 
   Value getPtrMemRef(unsigned ptrDim) const {
     return getMemRefField(SparseTensorFieldKind::PtrMemRef, ptrDim);
   }
 
   Value getIdxMemRef(unsigned idxDim) const {
     return getMemRefField(SparseTensorFieldKind::IdxMemRef, idxDim);
   }
 
   Value getValMemRef() const {
     return getMemRefField(SparseTensorFieldKind::ValMemRef, std::nullopt);
   }
 
   Value getMemRefField(SparseTensorFieldKind kind,
-                       Optional<unsigned> dim) const {
+                       std::optional<unsigned> dim) const {
     return fields[getMemRefFieldIndex(kind, dim)];
   }
 
   Value getMemRefField(unsigned fidx) const {
     assert(fidx < fields.size() - 1);
     return fields[fidx];
   }
 
   Value getField(unsigned fidx) const {
     assert(fidx < fields.size());
     return fields[fidx];
   }
 
   ValueRange getMemRefFields() const {
     ValueRange ret = fields;
     // Drop the last metadata fields.
     return ret.slice(0, fields.size() - 1);
   }
 
   Type getMemRefElementType(SparseTensorFieldKind kind,
-                            Optional<unsigned> dim) const {
+                            std::optional<unsigned> dim) const {
     return getMemRefField(kind, dim)
         .getType()
         .template cast<MemRefType>()
         .getElementType();
   }
 
   RankedTensorType getTensorType() const { return rType; }
   ValueArrayRef getFields() const { return fields; }
return getSpecifierField(builder, loc, StorageSpecifierKind::ValMemSize,
                              std::nullopt);
   }
 
   ///
   /// Setters: update the value for required field (only enabled for
   /// MutSparseTensorDescriptor).
   ///
 
-  template <typename T = Value>
-  void setMemRefField(SparseTensorFieldKind kind, Optional<unsigned> dim, T v) {
+  void setMemRefField(SparseTensorFieldKind kind, std::optional<unsigned> dim,
+                      Value v) {
     fields[getMemRefFieldIndex(kind, dim)] = v;
   }
 
-  template <typename T = Value>
-  void setMemRefField(unsigned fidx, T v) {
+  void setMemRefField(unsigned fidx, Value v) {
     assert(fidx < fields.size() - 1);
     fields[fidx] = v;
   }
 
-  template <typename T = Value>
-  void setField(unsigned fidx, T v) {
+  void setField(unsigned fidx, Value v) {
     assert(fidx < fields.size());
     fields[fidx] = v;
   }
 
-  template <typename T = Value>
   void setSpecifierField(OpBuilder &builder, Location loc,
-                         StorageSpecifierKind kind, Optional<unsigned> dim,
-                         T v) {
+                         StorageSpecifierKind kind, std::optional<unsigned> dim,
+                         Value v) {
     SparseTensorSpecifier md(fields.back());
     md.setSpecifierField(builder, loc, v, kind, dim);
     fields.back() = md;
   }
 
-  template <typename T = Value>
-  void setDimSize(OpBuilder &builder, Location loc, unsigned dim, T v) {
+  void setDimSize(OpBuilder &builder, Location loc, unsigned dim, Value v) {
     setSpecifierField(builder, loc, StorageSpecifierKind::DimSize, dim, v);
   }
 
   std::pair<unsigned, unsigned>
   getIdxMemRefIndexAndStride(unsigned idxDim) const {
     StorageLayout<true> layout(getSparseTensorEncoding(rType));
     return layout.getFieldIndexAndStride(SparseTensorFieldKind::IdxMemRef,
                                          idxDim);