[mlir][linalg] Cleanup LinalgOp usage in dependence analysis (NFC).

[gysit]

Summary

Replace the uses of deprecated Structured Op Interface methods in DependenceAnalysis.cpp and DependenceAnalysis.h. This patch is based on https://reviews.llvm.org/D103394.

[gysit]

Rebase

mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h

struct LinalgDependenceGraphElem {
     }
     // Return the indexing map of the operand/result in `opView` specified in
     // the owning LinalgOp. If the owner is not a LinalgOp returns llvm::None.
     static Optional<AffineMap> getIndexingMap(OpView opView) {
       auto owner = dyn_cast<LinalgOp>(getOwner(opView));
       if (!owner)
         return llvm::None;
       if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
-        return owner.getIndexingMap(operand->getOperandNumber());
-      return owner.getOutputIndexingMap(
-          opView.get<Value>().cast<OpResult>().getResultNumber());
+        return owner.getTiedIndexingMap(operand);
+      return owner.getTiedIndexingMap(owner.getOutputOperand(
+          opView.get<Value>().cast<OpResult>().getResultNumber()));
     }
     // Return the operand number if the `opView` is an OpOperand *. Otherwise
     // return llvm::None.
     static Optional<unsigned> getOperandNumber(OpView opView) {
       if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
         return operand->getOperandNumber();
       return llvm::None;
     }

mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp

if (iter == dependencesIntoGraphs[dt].end())
     return llvm::make_range(nullptr, nullptr);
   return llvm::make_range(iter->second.begin(), iter->second.end());
 }
 
 void LinalgDependenceGraph::addDependencesBetween(LinalgOp src, LinalgOp dst) {
   LLVM_DEBUG(dbgs() << "addDependencesBetween " << *src.getOperation()
                     << " and " << *dst.getOperation() << "\n");
   if (src.hasTensorSemantics() && dst.hasTensorSemantics()) {
-    for (OpOperand &dstOpOperand : dst.getInputOpOperands()) {
+    for (OpOperand *dstOpOperand : dst.getInputOperands()) {
       // Check if the operand is defined by the src.
-      auto definingOp = dstOpOperand.get().getDefiningOp<LinalgOp>();
+      auto definingOp = dstOpOperand->get().getDefiningOp<LinalgOp>();
       if (definingOp && definingOp == src)
-        addDependenceElem(DependenceType::RAW, dstOpOperand.get(),
-                          &dstOpOperand);
+        addDependenceElem(DependenceType::RAW, dstOpOperand->get(),
+                          dstOpOperand);
     }
-    for (OpOperand &dstOpOperand : dst.getOutputOpOperands()) {
+    for (OpOperand *dstOpOperand : dst.getOutputOperands()) {
       // Check if the operand is defined by the src.
-      auto definingOp = dstOpOperand.get().getDefiningOp<LinalgOp>();
+      auto definingOp = dstOpOperand->get().getDefiningOp<LinalgOp>();
       if (definingOp && definingOp == src) {
-        if (dst.isInitTensor(&dstOpOperand)) {
-          addDependenceElem(DependenceType::RAW, dstOpOperand.get(),
-                            &dstOpOperand);
+        if (dst.isInitTensor(dstOpOperand)) {
+          addDependenceElem(DependenceType::RAW, dstOpOperand->get(),
+                            dstOpOperand);
         }
-        addDependenceElem(DependenceType::WAW, dstOpOperand.get(),
-                          &dstOpOperand);
+        addDependenceElem(DependenceType::WAW, dstOpOperand->get(),
+                          dstOpOperand);
       }
     }
     return;
   }
   assert(src.hasBufferSemantics() && dst.hasBufferSemantics() &&
          "unhandled dependence tracking for mixed buffer/tensor operations");
-  for (OpOperand *srcOpOperand : src.getOutputBuffersOpOperands()) { // W
+  for (OpOperand *srcOpOperand : src.getOutputBufferOperands()) { // W
     // RAW graph
-    for (OpOperand *dstOpOperand : dst.getInputBuffersOpOperands()) // R
-      if (aliases.alias(srcOpOperand->get(), dstOpOperand->get()))  // RAW alias
+    for (OpOperand *dstOpOperand : dst.getInputBufferOperands())   // R
+      if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // RAW alias
         addDependenceElem(DependenceType::RAW, srcOpOperand, dstOpOperand);
     // WAW graph
-    for (OpOperand *dstOpOperand : dst.getOutputBuffersOpOperands()) // W
+    for (OpOperand *dstOpOperand : dst.getOutputBufferOperands())  // W
       if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // WAW alias
         addDependenceElem(DependenceType::WAW, srcOpOperand, dstOpOperand);
   }
-  for (OpOperand *srcOpOperand : src.getInputBuffersOpOperands()) { // R
+  for (OpOperand *srcOpOperand : src.getInputBufferOperands()) { // R
     // RAR graph
-    for (OpOperand *dstOpOperand : dst.getInputBuffersOpOperands()) // R
-      if (aliases.alias(srcOpOperand->get(), dstOpOperand->get()))  // RAR alias
+    for (OpOperand *dstOpOperand : dst.getInputBufferOperands())   // R
+      if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // RAR alias
         addDependenceElem(DependenceType::RAR, srcOpOperand, dstOpOperand);
     // WAR graph
-    for (OpOperand *dstOpOperand : dst.getOutputBuffersOpOperands()) // W
+    for (OpOperand *dstOpOperand : dst.getOutputBufferOperands())  // W
       if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // WAR alias
         addDependenceElem(DependenceType::WAR, srcOpOperand, dstOpOperand);
   }
 }
 
 SmallVector<Operation *, 8>
 LinalgDependenceGraph::findCoveringDependences(LinalgOp srcLinalgOp,
                                                LinalgOp dstLinalgOp) const {