[mlir][sparse] do not ignore ordering for "dense" tensor linked with sparse type

mlir/lib/Dialect/Linalg/Transforms/Sparsification.cpp

for (unsigned d = 0; d < rank; d++) {
       } else {
         assert(isDenseDim(dimAttr[d]));
         merger.setDim(t, idx, Dim::kDense);
       }
     }
   }
 }
 
+/// Returns true if tensor was set up with sparse storage scheme.
+static bool linkedSparse(linalg::GenericOp op, unsigned tensor) {
+  if (tensor < op.getNumInputs())
+    return isa_and_nonnull<linalg::SparseTensorFromPointerOp>(
+        op.getInput(tensor).getDefiningOp());
+  return false;
+}
+
 /// A DFS helper to compute a topological sort. Note that recursion is
 /// bounded by the number of implicit loops, which is always small.
 /// Returns false when a cycle is detected.
 static bool topSortDFS(unsigned i, std::vector<unsigned> &visit,
                        std::vector<unsigned> &topSort,
                        std::vector<std::vector<bool>> &adjM) {
   if (visit[i] != 0)
     return visit[i] != 1; // 1 denotes cycle!
static bool computeIterationGraph(Merger &merger, linalg::GenericOp op,
   std::vector<std::vector<bool>> adjM(n, std::vector<bool>(n, false));
 
   // Iterate over the indexing maps of every tensor in the tensor expression.
   unsigned numTensors = op.getNumShapedOperands();
   for (unsigned t = 0; t < numTensors; t++) {
     auto map = op.getIndexingMap(t);
     assert(map.getNumDims() == n);
     // Skip dense tensor constraints when sparse only is requested.
-    if (sparseOnly && !merger.isSparseTensor(t))
+    if (sparseOnly && !merger.isSparseTensor(t) && !linkedSparse(op, t))
       continue;
     // At the moment, we take the index variables in the tensor access
     // expression in the order in which they appear (conceptually a
     // "row-major" layout of every tensor). So, a tensor access A_ijk
     // forces the ordering i < j < k on the loop indices.
     // TODO: support affine map to define alternative dimension orders.
     for (unsigned d = 1, e = map.getNumResults(); d < e; d++) {
       unsigned f = map.getDimPosition(d - 1);
static Type genIntType(PatternRewriter &rewriter, linalg::SparseIntType tp) {
   case linalg::SparseIntType::kI16:
     return rewriter.getIntegerType(16);
   case linalg::SparseIntType::kI8:
     return rewriter.getIntegerType(8);
   }
   llvm_unreachable("unexpected SparseIntType");
 }
 
-/// Returns true if tensor was set up with sparse storage scheme.
-static bool linkedSparse(linalg::GenericOp op, unsigned tensor) {
-  if (tensor < op.getNumInputs())
-    return isa_and_nonnull<linalg::SparseTensorFromPointerOp>(
-        op.getInput(tensor).getDefiningOp());
-  return false;
-}
-
 /// Generates buffer for the output tensor.
 static Value genOutputBuffer(CodeGen &codegen, PatternRewriter &rewriter,
                              linalg::GenericOp op, MemRefType denseTp,
                              ArrayRef<Value> args) {
   Location loc = op.getLoc();
   Value tensor = op.getOutput(0);
   // The output tensor simply could materialize from the buffer that will
   // be generated for the tensor present in the outs() clause. This has
if (indices[b] && merger.isDim(b, Dim::kSparse)) {
       assert(codegen.pidxs[tensor][idx].getType().isa<IndexType>() &&
              "type mismatch for sparse index");
       operands.push_back(codegen.pidxs[tensor][idx]);
     }
   }
   if (needsUniv) {
     types.push_back(indexType);
     assert(codegen.loops[idx].getType().isa<IndexType>() &&
-           "type_mismatch for universal index");
+           "type mismatch for universal index");
     operands.push_back(codegen.loops[idx]);
   }
   Location loc = op.getLoc();
   scf::WhileOp whileOp = rewriter.create<scf::WhileOp>(loc, types, operands);
   Block *before = rewriter.createBlock(&whileOp.before(), {}, types);
   Block *after = rewriter.createBlock(&whileOp.after(), {}, types);
 
   // Build the "before" region, which effectively consists