[mlir][sparse] Correcting some terminology / naming-scheme errors.

[wrengr]

Summary

The name "coords" should be used for the complete tuple of Dimension-/Level-many "crd" values associated with a single element. Whereas the name "coordinates" should only be used for collections of "crd" values which span several elements (e.g., the tensor's coordinates buffer for a single level).

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

static void genInsertBody(OpBuilder &builder, ModuleOp module,
   const ValueRange args = entryBlock->getArguments();
   const Location loc = func.getLoc();
   const SparseTensorType stt(rtp);
   const Level lvlRank = stt.getLvlRank();
 
   // Extract fields and coordinates from args.
   SmallVector<Value> fields = llvm::to_vector(args.drop_back(lvlRank + 1));
   MutSparseTensorDescriptor desc(rtp, fields);
-  const SmallVector<Value> coordinates =
+  const SmallVector<Value> coords =
       llvm::to_vector(args.take_back(lvlRank + 1).drop_back());
   Value value = args.back();
   Value parentPos = constantZero(builder, loc, builder.getIndexType());
   // Generate code for every level.
   for (Level l = 0; l < lvlRank; l++) {
     const auto dlt = stt.getLvlType(l);
     if (isCompressedDLT(dlt)) {
       // Create:
       //   if (!present) {
       //     coordinates[l].push_back(coords[l])
       //     <update positions and prepare level l + 1>
       //   }
       //   positions[l] = coordinates.size() - 1
       //   <insert @ positions[l] at next level l + 1>
       parentPos =
-          genCompressed(builder, loc, desc, coordinates, value, parentPos, l);
+          genCompressed(builder, loc, desc, coords, value, parentPos, l);
     } else if (isSingletonDLT(dlt)) {
       // Create:
       //   coordinates[l].push_back(coords[l])
       //   positions[l] = positions[l-1]
       //   <insert @ positions[l] at next level l + 1>
       createPushback(builder, loc, desc, SparseTensorFieldKind::CrdMemRef, l,
-                     coordinates[l]);
+                     coords[l]);
     } else {
       assert(isDenseDLT(dlt));
       // Construct the new position as:
       //   positions[l] = size * positions[l-1] + coords[l]
       //   <insert @ positions[l] at next level l + 1>
       Value size = sizeFromTensorAtLvl(builder, loc, desc, l);
       Value mult = builder.create<arith::MulIOp>(loc, size, parentPos);
-      parentPos = builder.create<arith::AddIOp>(loc, mult, coordinates[l]);
+      parentPos = builder.create<arith::AddIOp>(loc, mult, coords[l]);
     }
   }
   // Reached the actual value append/insert.
   if (!stt.isDenseLvl(lvlRank - 1))
     createPushback(builder, loc, desc, SparseTensorFieldKind::ValMemRef,
                    std::nullopt, value);
   else
     genStore(builder, loc, value, desc.getValMemRef(), parentPos);
matchAndRewrite(ExpandOp op, OpAdaptor adaptor,
     auto desc = getDescriptorFromTensorTuple(adaptor.getTensor());
     const auto srcType = getSparseTensorType(op.getTensor());
     Type eltType = srcType.getElementType();
     Type boolType = rewriter.getIntegerType(1);
     Type idxType = rewriter.getIndexType();
     // All initialization should be done on entry of the loop nest.
     rewriter.setInsertionPointAfter(op.getTensor().getDefiningOp());
     // Determine the size for access expansion (always the innermost stored
-    // dimension size, translated back to original dimension). Note that we
+    // level size, translated back to original dimension). Note that we
     // recursively rewrite the new DimOp on the **original** tensor.
     // FIXME: `toOrigDim` is deprecated.
     const Dimension innerDim = toOrigDim(srcType, srcType.getLvlRank() - 1);
     const auto sz = sizeFromTensorAtDim(rewriter, loc, desc, innerDim);
     // Generate a memref for `sz` elements of type `t`.
     const auto genAlloc = [&](Type t) {
       const auto memTp = MemRefType::get({ShapedType::kDynamic}, t);
       return rewriter.create<memref::AllocOp>(loc, memTp, ValueRange{sz});