[mlir][linalg] Cleanup LinalgOp usage in comprehensive bufferization.

[gysit]

Summary

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

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

if (opOperand.getOperandNumber() == opOperand2.getOperandNumber())
       continue;
     if (opOperand.get() == opOperand2.get())
       return OpResult();
   }
   int64_t outputOperandIndex =
       opOperand.getOperandNumber() - linalgOp.getNumInputs();
   int64_t numOutputBuffers = 0;
   for (unsigned idx = 0; idx < outputOperandIndex; ++idx)
-    if (!linalgOp.getOutputShapedType(idx).isa<TensorType>())
+    if (!linalgOp.getOutputOperand(idx)->get().getType().isa<TensorType>())
       ++numOutputBuffers;
   return linalgOp->getResult(outputOperandIndex - numOutputBuffers);
 }
 
 /// Return the OpResult that matches an operand.
 /// Return null if no such result exists.
 OpResult getMatchingOpResult(VectorTransferOpInterface op,
                              OpOperand &opOperand) {
allocateBuffersForResults(OpBuilder &b, Location loc, LinalgOp op,
                           BlockAndValueMapping &bvm) {
   // Take a guard before anything else.
   OpBuilder::InsertionGuard g(b);
 
   // Lazily compute loopRanges.
   SmallVector<Range, 4> loopRanges;
 
   // Linalg invariant: output tensors and result match 1-1.
-  assert(op.getNumOutputTensors() == op->getNumResults());
-  for (auto &opOperand : op.getOutputOpOperands()) {
-    Value output = opOperand.get();
+  assert(op.getOutputTensorOperands().size() == op->getNumResults());
+  for (OpOperand *opOperand : op.getOutputOperands()) {
+    Value output = opOperand->get();
     if (output.getType().isa<MemRefType>()) {
       resultBuffers.push_back(output);
       continue;
     }
 
     // If output tensor is marked inPlace, just use the buffer.
     // The following uses internal knowledge of the position of tied operand /
     // results.
-    OpResult tiedResult = getMatchingOpResult(op, opOperand);
+    OpResult tiedResult = getMatchingOpResult(op, *opOperand);
     if (getInPlace(tiedResult) == InPlaceSpec::True) {
       Value v = lookup(bvm, output);
       if (!v)
         return failure();
       resultBuffers.push_back(v);
       continue;
     }
 
     Value dimTensor = bvm.lookupOrDefault(output);
     Value alloc = createNewAllocDeallocPairForShapedValue(b, loc, dimTensor);
     b.setInsertionPointAfter(alloc.getDefiningOp());
     resultBuffers.push_back(alloc);
 
     // Additionally, if the output buffer is used, clone its value for now.
-    if (op.payloadUsesValueFromOpOperand(&opOperand)) {
+    if (op.payloadUsesValueFromOperand(opOperand)) {
       Value v = lookup(bvm, output);
       if (!v)
         return failure();
       b.create<CopyOp>(loc, v, alloc);
     }
   }
   if (op->getNumResults())
     map(bvm, op->getResults(), resultBuffers);
if (op.hasBufferSemantics())
     return failure();
 
   LLVM_DEBUG(DBGS() << "bufferize: " << *op << "\n");
 
   b.setInsertionPoint(op);
   Location loc = op.getLoc();
   SmallVector<Value, 2> newInputBuffers;
   newInputBuffers.reserve(op.getNumInputs());
-  for (Value in : op.getInputs()) {
-    Value v = lookup(bvm, in);
+  for (OpOperand *opOperand : op.getInputOperands()) {
+    Value v = lookup(bvm, opOperand->get());
     if (!v)
       return failure();
     newInputBuffers.push_back(v);
   }
   SmallVector<Value, 2> newOutputBuffers;
   if (failed(allocateBuffersForResults(b, loc, op, newOutputBuffers, bvm)))
     return failure();
   finalizeBufferAllocation(b, op, newInputBuffers, newOutputBuffers, bvm);