[mlir][sparse] Refactoring: renaming StorageNewOp to StorageOp

[Peiming]

Summary

To address comment in https://reviews.llvm.org/D133241

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

def SparseTensor_YieldOp : SparseTensor_Op<"yield", [NoSideEffect, Terminator]>,
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Storage Operation. These operations are used internally by
 // sparse tensor codegen to progressively lower sparse tensors.
 //===----------------------------------------------------------------------===//
 
-def SparseTensor_StorageNewOp : SparseTensor_Op<"storage", []>,
+def SparseTensor_StorageOp : SparseTensor_Op<"storage", []>,
     Arguments<(ins Variadic<AnyType>:$inputs)>,
     Results<(outs AnyTuple:$result)> {
   let summary = "Pack a list of value into one sparse tensor storage value";
   let description = [{
      Pack a list of value into one sparse tensor storage value (represented as
      a tuple) at the given index.
 
      The result tuple elements' type should match the corresponding type in the

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

LogicalResult YieldOp::verify() {
   return emitOpError(
       "expected parent op to be sparse_tensor unary, binary, or reduce");
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Storage Operation.
 //===----------------------------------------------------------------------===//
 
-LogicalResult StorageNewOp::verify() {
+LogicalResult StorageOp::verify() {
   auto retTypes = getResult().getType().getTypes();
   if (retTypes.size() != getInputs().size())
     return emitError("The number of inputs is inconsistent with output tuple");
 
   for (auto pair : llvm::zip(getInputs(), retTypes)) {
     auto input = std::get<0>(pair);
     auto retTy = std::get<1>(pair);
 

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp

static Value createTupleGet(OpBuilder &builder, Location loc, Value tuple,
   Type indexType = builder.getIndexType();
   return builder.create<StorageGetOp>(loc, getFieldType(tuple, field), tuple,
                                       builder.getIntegerAttr(indexType, field));
 }
 
 /// Creates tuple.
 static Value createTupleMake(OpBuilder &builder, Location loc, Type type,
                              ValueRange values) {
-  return builder.create<StorageNewOp>(loc, type, values);
+  return builder.create<StorageOp>(loc, type, values);
 }
 
 /// Create allocation operation.
 static Value createAllocation(OpBuilder &builder, Location loc, Type type,
                               Value sz) {
   auto memType = MemRefType::get({ShapedType::kDynamicSize}, type);
   return builder.create<memref::AllocOp>(loc, memType, sz);
 }

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp

struct SparseTensorCodegenPass
 
   void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     SparseTensorTypeToBufferConverter converter;
     ConversionTarget target(*ctx);
     // Almost everything in the sparse dialect must go!
     target.addIllegalDialect<SparseTensorDialect>();
-    target.addLegalOp<StorageGetOp, StorageSetOp, StorageNewOp>();
+    target.addLegalOp<StorageGetOp, StorageSetOp, StorageOp>();
     // All dynamic rules below accept new function, call, return, and various
     // tensor and bufferization operations as legal output of the rewriting
     // provided that all sparse tensor types have been fully rewritten.
     target.addDynamicallyLegalOp<func::FuncOp>([&](func::FuncOp op) {
       return converter.isSignatureLegal(op.getFunctionType());
     });
     target.addDynamicallyLegalOp<func::CallOp>([&](func::CallOp op) {
       return converter.isSignatureLegal(op.getCalleeType());