[mlir][bufferization][NFC] Set emitAccessorPrefix dialect flag

[springerm]

Summary

Generate get/set accessors on all bufferization ops. Also update all internal uses.

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationBase.td

constexpr const static ::llvm::StringLiteral
         kWritableAttrName = "bufferization.writable";
 
     /// Attribute name used to mark the bufferization layout for region
     /// arguments during One-Shot Module Bufferize.
     constexpr const static ::llvm::StringLiteral
         kBufferLayoutAttrName = "bufferization.buffer_layout";
   }];
   let hasOperationAttrVerify = 1;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 #endif // BUFFERIZATION_BASE

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

let description = [{
     ```mlir
     %c = bufferization.alloc_tensor [%d1, %d2] : tensor<?x?xf32, #SparseMatrix>
     %0 = linalg.matmul
       ins(%a, %b: tensor<?x?xf32, #SparseMatrix>, tensor<?x?xf32, #SparseMatrix>)
       outs(%c: tensor<?x?xf32, #SparseMatrix>) -> tensor<?x?xf32, #SparseMatrix>
     ```
   }];
 
-  let arguments = (ins Variadic<Index>:$dynamicSizes,
+  let arguments = (ins Variadic<Index>:$dynamic_sizes,
                        Optional<AnyTensor>:$copy,
                        OptionalAttr<BoolAttr>:$escape);
 
   let results = (outs AnyTensor:$result);
 
   let extraClassDeclaration = [{
     LogicalResult bufferize(RewriterBase &rewriter,
                             const BufferizationOptions &options);
let extraClassDeclaration = [{
     bool isDynamicDim(unsigned idx) {
       return getType().isDynamicDim(idx);
     }
 
     // Return the argument position that contains the dynamic size of
     // the tensor at dimension `idx`. Asserts that the shape is
     // dynamic at that `idx`.
     unsigned getIndexOfDynamicSize(unsigned idx) {
-      assert(!copy() && "no dim sizes specified when copying a tensor");
+      assert(!getCopy() && "no dim sizes specified when copying a tensor");
       assert(isDynamicDim(idx) && "expected dynamic size");
       ArrayRef<int64_t> shape = getType().getShape();
       return std::count_if(
           shape.begin(), shape.begin() + idx,
           [&](int64_t size) { return ShapedType::isDynamic(size); });
     }
 
     // Return the Value of the dynamic size of the tensor at dimension
let description = [{
     of the clone operation after the clone operation thus leads to undefined
     behavior.
   }];
 
   let arguments = (ins Arg<AnyRankedOrUnrankedMemRef, "", []>:$input);
   let results = (outs Arg<AnyRankedOrUnrankedMemRef, "", []>:$output);
 
   let extraClassDeclaration = [{
-    Value getSource() { return input(); }
-    Value getTarget() { return output(); }
+    Value getSource() { return getInput(); }
+    Value getTarget() { return getOutput(); }
   }];
 
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 //===----------------------------------------------------------------------===//

mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp

matchAndRewrite(bufferization::CloneOp op, OpAdaptor adaptor,
     // Transform a clone operation into alloc + copy operation and pay
     // attention to the shape dimensions.
     Location loc = op->getLoc();
     SmallVector<Value, 4> dynamicOperands;
     for (int i = 0; i < memrefType.getRank(); ++i) {
       if (!memrefType.isDynamicDim(i))
         continue;
       Value size = rewriter.createOrFold<arith::ConstantIndexOp>(loc, i);
-      Value dim = rewriter.createOrFold<memref::DimOp>(loc, op.input(), size);
+      Value dim =
+          rewriter.createOrFold<memref::DimOp>(loc, op.getInput(), size);
       dynamicOperands.push_back(dim);
     }
 
     // Allocate a memref with identity layout.
     Value alloc = rewriter.create<memref::AllocOp>(op->getLoc(), allocType,
                                                    dynamicOperands);
     // Cast the allocation to the specified type if needed.
     if (memrefType != allocType)
       alloc = rewriter.create<memref::CastOp>(op->getLoc(), memrefType, alloc);
     rewriter.replaceOp(op, alloc);
-    rewriter.create<memref::CopyOp>(loc, op.input(), alloc);
+    rewriter.create<memref::CopyOp>(loc, op.getInput(), alloc);
     return success();
   }
 };
 } // namespace
 
 void mlir::populateBufferizationToMemRefConversionPatterns(
     RewritePatternSet &patterns) {
   patterns.add<CloneOpConversion>(patterns.getContext());

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

 
 Value bufferization::getBuffer(RewriterBase &rewriter, Value value,
                                const BufferizationOptions &options) {
   auto tensorType = value.getType().dyn_cast<TensorType>();
   assert(tensorType && "unexpected non-tensor type");
 
   // Replace "%t = to_tensor %m" with %m.
   if (auto toTensorOp = value.getDefiningOp<bufferization::ToTensorOp>())
-    return toTensorOp.memref();
+    return toTensorOp.getMemref();
 
   // Insert to_memref op.
   OpBuilder::InsertionGuard g(rewriter);
   setInsertionPointAfter(rewriter, value);
   Type memrefType = getMemRefType(tensorType, options);
   ensureToMemrefOpIsValid(value, memrefType);
   return rewriter.create<bufferization::ToMemrefOp>(value.getLoc(), memrefType,
                                                     value);
 }
 
 /// Return the buffer type for a given Value (tensor) after bufferization.
 BaseMemRefType
 bufferization::getBufferType(Value value, const BufferizationOptions &options) {
   auto tensorType = value.getType().dyn_cast<TensorType>();
   assert(tensorType && "unexpected non-tensor type");
 
   if (auto toTensorOp = value.getDefiningOp<bufferization::ToTensorOp>())
-    return toTensorOp.memref().getType().cast<BaseMemRefType>();
+    return toTensorOp.getMemref().getType().cast<BaseMemRefType>();
 
   return getMemRefType(tensorType, options);
 }
 
 void bufferization::replaceOpWithBufferizedValues(RewriterBase &rewriter,
                                                   Operation *op,
                                                   ValueRange values) {
   assert(values.size() == op->getNumResults() &&

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

mlir::bufferization::castOrReallocMemRefValue(OpBuilder &b, Value value,
   b.create<memref::CopyOp>(loc, value, copy);
   return copy;
 }
 
 /// Try to fold to_memref(to_tensor(x)). If x's type and the result type of the
 /// to_memref op are different, a memref.cast is needed.
 LogicalResult mlir::bufferization::foldToMemrefToTensorPair(
     RewriterBase &rewriter, ToMemrefOp toMemref, bool allowSameType) {
-  auto memrefToTensor = toMemref.tensor().getDefiningOp<ToTensorOp>();
+  auto memrefToTensor = toMemref.getTensor().getDefiningOp<ToTensorOp>();
   if (!memrefToTensor)
     return failure();
 
-  Type srcType = memrefToTensor.memref().getType();
+  Type srcType = memrefToTensor.getMemref().getType();
   Type destType = toMemref.getType();
 
   // Directly rewrite if the type did not change.
   if (srcType == destType) {
     // Function can be configured to only handle cases where a cast is needed.
     if (!allowSameType)
       return failure();
-    rewriter.replaceOp(toMemref, memrefToTensor.memref());
+    rewriter.replaceOp(toMemref, memrefToTensor.getMemref());
     return success();
   }
 
   auto rankedSrcType = srcType.dyn_cast<MemRefType>();
   auto rankedDestType = destType.dyn_cast<MemRefType>();
   auto unrankedSrcType = srcType.dyn_cast<UnrankedMemRefType>();
 
   // Ranked memref -> Ranked memref cast.
   if (rankedSrcType && rankedDestType) {
     FailureOr<Value> replacement = castOrReallocMemRefValue(
-        rewriter, memrefToTensor.memref(), rankedDestType);
+        rewriter, memrefToTensor.getMemref(), rankedDestType);
     if (failed(replacement))
       return failure();
 
     rewriter.replaceOp(toMemref, *replacement);
     return success();
   }
 
   // Unranked memref -> Ranked memref cast: May require a copy.
   // TODO: Not implemented at the moment.
   if (unrankedSrcType && rankedDestType)
     return failure();
 
   // Unranked memref -> unranked memref cast
   // Ranked memref -> unranked memref cast: No copy needed.
   assert(memref::CastOp::areCastCompatible(srcType, destType) &&
          "expected that types are cast compatible");
   rewriter.replaceOpWithNewOp<memref::CastOp>(toMemref, destType,
-                                              memrefToTensor.memref());
+                                              memrefToTensor.getMemref());
   return success();
 }
 
 void mlir::bufferization::populateDynamicDimSizes(
     OpBuilder &b, Location loc, Value shapedValue,
     SmallVector<Value> &dynamicDims) {
   auto shapedType = shapedValue.getType().cast<ShapedType>();
   for (int64_t i = 0; i < shapedType.getRank(); ++i) {
LogicalResult AllocTensorOp::bufferize(RewriterBase &rewriter,
   // Nothing to do for dead AllocTensorOps.
   if (getOperation()->getUses().empty()) {
     rewriter.eraseOp(getOperation());
     return success();
   }
 
   // Create buffer allocation.
   Value copyBuffer;
-  if (copy())
-    copyBuffer = getBuffer(rewriter, copy(), options);
+  if (getCopy())
+    copyBuffer = getBuffer(rewriter, getCopy(), options);
   auto allocType =
       MemRefType::get(getType().getShape(), getType().getElementType());
-  SmallVector<Value> dynamicDims = dynamicSizes();
-  if (copy()) {
+  SmallVector<Value> dynamicDims = getDynamicSizes();
+  if (getCopy()) {
     assert(dynamicDims.empty() && "expected either `copy` or `dynamicDims`");
     populateDynamicDimSizes(rewriter, loc, copyBuffer, dynamicDims);
   }
   FailureOr<Value> alloc =
       options.createAlloc(rewriter, loc, allocType, dynamicDims);
   if (failed(alloc))
     return failure();
 
   // Create memory copy (if any).
-  if (copy()) {
+  if (getCopy()) {
     if (failed(options.createMemCpy(rewriter, loc, copyBuffer, *alloc)))
       return failure();
   }
 
   // Should the buffer be deallocated?
   AnalysisState analysisState(options);
   bool dealloc;
-  if (escape().hasValue()) {
-    dealloc = !*escape();
+  if (getEscape().hasValue()) {
+    dealloc = !*getEscape();
   } else {
     // No "escape" annotation found.
     if (options.createDeallocs) {
       // Perform an ad-hoc analysis.
       dealloc = !analysisState.isTensorYielded(getResult());
     } else {
       dealloc = false;
     }
LogicalResult AllocTensorOp::bufferize(RewriterBase &rewriter,
   if (failed(options.createDealloc(rewriter, loc, *alloc)))
     return failure();
   return success();
 }
 
 bool AllocTensorOp::isMemoryWrite(OpResult opResult,
                                   const AnalysisState &state) {
   // AllocTensorOps do not write unless they have a `copy` value.
-  return static_cast<bool>(copy());
+  return static_cast<bool>(getCopy());
 }
 
 bool AllocTensorOp::bufferizesToMemoryRead(OpOperand &opOperand,
                                            const AnalysisState &state) {
   assert(opOperand.getOperandNumber() == getNumOperands() - 1 &&
          "expected copy operand");
   return true;
 }
 
 bool AllocTensorOp::bufferizesToMemoryWrite(OpOperand &opOperand,
                                             const AnalysisState &state) {
   assert(opOperand.getOperandNumber() == getNumOperands() - 1 &&
          "expected copy operand");
   return false;
 }
 
 SmallVector<OpResult>
 AllocTensorOp::getAliasingOpResult(OpOperand &opOperand,
                                    const AnalysisState &state) {
   // This is a new allocation. It does not alias with any other buffer.
   return {};
 }
 
 LogicalResult AllocTensorOp::verify() {
-  if (copy() && !dynamicSizes().empty())
+  if (getCopy() && !getDynamicSizes().empty())
     return emitError("dynamic sizes not needed when copying a tensor");
-  if (!copy() && getType().getNumDynamicDims() !=
-                     static_cast<int64_t>(dynamicSizes().size()))
+  if (!getCopy() && getType().getNumDynamicDims() !=
+                        static_cast<int64_t>(getDynamicSizes().size()))
     return emitError("expected ")
            << getType().getNumDynamicDims() << " dynamic sizes";
-  if (copy() && copy().getType() != getType())
+  if (getCopy() && getCopy().getType() != getType())
     return emitError("expected that `copy` and return type match");
   return success();
 }
 
 void AllocTensorOp::build(OpBuilder &builder, OperationState &result,
                           RankedTensorType type, ValueRange dynamicSizes) {
   build(builder, result, type, dynamicSizes, /*copy=*/Value(),
         /*escape=*/BoolAttr());

 ///  to
 ///
 ///  %0 = bufferization.alloc_tensor(%arg0) : tensor<?x5xf32>
 struct ReplaceStaticShapeDims : OpRewritePattern<AllocTensorOp> {
   using OpRewritePattern<AllocTensorOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AllocTensorOp op,
                                 PatternRewriter &rewriter) const override {
-    if (op.copy())
+    if (op.getCopy())
       return failure();
     SmallVector<int64_t> newShape = llvm::to_vector(op.getType().getShape());
     SmallVector<Value> newDynamicSizes;
     unsigned int dynValCounter = 0;
     for (int64_t i = 0; i < op.getType().getRank(); ++i) {
       if (!op.isDynamicDim(i))
         continue;
-      Value value = op.dynamicSizes()[dynValCounter++];
+      Value value = op.getDynamicSizes()[dynValCounter++];
       APInt intVal;
       if (matchPattern(value, m_ConstantInt(&intVal))) {
         newShape[i] = intVal.getSExtValue();
       } else {
         newDynamicSizes.push_back(value);
       }
     }
     RankedTensorType newType = RankedTensorType::get(
         newShape, op.getType().getElementType(), op.getType().getEncoding());
     if (newType == op.getType())
       return failure();
     auto newOp = rewriter.create<AllocTensorOp>(
         op.getLoc(), newType, newDynamicSizes, /*copy=*/Value(),
-        /*escape=*/op.escapeAttr());
+        /*escape=*/op.getEscapeAttr());
     rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(), newOp);
     return success();
   }
 };
 
 struct FoldDimOfAllocTensorOp : public OpRewritePattern<tensor::DimOp> {
   using OpRewritePattern<tensor::DimOp>::OpRewritePattern;
 
ParseResult AllocTensorOp::parse(OpAsmParser &parser, OperationState &result) {
   result.addAttribute(AllocTensorOp::getOperandSegmentSizeAttr(),
                       parser.getBuilder().getI32VectorAttr(
                           {static_cast<int32_t>(dynamicSizesOperands.size()),
                            static_cast<int32_t>(copyKeyword.succeeded())}));
   return success();
 }
 
 void AllocTensorOp::print(OpAsmPrinter &p) {
-  p << "(" << dynamicSizes() << ")";
-  if (copy())
-    p << " copy(" << copy() << ")";
+  p << "(" << getDynamicSizes() << ")";
+  if (getCopy())
+    p << " copy(" << getCopy() << ")";
   p.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{
                               AllocTensorOp::getOperandSegmentSizeAttr()});
   p << " : ";
-  auto type = result().getType();
+  auto type = getResult().getType();
   if (auto validType = type.dyn_cast<::mlir::TensorType>())
     p.printStrippedAttrOrType(validType);
   else
     p << type;
 }
 
 Value AllocTensorOp::getDynamicSize(OpBuilder &b, unsigned idx) {
   assert(isDynamicDim(idx) && "expected dynamic dim");
-  if (copy())
-    return b.create<tensor::DimOp>(getLoc(), copy(), idx);
+  if (getCopy())
+    return b.create<tensor::DimOp>(getLoc(), getCopy(), idx);
   return getOperand(getIndexOfDynamicSize(idx));
 }
 
 //===----------------------------------------------------------------------===//
 // CloneOp
 //===----------------------------------------------------------------------===//
 
 void CloneOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
-  effects.emplace_back(MemoryEffects::Read::get(), input(),
+  effects.emplace_back(MemoryEffects::Read::get(), getInput(),
                        SideEffects::DefaultResource::get());
-  effects.emplace_back(MemoryEffects::Write::get(), output(),
+  effects.emplace_back(MemoryEffects::Write::get(), getOutput(),
                        SideEffects::DefaultResource::get());
-  effects.emplace_back(MemoryEffects::Allocate::get(), output(),
+  effects.emplace_back(MemoryEffects::Allocate::get(), getOutput(),
                        SideEffects::DefaultResource::get());
 }
 
 OpFoldResult CloneOp::fold(ArrayRef<Attribute> operands) {
   return succeeded(memref::foldMemRefCast(*this)) ? getResult() : Value();
 }
 
 namespace {
 
 /// Merge the clone and its source (by converting the clone to a cast) when
 /// possible.
 struct SimplifyClones : public OpRewritePattern<CloneOp> {
   using OpRewritePattern<CloneOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CloneOp cloneOp,
                                 PatternRewriter &rewriter) const override {
     if (cloneOp.use_empty()) {
       rewriter.eraseOp(cloneOp);
       return success();
     }
 
-    Value source = cloneOp.input();
+    Value source = cloneOp.getInput();
 
     // This only finds dealloc operations for the immediate value. It should
     // also consider aliases. That would also make the safety check below
     // redundant.
     llvm::Optional<Operation *> maybeCloneDeallocOp =
-        memref::findDealloc(cloneOp.output());
+        memref::findDealloc(cloneOp.getOutput());
     // Skip if either of them has > 1 deallocate operations.
     if (!maybeCloneDeallocOp.hasValue())
       return failure();
     llvm::Optional<Operation *> maybeSourceDeallocOp =
         memref::findDealloc(source);
     if (!maybeSourceDeallocOp.hasValue())
       return failure();
     Operation *cloneDeallocOp = *maybeCloneDeallocOp;
void CloneOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<SimplifyClones>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ToTensorOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ToTensorOp::fold(ArrayRef<Attribute>) {
-  if (auto toMemref = memref().getDefiningOp<ToMemrefOp>())
+  if (auto toMemref = getMemref().getDefiningOp<ToMemrefOp>())
     // Approximate alias analysis by conservatively folding only when no there
     // is no interleaved operation.
     if (toMemref->getBlock() == this->getOperation()->getBlock() &&
         toMemref->getNextNode() == this->getOperation())
-      return toMemref.tensor();
+      return toMemref.getTensor();
   return {};
 }
 
 namespace {
 
 struct DimOfToTensorFolder : public OpRewritePattern<tensor::DimOp> {
   using OpRewritePattern<tensor::DimOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tensor::DimOp dimOp,
                                 PatternRewriter &rewriter) const override {
     auto memrefToTensorOp = dimOp.source().getDefiningOp<ToTensorOp>();
     if (!memrefToTensorOp)
       return failure();
 
-    rewriter.replaceOpWithNewOp<memref::DimOp>(dimOp, memrefToTensorOp.memref(),
-                                               dimOp.index());
+    rewriter.replaceOpWithNewOp<memref::DimOp>(
+        dimOp, memrefToTensorOp.getMemref(), dimOp.index());
     return success();
   }
 };
 
 } // namespace
 
 void ToTensorOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                              MLIRContext *context) {
   results.add<DimOfToTensorFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ToMemrefOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ToMemrefOp::fold(ArrayRef<Attribute>) {
-  if (auto memrefToTensor = tensor().getDefiningOp<ToTensorOp>())
-    if (memrefToTensor.memref().getType() == getType())
-      return memrefToTensor.memref();
+  if (auto memrefToTensor = getTensor().getDefiningOp<ToTensorOp>())
+    if (memrefToTensor.getMemref().getType() == getType())
+      return memrefToTensor.getMemref();
   return {};
 }
 
 namespace {
 
 /// Replace tensor.cast + to_memref by to_memref + memref.cast.
 struct ToMemrefOfCast : public OpRewritePattern<ToMemrefOp> {
   using OpRewritePattern<ToMemrefOp>::OpRewritePattern;
struct LoadOfToMemref : public OpRewritePattern<memref::LoadOp> {
   using OpRewritePattern<memref::LoadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(memref::LoadOp load,
                                 PatternRewriter &rewriter) const override {
     auto toMemref = load.memref().getDefiningOp<ToMemrefOp>();
     if (!toMemref)
       return failure();
 
-    rewriter.replaceOpWithNewOp<tensor::ExtractOp>(load, toMemref.tensor(),
+    rewriter.replaceOpWithNewOp<tensor::ExtractOp>(load, toMemref.getTensor(),
                                                    load.indices());
     return success();
   }
 };
 
 /// Fold dim of a to_memref into the dim of the tensor.
 struct DimOfCastOp : public OpRewritePattern<memref::DimOp> {
   using OpRewritePattern<memref::DimOp>::OpRewritePattern;

mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp

 // converted to memrefs, thus, this op becomes an identity.
 class BufferizeToTensorOp
     : public OpConversionPattern<bufferization::ToTensorOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(bufferization::ToTensorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOp(op, adaptor.memref());
+    rewriter.replaceOp(op, adaptor.getMemref());
     return success();
   }
 };
 } // namespace
 
 namespace {
 // In a finalizing bufferize conversion, we know that all tensors have been
 // converted to memrefs, thus, this op becomes an identity.
 class BufferizeToMemrefOp
     : public OpConversionPattern<bufferization::ToMemrefOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(bufferization::ToMemrefOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOp(op, adaptor.tensor());
+    rewriter.replaceOp(op, adaptor.getTensor());
     return success();
   }
 };
 } // namespace
 
 void mlir::bufferization::populateEliminateBufferizeMaterializationsPatterns(
     BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns) {
   patterns.add<BufferizeToTensorOp, BufferizeToMemrefOp>(typeConverter,

mlir/lib/Dialect/Bufferization/Transforms/TensorCopyInsertion.cpp

mlir::bufferization::insertTensorCopies(Operation *op,
   WalkResult result = op->walk([&](Operation *op) {
     auto bufferizableOp = state.getOptions().dynCastBufferizableOp(op);
     if (!bufferizableOp)
       return WalkResult::skip();
 
     // Find AllocTensorOps without an `escape` attribute and add the attribute
     // based on analysis results.
     if (auto allocTensorOp = dyn_cast<AllocTensorOp>(op)) {
-      if (allocTensorOp.escape())
+      if (allocTensorOp.getEscape())
         return WalkResult::advance();
       bool escape = !state.getOptions().createDeallocs ||
-                    state.isTensorYielded(allocTensorOp.result());
-      allocTensorOp.escapeAttr(rewriter.getBoolAttr(escape));
+                    state.isTensorYielded(allocTensorOp.getResult());
+      allocTensorOp.setEscapeAttr(rewriter.getBoolAttr(escape));
       return WalkResult::advance();
     }
 
     // Find inplacability conflicts and resolve them. (Typically with explicit
     // tensor copies in the form of AllocTensorOps.)
     rewriter.setInsertionPoint(op);
     if (failed(bufferizableOp.resolveConflicts(rewriter, state)))
       return WalkResult::interrupt();

mlir/lib/Dialect/SCF/SCF.cpp

for (BlockArgument bbArg : forOp.getRegionIterArgs()) {
       bufferization::ToMemrefOp tensorToMemref;
       // Either bbArg has no use or it has a single buffer_cast use.
       if (bbArg.hasOneUse())
         tensorToMemref =
             dyn_cast<bufferization::ToMemrefOp>(*bbArg.getUsers().begin());
       if (!isTensor || !tensorLoadOp || (!bbArg.use_empty() && !tensorToMemref))
         continue;
       // If tensorToMemref is present, it must feed into the `ToTensorOp`.
-      if (tensorToMemref && tensorLoadOp.memref() != tensorToMemref)
+      if (tensorToMemref && tensorLoadOp.getMemref() != tensorToMemref)
         continue;
       // TODO: Any aliasing write of tensorLoadOp.memref() nested under `forOp`
       // must be before `ToTensorOp` in the block so that the lastWrite
       // property is not subject to additional side-effects.
       // For now, we only support the case when ToTensorOp appears
       // immediately before the terminator.
       if (tensorLoadOp->getNextNode() != yieldOp)
         continue;
 
       // Clone the optional tensorToMemref before forOp.
       if (tensorToMemref) {
         rewriter.setInsertionPoint(forOp);
         rewriter.replaceOpWithNewOp<bufferization::ToMemrefOp>(
-            tensorToMemref, tensorToMemref.memref().getType(),
-            tensorToMemref.tensor());
+            tensorToMemref, tensorToMemref.getMemref().getType(),
+            tensorToMemref.getTensor());
       }
 
       // Clone the tensorLoad after forOp.
       rewriter.setInsertionPointAfter(forOp);
       Value newTensorLoad = rewriter.create<bufferization::ToTensorOp>(
-          loc, tensorLoadOp.memref());
+          loc, tensorLoadOp.getMemref());
       Value forOpResult = forOp.getResult(bbArg.getArgNumber() - /*iv=*/1);
       replacements.insert(std::make_pair(forOpResult, newTensorLoad));
 
       // Make the terminator just yield the bbArg, the old tensorLoadOp + the
       // old bbArg (that is now directly yielded) will canonicalize away.
       rewriter.startRootUpdate(yieldOp);
       yieldOp.setOperand(idx, bbArg);
       rewriter.finalizeRootUpdate(yieldOp);