[mlir][bufferization][NFC] Rename resultBufferizesToMemoryWrite

Author: matthias-springer

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h

@@ -720,10 +720,10 @@ defaultGetBufferType(Value value, const BufferizationOptions &options,
  SmallVector<Value> &invocationStack);
 
 /// This is the default implementation of
-/// BufferizableOpInterface::resultBufferizesToMemoryWrite. Should not be called
+/// BufferizableOpInterface::bufferizesToMemoryWrite. Should not be called
 /// from other places.
-bool defaultResultBufferizesToMemoryWrite(OpResult opResult,
-  const AnalysisState &state);
+bool defaultBufferizesToMemoryWrite(OpResult opResult,
+ const AnalysisState &state);
 
 /// This is the default implementation of
 /// BufferizableOpInterface::isRepetitiveRegion. Should not be called from other

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

@@ -148,8 +148,8 @@ def BufferizableOpInterface : OpInterface<"BufferizableOpInterface"> {
  InterfaceMethod<
  /*desc=*/[{
  Return `true` if the given OpResult bufferizes to a memory write.
- This is the same property as `bufferizesToMemoryWrite`, but from The
- perspective of OpResults.
+ This is the same property as `bufferizesToMemoryWrite(OpOperand &)`,
+ but from the perspective of OpResults.
 
  This method will never be called on OpResults that do not have a
  tensor type.
@@ -165,7 +165,7 @@ def BufferizableOpInterface : OpInterface<"BufferizableOpInterface"> {
 
  Counter-example: bufferization.alloc_tensor
  The op just allocates and does not specify the data of the tensor,
- so resultBufferizesToMemoryWrite is overridden to return false.
+ so `bufferizesToMemoryWrite` is overridden to return false.
 
  2. At least one aliasing OpOperand bufferizes to a memory write.
 
@@ -192,14 +192,14 @@ def BufferizableOpInterface : OpInterface<"BufferizableOpInterface"> {
  write.
  }],
  /*retType=*/"bool",
- /*methodName=*/"resultBufferizesToMemoryWrite",
+ /*methodName=*/"bufferizesToMemoryWrite",
  /*args=*/(ins "::mlir::OpResult":$opResult,
  "const ::mlir::bufferization::AnalysisState &":$state),
  /*methodBody=*/"",
  /*defaultImplementation=*/[{
  assert(opResult.getDefiningOp() == $_op.getOperation() &&
  "invalid OpResult");
- return ::mlir::bufferization::detail::defaultResultBufferizesToMemoryWrite(
+ return ::mlir::bufferization::detail::defaultBufferizesToMemoryWrite(
  opResult, state);
  }]
  >,

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

@@ -96,7 +96,7 @@ def Bufferization_AllocTensorOp : Bufferization_Op<"alloc_tensor",
  const BufferizationOptions &options,
  BufferizationState &state);
 
- bool resultBufferizesToMemoryWrite(OpResult opResult,
+ bool bufferizesToMemoryWrite(OpResult opResult,
  const AnalysisState &state);
 
  bool bufferizesToAllocation(Value value) { return true; }

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

@@ -496,7 +496,7 @@ bool AnalysisState::bufferizesToMemoryWrite(Value value) const {
  auto bufferizableOp = getOptions().dynCastBufferizableOp(value);
  if (!bufferizableOp)
  return true;
- return bufferizableOp.resultBufferizesToMemoryWrite(opResult, *this);
+ return bufferizableOp.bufferizesToMemoryWrite(opResult, *this);
 }
 
 /// Return true if the given value is read by an op that bufferizes to a memory
@@ -882,7 +882,7 @@ bufferization::getMemRefTypeWithStaticIdentityLayout(TensorType tensorType,
 // Default implementations of interface methods
 //===----------------------------------------------------------------------===//
 
-bool bufferization::detail::defaultResultBufferizesToMemoryWrite(
+bool bufferization::detail::defaultBufferizesToMemoryWrite(
  OpResult opResult, const AnalysisState &state) {
  auto bufferizableOp = cast<BufferizableOpInterface>(opResult.getDefiningOp());
  AliasingOpOperandList opOperands =

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

@@ -195,8 +195,9 @@ LogicalResult AllocTensorOp::bufferize(RewriterBase &rewriter,
  return success();
 }
 
-bool AllocTensorOp::resultBufferizesToMemoryWrite(OpResult opResult,
- const AnalysisState &state) {
+bool AllocTensorOp::bufferizesToMemoryWrite(OpResult opResult,
+ const AnalysisState &state) {
+
  // AllocTensorOps do not write unless they have a `copy` value.
  return static_cast<bool>(getCopy());
 }

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

@@ -112,8 +112,8 @@ struct LoadOpInterface
 struct NewOpInterface
  : public SparseBufferizableOpInterfaceExternalModel<NewOpInterface,
  sparse_tensor::NewOp> {
- bool resultBufferizesToMemoryWrite(Operation *op, OpResult opResult,
-  const AnalysisState &state) const {
+ bool bufferizesToMemoryWrite(Operation *op, OpResult opResult,
+ const AnalysisState &state) const {
  // NewOps allocate but do not write.
  return false;
  }

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

@@ -272,8 +272,8 @@ struct EmptyOpInterface
  tensor::EmptyOp> {
  bool bufferizesToAllocation(Operation *op, Value value) const { return true; }
 
- bool resultBufferizesToMemoryWrite(Operation *op, OpResult opResult,
-  const AnalysisState &state) const {
+ bool bufferizesToMemoryWrite(Operation *op, OpResult opResult,
+ const AnalysisState &state) const {
  // The returned tensor does not have specified contents.
  return false;
  }